Copy disabled (too large)
Download .txt
Showing preview only (16,958K chars total). Download the full file to get everything.
Repository: facebook/igl
Branch: main
Commit: 8673f9c38a7a
Files: 1071
Total size: 16.0 MB
Directory structure:
gitextract_czmiq_qe/
├── .clang-format
├── .claude/
│ └── CLAUDE.md
├── .cmake-format
├── .github/
│ ├── pull_request_template.md
│ └── workflows/
│ ├── c-cpp.yml
│ ├── cmake-install-test.yml
│ └── doc-build.yml
├── .gitignore
├── CMakeLists.txt
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── IGLU/
│ ├── CMakeLists.txt
│ ├── bitmap/
│ │ ├── BitmapWriter.cpp
│ │ └── BitmapWriter.h
│ ├── command_buffer_allocator/
│ │ ├── ICommandBufferAllocator.cpp
│ │ └── ICommandBufferAllocator.h
│ ├── imgui/
│ │ ├── InputListener.cpp
│ │ ├── InputListener.h
│ │ ├── KeyCodeTranslator.cpp
│ │ ├── KeyCodeTranslator.h
│ │ ├── Session.cpp
│ │ ├── Session.h
│ │ ├── compile_shaders.bat
│ │ ├── compile_shaders.py
│ │ ├── imgui_ps_d3d12.hlsl
│ │ ├── imgui_ps_d3d12_fxc.h
│ │ ├── imgui_vs_d3d12.hlsl
│ │ └── imgui_vs_d3d12_fxc.h
│ ├── managedUniformBuffer/
│ │ ├── ManagedUniformBuffer.cpp
│ │ └── ManagedUniformBuffer.h
│ ├── sentinel/
│ │ ├── Assert.h
│ │ ├── Buffer.cpp
│ │ ├── Buffer.h
│ │ ├── CommandBuffer.cpp
│ │ ├── CommandBuffer.h
│ │ ├── CommandQueue.cpp
│ │ ├── CommandQueue.h
│ │ ├── Device.cpp
│ │ ├── Device.h
│ │ ├── Framebuffer.cpp
│ │ ├── Framebuffer.h
│ │ ├── PlatformDevice.cpp
│ │ └── PlatformDevice.h
│ ├── shaderCross/
│ │ ├── ShaderCross.cpp
│ │ ├── ShaderCross.h
│ │ ├── ShaderCrossUniformBuffer.cpp
│ │ └── ShaderCrossUniformBuffer.h
│ ├── simdtypes/
│ │ ├── SimdTypes.h
│ │ └── SimdUtilities.h
│ ├── simple_renderer/
│ │ ├── Drawable.cpp
│ │ ├── Drawable.h
│ │ ├── ForwardRenderPass.cpp
│ │ ├── ForwardRenderPass.h
│ │ ├── Material.cpp
│ │ ├── Material.h
│ │ ├── ParametricVertexData.cpp
│ │ ├── ParametricVertexData.h
│ │ ├── ShaderProgram.cpp
│ │ ├── ShaderProgram.h
│ │ ├── ShaderUniforms.cpp
│ │ ├── ShaderUniforms.h
│ │ ├── VertexData.cpp
│ │ └── VertexData.h
│ ├── state_pool/
│ │ ├── ComputePipelineStatePool.cpp
│ │ ├── ComputePipelineStatePool.h
│ │ ├── DepthStencilStatePool.cpp
│ │ ├── DepthStencilStatePool.h
│ │ ├── RenderPipelineStatePool.cpp
│ │ ├── RenderPipelineStatePool.h
│ │ ├── StatePool.h
│ │ ├── VertexInputStatePool.cpp
│ │ └── VertexInputStatePool.h
│ ├── texture_accessor/
│ │ ├── ITextureAccessor.h
│ │ ├── MetalTextureAccessor.h
│ │ ├── MetalTextureAccessor.mm
│ │ ├── OpenGLTextureAccessor.cpp
│ │ ├── OpenGLTextureAccessor.h
│ │ ├── TextureAccessorFactory.cpp
│ │ ├── TextureAccessorFactory.h
│ │ ├── VulkanTextureAccessor.cpp
│ │ └── VulkanTextureAccessor.h
│ ├── texture_loader/
│ │ ├── DataReader.cpp
│ │ ├── DataReader.h
│ │ ├── IData.cpp
│ │ ├── IData.h
│ │ ├── ITextureLoader.cpp
│ │ ├── ITextureLoader.h
│ │ ├── ITextureLoaderFactory.cpp
│ │ ├── ITextureLoaderFactory.h
│ │ ├── TextureLoaderFactory.cpp
│ │ ├── TextureLoaderFactory.h
│ │ ├── ktx/
│ │ │ ├── TextureLoaderFactory.cpp
│ │ │ └── TextureLoaderFactory.h
│ │ ├── ktx1/
│ │ │ ├── Header.cpp
│ │ │ ├── Header.h
│ │ │ ├── TextureLoaderFactory.cpp
│ │ │ └── TextureLoaderFactory.h
│ │ ├── ktx2/
│ │ │ ├── Header.cpp
│ │ │ ├── Header.h
│ │ │ ├── TextureLoaderFactory.cpp
│ │ │ └── TextureLoaderFactory.h
│ │ ├── stb_hdr/
│ │ │ ├── Header.cpp
│ │ │ ├── Header.h
│ │ │ ├── TextureLoaderFactory.cpp
│ │ │ └── TextureLoaderFactory.h
│ │ ├── stb_image/
│ │ │ ├── TextureLoaderFactory.cpp
│ │ │ └── TextureLoaderFactory.h
│ │ ├── stb_jpeg/
│ │ │ ├── Header.cpp
│ │ │ ├── Header.h
│ │ │ ├── TextureLoaderFactory.cpp
│ │ │ └── TextureLoaderFactory.h
│ │ ├── stb_png/
│ │ │ ├── Header.cpp
│ │ │ ├── Header.h
│ │ │ ├── TextureLoaderFactory.cpp
│ │ │ └── TextureLoaderFactory.h
│ │ └── xtc1/
│ │ ├── Header.cpp
│ │ ├── Header.h
│ │ ├── TextureLoaderFactory.cpp
│ │ └── TextureLoaderFactory.h
│ └── uniform/
│ ├── Collection.cpp
│ ├── Collection.h
│ ├── CollectionEncoder.cpp
│ ├── CollectionEncoder.h
│ ├── Descriptor.cpp
│ ├── Descriptor.h
│ ├── Encoder.cpp
│ ├── Encoder.h
│ └── Trait.h
├── LICENSE.md
├── README.md
├── ROADMAP.md
├── build/
│ └── .gitignore
├── cmake/
│ ├── IGLConfig.cmake.in
│ └── install.cmake
├── deploy_content.py
├── deploy_deps.py
├── docs/
│ ├── .gitignore
│ ├── Makefile
│ ├── README.md
│ ├── make.bat
│ ├── requirements.txt
│ └── source/
│ ├── _extensions/
│ │ └── style.py
│ ├── conf.py
│ ├── data/
│ │ └── placeholder
│ ├── getting-started/
│ │ └── index.md
│ ├── index.md
│ ├── introduction.md
│ ├── theme/
│ │ ├── extra.css
│ │ └── sphinx_literate.css
│ └── video/
│ └── placeholder
├── getting-started.md
├── samples/
│ ├── android/
│ │ ├── opengl/
│ │ │ ├── java/
│ │ │ │ └── com/
│ │ │ │ └── facebook/
│ │ │ │ └── igl/
│ │ │ │ └── sample/
│ │ │ │ ├── AndroidManifest.xml
│ │ │ │ ├── SampleActivity.java
│ │ │ │ ├── SampleLib.java
│ │ │ │ └── SampleView.java
│ │ │ └── jni/
│ │ │ ├── Jni.cpp
│ │ │ ├── TinyRenderer.cpp
│ │ │ └── TinyRenderer.h
│ │ └── vulkan/
│ │ ├── java/
│ │ │ └── com/
│ │ │ └── facebook/
│ │ │ └── igl/
│ │ │ └── sample/
│ │ │ ├── AndroidManifest.xml
│ │ │ └── SampleActivity.java
│ │ └── jni/
│ │ └── Tiny.cpp
│ ├── desktop/
│ │ ├── CMakeLists.txt
│ │ └── Tiny/
│ │ ├── Tiny.cpp
│ │ ├── Tiny_Mesh.cpp
│ │ └── Tiny_MeshLarge.cpp
│ ├── ios/
│ │ └── snapshot_test_support/
│ │ ├── IGLBytesToUIImage.h
│ │ ├── IGLBytesToUIImage.mm
│ │ ├── IGLSnapshotTestCase.h
│ │ ├── IGLSnapshotTestCase.mm
│ │ ├── TinyRenderable.cpp
│ │ └── TinyRenderable.hpp
│ └── wasm/
│ ├── CMakeLists.txt
│ ├── Common.cpp
│ ├── Common.h
│ ├── Tiny_Mesh.cpp
│ ├── Triangle.cpp
│ └── igl.html
├── shell/
│ ├── CMakeLists.txt
│ ├── android/
│ │ ├── CMakeLists.txt
│ │ ├── java/
│ │ │ └── com/
│ │ │ └── facebook/
│ │ │ └── igl/
│ │ │ └── sample/
│ │ │ ├── AndroidManifest.xml
│ │ │ ├── SampleActivity.java
│ │ │ ├── SampleLib.java
│ │ │ ├── SampleView.java
│ │ │ └── VulkanView.java
│ │ └── jni/
│ │ ├── Jni.cpp
│ │ ├── TinyRenderer.cpp
│ │ └── TinyRenderer.h
│ ├── apps/
│ │ └── SessionApp.cpp
│ ├── ios/
│ │ ├── AppDelegate.h
│ │ ├── AppDelegate.mm
│ │ ├── BackendVersion.h
│ │ ├── BackendVersion.mm
│ │ ├── CMakeLists.txt
│ │ ├── IglShellPlatformAdapter.h
│ │ ├── IglShellPlatformAdapterInternal.hpp
│ │ ├── IglSurfaceTexturesAdapter.h
│ │ ├── IglSurfaceTexturesAdapterInternal.hpp
│ │ ├── RenderSessionController.h
│ │ ├── RenderSessionController.mm
│ │ ├── RenderSessionFactoryAdapter.h
│ │ ├── RenderSessionFactoryAdapterInternal.hpp
│ │ ├── RenderSessionFactoryProvider.h
│ │ ├── RenderSessionFactoryProvider.mm
│ │ ├── View.h
│ │ ├── View.m
│ │ ├── ViewController.h
│ │ ├── ViewController.mm
│ │ └── main.mm
│ ├── mac/
│ │ ├── AppDelegate.h
│ │ ├── AppDelegate.mm
│ │ ├── CMakeLists.txt
│ │ ├── GLView.h
│ │ ├── GLView.mm
│ │ ├── HeadlessView.h
│ │ ├── HeadlessView.mm
│ │ ├── MetalView.h
│ │ ├── MetalView.m
│ │ ├── ViewController.h
│ │ ├── ViewController.mm
│ │ ├── VulkanView.h
│ │ ├── VulkanView.mm
│ │ └── main.mm
│ ├── openxr/
│ │ ├── CMakeLists.txt
│ │ ├── XrApp.h
│ │ ├── XrComposition.cpp
│ │ ├── XrComposition.h
│ │ ├── XrCompositionProjection.cpp
│ │ ├── XrCompositionProjection.h
│ │ ├── XrCompositionQuad.cpp
│ │ ├── XrCompositionQuad.h
│ │ ├── XrHands.cpp
│ │ ├── XrHands.h
│ │ ├── XrLog.cpp
│ │ ├── XrLog.h
│ │ ├── XrPassthrough.cpp
│ │ ├── XrPassthrough.h
│ │ ├── XrPlatform.h
│ │ ├── XrRefreshRate.cpp
│ │ ├── XrRefreshRate.h
│ │ ├── XrSwapchainProvider.cpp
│ │ ├── XrSwapchainProvider.h
│ │ ├── impl/
│ │ │ ├── XrAppImpl.h
│ │ │ └── XrSwapchainProviderImpl.h
│ │ └── mobile/
│ │ ├── AndroidMain.cpp
│ │ ├── XrApp.cpp
│ │ ├── java/
│ │ │ └── com/
│ │ │ └── facebook/
│ │ │ └── igl/
│ │ │ └── shell/
│ │ │ └── openxr/
│ │ │ ├── gles/
│ │ │ │ ├── AndroidManifest.xml
│ │ │ │ └── MainActivity.java
│ │ │ └── vulkan/
│ │ │ ├── AndroidManifest.xml
│ │ │ └── MainActivity.java
│ │ ├── opengl/
│ │ │ ├── XrAppImplGLES.cpp
│ │ │ ├── XrAppImplGLES.h
│ │ │ ├── XrSwapchainProviderImplGLES.cpp
│ │ │ └── XrSwapchainProviderImplGLES.h
│ │ └── vulkan/
│ │ ├── XrAppImplVulkan.cpp
│ │ ├── XrAppImplVulkan.h
│ │ ├── XrSwapchainProviderImplVulkan.cpp
│ │ └── XrSwapchainProviderImplVulkan.h
│ ├── renderSessionTests/
│ │ ├── BasicFramebufferTests.cpp
│ │ └── IGLSampleTests.cpp
│ ├── renderSessions/
│ │ ├── BasicFramebufferSession.cpp
│ │ ├── BasicFramebufferSession.h
│ │ ├── BindGroupSession.cpp
│ │ ├── BindGroupSession.h
│ │ ├── BindlessBufferSession.cpp
│ │ ├── BindlessBufferSession.h
│ │ ├── BufferMappingSession.cpp
│ │ ├── BufferMappingSession.h
│ │ ├── CheckerboardMipmapSession.cpp
│ │ ├── CheckerboardMipmapSession.h
│ │ ├── ColorSession.cpp
│ │ ├── ColorSession.h
│ │ ├── CopyOperationsSession.cpp
│ │ ├── CopyOperationsSession.h
│ │ ├── DepthBiasSession.cpp
│ │ ├── DepthBiasSession.h
│ │ ├── DrawInstancedSession.cpp
│ │ ├── DrawInstancedSession.h
│ │ ├── EmptySession.cpp
│ │ ├── EmptySession.h
│ │ ├── FireworksSession.cpp
│ │ ├── FireworksSession.h
│ │ ├── GPUStressSession.cpp
│ │ ├── GPUStressSession.h
│ │ ├── GPUTimerSession.cpp
│ │ ├── GPUTimerSession.h
│ │ ├── HandsOpenXRSession.cpp
│ │ ├── HandsOpenXRSession.h
│ │ ├── HelloOpenXRSession.cpp
│ │ ├── HelloOpenXRSession.h
│ │ ├── HelloWorldSession.cpp
│ │ ├── HelloWorldSession.h
│ │ ├── ImguiSession.cpp
│ │ ├── ImguiSession.h
│ │ ├── MRTSession.cpp
│ │ ├── MRTSession.h
│ │ ├── MeshShaderTriangleSession.cpp
│ │ ├── MeshShaderTriangleSession.h
│ │ ├── MultiDrawIndexedIndirectSession.cpp
│ │ ├── MultiDrawIndexedIndirectSession.h
│ │ ├── ScissorTestSession.cpp
│ │ ├── ScissorTestSession.h
│ │ ├── StencilOutlineSession.cpp
│ │ ├── StencilOutlineSession.h
│ │ ├── TQMultiRenderPassSession.cpp
│ │ ├── TQMultiRenderPassSession.h
│ │ ├── TQSession.cpp
│ │ ├── TQSession.h
│ │ ├── TextureViewSession.cpp
│ │ ├── TextureViewSession.h
│ │ ├── Textured3DCubeSession.cpp
│ │ ├── Textured3DCubeSession.h
│ │ ├── TinyMeshBindGroupSession.cpp
│ │ ├── TinyMeshBindGroupSession.h
│ │ ├── TinyMeshSession.cpp
│ │ ├── TinyMeshSession.h
│ │ ├── WireframeSession.cpp
│ │ ├── WireframeSession.h
│ │ ├── YUVColorSession.cpp
│ │ └── YUVColorSession.h
│ ├── resources/
│ │ ├── images/
│ │ │ ├── macbeth.ktx
│ │ │ ├── macbeth.ktx2
│ │ │ ├── output_frame_900.420p.txt
│ │ │ ├── output_frame_900.420p.yuv
│ │ │ ├── output_frame_900.nv12.txt
│ │ │ └── output_frame_900.nv12.yuv
│ │ ├── mac/
│ │ │ ├── Assets.xcassets/
│ │ │ │ ├── AppIcon.appiconset/
│ │ │ │ │ └── Contents.json
│ │ │ │ └── Contents.json
│ │ │ ├── Base.lproj/
│ │ │ │ └── MainMenu.xib
│ │ │ ├── Entitlements.plist
│ │ │ └── Info.plist
│ │ ├── models/
│ │ │ └── DamagedHelmet.gltf
│ │ └── shaders/
│ │ ├── ShaderLibraryTest-ios.metallib
│ │ ├── ShaderLibraryTest-macos.metallib
│ │ └── ShaderLibraryTest.metal
│ ├── shared/
│ │ ├── extension/
│ │ │ ├── Extension.h
│ │ │ ├── ExtensionLoader.cpp
│ │ │ ├── ExtensionLoader.h
│ │ │ ├── SymbolFactoryLoader.cpp
│ │ │ └── SymbolFactoryLoader.h
│ │ ├── fileLoader/
│ │ │ ├── FileLoader.cpp
│ │ │ ├── FileLoader.h
│ │ │ ├── android/
│ │ │ │ ├── FileLoaderAndroid.cpp
│ │ │ │ └── FileLoaderAndroid.h
│ │ │ ├── apple/
│ │ │ │ ├── FileLoaderApple.h
│ │ │ │ └── FileLoaderApple.mm
│ │ │ ├── linux/
│ │ │ │ ├── FileLoaderLinux.cpp
│ │ │ │ └── FileLoaderLinux.h
│ │ │ └── win/
│ │ │ ├── FileLoaderWin.cpp
│ │ │ └── FileLoaderWin.h
│ │ ├── imageLoader/
│ │ │ ├── ImageLoader.cpp
│ │ │ ├── ImageLoader.h
│ │ │ └── tests/
│ │ │ └── ImageLoaderTest.cpp
│ │ ├── imageWriter/
│ │ │ ├── ImageWriter.h
│ │ │ ├── android/
│ │ │ │ └── ImageWriterAndroid.h
│ │ │ ├── ios/
│ │ │ │ ├── ImageWriterIos.h
│ │ │ │ └── ImageWriterIos.mm
│ │ │ ├── linux/
│ │ │ │ └── ImageWriterLinux.h
│ │ │ ├── mac/
│ │ │ │ └── ImageWriterMac.h
│ │ │ ├── stb/
│ │ │ │ ├── ImageWriterSTB.cpp
│ │ │ │ └── ImageWriterSTB.h
│ │ │ └── win/
│ │ │ └── ImageWriterWin.h
│ │ ├── input/
│ │ │ ├── InputDispatcher.cpp
│ │ │ ├── InputDispatcher.h
│ │ │ ├── IntentListener.h
│ │ │ ├── KeyListener.h
│ │ │ ├── MouseListener.h
│ │ │ ├── RayListener.h
│ │ │ └── TouchListener.h
│ │ ├── netservice/
│ │ │ ├── NetService.h
│ │ │ ├── NetServiceExtension.cpp
│ │ │ ├── NetServiceExtension.h
│ │ │ ├── NetServiceFactory.h
│ │ │ ├── Stream.h
│ │ │ ├── apple/
│ │ │ │ ├── NetServiceApple.h
│ │ │ │ ├── NetServiceApple.mm
│ │ │ │ ├── NetServiceExtensionApple.h
│ │ │ │ ├── NetServiceExtensionApple.mm
│ │ │ │ ├── StreamApple.h
│ │ │ │ └── StreamApple.mm
│ │ │ └── zeromq/
│ │ │ ├── NetServiceExtensionZeroMQ.h
│ │ │ ├── NetServiceZeroMQ.h
│ │ │ └── StreamZeroMQ.h
│ │ ├── platform/
│ │ │ ├── DisplayContext.h
│ │ │ ├── Factory.cpp
│ │ │ ├── Factory.h
│ │ │ ├── Platform.cpp
│ │ │ ├── Platform.h
│ │ │ ├── android/
│ │ │ │ ├── PlatformAndroid.cpp
│ │ │ │ └── PlatformAndroid.h
│ │ │ ├── ios/
│ │ │ │ ├── PlatformIos.h
│ │ │ │ └── PlatformIos.mm
│ │ │ ├── linux/
│ │ │ │ ├── PlatformLinux.cpp
│ │ │ │ └── PlatformLinux.h
│ │ │ ├── mac/
│ │ │ │ ├── PlatformMac.cpp
│ │ │ │ └── PlatformMac.h
│ │ │ └── win/
│ │ │ ├── PlatformWin.cpp
│ │ │ └── PlatformWin.h
│ │ ├── renderSession/
│ │ │ ├── AppParams.h
│ │ │ ├── BenchmarkTracker.cpp
│ │ │ ├── BenchmarkTracker.h
│ │ │ ├── DefaultRenderSessionFactory.h
│ │ │ ├── DefaultSession.h
│ │ │ ├── DepthParams.h
│ │ │ ├── Fov.h
│ │ │ ├── Hands.h
│ │ │ ├── IRenderSessionFactory.h
│ │ │ ├── QuadLayerParams.h
│ │ │ ├── RenderMode.h
│ │ │ ├── RenderSession.cpp
│ │ │ ├── RenderSession.h
│ │ │ ├── RenderSessionConfig.h
│ │ │ ├── RenderSessionLoader.hpp
│ │ │ ├── RenderSessionRegistry.cpp
│ │ │ ├── RenderSessionRegistry.hpp
│ │ │ ├── RenderSessionWindowConfig.h
│ │ │ ├── ScreenshotTestRenderSessionHelper.cpp
│ │ │ ├── ScreenshotTestRenderSessionHelper.h
│ │ │ ├── ShaderProvider.h
│ │ │ ├── ShaderStagesCreator.cpp
│ │ │ ├── ShaderStagesCreator.h
│ │ │ ├── ShellParams.cpp
│ │ │ ├── ShellParams.h
│ │ │ ├── ShellType.h
│ │ │ └── ViewParams.h
│ │ └── testShell/
│ │ ├── TestShell.cpp
│ │ └── TestShell.h
│ └── windows/
│ ├── CMakeLists.txt
│ ├── common/
│ │ ├── GlfwShell.cpp
│ │ └── GlfwShell.h
│ ├── d3d12/
│ │ └── App.cpp
│ ├── opengl/
│ │ ├── App.cpp
│ │ └── AutoContextReleaseDevice.h
│ ├── opengles/
│ │ └── App.cpp
│ └── vulkan/
│ └── App.cpp
├── src/
│ └── igl/
│ ├── Assert.cpp
│ ├── Assert.h
│ ├── Buffer.h
│ ├── CMakeLists.txt
│ ├── Color.h
│ ├── ColorSpace.h
│ ├── CommandBuffer.h
│ ├── CommandEncoder.h
│ ├── CommandQueue.h
│ ├── Common.cpp
│ ├── Common.h
│ ├── ComputeCommandEncoder.h
│ ├── ComputePipelineState.h
│ ├── Config.h
│ ├── Core.h
│ ├── DebugMacros.h
│ ├── DepthStencilState.cpp
│ ├── DepthStencilState.h
│ ├── Device.cpp
│ ├── Device.h
│ ├── DeviceFeatures.h
│ ├── FPSCounter.h
│ ├── Format.h
│ ├── Framebuffer.h
│ ├── FramebufferWrapper.cpp
│ ├── FramebufferWrapper.h
│ ├── HWDevice.h
│ ├── IGL.h
│ ├── IGLFolly.h
│ ├── IGLSafeC.h
│ ├── IResourceTracker.h
│ ├── ITrackedResource.h
│ ├── Log.cpp
│ ├── Log.h
│ ├── Macros.h
│ ├── NameHandle.cpp
│ ├── NameHandle.h
│ ├── PlatformDevice.h
│ ├── RenderCommandEncoder.h
│ ├── RenderPass.h
│ ├── RenderPipelineReflection.h
│ ├── RenderPipelineState.cpp
│ ├── RenderPipelineState.h
│ ├── SamplerState.cpp
│ ├── SamplerState.h
│ ├── Shader.cpp
│ ├── Shader.h
│ ├── ShaderCreator.cpp
│ ├── ShaderCreator.h
│ ├── Texture.cpp
│ ├── Texture.h
│ ├── TextureFormat.h
│ ├── Timer.h
│ ├── TimestampQueries.h
│ ├── Uniform.cpp
│ ├── Uniform.h
│ ├── VertexInputState.cpp
│ ├── VertexInputState.h
│ ├── android/
│ │ ├── LogDefault.cpp
│ │ ├── LogDefault.h
│ │ ├── NativeHWBuffer.cpp
│ │ └── NativeHWBuffer.h
│ ├── apple/
│ │ ├── LogDefault.cpp
│ │ └── LogDefault.h
│ ├── base/
│ │ ├── Common.h
│ │ ├── IAttachmentInterop.h
│ │ ├── IDeviceBase.h
│ │ ├── IFramebufferInterop.h
│ │ └── IStagingBufferInterop.h
│ ├── d3d12/
│ │ ├── Buffer.cpp
│ │ ├── Buffer.h
│ │ ├── CMakeLists.txt
│ │ ├── CommandBuffer.cpp
│ │ ├── CommandBuffer.h
│ │ ├── CommandQueue.cpp
│ │ ├── CommandQueue.h
│ │ ├── Common.cpp
│ │ ├── Common.h
│ │ ├── ComputeCommandEncoder.cpp
│ │ ├── ComputeCommandEncoder.h
│ │ ├── ComputePipelineState.cpp
│ │ ├── ComputePipelineState.h
│ │ ├── D3D12AllocatorPool.cpp
│ │ ├── D3D12AllocatorPool.h
│ │ ├── D3D12Context.cpp
│ │ ├── D3D12Context.h
│ │ ├── D3D12DeviceCapabilities.cpp
│ │ ├── D3D12DeviceCapabilities.h
│ │ ├── D3D12FenceWaiter.cpp
│ │ ├── D3D12FenceWaiter.h
│ │ ├── D3D12FrameManager.cpp
│ │ ├── D3D12FrameManager.h
│ │ ├── D3D12Headers.h
│ │ ├── D3D12ImmediateCommands.cpp
│ │ ├── D3D12ImmediateCommands.h
│ │ ├── D3D12PipelineBuilder.cpp
│ │ ├── D3D12PipelineBuilder.h
│ │ ├── D3D12PipelineCache.cpp
│ │ ├── D3D12PipelineCache.h
│ │ ├── D3D12PresentManager.cpp
│ │ ├── D3D12PresentManager.h
│ │ ├── D3D12ReflectionUtils.cpp
│ │ ├── D3D12ReflectionUtils.h
│ │ ├── D3D12ResourcesBinder.cpp
│ │ ├── D3D12ResourcesBinder.h
│ │ ├── D3D12RootSignatureKey.h
│ │ ├── D3D12SamplerCache.h
│ │ ├── D3D12StagingDevice.cpp
│ │ ├── D3D12StagingDevice.h
│ │ ├── D3D12StateTransition.h
│ │ ├── D3D12Telemetry.h
│ │ ├── DXCCompiler.cpp
│ │ ├── DXCCompiler.h
│ │ ├── DepthStencilState.h
│ │ ├── DescriptorHeapManager.cpp
│ │ ├── DescriptorHeapManager.h
│ │ ├── Device.cpp
│ │ ├── Device.h
│ │ ├── Framebuffer.cpp
│ │ ├── Framebuffer.h
│ │ ├── HeadlessContext.cpp
│ │ ├── HeadlessContext.h
│ │ ├── PlatformDevice.cpp
│ │ ├── PlatformDevice.h
│ │ ├── RenderCommandEncoder.cpp
│ │ ├── RenderCommandEncoder.h
│ │ ├── RenderPipelineState.cpp
│ │ ├── RenderPipelineState.h
│ │ ├── SamplerState.cpp
│ │ ├── SamplerState.h
│ │ ├── ShaderModule.cpp
│ │ ├── ShaderModule.h
│ │ ├── Texture.cpp
│ │ ├── Texture.h
│ │ ├── TextureCopyUtils.cpp
│ │ ├── TextureCopyUtils.h
│ │ ├── Timer.cpp
│ │ ├── Timer.h
│ │ ├── UploadRingBuffer.cpp
│ │ ├── UploadRingBuffer.h
│ │ └── VertexInputState.h
│ ├── glslang/
│ │ ├── CMakeLists.txt
│ │ ├── GlslCompiler.cpp
│ │ ├── GlslCompiler.h
│ │ ├── GlslangHelpers.c
│ │ └── GlslangHelpers.h
│ ├── metal/
│ │ ├── Buffer.h
│ │ ├── Buffer.mm
│ │ ├── BufferSynchronizationManager.h
│ │ ├── BufferSynchronizationManager.mm
│ │ ├── CMakeLists.txt
│ │ ├── ColorSpace.h
│ │ ├── ColorSpace.mm
│ │ ├── CommandBuffer.h
│ │ ├── CommandBuffer.mm
│ │ ├── CommandQueue.h
│ │ ├── CommandQueue.mm
│ │ ├── ComputeCommandEncoder.h
│ │ ├── ComputeCommandEncoder.mm
│ │ ├── ComputePipelineState.h
│ │ ├── ComputePipelineState.mm
│ │ ├── DepthStencilState.h
│ │ ├── DepthStencilState.mm
│ │ ├── Device.h
│ │ ├── Device.mm
│ │ ├── DeviceFeatureSet.h
│ │ ├── DeviceFeatureSet.mm
│ │ ├── DeviceStatistics.h
│ │ ├── DeviceStatistics.mm
│ │ ├── Framebuffer.h
│ │ ├── Framebuffer.mm
│ │ ├── HWDevice.h
│ │ ├── HWDevice.mm
│ │ ├── PlatformDevice.h
│ │ ├── PlatformDevice.mm
│ │ ├── RenderCommandEncoder.h
│ │ ├── RenderCommandEncoder.mm
│ │ ├── RenderPipelineReflection.h
│ │ ├── RenderPipelineReflection.mm
│ │ ├── RenderPipelineState.h
│ │ ├── RenderPipelineState.mm
│ │ ├── Result.h
│ │ ├── SamplerState.h
│ │ ├── SamplerState.mm
│ │ ├── Shader.h
│ │ ├── Shader.mm
│ │ ├── Texture.h
│ │ ├── Texture.mm
│ │ ├── Timer.h
│ │ ├── TimestampQueries.h
│ │ ├── TimestampQueries.mm
│ │ ├── VertexInputState.h
│ │ ├── VertexInputState.mm
│ │ ├── ios/
│ │ │ ├── Device.h
│ │ │ ├── Device.mm
│ │ │ ├── Framebuffer.h
│ │ │ └── Framebuffer.mm
│ │ └── macos/
│ │ ├── Device.h
│ │ ├── Device.mm
│ │ ├── Framebuffer.h
│ │ └── Framebuffer.mm
│ ├── opengl/
│ │ ├── Buffer.cpp
│ │ ├── Buffer.h
│ │ ├── CMakeLists.txt
│ │ ├── CommandBuffer.cpp
│ │ ├── CommandBuffer.h
│ │ ├── CommandQueue.cpp
│ │ ├── CommandQueue.h
│ │ ├── ComputeCommandAdapter.cpp
│ │ ├── ComputeCommandAdapter.h
│ │ ├── ComputeCommandEncoder.cpp
│ │ ├── ComputeCommandEncoder.h
│ │ ├── ComputePipelineState.cpp
│ │ ├── ComputePipelineState.h
│ │ ├── Config.h
│ │ ├── DepthStencilState.cpp
│ │ ├── DepthStencilState.h
│ │ ├── DestructionGuard.cpp
│ │ ├── DestructionGuard.h
│ │ ├── Device.cpp
│ │ ├── Device.h
│ │ ├── DeviceFeatureSet.cpp
│ │ ├── DeviceFeatureSet.h
│ │ ├── DummyTexture.h
│ │ ├── Framebuffer.cpp
│ │ ├── Framebuffer.h
│ │ ├── FramebufferWrapper.h
│ │ ├── GLFunc.cpp
│ │ ├── GLFunc.h
│ │ ├── GLIncludes.h
│ │ ├── HWDevice.cpp
│ │ ├── HWDevice.h
│ │ ├── IContext.cpp
│ │ ├── IContext.h
│ │ ├── PlatformDevice.cpp
│ │ ├── PlatformDevice.h
│ │ ├── RenderCommandAdapter.cpp
│ │ ├── RenderCommandAdapter.h
│ │ ├── RenderCommandEncoder.cpp
│ │ ├── RenderCommandEncoder.h
│ │ ├── RenderPipelineReflection.cpp
│ │ ├── RenderPipelineReflection.h
│ │ ├── RenderPipelineState.cpp
│ │ ├── RenderPipelineState.h
│ │ ├── SamplerState.cpp
│ │ ├── SamplerState.h
│ │ ├── Shader.cpp
│ │ ├── Shader.h
│ │ ├── Texture.cpp
│ │ ├── Texture.h
│ │ ├── TextureBuffer.cpp
│ │ ├── TextureBuffer.h
│ │ ├── TextureBufferBase.cpp
│ │ ├── TextureBufferBase.h
│ │ ├── TextureBufferExternal.cpp
│ │ ├── TextureBufferExternal.h
│ │ ├── TextureTarget.cpp
│ │ ├── TextureTarget.h
│ │ ├── Timer.cpp
│ │ ├── Timer.h
│ │ ├── TimestampQueries.cpp
│ │ ├── TimestampQueries.h
│ │ ├── UnbindPolicy.h
│ │ ├── UniformAdapter.cpp
│ │ ├── UniformAdapter.h
│ │ ├── UniformBuffer.cpp
│ │ ├── UniformBuffer.h
│ │ ├── Version.cpp
│ │ ├── Version.h
│ │ ├── VertexArrayObject.cpp
│ │ ├── VertexArrayObject.h
│ │ ├── VertexInputState.cpp
│ │ ├── VertexInputState.h
│ │ ├── ViewTextureTarget.cpp
│ │ ├── ViewTextureTarget.h
│ │ ├── WithContext.cpp
│ │ ├── WithContext.h
│ │ ├── egl/
│ │ │ ├── Context.cpp
│ │ │ ├── Context.h
│ │ │ ├── Device.cpp
│ │ │ ├── Device.h
│ │ │ ├── HWDevice.cpp
│ │ │ ├── HWDevice.h
│ │ │ ├── PlatformDevice.cpp
│ │ │ ├── PlatformDevice.h
│ │ │ └── android/
│ │ │ ├── NativeHWBuffer.cpp
│ │ │ └── NativeHWBuffer.h
│ │ ├── empty/
│ │ │ ├── Context.cpp
│ │ │ ├── Context.h
│ │ │ ├── Device.cpp
│ │ │ ├── Device.h
│ │ │ ├── HWDevice.cpp
│ │ │ └── HWDevice.h
│ │ ├── glx/
│ │ │ ├── Context.cpp
│ │ │ ├── Context.h
│ │ │ ├── Device.cpp
│ │ │ ├── Device.h
│ │ │ ├── HWDevice.cpp
│ │ │ ├── HWDevice.h
│ │ │ ├── PlatformDevice.cpp
│ │ │ └── PlatformDevice.h
│ │ ├── ios/
│ │ │ ├── Context.h
│ │ │ ├── Context.mm
│ │ │ ├── Device.h
│ │ │ ├── Device.mm
│ │ │ ├── HWDevice.h
│ │ │ ├── HWDevice.mm
│ │ │ ├── PlatformDevice.h
│ │ │ ├── PlatformDevice.mm
│ │ │ ├── TextureBuffer.h
│ │ │ └── TextureBuffer.mm
│ │ ├── macos/
│ │ │ ├── Context.h
│ │ │ ├── Context.mm
│ │ │ ├── Device.h
│ │ │ ├── Device.mm
│ │ │ ├── HWDevice.h
│ │ │ ├── HWDevice.mm
│ │ │ ├── PlatformDevice.h
│ │ │ ├── PlatformDevice.mm
│ │ │ ├── TextureBuffer.h
│ │ │ └── TextureBuffer.mm
│ │ ├── util/
│ │ │ ├── TextureFormat.cpp
│ │ │ └── TextureFormat.h
│ │ ├── webgl/
│ │ │ ├── Context.cpp
│ │ │ ├── Context.h
│ │ │ ├── Device.cpp
│ │ │ ├── Device.h
│ │ │ ├── HWDevice.cpp
│ │ │ ├── HWDevice.h
│ │ │ ├── PlatformDevice.cpp
│ │ │ └── PlatformDevice.h
│ │ └── wgl/
│ │ ├── Context.cpp
│ │ ├── Context.h
│ │ ├── Device.cpp
│ │ ├── Device.h
│ │ ├── HWDevice.cpp
│ │ ├── HWDevice.h
│ │ ├── PlatformDevice.cpp
│ │ └── PlatformDevice.h
│ ├── tests/
│ │ ├── Assert.cpp
│ │ ├── Backend.cpp
│ │ ├── Blending.cpp
│ │ ├── Buffer.cpp
│ │ ├── CMakeLists.txt
│ │ ├── Color.cpp
│ │ ├── ColorSpace.cpp
│ │ ├── CommandBuffer.cpp
│ │ ├── Common.cpp
│ │ ├── ComputeCommandEncoder.cpp
│ │ ├── Device.cpp
│ │ ├── DeviceFeatureSet.cpp
│ │ ├── Framebuffer.cpp
│ │ ├── FramebufferInterop.cpp
│ │ ├── Hash.cpp
│ │ ├── IglTestsTSANSuppressions.txt
│ │ ├── Log.cpp
│ │ ├── Multiview.cpp
│ │ ├── NameHandleTests.cpp
│ │ ├── RenderCommandEncoder.cpp
│ │ ├── Resource.cpp
│ │ ├── ShaderLibrary.cpp
│ │ ├── ShaderModule.cpp
│ │ ├── Texture.cpp
│ │ ├── Texture.h
│ │ ├── TextureArray.cpp
│ │ ├── TextureArrayFloat.cpp
│ │ ├── TextureCube.cpp
│ │ ├── TextureFloat.cpp
│ │ ├── TextureFormat.cpp
│ │ ├── TextureFormatProperties.cpp
│ │ ├── TextureHalfFloat.cpp
│ │ ├── TextureMipmap.cpp
│ │ ├── TextureRangeDesc.cpp
│ │ ├── TexturesRGB.cpp
│ │ ├── VertexInputState.cpp
│ │ ├── android/
│ │ │ └── NativeHWBuffer.cpp
│ │ ├── data/
│ │ │ ├── ShaderData.h
│ │ │ ├── TextureData.h
│ │ │ └── VertexIndexData.h
│ │ ├── iglu/
│ │ │ ├── ManagedUniformBuffer.cpp
│ │ │ ├── ShaderCrossTest.cpp
│ │ │ ├── ShaderUniformsTest.cpp
│ │ │ ├── StatePool.cpp
│ │ │ ├── TextureAccessor.cpp
│ │ │ ├── UniformCollection.cpp
│ │ │ ├── UniformDescriptor.cpp
│ │ │ ├── UniformTests.h
│ │ │ ├── bitmap/
│ │ │ │ └── BitmapWriterTest.cpp
│ │ │ └── texture_loader/
│ │ │ ├── BaseTextureLoader.cpp
│ │ │ ├── IDataTest.cpp
│ │ │ ├── Ktx1TextureLoaderTest.cpp
│ │ │ ├── Ktx2TextureLoaderTest.cpp
│ │ │ ├── StbHdrTextureLoaderTest.cpp
│ │ │ ├── StbJpegTextureLoaderTest.cpp
│ │ │ ├── StbPngTextureLoaderTest.cpp
│ │ │ ├── TextureLoaderFactoryTest.cpp
│ │ │ └── Xtc1TextureLoaderTest.cpp
│ │ ├── main.cpp
│ │ ├── metal/
│ │ │ ├── BindGroup.mm
│ │ │ ├── Buffer.mm
│ │ │ ├── BufferSynchronizationManager.mm
│ │ │ ├── BytesBinding.mm
│ │ │ ├── ColorSpace.mm
│ │ │ ├── CommandBuffer.mm
│ │ │ ├── CommandBufferOps.mm
│ │ │ ├── CommandQueue.mm
│ │ │ ├── ComputeCommandEncoder.mm
│ │ │ ├── ComputePipelineState.mm
│ │ │ ├── DepthStencilCreation.mm
│ │ │ ├── DepthStencilState.mm
│ │ │ ├── Device.mm
│ │ │ ├── DeviceFeatureSet.mm
│ │ │ ├── DeviceStatistics.mm
│ │ │ ├── DrawCall.mm
│ │ │ ├── ErrorPaths.mm
│ │ │ ├── Framebuffer.mm
│ │ │ ├── HWDevice.mm
│ │ │ ├── IndirectDraw.mm
│ │ │ ├── MeshShader.mm
│ │ │ ├── PlatformDevice.mm
│ │ │ ├── RenderCommandEncoder.mm
│ │ │ ├── RenderEncoderState.mm
│ │ │ ├── RenderPass.mm
│ │ │ ├── RenderPipelineCreation.mm
│ │ │ ├── RenderPipelineReflection.mm
│ │ │ ├── RenderPipelineState.mm
│ │ │ ├── SamplerCreation.mm
│ │ │ ├── SamplerState.mm
│ │ │ ├── ShaderLibrary.mm
│ │ │ ├── StorageMode.mm
│ │ │ ├── Texture.mm
│ │ │ ├── TextureDataRoundtrip.mm
│ │ │ ├── Timer.mm
│ │ │ └── VertexInputState.mm
│ │ ├── ogl/
│ │ │ ├── BindlessTextures.cpp
│ │ │ ├── BlendModeConversion.cpp
│ │ │ ├── BufferMapping.cpp
│ │ │ ├── CommandBufferOGL.cpp
│ │ │ ├── CompressedTexture.cpp
│ │ │ ├── ComputeCommandAdapter.cpp
│ │ │ ├── ComputePipelineStateOGL.cpp
│ │ │ ├── Context.cpp
│ │ │ ├── CopyTexSubImage.cpp
│ │ │ ├── CubeMapAttachment.cpp
│ │ │ ├── DebugOutput.cpp
│ │ │ ├── DepthRange.cpp
│ │ │ ├── DepthStencilState.cpp
│ │ │ ├── DestructionGuard.cpp
│ │ │ ├── Device.cpp
│ │ │ ├── DeviceFeatureSetFull.cpp
│ │ │ ├── ExtensionDetection.cpp
│ │ │ ├── FeatureLimits.cpp
│ │ │ ├── FramebufferBlit.cpp
│ │ │ ├── HWDevice.cpp
│ │ │ ├── ImageLoadStore.cpp
│ │ │ ├── InvalidateFramebuffer.cpp
│ │ │ ├── MSAATextureAttachment.cpp
│ │ │ ├── Memcpy.cpp
│ │ │ ├── MemoryObjectImport.cpp
│ │ │ ├── MultiviewFramebuffer.cpp
│ │ │ ├── PipelineState.cpp
│ │ │ ├── PlatformDevice.cpp
│ │ │ ├── RenderCommandAdapter.cpp
│ │ │ ├── RenderPipelineReflection.cpp
│ │ │ ├── RenderStateApplication.cpp
│ │ │ ├── Resource.cpp
│ │ │ ├── SRGBWriteControl.cpp
│ │ │ ├── SamplerState.cpp
│ │ │ ├── SyncObjects.cpp
│ │ │ ├── Texture.cpp
│ │ │ ├── Texture3D.cpp
│ │ │ ├── TextureBuffer.cpp
│ │ │ ├── TextureBufferBase.cpp
│ │ │ ├── TextureTarget.cpp
│ │ │ ├── Timer.cpp
│ │ │ ├── UniformAdapter.cpp
│ │ │ ├── UniformBlockBuffer.cpp
│ │ │ ├── UniformBuffer.cpp
│ │ │ ├── Version.cpp
│ │ │ ├── VertexArrayObjectOGL.cpp
│ │ │ ├── VertexInputState.cpp
│ │ │ ├── ViewTextureTarget.cpp
│ │ │ ├── ios/
│ │ │ │ └── TextureBuffer.mm
│ │ │ └── macos/
│ │ │ └── TextureBuffer.mm
│ │ ├── util/
│ │ │ ├── Color.h
│ │ │ ├── Common.cpp
│ │ │ ├── Common.h
│ │ │ ├── Half.h
│ │ │ ├── SpvModules.cpp
│ │ │ ├── SpvModules.h
│ │ │ ├── TestDevice.cpp
│ │ │ ├── TestDevice.h
│ │ │ ├── TestErrorGuard.cpp
│ │ │ ├── TestErrorGuard.h
│ │ │ ├── TextureFormatTestBase.cpp
│ │ │ ├── TextureFormatTestBase.h
│ │ │ ├── TextureValidationHelpers.h
│ │ │ ├── device/
│ │ │ │ ├── MetalTestDevice.h
│ │ │ │ ├── MetalTestDevice.mm
│ │ │ │ ├── TestDevice.cpp
│ │ │ │ ├── TestDevice.h
│ │ │ │ ├── d3d12/
│ │ │ │ │ ├── TestDevice.cpp
│ │ │ │ │ └── TestDevice.h
│ │ │ │ ├── metal/
│ │ │ │ │ ├── TestDevice.h
│ │ │ │ │ └── TestDevice.mm
│ │ │ │ ├── opengl/
│ │ │ │ │ ├── TestDevice.cpp
│ │ │ │ │ └── TestDevice.h
│ │ │ │ └── vulkan/
│ │ │ │ ├── TestDevice.cpp
│ │ │ │ └── TestDevice.h
│ │ │ └── simdstub.h
│ │ └── vulkan/
│ │ ├── ColorSpace.cpp
│ │ ├── CommandBufferVulkanTest.cpp
│ │ ├── CommonTest.cpp
│ │ ├── ComputeCommandEncoderVulkanTest.cpp
│ │ ├── DescriptorPoolArenaTest.cpp
│ │ ├── Device.cpp
│ │ ├── DeviceExtendedVulkanTest.cpp
│ │ ├── FramebufferVulkanTest.cpp
│ │ ├── ImageLayoutTransitionTest.cpp
│ │ ├── PipelineStateTest.cpp
│ │ ├── RenderCommandEncoderVulkanTest.cpp
│ │ ├── RenderPipelineStateTest.cpp
│ │ ├── ResourcesBinderTest.cpp
│ │ ├── SpvConstantSpecializationExtendedTest.cpp
│ │ ├── SpvConstantSpecializationTest.cpp
│ │ ├── SpvReflectionTest.cpp
│ │ ├── Texture.cpp
│ │ ├── TextureFormat.cpp
│ │ ├── TextureVulkanExtendedTest.cpp
│ │ ├── VulkanBufferTest.cpp
│ │ ├── VulkanContextExtendedTest.cpp
│ │ ├── VulkanDescriptorSetLayoutTest.cpp
│ │ ├── VulkanFeaturesTest.cpp
│ │ ├── VulkanFenceTest.cpp
│ │ ├── VulkanHelpersTest.cpp
│ │ ├── VulkanImageTest.cpp
│ │ ├── VulkanImageViewTest.cpp
│ │ ├── VulkanImmediateCommandsTest.cpp
│ │ ├── VulkanPipelineBuilderTest.cpp
│ │ ├── VulkanQueuePool.cpp
│ │ ├── VulkanRenderPassBuilderTest.cpp
│ │ ├── VulkanSemaphoreExtendedTest.cpp
│ │ ├── VulkanStagingDeviceTest.cpp
│ │ ├── VulkanSwapchainExtendedTest.cpp
│ │ └── VulkanSwapchainTest.cpp
│ ├── vulkan/
│ │ ├── Buffer.cpp
│ │ ├── Buffer.h
│ │ ├── CMakeLists.txt
│ │ ├── CommandBuffer.cpp
│ │ ├── CommandBuffer.h
│ │ ├── CommandQueue.cpp
│ │ ├── CommandQueue.h
│ │ ├── Common.cpp
│ │ ├── Common.h
│ │ ├── ComputeCommandEncoder.cpp
│ │ ├── ComputeCommandEncoder.h
│ │ ├── ComputePipelineState.cpp
│ │ ├── ComputePipelineState.h
│ │ ├── Device.cpp
│ │ ├── Device.h
│ │ ├── Framebuffer.cpp
│ │ ├── Framebuffer.h
│ │ ├── HWDevice.cpp
│ │ ├── HWDevice.h
│ │ ├── PipelineState.cpp
│ │ ├── PipelineState.h
│ │ ├── PlatformDevice.cpp
│ │ ├── PlatformDevice.h
│ │ ├── RenderCommandEncoder.cpp
│ │ ├── RenderCommandEncoder.h
│ │ ├── RenderPipelineReflection.cpp
│ │ ├── RenderPipelineReflection.h
│ │ ├── RenderPipelineState.cpp
│ │ ├── RenderPipelineState.h
│ │ ├── ResourcesBinder.cpp
│ │ ├── ResourcesBinder.h
│ │ ├── SamplerState.cpp
│ │ ├── SamplerState.h
│ │ ├── ShaderModule.cpp
│ │ ├── ShaderModule.h
│ │ ├── Texture.cpp
│ │ ├── Texture.h
│ │ ├── VulkanBuffer.cpp
│ │ ├── VulkanBuffer.h
│ │ ├── VulkanContext.cpp
│ │ ├── VulkanContext.h
│ │ ├── VulkanDescriptorSetLayout.cpp
│ │ ├── VulkanDescriptorSetLayout.h
│ │ ├── VulkanFeatures.cpp
│ │ ├── VulkanFeatures.h
│ │ ├── VulkanFence.cpp
│ │ ├── VulkanFence.h
│ │ ├── VulkanFramebuffer.cpp
│ │ ├── VulkanFramebuffer.h
│ │ ├── VulkanFunctionTable.c
│ │ ├── VulkanFunctionTable.h
│ │ ├── VulkanHelpers.c
│ │ ├── VulkanHelpers.h
│ │ ├── VulkanImage.cpp
│ │ ├── VulkanImage.h
│ │ ├── VulkanImageView.cpp
│ │ ├── VulkanImageView.h
│ │ ├── VulkanImmediateCommands.cpp
│ │ ├── VulkanImmediateCommands.h
│ │ ├── VulkanPipelineBuilder.cpp
│ │ ├── VulkanPipelineBuilder.h
│ │ ├── VulkanQueuePool.cpp
│ │ ├── VulkanQueuePool.h
│ │ ├── VulkanRenderPassBuilder.cpp
│ │ ├── VulkanRenderPassBuilder.h
│ │ ├── VulkanSemaphore.cpp
│ │ ├── VulkanSemaphore.h
│ │ ├── VulkanShaderModule.cpp
│ │ ├── VulkanShaderModule.h
│ │ ├── VulkanStagingDevice.cpp
│ │ ├── VulkanStagingDevice.h
│ │ ├── VulkanSwapchain.cpp
│ │ ├── VulkanSwapchain.h
│ │ ├── VulkanTexture.cpp
│ │ ├── VulkanTexture.h
│ │ ├── VulkanVma.h
│ │ ├── android/
│ │ │ ├── NativeHWBuffer.cpp
│ │ │ └── NativeHWBuffer.h
│ │ ├── moltenvk/
│ │ │ ├── MoltenVkHelpers.h
│ │ │ └── MoltenVkHelpers.mm
│ │ └── util/
│ │ ├── SpvConstantSpecialization.cpp
│ │ ├── SpvConstantSpecialization.h
│ │ ├── SpvReflection.cpp
│ │ ├── SpvReflection.h
│ │ ├── TextureFormat.cpp
│ │ └── TextureFormat.h
│ └── win/
│ ├── LogDefault.cpp
│ └── LogDefault.h
└── third-party/
├── .gitignore
├── bootstrap-content.json
├── bootstrap-deps.json
└── bootstrap.py
================================================
FILE CONTENTS
================================================
================================================
FILE: .clang-format
================================================
---
AccessModifierOffset: -1
AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false
AlignEscapedNewlines: Left
# AlingOperands: true # Unsupported
AlignTrailingComments: false
AllowAllParametersOfDeclarationOnNextLine: false
AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: Empty
AllowShortIfStatementsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: true
AlwaysBreakTemplateDeclarations: true
BinPackArguments: false
BinPackParameters: false
BreakBeforeBinaryOperators: false
BreakBeforeBraces: Attach
BreakBeforeInheritanceComma: false
BreakBeforeTernaryOperators: true
BreakConstructorInitializers: AfterColon
BreakStringLiterals: true
ColumnLimit: 100
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: true
ConstructorInitializerIndentWidth: 2
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DerivePointerAlignment: false
FixNamespaceComments: true
SortIncludes: true
IncludeBlocks: Regroup
IncludeCategories:
# Making gtest/gmock show up first
- Regex: '^((<|")(gtest/|gmock/|folly/portability/(GTest|GMock|GFlags)))'
Priority: -10
MainIncludeChar: Any
IncludeIsMainRegex: '(Test)?$'
IndentCaseLabels: false
IndentPPDirectives: None
IndentWidth: 2
IndentWrappedFunctionNames: false
KeepEmptyLinesAtTheStartOfBlocks: false
# LanguageKind: Cpp # Unsupported
MaxEmptyLinesToKeep: 1
NamespaceIndentation: None
# ObjCBinPackProtocolList: Never # Unsupported
ObjCBlockIndentWidth: 2
ObjCSpaceAfterProperty: true
ObjCSpaceBeforeProtocolList: true
PenaltyBreakAssignment: 5
PenaltyBreakBeforeFirstCallParameter: 10
PenaltyBreakComment: 60
PenaltyBreakFirstLessLess: 20
PenaltyBreakString: 1000
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 200
PointerAlignment: Left
QualifierAlignment: Left
ReflowComments: true
SortUsingDeclarations: true
SpaceAfterCStyleCast: false
SpaceAfterTemplateKeyword: false
SpaceBeforeAssignmentOperators: true
# SpaceBeforeCtorInitializerColon: false # Unsupported
# SpaceBeforeInheritanceColon: false # Unsupported
SpaceBeforeParens: ControlStatements
# SpaceBeforeRangeBasedForLoopColon: true # Unsupported
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: false
SpacesInContainerLiterals: true
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
Standard: Cpp11
TabWidth: 2
UseTab: Never
...
================================================
FILE: .claude/CLAUDE.md
================================================
# IGL Project Instructions
## Diff Formatting
- Use Markdown formatting in diff summaries, titles, and test plans.
- Diff titles should start with the relevant backend prefix, e.g., `igl | vulkan |`, `igl | metal |`, `igl | opengl |`. Use `igl | cmake |` for CMake-related changes, `igl | github |` for purely open-source related changes, and `igl |` alone for changes not specific to a single backend.
- Always add trailing `()` to function and method names mentioned in titles, summaries, test plans, and actual code comments (e.g., `createInstance()`, `enable()`). Do not add `()` to type or class names (e.g., `RenderPipelineState`, `TextureDesc`).
## Coding Style
- Use C++20 designated initializers whenever possible.
- For NESTED designated initializers that fit on a single line, omit the trailing comma.
- Prefer `const` for local variables whenever possible. Be aggressive, i.e., the structure `RenderPipelineDesc` can be initialized like that with all the nested fields, including attachments.
================================================
FILE: .cmake-format
================================================
{
"_help_parse": "Options affecting listfile parsing",
"parse": {
"_help_additional_commands": [
"Specify structure for custom cmake functions"
],
"additional_commands": {
"foo": {
"flags": [
"BAR",
"BAZ"
],
"kwargs": {
"HEADERS": "*",
"SOURCES": "*",
"DEPENDS": "*"
}
}
},
"_help_override_spec": [
"Override configurations per-command where available"
],
"override_spec": {},
"_help_vartags": [
"Specify variable tags."
],
"vartags": [],
"_help_proptags": [
"Specify property tags."
],
"proptags": []
},
"_help_format": "Options affecting formatting.",
"format": {
"_help_disable": [
"Disable formatting entirely, making cmake-format a no-op"
],
"disable": false,
"_help_line_width": [
"How wide to allow formatted cmake files"
],
"line_width": 130,
"_help_tab_size": [
"How many spaces to tab for indent"
],
"tab_size": 2,
"_help_use_tabchars": [
"If true, lines are indented using tab characters (utf-8",
"0x09) instead of <tab_size> space characters (utf-8 0x20).",
"In cases where the layout would require a fractional tab",
"character, the behavior of the fractional indentation is",
"governed by <fractional_tab_policy>"
],
"use_tabchars": false,
"_help_fractional_tab_policy": [
"If <use_tabchars> is True, then the value of this variable",
"indicates how fractional indentions are handled during",
"whitespace replacement. If set to 'use-space', fractional",
"indentation is left as spaces (utf-8 0x20). If set to",
"`round-up` fractional indentation is replaced with a single",
"tab character (utf-8 0x09) effectively shifting the column",
"to the next tabstop"
],
"fractional_tab_policy": "use-space",
"_help_max_subgroups_hwrap": [
"If an argument group contains more than this many sub-groups",
"(parg or kwarg groups) then force it to a vertical layout."
],
"max_subgroups_hwrap": 8,
"_help_max_pargs_hwrap": [
"If a positional argument group contains more than this many",
"arguments, then force it to a vertical layout."
],
"max_pargs_hwrap": 8,
"_help_max_rows_cmdline": [
"If a cmdline positional group consumes more than this many",
"lines without nesting, then invalidate the layout (and nest)"
],
"max_rows_cmdline": 2,
"_help_separate_ctrl_name_with_space": [
"If true, separate flow control names from their parentheses",
"with a space"
],
"separate_ctrl_name_with_space": false,
"_help_separate_fn_name_with_space": [
"If true, separate function names from parentheses with a",
"space"
],
"separate_fn_name_with_space": false,
"_help_dangle_parens": [
"If a statement is wrapped to more than one line, than dangle",
"the closing parenthesis on its own line."
],
"dangle_parens": false,
"_help_dangle_align": [
"If the trailing parenthesis must be 'dangled' on its on",
"line, then align it to this reference: `prefix`: the start",
"of the statement, `prefix-indent`: the start of the",
"statement, plus one indentation level, `child`: align to",
"the column of the arguments"
],
"dangle_align": "prefix",
"_help_min_prefix_chars": [
"If the statement spelling length (including space and",
"parenthesis) is smaller than this amount, then force reject",
"nested layouts."
],
"min_prefix_chars": 4,
"_help_max_prefix_chars": [
"If the statement spelling length (including space and",
"parenthesis) is larger than the tab width by more than this",
"amount, then force reject un-nested layouts."
],
"max_prefix_chars": 10,
"_help_max_lines_hwrap": [
"If a candidate layout is wrapped horizontally but it exceeds",
"this many lines, then reject the layout."
],
"max_lines_hwrap": 2,
"_help_line_ending": [
"What style line endings to use in the output."
],
"line_ending": "unix",
"_help_command_case": [
"Format command names consistently as 'lower' or 'upper' case"
],
"command_case": "canonical",
"_help_keyword_case": [
"Format keywords consistently as 'lower' or 'upper' case"
],
"keyword_case": "upper",
"_help_always_wrap": [
"A list of command names which should always be wrapped"
],
"always_wrap": [],
"_help_enable_sort": [
"If true, the argument lists which are known to be sortable",
"will be sorted lexicographicall"
],
"enable_sort": true,
"_help_autosort": [
"If true, the parsers may infer whether or not an argument",
"list is sortable (without annotation)."
],
"autosort": false,
"_help_require_valid_layout": [
"By default, if cmake-format cannot successfully fit",
"everything into the desired linewidth it will apply the",
"last, most agressive attempt that it made. If this flag is",
"True, however, cmake-format will print error, exit with non-",
"zero status code, and write-out nothing"
],
"require_valid_layout": false,
"_help_layout_passes": [
"A dictionary mapping layout nodes to a list of wrap",
"decisions. See the documentation for more information."
],
"layout_passes": {}
},
"_help_markup": "Options affecting comment reflow and formatting.",
"markup": {
"_help_bullet_char": [
"What character to use for bulleted lists"
],
"bullet_char": "*",
"_help_enum_char": [
"What character to use as punctuation after numerals in an",
"enumerated list"
],
"enum_char": ".",
"_help_first_comment_is_literal": [
"If comment markup is enabled, don't reflow the first comment",
"block in each listfile. Use this to preserve formatting of",
"your copyright/license statements."
],
"first_comment_is_literal": false,
"_help_literal_comment_pattern": [
"If comment markup is enabled, don't reflow any comment block",
"which matches this (regex) pattern. Default is `None`",
"(disabled)."
],
"literal_comment_pattern": ".*",
"_help_fence_pattern": [
"Regular expression to match preformat fences in comments",
"default= ``r'^\\s*([`~]{3}[`~]*)(.*)$'``"
],
"fence_pattern": "^\\s*([`~]{3}[`~]*)(.*)$",
"_help_ruler_pattern": [
"Regular expression to match rulers in comments default=",
"``r'^\\s*[^\\w\\s]{3}.*[^\\w\\s]{3}$'``"
],
"ruler_pattern": "^\\s*[^\\w\\s]{3}.*[^\\w\\s]{3}$",
"_help_explicit_trailing_pattern": [
"If a comment line matches starts with this pattern then it",
"is explicitly a trailing comment for the preceeding",
"argument. Default is '#<'"
],
"explicit_trailing_pattern": "#<",
"_help_hashruler_min_length": [
"If a comment line starts with at least this many consecutive",
"hash characters, then don't lstrip() them off. This allows",
"for lazy hash rulers where the first hash char is not",
"separated by space"
],
"hashruler_min_length": 10,
"_help_canonicalize_hashrulers": [
"If true, then insert a space between the first hash char and",
"remaining hash chars in a hash ruler, and normalize its",
"length to fill the column"
],
"canonicalize_hashrulers": true,
"_help_enable_markup": [
"enable comment markup parsing and reflow"
],
"enable_markup": true
},
"_help_lint": "Options affecting the linter",
"lint": {
"_help_disabled_codes": [
"a list of lint codes to disable"
],
"disabled_codes": [],
"_help_function_pattern": [
"regular expression pattern describing valid function names"
],
"function_pattern": "[0-9a-z_]+",
"_help_macro_pattern": [
"regular expression pattern describing valid macro names"
],
"macro_pattern": "[0-9A-Z_]+",
"_help_global_var_pattern": [
"regular expression pattern describing valid names for",
"variables with global (cache) scope"
],
"global_var_pattern": "[A-Z][0-9A-Z_]+",
"_help_internal_var_pattern": [
"regular expression pattern describing valid names for",
"variables with global scope (but internal semantic)"
],
"internal_var_pattern": "_[A-Z][0-9A-Z_]+",
"_help_local_var_pattern": [
"regular expression pattern describing valid names for",
"variables with local scope"
],
"local_var_pattern": "[a-z][a-z0-9_]+",
"_help_private_var_pattern": [
"regular expression pattern describing valid names for",
"privatedirectory variables"
],
"private_var_pattern": "_[0-9a-z_]+",
"_help_public_var_pattern": [
"regular expression pattern describing valid names for public",
"directory variables"
],
"public_var_pattern": "[A-Z][0-9A-Z_]+",
"_help_argument_var_pattern": [
"regular expression pattern describing valid names for",
"function/macro arguments and loop variables."
],
"argument_var_pattern": "[a-z][a-z0-9_]+",
"_help_keyword_pattern": [
"regular expression pattern describing valid names for",
"keywords used in functions or macros"
],
"keyword_pattern": "[A-Z][0-9A-Z_]+",
"_help_max_conditionals_custom_parser": [
"In the heuristic for C0201, how many conditionals to match",
"within a loop in before considering the loop a parser."
],
"max_conditionals_custom_parser": 2,
"_help_min_statement_spacing": [
"Require at least this many newlines between statements"
],
"min_statement_spacing": 1,
"_help_max_statement_spacing": [
"Require no more than this many newlines between statements"
],
"max_statement_spacing": 2,
"max_returns": 6,
"max_branches": 12,
"max_arguments": 5,
"max_localvars": 15,
"max_statements": 50
},
"_help_encode": "Options affecting file encoding",
"encode": {
"_help_emit_byteorder_mark": [
"If true, emit the unicode byte-order mark (BOM) at the start",
"of the file"
],
"emit_byteorder_mark": false,
"_help_input_encoding": [
"Specify the encoding of the input file. Defaults to utf-8"
],
"input_encoding": "utf-8",
"_help_output_encoding": [
"Specify the encoding of the output file. Defaults to utf-8.",
"Note that cmake only claims to support utf-8 so be careful",
"when using anything else"
],
"output_encoding": "utf-8"
},
"_help_misc": "Miscellaneous configurations options.",
"misc": {
"_help_per_command": [
"A dictionary containing any per-command configuration",
"overrides. Currently only `command_case` is supported."
],
"per_command": {}
}
}
================================================
FILE: .github/pull_request_template.md
================================================
Our [contribution guidelines](https://github.com/facebook/igl/blob/main/CONTRIBUTING.md):
## Pull Requests
We actively welcome your pull requests. Here's the procedure to submit pull requests to IGL:
1. **Submit an issue describing your proposed changes.**
2. The repo owner will respond to your issue.
3. If your proposed changes are accepted, fork the repo and develop & test your changes.
4. If you've added code that should be tested, add tests (and ensure they do pass).
5. Verify your changes work as expected on all relevant rendering backends, and also test them when any combination of backends is disabled using the `IGL_WITH_*` CMake options.
6. If you've changed APIs, update the documentation.
7. Make sure your code lints (run `clang-format` or use `.clang-format` in Visual Studio).
8. If you haven't already, complete the Contributor License Agreement ("CLA").
9. Please respect `// @fb-only` comments and do not delete them!
10. Open a pull request.
## Dependencies
One of our design objectives is that IGL itself should have as few dependencies as possible.
No new third-party dependencies will be accepted unless they are absolutely critical to the core functionality of IGL.
**Please include a link to the related (and accepted) GitHub issue in this PR!**
================================================
FILE: .github/workflows/c-cpp.yml
================================================
name: C/C++ CI
on:
push:
branches: [ "**" ]
pull_request:
branches: [ "**" ]
# https://github.com/git-lfs/git-lfs/issues/5749
env:
GIT_CLONE_PROTECTION_ACTIVE: false
jobs:
build:
name: "Android (Ubuntu)"
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6
with:
submodules: recursive
- name: Free up disk space
run: |
df -h
sudo rm -rf /usr/share/dotnet /opt/ghc
sudo docker system prune --all --force --volumes
sudo apt-get clean -y
df -h
- name: Set up NDK
uses: nttld/setup-ndk@v1
with:
ndk-version: r26b
- name: Set up JDK
uses: actions/setup-java@v5
with:
java-version: 21
distribution: 'oracle'
- name: Assemble APK debug
run: |
cd build/android
chmod +x ./gradlew
./gradlew assembleDebug
cmake-build:
strategy:
fail-fast: false
matrix:
config:
- {
name: "Windows - MSVC 2022",
os: windows-latest,
build_type: "Debug",
cc: "cl",
cxx: "cl",
generators: "Visual Studio 17 2022",
cmake_args: "-DIGL_WITH_TRACY=ON -DIGL_WITH_TESTS=ON"
}
- {
name: "Windows - MSVC 2022 (no OpenGL)",
os: windows-latest,
build_type: "Debug",
cc: "cl",
cxx: "cl",
generators: "Visual Studio 17 2022",
cmake_args: "-DIGL_WITH_TRACY=ON -DIGL_WITH_TESTS=ON -DIGL_WITH_OPENGL=OFF"
}
- {
name: "Ubuntu - Clang",
os: ubuntu-latest,
build_type: "Debug",
cc: "clang",
cxx: "clang++",
generators: "Unix Makefiles",
cmake_args: "-DIGL_WITH_TRACY=ON"
}
- {
name: "Ubuntu - GCC",
os: ubuntu-latest,
build_type: "Debug",
cc: "gcc",
cxx: "g++",
generators: "Unix Makefiles",
# TODO: Fix killing GCC process on Github CI when IGL_WITH_SHELL is ON.
cmake_args: "-DIGL_WITH_TRACY=ON -DIGL_WITH_SHELL=OFF"
}
# https://github.com/emscripten-core/emscripten/pull/20802#issuecomment-1858114093
# - {
# name: "Emscripten (Ubuntu)",
# os: ubuntu-latest,
# build_type: "Debug",
# cc: "emcc",
# cxx: "em++",
# generators: "Ninja",
# }
# - {
# name: "macOS - Clang (Xcode)",
# os: macos-latest,
# build_type: "Debug",
# cc: "clang",
# cxx: "clang++",
# generators: "Xcode",
# cmake_args: "-DIGL_WITH_VULKAN=OFF"
# }
# - {
# name: "macOS - Clang (Unix Makefiles)",
# os: macos-latest,
# build_type: "Debug",
# cc: "clang",
# cxx: "clang++",
# generators: "Unix Makefiles",
# cmake_args: "-DIGL_WITH_VULKAN=OFF"
# }
runs-on: ${{ matrix.config.os }}
steps:
- uses: actions/checkout@v6
with:
submodules: recursive
- if: startsWith(matrix.config.os, 'windows')
run: |
git config --system core.longpaths true
- if: startsWith(matrix.config.name, 'Emscripten')
run: |
sudo sed -i 's/azure\.//' /etc/apt/sources.list
sudo apt-get update
sudo apt-get install -y clang emscripten xorg-dev libxinerama-dev libxcursor-dev libgles2-mesa-dev libegl1-mesa-dev libglfw3-dev libglew-dev libstdc++-12-dev
- if: startsWith(matrix.config.name, 'Ubuntu' )
run: |
sudo sed -i 's/azure\.//' /etc/apt/sources.list
sudo apt-get update
sudo apt-get install -y clang xorg-dev libxinerama-dev libxcursor-dev libgles2-mesa-dev libegl1-mesa-dev libglfw3-dev libglew-dev libstdc++-12-dev
- name: Prepare Vulkan SDK
uses: jakoch/install-vulkan-sdk-action@v1.2.5
with:
vulkan_version: 1.4.309.0
install_runtime: true
cache: true
stripdown: true
- name: Get the number of CPU cores
uses: SimenB/github-actions-cpu-cores@v2
- name: Build
shell: bash
env:
CC: ${{ matrix.config.cc }}
CXX: ${{ matrix.config.cxx }}
if: ${{ matrix.config.name != 'Emscripten (Ubuntu)' }}
run: |
cmake ${{ env.CMAKE_GENERATOR }} -S "${{ github.workspace }}" -B build ${{ matrix.config.cmake_args }}
cd build
cmake --build . --parallel ${{ steps.cpu-cores.outputs.count }}
- name: Build Emscripten
shell: bash
env:
CC: ${{ matrix.config.cc }}
CXX: ${{ matrix.config.cxx }}
if: ${{ matrix.config.name == 'Emscripten (Ubuntu)' }}
run: |
emcmake cmake ${{ env.CMAKE_GENERATOR }} -S "${{ github.workspace }}" -B build ${{ matrix.config.cmake_args }}
cd build
cmake --build . --parallel ${{ steps.cpu-cores.outputs.count }}
cmake-test-ubuntu:
strategy:
fail-fast: false
matrix:
config:
- {
name: "Ubuntu - Clang",
os: ubuntu-latest,
build_type: "Debug",
cc: "clang-16",
cxx: "clang++-16",
generators: "Unix Makefiles",
}
runs-on: ${{ matrix.config.os }}
steps:
- uses: actions/checkout@v6
with:
submodules: recursive
- name: Install Ubuntu packages
shell: bash
run: |
sudo apt-get update
sudo apt-get install -y gcc-13 clang-16 xorg-dev libxinerama-dev libxcursor-dev libgles2-mesa-dev libegl1-mesa-dev libglfw3-dev libglew-dev libstdc++-12-dev extra-cmake-modules libxkbcommon-x11-dev wayland-protocols ninja-build
sudo apt-get install -y mesa-vulkan-drivers libvulkan1 vulkan-tools vulkan-validationlayers
cmake --version
vulkaninfo
- name: Install Vulkan SDK
uses: jakoch/install-vulkan-sdk-action@v1.2.5
with:
vulkan_version: 1.4.309.0
install_runtime: true
cache: true
stripdown: true
- name: Get the number of CPU cores
uses: SimenB/github-actions-cpu-cores@v2
- name: Check disk space
run: df -h
- name: Build
shell: bash
env:
CC: ${{ matrix.config.cc }}
CXX: ${{ matrix.config.cxx }}
run: |
cmake ${{ env.CMAKE_GENERATOR }} -S "${{ github.workspace }}" -B build ${{ matrix.config.cmake_args }} -DCMAKE_BUILD_TYPE=Debug
cd build
cmake --build . --target Tiny --parallel ${{ steps.cpu-cores.outputs.count }}
cmake --build . --target BasicFramebufferSession_vulkan --parallel ${{ steps.cpu-cores.outputs.count }}
cmake --build . --target BindGroupSession_vulkan --parallel ${{ steps.cpu-cores.outputs.count }}
cmake --build . --target ColorSession_vulkan --parallel ${{ steps.cpu-cores.outputs.count }}
cmake --build . --target DrawInstancedSession_vulkan --parallel ${{ steps.cpu-cores.outputs.count }}
cmake --build . --target GPUStressSession_vulkan --parallel ${{ steps.cpu-cores.outputs.count }}
cmake --build . --target HelloWorldSession_vulkan --parallel ${{ steps.cpu-cores.outputs.count }}
cmake --build . --target ImguiSession_vulkan --parallel ${{ steps.cpu-cores.outputs.count }}
cmake --build . --target MRTSession_vulkan --parallel ${{ steps.cpu-cores.outputs.count }}
cmake --build . --target Textured3DCubeSession_vulkan --parallel ${{ steps.cpu-cores.outputs.count }}
cmake --build . --target TextureViewSession_vulkan --parallel ${{ steps.cpu-cores.outputs.count }}
cmake --build . --target TinyMeshBindGroupSession_vulkan --parallel ${{ steps.cpu-cores.outputs.count }}
cmake --build . --target TinyMeshSession_vulkan --parallel ${{ steps.cpu-cores.outputs.count }}
cmake --build . --target TQSession_vulkan --parallel ${{ steps.cpu-cores.outputs.count }}
cmake --build . --target YUVColorSession_vulkan --parallel ${{ steps.cpu-cores.outputs.count }}
- name: Run tests (shell)
run: |
ls build/shell
./build/shell/BasicFramebufferSession_vulkan --headless --viewport-size 1600x900 --screenshot-file BasicFramebufferSession.png
./build/shell/BindGroupSession_vulkan --headless --viewport-size 1600x900 --screenshot-file BindGroupSession.png
./build/shell/ColorSession_vulkan --headless --viewport-size 1600x900 --screenshot-file ColorSession.png
./build/shell/DrawInstancedSession_vulkan --headless --viewport-size 1600x900 --screenshot-file DrawInstancedSession.png
./build/shell/GPUStressSession_vulkan --headless --viewport-size 1600x900 --screenshot-file GPUStressSession.png
./build/shell/HelloWorldSession_vulkan --headless --viewport-size 1600x900 --screenshot-file HelloWorldSession.png
./build/shell/ImguiSession_vulkan --headless --viewport-size 1600x900 --screenshot-file ImguiSession.png
./build/shell/MRTSession_vulkan --headless --viewport-size 1600x900 --screenshot-file MRTSession.png
./build/shell/Textured3DCubeSession_vulkan --headless --viewport-size 1600x900 --screenshot-file Textured3DCubeSession.png
./build/shell/TextureViewSession_vulkan --headless --viewport-size 1600x900 --screenshot-file TextureViewSession.png
./build/shell/TinyMeshBindGroupSession_vulkan --headless --viewport-size 1600x900 --screenshot-file TinyMeshBindGroupSession.png
./build/shell/TinyMeshSession_vulkan --headless --viewport-size 1600x900 --screenshot-file TinyMeshSession.png
./build/shell/TQSession_vulkan --headless --viewport-size 1600x900 --screenshot-file TQSession.png
./build/shell/YUVColorSession_vulkan --headless --viewport-size 1600x900 --screenshot-file YUVColorSession.png
- name: Run tests (desktop)
run: |
ls build/samples/desktop
#./build/samples/desktop/Tiny --headless
- name: Upload artifacts
uses: actions/upload-artifact@v6
with:
name: Screenshots
path: |
BasicFramebufferSession.png
BindGroupSession.png
ColorSession.png
DrawInstancedSession.png
GPUStressSession.png
HelloWorldSession.png
ImguiSession.png
MRTSession.png
Textured3DCubeSession.png
TextureViewSession.png
TinyMeshBindGroupSession.png
TinyMeshSession.png
TQSession.png
YUVColorSession.png
if-no-files-found: error
retention-days: 5
overwrite: true
================================================
FILE: .github/workflows/cmake-install-test.yml
================================================
name: CMake Install Test
on:
push:
branches: [ "**" ]
paths:
- 'CMakeLists.txt'
- 'cmake/**'
- 'src/**'
- 'IGLU/**'
- '.github/workflows/cmake-install-test.yml'
pull_request:
branches: [ "**" ]
paths:
- 'CMakeLists.txt'
- 'cmake/**'
- 'src/**'
- 'IGLU/**'
- '.github/workflows/cmake-install-test.yml'
# https://github.com/git-lfs/git-lfs/issues/5749
env:
GIT_CLONE_PROTECTION_ACTIVE: false
jobs:
install-test:
strategy:
fail-fast: false
matrix:
config:
- {
name: "Ubuntu - Clang",
os: ubuntu-latest,
build_type: "Release",
cc: "clang",
cxx: "clang++",
generators: "Unix Makefiles",
cmake_args: "-DIGL_ENABLE_INSTALL=ON -DIGL_WITH_SAMPLES=OFF -DIGL_WITH_SHELL=OFF -DIGL_WITH_TESTS=OFF"
}
runs-on: ${{ matrix.config.os }}
name: ${{ matrix.config.name }}
steps:
- uses: actions/checkout@v6
with:
submodules: recursive
- if: startsWith(matrix.config.os, 'windows')
run: |
git config --system core.longpaths true
- if: startsWith(matrix.config.name, 'Ubuntu') && !matrix.config.android
run: |
sudo sed -i 's/azure\.//' /etc/apt/sources.list
sudo apt-get update
sudo apt-get install -y clang xorg-dev libxinerama-dev libxcursor-dev libgles2-mesa-dev libegl1-mesa-dev libglfw3-dev libglew-dev libstdc++-12-dev
- name: Prepare Vulkan SDK
if: ${{ !contains(matrix.config.cmake_args, 'IGL_WITH_VULKAN=OFF') }}
uses: jakoch/install-vulkan-sdk-action@v1.1.1
with:
vulkan_version: 1.4.304.1
install_runtime: true
cache: true
stripdown: true
- name: Get the number of CPU cores
uses: SimenB/github-actions-cpu-cores@v2
- name: Configure CMake
shell: bash
env:
CC: ${{ matrix.config.cc }}
CXX: ${{ matrix.config.cxx }}
run: |
# Set up platform-specific CMake arguments
CMAKE_PLATFORM_ARGS=""
cmake -G "${{ matrix.config.generators }}" \
-S "${{ github.workspace }}" \
-B build \
-DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} \
-DCMAKE_INSTALL_PREFIX="${{ github.workspace }}/install" \
$CMAKE_PLATFORM_ARGS \
${{ matrix.config.cmake_args }}
- name: Build
shell: bash
run: |
cd build
cmake --build . --parallel ${{ steps.cpu-cores.outputs.count }} --config ${{ matrix.config.build_type }}
- name: Install
shell: bash
run: |
cd build
cmake --install . --config ${{ matrix.config.build_type }}
- name: Verify Installation Structure
shell: bash
run: |
echo "=== Verifying Installation Structure ==="
# Check install directory exists
if [ ! -d "${{ github.workspace }}/install" ]; then
echo "ERROR: Install directory not found!"
exit 1
fi
# Check for library directory
if [ ! -d "${{ github.workspace }}/install/lib" ]; then
echo "ERROR: lib directory not found!"
exit 1
fi
# Check for include directory
if [ ! -d "${{ github.workspace }}/install/include" ]; then
echo "ERROR: include directory not found!"
exit 1
fi
# Check for CMake config
if [ ! -f "${{ github.workspace }}/install/lib/cmake/IGL/IGLConfig.cmake" ]; then
echo "ERROR: IGLConfig.cmake not found!"
exit 1
fi
# List installed files for debugging
echo "=== Installed Libraries ==="
find "${{ github.workspace }}/install/lib" -name "*.a" -o -name "*.lib" -o -name "*.so" -o -name "*.dylib" -o -name "*.dll" || true
echo "=== Installed Headers ==="
find "${{ github.workspace }}/install/include" -type d | head -10
echo "=== CMake Config Files ==="
find "${{ github.workspace }}/install" -name "*.cmake" | head -10
- name: Test find_package Integration
if: ${{ !matrix.config.android && !matrix.config.ios }}
shell: bash
run: |
echo "=== Testing find_package Integration ==="
# Create test project directory
mkdir -p test-project
# Create CMakeLists.txt
cat > test-project/CMakeLists.txt << 'EOF'
cmake_minimum_required(VERSION 3.19)
project(IGLInstallTest)
# Set C++ standard to match IGL requirements
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# Find IGL
find_package(IGL REQUIRED)
# Print information
message(STATUS "IGL_FOUND: ${IGL_FOUND}")
message(STATUS "IGL_VERSION: ${IGL_VERSION}")
# Create test executable
add_executable(igl_install_test main.cpp)
target_link_libraries(igl_install_test PRIVATE IGL::IGLLibrary)
# Test component discovery
if(TARGET IGL::IGLOpenGL)
message(STATUS "OpenGL backend available")
target_link_libraries(igl_install_test PRIVATE IGL::IGLOpenGL)
target_compile_definitions(igl_install_test PRIVATE HAVE_OPENGL=1)
endif()
if(TARGET IGL::IGLVulkan)
message(STATUS "Vulkan backend available")
target_link_libraries(igl_install_test PRIVATE IGL::IGLVulkan)
target_compile_definitions(igl_install_test PRIVATE HAVE_VULKAN=1)
endif()
if(TARGET IGL::IGLMetal)
message(STATUS "Metal backend available")
target_link_libraries(igl_install_test PRIVATE IGL::IGLMetal)
target_compile_definitions(igl_install_test PRIVATE HAVE_METAL=1)
endif()
EOF
# Create main.cpp
cat > test-project/main.cpp << 'EOF'
#include <igl/IGL.h>
#include <iostream>
int main() {
std::cout << "IGL Install Test - SUCCESS!" << std::endl;
std::cout << "IGL library linking works correctly!" << std::endl;
#ifdef HAVE_OPENGL
std::cout << "OpenGL backend: Available" << std::endl;
#endif
#ifdef HAVE_VULKAN
std::cout << "Vulkan backend: Available" << std::endl;
#endif
#ifdef HAVE_METAL
std::cout << "Metal backend: Available" << std::endl;
#endif
// Test basic IGL functionality
auto backendType = igl::BackendType::OpenGL;
std::cout << "IGL BackendType test: " << static_cast<int>(backendType) << std::endl;
return 0;
}
EOF
- name: Build Test Project
if: ${{ !matrix.config.android && !matrix.config.ios }}
shell: bash
run: |
cd test-project
cmake -B build -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} -DCMAKE_PREFIX_PATH="${{ github.workspace }}/install" .
cmake --build build --config ${{ matrix.config.build_type }}
- name: Run Test Executable
if: ${{ !matrix.config.android && !matrix.config.ios }}
shell: bash
run: |
cd test-project
if [ "${{ matrix.config.os }}" = "windows-latest" ]; then
./build/${{ matrix.config.build_type }}/igl_install_test.exe
else
./build/igl_install_test
fi
- name: Test Install Disabled (Control Test)
shell: bash
env:
CC: ${{ matrix.config.cc }}
CXX: ${{ matrix.config.cxx }}
run: |
echo "=== Testing Install Disabled ==="
# Clean and configure without install
rm -rf build-control
# Create cmake args without the install flag
CMAKE_ARGS="${{ matrix.config.cmake_args }}"
CMAKE_ARGS_CLEAN=$(echo "$CMAKE_ARGS" | sed 's/-DIGL_ENABLE_INSTALL=ON//g')
# Set up platform-specific CMake arguments (same as configure step)
CMAKE_PLATFORM_ARGS=""
cmake -G "${{ matrix.config.generators }}" \
-S "${{ github.workspace }}" \
-B build-control \
-DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} \
-DIGL_ENABLE_INSTALL=OFF \
$CMAKE_PLATFORM_ARGS \
$CMAKE_ARGS_CLEAN
# Build should succeed
cd build-control
cmake --build . --parallel ${{ steps.cpu-cores.outputs.count }} --config ${{ matrix.config.build_type }}
# Verify no install targets are created
if cmake --build . --target install 2>/dev/null; then
echo "WARNING: Install succeeded when it should be disabled"
else
echo "SUCCESS: Install properly disabled"
fi
# Test that install doesn't break when new targets are added
install-backward-compatibility:
runs-on: ubuntu-latest
name: "Backward Compatibility Test"
steps:
- uses: actions/checkout@v6
with:
submodules: recursive
- run: |
sudo sed -i 's/azure\.//' /etc/apt/sources.list
sudo apt-get update
sudo apt-get install -y clang xorg-dev libxinerama-dev libxcursor-dev libgles2-mesa-dev libegl1-mesa-dev libglfw3-dev libglew-dev libstdc++-12-dev
- name: Test Default Build (Install Disabled)
run: |
cmake -B build-default .
cmake --build build-default --parallel 2
echo "SUCCESS: Default build works with install code present"
- name: Test All Backends Enabled
run: |
cmake -B build-all \
-DIGL_ENABLE_INSTALL=ON \
-DCMAKE_INSTALL_PREFIX=install-all \
.
cmake --build build-all --parallel 2
cmake --install build-all
# Verify all components are installed
find install-all -name "*.a" | grep -E "(IGLLibrary|IGLOpenGL|IGLVulkan|IGLUimgui)" | wc -l | grep -v "^0$"
echo "SUCCESS: All backends install correctly"
================================================
FILE: .github/workflows/doc-build.yml
================================================
name: Doc Build
on:
push:
branches:
- main
paths:
- 'docs/**'
pull_request:
types: opened
branches:
- main
paths:
- 'docs/**'
jobs:
build_docs_job:
runs-on: ubuntu-latest
strategy:
matrix:
python-version: [3.6]
steps:
- name: Checkout
uses: actions/checkout@v6
- name: Dependencies
run: |
echo `python3 --version`
sudo apt-get install -y python3-sphinx
python3 -m pip install --upgrade pip
python3 -m pip install setuptools
id: build
- name: Build the docset
run: |
cd docs
pip install -r requirements.txt
make html
- name: Get output time
run: echo "The time was ${{ steps.build.outputs.time }}"
- name: Deploy
uses: JamesIves/github-pages-deploy-action@v4
with:
BRANCH: gh-pages # The branch the action should deploy to
FOLDER: ./docs/build/html # The folder the action should deploy
================================================
FILE: .gitignore
================================================
.idea
.vscode
================================================
FILE: CMakeLists.txt
================================================
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
cmake_minimum_required(VERSION 3.19)
project("IGL" CXX C)
# cmake-format: off
option(IGL_WITH_SAMPLES "Enable sample demo apps" ON)
option(IGL_WITH_OPENGL "Enable IGL/OpenGL" ON)
option(IGL_WITH_OPENGLES "Enable IGL/OpenGL ES" OFF)
option(IGL_WITH_VULKAN "Enable IGL/Vulkan" ON)
option(IGL_WITH_METAL "Enable IGL/Metal" ON)
option(IGL_WITH_WEBGL "Enable IGL/WebGL" OFF)
option(IGL_WITH_D3D12 "Enable IGL/DirectX 12" OFF)
option(IGL_WITH_IGLU "Enable IGLU utils" ON)
option(IGL_WITH_SHELL "Enable Shell utils" ON)
option(IGL_WITH_TESTS "Enable IGL tests (gtest)" OFF)
option(IGL_WITH_TRACY "Enable Tracy profiler" OFF)
option(IGL_WITH_TRACY_GPU "Enable Tracy profiler for the GPU" OFF)
option(IGL_WITH_OPENXR "Enable OpenXR" OFF)
option(IGL_ENFORCE_LOGS "Enable logs in Release builds" ON)
option(IGL_DEPLOY_DEPS "Deploy dependencies via CMake" ON)
option(IGL_ENABLE_INSTALL "Enable install targets for IGL" OFF)
# cmake-format: on
if(DEFINED ENV{VULKAN_SDK})
message(STATUS "VULKAN_SDK=$ENV{VULKAN_SDK}")
if(NOT EXISTS $ENV{VULKAN_SDK})
message(FATAL_ERROR "$ENV{VULKAN_SDK} does not exist.")
endif()
endif()
if(IOS)
if(IGL_WITH_OPENGL)
set(IGL_WITH_OPENGLES ON)
endif()
set(IGL_WITH_OPENGL OFF)
set(IGL_WITH_VULKAN OFF)
set(IGL_WITH_WEBGL OFF)
endif()
if(NOT APPLE)
set(IGL_WITH_METAL OFF)
endif()
if(NOT WIN32)
set(IGL_WITH_D3D12 OFF)
endif()
if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
# disable for all targets due to warnings in third-party code
add_definitions(-Wno-nullability-completeness)
elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-Wno-volatile>)
endif()
if(ANDROID)
if(IGL_WITH_OPENGL)
set(IGL_WITH_OPENGLES ON)
endif()
set(IGL_WITH_OPENGL OFF)
set(IGL_WITH_VULKAN ON)
set(IGL_WITH_WEBGL OFF)
elseif(UNIX)
# disable for all targets due to warnings in third-party code
add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-Wno-deprecated-volatile>)
add_definitions(-Wno-attributes)
endif()
if(EMSCRIPTEN)
if(IGL_WITH_OPENXR)
message(FATAL_ERROR "OpenXR is not supported on Emscripten.")
endif()
set(IGL_WITH_IGLU ON)
set(IGL_WITH_OPENGL OFF)
set(IGL_WITH_OPENGLES OFF)
set(IGL_WITH_VULKAN OFF)
set(IGL_WITH_WEBGL ON)
set(IGL_WITH_SHELL OFF) # shell doesn't supported yet
endif()
set_property(GLOBAL PROPERTY USE_FOLDERS ON)
function(igl_set_folder target folder_name)
set_property(TARGET ${target} PROPERTY FOLDER ${folder_name})
endfunction()
function(igl_set_cxxstd target cpp_version)
set_property(TARGET ${target} PROPERTY CXX_STANDARD ${cpp_version})
set_property(TARGET ${target} PROPERTY CXX_STANDARD_REQUIRED ON)
endfunction()
# cmake-format: off
message(STATUS "IGL_WITH_SAMPLES = ${IGL_WITH_SAMPLES}")
message(STATUS "IGL_WITH_OPENGL = ${IGL_WITH_OPENGL}")
message(STATUS "IGL_WITH_OPENGLES = ${IGL_WITH_OPENGLES}")
message(STATUS "IGL_WITH_VULKAN = ${IGL_WITH_VULKAN}")
message(STATUS "IGL_WITH_METAL = ${IGL_WITH_METAL}")
message(STATUS "IGL_WITH_WEBGL = ${IGL_WITH_WEBGL}")
message(STATUS "IGL_WITH_D3D12 = ${IGL_WITH_D3D12}")
message(STATUS "IGL_WITH_IGLU = ${IGL_WITH_IGLU}")
message(STATUS "IGL_WITH_SHELL = ${IGL_WITH_SHELL}")
message(STATUS "IGL_WITH_TESTS = ${IGL_WITH_TESTS}")
message(STATUS "IGL_WITH_TRACY = ${IGL_WITH_TRACY}")
message(STATUS "IGL_WITH_TRACY_GPU = ${IGL_WITH_TRACY_GPU}")
message(STATUS "IGL_WITH_OPENXR = ${IGL_WITH_OPENXR}")
message(STATUS "IGL_ENFORCE_LOGS = ${IGL_ENFORCE_LOGS}")
message(STATUS "IGL_DEPLOY_DEPS = ${IGL_DEPLOY_DEPS}")
# cmake-format: on
if(APPLE)
if(IGL_WITH_OPENXR)
message(FATAL_ERROR "OpenXR is not supported on Apple (yet).")
endif()
if(NOT (IGL_WITH_OPENGL OR IGL_WITH_VULKAN OR IGL_WITH_OPENGLES OR IGL_WITH_METAL OR IGL_WITH_WEBGL))
message(FATAL_ERROR "At least one rendering backend should be defined (OpenGL, Vulkan or Metal).")
endif()
else()
if(NOT (IGL_WITH_OPENGL OR IGL_WITH_VULKAN OR IGL_WITH_OPENGLES OR IGL_WITH_WEBGL OR IGL_WITH_D3D12))
message(FATAL_ERROR "At least one rendering backend should be defined (OpenGL, Vulkan, or DirectX 12).")
endif()
endif()
if(IGL_WITH_SHELL AND (NOT IGL_WITH_IGLU))
message(FATAL_ERROR "IGL_WITH_SHELL requires enabling IGL_WITH_IGLU.")
endif()
if(APPLE)
enable_language(OBJC)
enable_language(OBJCXX)
endif()
if(NOT DEFINED CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE "Debug")
endif()
message(STATUS "IGL generator : " ${CMAKE_GENERATOR})
message(STATUS "IGL build type: " ${CMAKE_BUILD_TYPE})
set(IGL_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR})
set(IGL_DEPS_CACHE_FILE "${IGL_ROOT_DIR}/third-party/.bootstrap-deps.json")
find_package(Python3 COMPONENTS Interpreter)
message(STATUS "IGL_ROOT_DIR = " ${IGL_ROOT_DIR})
# Enable local "in-tree" builds
if(${CMAKE_CURRENT_SOURCE_DIR} MATCHES "^.*fbsource.*")
get_filename_component(REPO_ROOT_DIR "../../../.." ABSOLUTE)
message(STATUS "REPO_ROOT_DIR = " ${REPO_ROOT_DIR})
include_directories(${REPO_ROOT_DIR})
endif()
# Enables multithreaded compilation and a conformant preprocessor on visual studio
if(MSVC)
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /MP")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
endif()
if(IGL_DEPLOY_DEPS)
# deploy dependencies during configuration
execute_process(COMMAND ${Python3_EXECUTABLE} deploy_deps.py WORKING_DIRECTORY ${IGL_ROOT_DIR} COMMAND_ERROR_IS_FATAL ANY)
if(NOT EXISTS ${IGL_DEPS_CACHE_FILE})
message(FATAL_ERROR "Cannot deploy dependencies.")
endif()
# regenerate dependencies when .bootstrap-deps.json is older than bootstrap-deps.json
add_custom_command(COMMAND ${Python3_EXECUTABLE} deploy_deps.py OUTPUT ${IGL_DEPS_CACHE_FILE}
DEPENDS "${IGL_ROOT_DIR}/third-party/bootstrap-deps.json" WORKING_DIRECTORY ${IGL_ROOT_DIR})
add_custom_target(IGLDependencies DEPENDS ${IGL_DEPS_CACHE_FILE})
igl_set_folder(IGLDependencies "IGL")
endif()
if (NOT IGL_WITH_TRACY AND IGL_WITH_TRACY_GPU)
message(FATAL_ERROR "IGL_WITH_TRACY must be enabled to use Tracy's GPU profiling")
endif()
if(IGL_WITH_TRACY)
add_definitions("-DTRACY_ENABLE=1")
add_definitions("-DTRACY_VK_USE_SYMBOL_TABLE=1")
add_subdirectory(third-party/deps/src/tracy)
igl_set_folder(TracyClient "third-party")
endif()
if(IGL_WITH_OPENXR)
add_subdirectory(third-party/deps/src/openxr-sdk)
igl_set_folder(openxr_loader "third-party/OpenXR")
endif()
if(WIN32 AND IGL_WITH_D3D12)
set(DIRECTX_HEADERS_ROOT "${IGL_ROOT_DIR}/third-party/deps/src/DirectX-Headers")
if(EXISTS "${DIRECTX_HEADERS_ROOT}/CMakeLists.txt")
add_subdirectory("${DIRECTX_HEADERS_ROOT}" "${CMAKE_BINARY_DIR}/DirectX-Headers")
set(DIRECTX_HEADERS_INCLUDE_DIR "${DIRECTX_HEADERS_ROOT}/include/directx")
else()
message(FATAL_ERROR "DirectX-Headers dependency not found. Run deploy_deps.py to download third-party/deps/src/DirectX-Headers.")
endif()
endif()
add_subdirectory(src/igl)
if(IGL_WITH_TRACY)
target_compile_definitions(IGLLibrary PUBLIC "IGL_WITH_TRACY=1")
if(IGL_WITH_TRACY_GPU)
target_compile_definitions(IGLLibrary PUBLIC "IGL_WITH_TRACY_GPU=1")
endif()
endif()
if(IGL_DEPLOY_DEPS)
add_dependencies(IGLLibrary IGLDependencies)
endif()
if(IGL_ENFORCE_LOGS)
target_compile_definitions(IGLLibrary PUBLIC "IGL_FORCE_ENABLE_LOGS=1")
endif()
if(UNIX AND NOT APPLE AND NOT ANDROID AND NOT EMSCRIPTEN)
if(IGL_WITH_SAMPLES OR IGL_WITH_SHELL)
target_compile_definitions(IGLLibrary PUBLIC "IGL_PLATFORM_LINUX_USE_EGL=0")
else()
target_compile_definitions(IGLLibrary PUBLIC "IGL_PLATFORM_LINUX_USE_EGL=1")
endif()
endif()
# in the client code, use IGL_BACKEND_* macros instead of IGL_BACKEND_ENABLE_*
if(IGL_WITH_OPENGL)
target_compile_definitions(IGLLibrary PUBLIC "IGL_BACKEND_ENABLE_OPENGL=1")
endif()
if(IGL_WITH_OPENGLES OR IGL_WITH_WEBGL)
target_compile_definitions(IGLLibrary PUBLIC "IGL_BACKEND_ENABLE_OPENGL=1")
endif()
if(IGL_WITH_VULKAN)
target_compile_definitions(IGLLibrary PUBLIC "IGL_BACKEND_ENABLE_VULKAN=1")
endif()
if(IGL_WITH_IGLU)
target_compile_definitions(IGLLibrary PUBLIC "IGL_WITH_IGLU=1")
endif()
if(APPLE AND IGL_WITH_METAL)
target_compile_definitions(IGLLibrary PUBLIC "IGL_BACKEND_ENABLE_METAL=1")
endif()
if(WIN32 AND IGL_WITH_D3D12)
target_compile_definitions(IGLLibrary PUBLIC "IGL_BACKEND_ENABLE_D3D12=1")
endif()
if(NOT IGL_WITH_VULKAN)
target_sources(IGLLibrary PRIVATE "src/igl/vulkan/util/TextureFormat.cpp")
endif()
target_compile_definitions(IGLLibrary PUBLIC "IGL_CMAKE_BUILD=1")
include_directories(.)
# Enable CTest at top-level when tests are requested so `ctest` can discover tests
if(IGL_WITH_TESTS)
include(CTest)
enable_testing()
endif()
if(IGL_WITH_IGLU OR IGL_WITH_SAMPLES)
add_library(IGLstb third-party/deps/patches/stb_impl/stb_image.c third-party/deps/patches/stb_impl/stb_image_resize.c
third-party/deps/patches/stb_impl/stb_image_write.c)
target_include_directories(IGLstb PUBLIC "third-party/deps/src/stb")
target_include_directories(IGLstb PUBLIC "third-party/deps/src")
igl_set_folder(IGLstb "IGL")
endif()
if (IGL_WITH_IGLU)
include_directories("third-party/deps/src/imgui")
add_subdirectory(IGLU)
if(IGL_WITH_SHELL)
include_directories("third-party/deps/src/stb")
add_subdirectory(shell)
endif()
endif()
if(IGL_WITH_SAMPLES)
if (EMSCRIPTEN)
add_subdirectory(samples/wasm)
else()
include_directories("third-party/deps/src")
include_directories("third-party/deps/src/bc7enc")
include_directories("third-party/deps/src/gli")
include_directories("third-party/deps/src/glm")
include_directories("third-party/deps/src/stb")
include_directories("third-party/deps/src/taskflow")
include_directories("third-party/deps/src/3D-Graphics-Rendering-Cookbook")
if(WIN32 OR (UNIX AND NOT APPLE AND NOT ANDROID))
# cmake-format: off
set(GLFW_BUILD_DOCS OFF CACHE BOOL "")
set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "")
set(GLFW_BUILD_TESTS OFF CACHE BOOL "")
set(GLFW_INSTALL OFF CACHE BOOL "")
set(GLFW_VULKAN_STATIC OFF CACHE BOOL "")
# cmake-format: on
add_subdirectory(third-party/deps/src/glfw)
igl_set_folder(update_mappings "third-party/GLFW3")
endif()
if(UNIX AND NOT APPLE AND NOT ANDROID)
find_package(OpenGL REQUIRED)
endif()
add_subdirectory(third-party/deps/src/bc7enc)
igl_set_cxxstd(bc7enc 17)
add_subdirectory(third-party/deps/src/meshoptimizer)
add_subdirectory(third-party/deps/src/tinyobjloader)
igl_set_folder(bc7enc "third-party")
igl_set_folder(meshoptimizer "third-party")
igl_set_folder(tinyobjloader "third-party/tinyobjloader")
igl_set_folder(uninstall "third-party/tinyobjloader")
if(NOT APPLE AND NOT ANDROID)
add_subdirectory(samples/desktop)
igl_set_folder(glfw "third-party/GLFW3")
endif()
endif()
endif()
if (IGL_WITH_VULKAN OR IGL_WITH_IGLU OR IGL_WITH_SAMPLES)
add_subdirectory(third-party/deps/src/fmt "fmt")
igl_set_folder(fmt "third-party")
endif()
if (IGL_WITH_IGLU OR IGL_WITH_SAMPLES)
set(KTX_FEATURE_DOC OFF CACHE BOOL "")
if (NOT EMSCRIPTEN)
set(KTX_FEATURE_GL_UPLOAD OFF CACHE BOOL "")
endif()
set(KTX_FEATURE_JNI OFF CACHE BOOL "")
set(KTX_FEATURE_KTX1 ON CACHE BOOL "")
set(KTX_FEATURE_KTX2 ON CACHE BOOL "")
set(KTX_FEATURE_LOADTEST_APPS OFF CACHE BOOL "")
set(KTX_FEATURE_STATIC_LIBRARY ON CACHE BOOL "")
set(KTX_FEATURE_TESTS OFF CACHE BOOL "")
set(KTX_FEATURE_TOOLS OFF CACHE BOOL "")
set(KTX_FEATURE_VK_UPLOAD OFF CACHE BOOL "")
add_subdirectory(third-party/deps/src/ktx-software)
if(TARGET astcenc-avx2-static)
igl_set_folder(astcenc-avx2-static "third-party/ktx-software")
endif()
igl_set_folder(ktx "third-party/ktx-software")
igl_set_folder(ktx_read "third-party/ktx-software")
igl_set_folder(ktx_version "third-party/ktx-software")
igl_set_folder(obj_basisu_cbind "third-party/ktx-software")
igl_set_folder(objUtil "third-party/ktx-software")
endif()
if(IGL_WITH_TRACY)
target_link_libraries(IGLLibrary PUBLIC TracyClient)
endif()
if(IGL_WITH_OPENXR)
target_compile_definitions(IGLLibrary PUBLIC "IGL_WITH_OPENXR=1")
target_link_libraries(IGLLibrary PUBLIC OpenXR::openxr_loader)
target_include_directories(IGLLibrary PUBLIC "${IGL_ROOT_DIR}/third-party/deps/src/openxr-sdk/include")
endif()
if(IGL_ENABLE_INSTALL)
include(cmake/install.cmake)
endif()
================================================
FILE: CODE_OF_CONDUCT.md
================================================
# Code of Conduct
## Our Pledge
In the interest of fostering an open and welcoming environment, we as
contributors and maintainers pledge to make participation in our project and
our community a harassment-free experience for everyone, regardless of age, body
size, disability, ethnicity, sex characteristics, gender identity and expression,
level of experience, education, socio-economic status, nationality, personal
appearance, race, religion, or sexual identity and orientation.
## Our Standards
Examples of behavior that contributes to creating a positive environment
include:
* Using welcoming and inclusive language
* Being respectful of differing viewpoints and experiences
* Gracefully accepting constructive criticism
* Focusing on what is best for the community
* Showing empathy towards other community members
Examples of unacceptable behavior by participants include:
* The use of sexualized language or imagery and unwelcome sexual attention or
advances
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or electronic
address, without explicit permission
* Other conduct which could reasonably be considered inappropriate in a
professional setting
## Our Responsibilities
Project maintainers are responsible for clarifying the standards of acceptable
behavior and are expected to take appropriate and fair corrective action in
response to any instances of unacceptable behavior.
Project maintainers have the right and responsibility to remove, edit, or
reject comments, commits, code, wiki edits, issues, and other contributions
that are not aligned to this Code of Conduct, or to ban temporarily or
permanently any contributor for other behaviors that they deem inappropriate,
threatening, offensive, or harmful.
## Scope
This Code of Conduct applies within all project spaces, and it also applies when
an individual is representing the project or its community in public spaces.
Examples of representing a project or community include using an official
project e-mail address, posting via an official social media account, or acting
as an appointed representative at an online or offline event. Representation of
a project may be further defined and clarified by project maintainers.
## Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be
reported by contacting the project team at <opensource-conduct@fb.com>. All
complaints will be reviewed and investigated and will result in a response that
is deemed necessary and appropriate to the circumstances. The project team is
obligated to maintain confidentiality with regard to the reporter of an incident.
Further details of specific enforcement policies may be posted separately.
Project maintainers who do not follow or enforce the Code of Conduct in good
faith may face temporary or permanent repercussions as determined by other
members of the project's leadership.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
[homepage]: https://www.contributor-covenant.org
For answers to common questions about this code of conduct, see
https://www.contributor-covenant.org/faq
================================================
FILE: CONTRIBUTING.md
================================================
# Contributing to IGL
We want to make contributing to this project as easy and transparent as
possible.
## Pull Requests
We actively welcome your pull requests. Here's the procedure to submit pull requests to IGL:
1. Submit an issue describing your proposed changes.
2. The repo owner will respond to your issue.
3. If your proposed changes are accepted, fork the repo and develop & test your changes.
4. If you've added code that should be tested, add tests (and ensure they do pass).
5. Verify your changes work as expected on all relevant rendering backends, and also test them when any combination of backends is disabled using the `IGL_WITH_*` CMake options.
6. If you've changed APIs, update the documentation.
7. Make sure your code lints (run `clang-format` or use `.clang-format` in Visual Studio).
8. If you haven't already, complete the Contributor License Agreement ("CLA").
9. Please respect `// @fb-only` comments and do not delete them!
10. Open a pull request.
## Dependencies
One of our design objectives is that IGL itself should have as few dependencies as possible.
No new third-party dependencies will be accepted unless they are absolutely critical to the core functionality of IGL.
## Contributor License Agreement ("CLA")
In order to accept your pull request, we need you to submit a CLA. You only need
to do this once to work on any of Facebook's open source projects.
Complete your CLA here: <https://code.facebook.com/cla>
## Issues
We use GitHub issues to track public bugs. Please ensure your description is
clear and has sufficient instructions to be able to reproduce the issue.
Facebook has a [bounty program](https://www.facebook.com/whitehat/) for the safe
disclosure of security bugs. In those cases, please go through the process
outlined on that page and do not file a public issue.
## License
By contributing to igl, you agree that your contributions will be licensed
under the LICENSE file in the root directory of this source tree.
================================================
FILE: IGLU/CMakeLists.txt
================================================
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
cmake_minimum_required(VERSION 3.19)
set(PROJECT_NAME "IGLU")
macro(ADD_IGLU_MODULE module)
file(GLOB_RECURSE SRC_FILES LIST_DIRECTORIES false RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${module}/*.cpp ${module}/*.mm)
file(GLOB_RECURSE HEADER_FILES LIST_DIRECTORIES false RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${module}/*.h)
if((NOT IGL_WITH_OPENGL) AND (NOT IGL_WITH_OPENGLES))
list(REMOVE_ITEM SRC_FILES ${module}/OpenGLTextureAccessor.cpp)
list(REMOVE_ITEM HEADER_FILES ${module}/OpenGLTextureAccessor.h)
endif()
if(NOT IGL_WITH_METAL)
list(REMOVE_ITEM SRC_FILES ${module}/MetalTextureAccessor.mm)
list(REMOVE_ITEM HEADER_FILES ${module}/MetalTextureAccessor.h)
endif()
add_library(IGLU${module} ${SRC_FILES} ${HEADER_FILES})
igl_set_cxxstd(IGLU${module} 20)
igl_set_folder(IGLU${module} "IGL/${PROJECT_NAME}")
target_link_libraries(IGLU${module} PRIVATE IGLLibrary)
target_include_directories(IGLU${module} PUBLIC "${CMAKE_CURRENT_BINARY_DIR}/include")
target_include_directories(IGLU${module} PUBLIC "${CMAKE_CURRENT_BINARY_DIR}/include_${module}")
target_include_directories(IGLU${module} PUBLIC "${IGL_ROOT_DIR}")
endmacro()
add_iglu_module(imgui)
add_iglu_module(managedUniformBuffer)
add_iglu_module(sentinel)
add_iglu_module(simple_renderer)
add_iglu_module(state_pool)
add_iglu_module(shaderCross)
add_iglu_module(texture_accessor)
add_iglu_module(texture_loader)
add_iglu_module(uniform)
# header-only
add_library(IGLUsimdtypes INTERFACE)
target_include_directories(IGLUsimdtypes INTERFACE "simdtypes")
target_link_libraries(IGLUtexture_loader PRIVATE IGLstb)
target_link_libraries(IGLUtexture_loader PRIVATE ktx)
if(IGL_WITH_SHELL)
target_link_libraries(IGLUimgui PRIVATE IGLShellShared)
else()
target_sources(IGLUimgui PRIVATE "${IGL_ROOT_DIR}/shell/shared/input/InputDispatcher.cpp")
endif()
# ImGui
target_sources(IGLUimgui PRIVATE "${IGL_ROOT_DIR}/third-party/deps/src/imgui/imgui.cpp")
target_sources(IGLUimgui PRIVATE "${IGL_ROOT_DIR}/third-party/deps/src/imgui/imgui_demo.cpp")
target_sources(IGLUimgui PRIVATE "${IGL_ROOT_DIR}/third-party/deps/src/imgui/imgui_draw.cpp")
target_sources(IGLUimgui PRIVATE "${IGL_ROOT_DIR}/third-party/deps/src/imgui/imgui_tables.cpp")
target_sources(IGLUimgui PRIVATE "${IGL_ROOT_DIR}/third-party/deps/src/imgui/imgui_widgets.cpp")
target_include_directories(IGLUimgui PUBLIC "${IGL_ROOT_DIR}/third-party/deps/src/imgui")
target_include_directories(IGLUtexture_accessor PUBLIC "${IGL_ROOT_DIR}/third-party/deps/src/glew/include")
if(UNIX)
if (CMAKE_C_COMPILER_ID STREQUAL "GNU")
target_compile_options(IGLUimgui PUBLIC $<$<COMPILE_LANGUAGE:CXX>:-Wno-volatile>)
endif()
endif()
# SPIRV-Cross
# cmake-format: off
set(SPIRV_CROSS_SHARED OFF CACHE BOOL "")
set(SPIRV_CROSS_STATIC ON CACHE BOOL "")
set(SPIRV_CROSS_CLI OFF CACHE BOOL "")
set(SPIRV_CROSS_ENABLE_TESTS OFF CACHE BOOL "")
set(SPIRV_CROSS_ENABLE_GLSL ON CACHE BOOL "")
set(SPIRV_CROSS_ENABLE_HLSL OFF CACHE BOOL "")
set(SPIRV_CROSS_ENABLE_MSL ON CACHE BOOL "")
set(SPIRV_CROSS_ENABLE_CPP OFF CACHE BOOL "")
set(SPIRV_CROSS_ENABLE_REFLECT OFF CACHE BOOL "")
set(SPIRV_CROSS_SKIP_INSTALL ON CACHE BOOL "")
add_subdirectory(${IGL_ROOT_DIR}/third-party/deps/src/SPIRV-Cross "SPIRV-Cross")
igl_set_folder(spirv-cross-core "third-party/spirv-cross/spirv-cross-core")
igl_set_folder(spirv-cross-glsl "third-party/spirv-cross/spirv-cross-glsl")
igl_set_folder(spirv-cross-msl "third-party/spirv-cross/spirv-cross-msl")
igl_set_folder(spirv-cross-util "third-party/spirv-cross/spirv-cross-util")
igl_set_folder(spirv-cross-c "third-party/spirv-cross/spirv-cross-c")
# cmake-format: on
target_include_directories(IGLUshaderCross PRIVATE "${IGL_ROOT_DIR}/third-party/deps/src/SPIRV-Cross" "${IGL_ROOT_DIR}/third-party/deps/src/glslang")
target_link_libraries(IGLUshaderCross PRIVATE IGLGlslang IGLUmanagedUniformBuffer spirv-cross-core spirv-cross-glsl spirv-cross-msl spirv-cross-util spirv-cross-c)
================================================
FILE: IGLU/bitmap/BitmapWriter.cpp
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#include <IGLU/bitmap/BitmapWriter.h>
#include <IGLU/texture_accessor/TextureAccessorFactory.h>
#include <ostream>
#include <igl/Common.h>
namespace igl::iglu {
namespace {
#if defined(_MSC_VER)
#pragma pack(push, 1)
#endif
struct BMPHeader {
// Bitmap file header
uint16_t signature = 0x4D42; // Signature ("BM" in ASCII), default value 0x4D42 for BMP format
uint32_t fileSize = 0;
uint16_t reserved1 = 0;
uint16_t reserved2 = 0;
uint32_t dataOffset = sizeof(BMPHeader); // Offset to the start of image data
// DIB header (Bitmap information header)
uint32_t headerSize = 40; // Size of the DIB header
int32_t imageWidth = 0;
int32_t imageHeight = 0;
uint16_t colorPlanes = 1; // Number of color planes
uint16_t bitsPerPixel = 24;
uint32_t compression = 0; // Compression method (initialized to 0 for no compression)
uint32_t imageSizeBytes = 0;
int32_t horizontalResolution = 0; // Horizontal resolution in pixels per meter
int32_t verticalResolution = 0; // Vertical resolution in pixels per meter
uint32_t numColors = 0; // Number of colors in the color palette
uint32_t importantColors = 0; // Number of important colors used
}
#if defined(__GNUC__) || defined(__clang__)
__attribute__((packed))
#endif
;
#if defined(_MSC_VER)
#pragma pack(pop)
#endif
struct BufferOffsets {
size_t r;
size_t g;
size_t b;
};
BufferOffsets getBufferOffsets(TextureFormat format) {
switch (format) {
case igl::TextureFormat::RGBA_UNorm8:
case igl::TextureFormat::RGBX_UNorm8:
case igl::TextureFormat::RGBA_SRGB: {
return {.r = 0, .g = 1, .b = 2};
}
case igl::TextureFormat::BGRA_UNorm8:
case igl::TextureFormat::BGRA_SRGB: {
return {.r = 2, .g = 1, .b = 0};
}
default:
IGL_DEBUG_ASSERT_NOT_IMPLEMENTED();
return {.r = 0, .g = 1, .b = 2};
}
}
} // namespace
bool isSupportedBitmapTextureFormat(TextureFormat format) {
switch (format) {
case igl::TextureFormat::RGBA_UNorm8:
case igl::TextureFormat::RGBX_UNorm8:
case igl::TextureFormat::RGBA_SRGB:
case igl::TextureFormat::BGRA_UNorm8:
case igl::TextureFormat::BGRA_SRGB:
return true;
default:
return false;
}
}
void writeBitmap(std::ostream& stream,
std::shared_ptr<ITexture> texture,
IDevice& device,
bool flipY) {
IGL_DEBUG_ASSERT(texture);
IGL_DEBUG_ASSERT(texture->getType() == igl::TextureType::TwoD);
IGL_DEBUG_ASSERT(isSupportedBitmapTextureFormat(texture->getFormat()));
const auto textureAccessor =
::iglu::textureaccessor::TextureAccessorFactory::createTextureAccessor(
device.getBackendType(), texture, device);
const igl::CommandQueueDesc desc{};
Result result;
const auto commandQueue = device.createCommandQueue(desc, &result);
if (!IGL_DEBUG_VERIFY(result.isOk()) || !IGL_DEBUG_VERIFY(commandQueue)) {
return;
}
textureAccessor->requestBytes(*commandQueue, nullptr);
const auto& buffer = textureAccessor->getBytes();
const auto size = texture->getSize();
const TextureRangeDesc textureRange = texture->getFullRange();
const auto& properties = texture->getProperties();
const uint32_t bytesPerRow = properties.getBytesPerRow(textureRange);
std::vector<uint8_t> imageData;
imageData.reserve(size.width * size.height * 3);
IGL_DEBUG_ASSERT(buffer.size() == size.height * bytesPerRow);
const auto bufferOffsets = getBufferOffsets(texture->getFormat());
for (size_t y = 0; y < size.height; ++y) {
const size_t row = flipY ? size.height - y - 1 : y;
for (size_t byte = 0; byte < bytesPerRow; byte += 4) {
const size_t index = row * bytesPerRow + byte;
const uint8_t r = buffer[index + bufferOffsets.r];
const uint8_t g = buffer[index + bufferOffsets.g];
const uint8_t b = buffer[index + bufferOffsets.b];
imageData.push_back(b);
imageData.push_back(g);
imageData.push_back(r);
}
}
writeBitmap(stream, static_cast<const uint8_t*>(imageData.data()), size.width, size.height);
}
void writeBitmap(std::ostream& stream, const uint8_t* imageData, uint32_t width, uint32_t height) {
const uint32_t imageSize = width * height * 3;
BMPHeader header{
.fileSize = static_cast<uint32_t>(sizeof(BMPHeader) + imageSize),
.imageWidth = static_cast<int32_t>(width),
.imageHeight = static_cast<int32_t>(height),
.imageSizeBytes = static_cast<uint32_t>(imageSize),
};
stream.write(reinterpret_cast<const char*>(&header), sizeof(header));
stream.write(reinterpret_cast<const char*>(imageData), imageSize);
}
} // namespace igl::iglu
================================================
FILE: IGLU/bitmap/BitmapWriter.h
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include <cstdint>
#include <igl/IGL.h>
namespace igl::iglu {
// Check if a texture format is supported by the bitmap writer
bool isSupportedBitmapTextureFormat(TextureFormat format);
// Write the contents of a texture to a bitmap file
void writeBitmap(std::ostream& stream,
std::shared_ptr<ITexture> texture,
IDevice& device,
bool flipY = false);
void writeBitmap(std::ostream& stream, const uint8_t* imageData, uint32_t width, uint32_t height);
} // namespace igl::iglu
================================================
FILE: IGLU/command_buffer_allocator/ICommandBufferAllocator.cpp
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#include <IGLU/command_buffer_allocator/ICommandBufferAllocator.h>
#include <igl/CommandBuffer.h>
namespace iglu::command_buffer_allocator {
ICommandBufferAllocator::CommandBufferScope::CommandBufferScope(
ICommandBufferAllocator& allocator,
igl::ICommandBuffer& commandBuffer,
bool shouldFinalizeCommandBuffer) noexcept :
allocator_(allocator),
commandBuffer_(commandBuffer),
shouldFinalizeCommandBuffer_(shouldFinalizeCommandBuffer) {}
ICommandBufferAllocator::CommandBufferScope::~CommandBufferScope() noexcept {
if (shouldFinalizeCommandBuffer_) {
allocator_.finalizeCommandBuffer();
}
}
igl::ICommandBuffer& ICommandBufferAllocator::CommandBufferScope::commandBuffer() noexcept {
return commandBuffer_;
}
const igl::ICommandBuffer& ICommandBufferAllocator::CommandBufferScope::commandBuffer()
const noexcept {
return commandBuffer_;
}
} // namespace iglu::command_buffer_allocator
================================================
FILE: IGLU/command_buffer_allocator/ICommandBufferAllocator.h
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include <igl/CommandBuffer.h>
namespace iglu::command_buffer_allocator {
/**
* ICommandBuffer Allocator is am interface to allocate Command Buffers and submit them all at once.
*/
class ICommandBufferAllocator {
public:
ICommandBufferAllocator() = default;
virtual ~ICommandBufferAllocator() = default;
struct CommandBufferScopeConfig {
bool present = false;
std::shared_ptr<igl::ITexture> presentTexture = nullptr;
bool waitUntilScheduled = false;
bool waitUntilCompleted = false;
std::string debugName = "<unknown>";
};
struct CommandBufferScope {
public:
~CommandBufferScope() noexcept;
static void* operator new(size_t) = delete; // stack allocation only
[[nodiscard]] igl::ICommandBuffer& commandBuffer() noexcept;
[[nodiscard]] const igl::ICommandBuffer& commandBuffer() const noexcept;
private:
friend class ICommandBufferAllocator;
CommandBufferScope(ICommandBufferAllocator& allocator,
igl::ICommandBuffer& commandBuffer,
bool shouldFinalizeCommandBuffer) noexcept;
ICommandBufferAllocator& allocator_;
igl::ICommandBuffer& commandBuffer_;
bool shouldFinalizeCommandBuffer_ = false;
};
virtual void createCommandBuffer(const std::string& debugName) noexcept = 0;
[[nodiscard]] virtual CommandBufferScope commandBufferScope() noexcept = 0;
[[nodiscard]] virtual CommandBufferScope commandBufferScope(
ICommandBufferAllocator& allocator,
igl::ICommandBuffer& commandBuffer,
bool shouldFinalizeCommandBuffer) noexcept {
return {allocator, commandBuffer, shouldFinalizeCommandBuffer};
}
[[nodiscard]] virtual CommandBufferScope commandBufferScope(
CommandBufferScopeConfig config) noexcept = 0;
virtual void finalizeCommandBuffer() noexcept = 0;
};
} // namespace iglu::command_buffer_allocator
================================================
FILE: IGLU/imgui/InputListener.cpp
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
// @fb-only
#include "InputListener.h"
#include "KeyCodeTranslator.h"
// ImGui has a very awkward expectation when it comes to processing inputs and making decisions
// based on them. This is what it expects clients to do, in order, every frame:
// 1. Send ImGui all events via the input parameters in ImGuiIO.
// 2. Call ImGui::NewFrame -- that's when events are processed.
// 3. Read the output parameters of ImGuiIO to know which events it wants to capture.
// 4. Forward uncaptured events to other systems.
//
// This is an awkward expectation and we currently don't follow it. Instead, we process events
// before calling ImGui::NewFrame and immediately check whether ImGui wants to capture events, which
// is one frame old. This can be a source of problems if we have multiple input listeners and
// depending on how they process inputs.
namespace iglu::imgui {
InputListener::InputListener(ImGuiContext* context) {
context_ = context;
}
bool InputListener::process(const igl::shell::MouseButtonEvent& event) {
makeCurrentContext();
ImGuiIO& io = ImGui::GetIO();
io.MousePos = ImVec2(event.x, event.y);
io.MouseDown[event.button] = event.isDown;
return io.WantCaptureMouse;
}
bool InputListener::process(const igl::shell::MouseMotionEvent& event) {
makeCurrentContext();
ImGuiIO& io = ImGui::GetIO();
io.MousePos = ImVec2(event.x, event.y);
return io.WantCaptureMouse;
}
bool InputListener::process(const igl::shell::MouseWheelEvent& event) {
makeCurrentContext();
ImGuiIO& io = ImGui::GetIO();
io.MouseWheelH = event.dx;
io.MouseWheel = event.dy;
return io.WantCaptureMouse;
}
bool InputListener::process(const igl::shell::TouchEvent& event) {
makeCurrentContext();
ImGuiIO& io = ImGui::GetIO();
io.MousePos = ImVec2(event.x, event.y);
io.MouseDown[0] = event.isDown;
return io.WantCaptureMouse;
}
void InputListener::makeCurrentContext() const {
ImGui::SetCurrentContext(context_);
}
bool InputListener::process(const igl::shell::KeyEvent& event) {
makeCurrentContext();
ImGuiIO& io = ImGui::GetIO();
ImGuiKey key = keyFromShellKeyEvent(event);
if (key != ImGuiKey_None) {
io.AddKeyEvent(key, event.isDown);
}
return io.WantCaptureKeyboard;
}
bool InputListener::process(const igl::shell::CharEvent& event) {
makeCurrentContext();
ImGuiIO& io = ImGui::GetIO();
io.AddInputCharacter(event.character);
return io.WantTextInput;
}
} // namespace iglu::imgui
================================================
FILE: IGLU/imgui/InputListener.h
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
// @fb-only
#pragma once
#include "imgui.h"
#include <shell/shared/input/InputDispatcher.h> // IWYU pragma: export
#include <shell/shared/input/KeyListener.h>
#include <shell/shared/input/MouseListener.h>
namespace iglu::imgui {
class InputListener : public igl::shell::IMouseListener,
public igl::shell::ITouchListener,
public igl::shell::IKeyListener {
public:
explicit InputListener(ImGuiContext* context);
~InputListener() override = default;
protected:
bool process(const igl::shell::MouseButtonEvent& event) override;
bool process(const igl::shell::MouseMotionEvent& event) override;
bool process(const igl::shell::MouseWheelEvent& event) override;
bool process(const igl::shell::TouchEvent& event) override;
bool process(const igl::shell::KeyEvent& event) override;
bool process(const igl::shell::CharEvent& event) override;
private:
ImGuiContext* context_;
void makeCurrentContext() const;
};
} // namespace iglu::imgui
================================================
FILE: IGLU/imgui/KeyCodeTranslator.cpp
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
// @fb-only
#include "KeyCodeTranslator.h"
#include <igl/Config.h>
#if IGL_PLATFORM_APPLE
namespace {
enum KeyModifiers {
kVK_Return = 0x24,
kVK_Tab = 0x30,
kVK_Delete = 0x33,
kVK_Escape = 0x35,
kVK_Shift = 0x38,
kVK_Option = 0x3A,
kVK_Control = 0x3B,
kVK_RightArrow = 0x7C,
kVK_LeftArrow = 0x7B,
kVK_DownArrow = 0x7D,
kVK_UpArrow = 0x7E,
kVK_ForwardDelete = 0x75,
kVK_Home = 0x73,
kVK_End = 0x77,
kVK_PageUp = 0x74,
kVK_PageDown = 0x79,
};
[[maybe_unused]] ImGuiKey keyFromShellKeyEventApple(igl::shell::KeyEvent event) {
int keyCode = event.key;
switch (keyCode) {
case kVK_Return:
return ImGuiKey_Enter;
case kVK_Tab:
return ImGuiKey_Tab;
case kVK_Delete:
return ImGuiKey_Backspace;
case kVK_ForwardDelete:
return ImGuiKey_Delete;
case kVK_Escape:
return ImGuiKey_Escape;
case kVK_Shift:
return ImGuiKey_LeftShift;
case kVK_Option:
return ImGuiKey_LeftAlt;
case kVK_Control:
return ImGuiKey_LeftCtrl;
case kVK_LeftArrow:
return ImGuiKey_LeftArrow;
case kVK_RightArrow:
return ImGuiKey_RightArrow;
case kVK_UpArrow:
return ImGuiKey_UpArrow;
case kVK_DownArrow:
return ImGuiKey_DownArrow;
case kVK_Home:
return ImGuiKey_Home;
case kVK_End:
return ImGuiKey_End;
case kVK_PageUp:
return ImGuiKey_PageUp;
case kVK_PageDown:
return ImGuiKey_PageDown;
default:
return ImGuiKey_None;
}
}
} // namespace
#endif
namespace iglu::imgui {
ImGuiKey keyFromShellKeyEvent(igl::shell::KeyEvent event) {
#if IGL_PLATFORM_APPLE
return keyFromShellKeyEventApple(event);
#else
// For non-Apple platforms, return ImGuiKey_None for unmapped keys
// to avoid passing invalid key codes to ImGui
return ImGuiKey_None;
#endif
}
} // namespace iglu::imgui
================================================
FILE: IGLU/imgui/KeyCodeTranslator.h
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
// @fb-only
#pragma once
#include "imgui.h"
#include <shell/shared/input/KeyListener.h>
namespace iglu::imgui {
ImGuiKey keyFromShellKeyEvent(igl::shell::KeyEvent event);
} // namespace iglu::imgui
================================================
FILE: IGLU/imgui/Session.cpp
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
// @fb-only
#include "Session.h"
#include <IGLU/simple_renderer/Drawable.h>
#include <IGLU/simple_renderer/Material.h>
#include <igl/ShaderCreator.h>
// D3D12 FXC precompiled shaders
#include "imgui_ps_d3d12_fxc.h"
#include "imgui_vs_d3d12_fxc.h"
namespace iglu::imgui {
/* internal renderer -- based on imgui_impl_metal.mm */
#define PLAIN_SHADER_STRINGIFY(...) #__VA_ARGS__
#define PLAIN_SHADER(...) PLAIN_SHADER_STRINGIFY(__VA_ARGS__)
static const char* metalShaderStr() {
return PLAIN_SHADER(
using namespace metal;
struct Uniforms { float4x4 projectionMatrix; };
struct VertexIn {
float2 position [[attribute(0)]];
float2 texCoords [[attribute(1)]];
float4 color [[attribute(2)]];
};
struct VertexOut {
float4 position [[position]];
float2 texCoords;
float4 color;
};
vertex VertexOut vertex_main(VertexIn in [[stage_in]],
constant Uniforms & uniforms [[buffer(1)]]) {
VertexOut out;
out.position = uniforms.projectionMatrix * float4(in.position, 0, 1);
out.texCoords = in.texCoords;
out.color = in.color;
return out;
}
fragment half4 fragment_main(VertexOut in [[stage_in]],
texture2d<half, access::sample> texture [[texture(0)]]) {
constexpr sampler linearSampler(
coord::normalized, min_filter::linear, mag_filter::linear, mip_filter::linear);
half4 texColor = texture.sample(linearSampler, in.texCoords);
return half4(in.color) * texColor;
}
);
}
static std::string getOpenGLVertexShaderSource(igl::ShaderVersion shaderVersion) {
std::string shader;
if (shaderVersion.majorVersion > 1 || shaderVersion.minorVersion > 30 ||
shaderVersion.family == igl::ShaderFamily::GlslEs) {
#if IGL_PLATFORM_MACOSX
shader += "#version 100\n";
#endif
shader += "precision mediump float;";
}
shader += PLAIN_SHADER(attribute vec2 position; attribute vec2 texCoords; attribute vec4 color;
uniform mat4 projectionMatrix;
varying vec2 Frag_UV;
varying vec4 Frag_Color;
void main() {
Frag_UV = texCoords;
Frag_Color = color;
gl_Position = projectionMatrix * vec4(position.xy, 0, 1);
});
return shader;
}
static const char* getVulkanVertexShaderSource() {
return R"(
layout(location = 0) in vec2 position;
layout(location = 1) in vec2 texCoords;
layout(location = 2) in vec4 col;
layout (location = 0) out vec4 color;
layout (location = 1) out vec2 uv;
layout(push_constant) uniform PushConstants {
mat4 proj;
} pc;
out gl_PerVertex { vec4 gl_Position; };
void main() {
color = col;
uv = texCoords;
gl_Position = pc.proj * vec4(position.xy, 0, 1);
})";
}
static std::string getOpenGLFragmentShaderSource(igl::ShaderVersion shaderVersion) {
std::string shader;
if (shaderVersion.majorVersion > 1 || shaderVersion.minorVersion > 30 ||
shaderVersion.family == igl::ShaderFamily::GlslEs) {
#if IGL_PLATFORM_MACOSX
shader += "#version 100\n";
#endif
shader += "precision mediump float;";
}
shader +=
PLAIN_SHADER(uniform sampler2D texture; varying vec2 Frag_UV; varying vec4 Frag_Color;
void main() { gl_FragColor = Frag_Color * texture2D(texture, Frag_UV.st); });
return shader;
}
static const char* getVulkanFragmentShaderSource() {
return R"(
layout(location = 0) out vec4 fColor;
layout(location = 0) in vec4 color;
layout(location = 1) in vec2 uv;
layout (set = 0, binding = 0) uniform sampler2D uTex;
void main() {
fColor = color * texture(uTex, uv);
})";
}
// Note: D3D12 shader source functions are kept for reference but not used.
// The D3D12 backend uses pre-compiled binary shaders.
#if IGL_PLATFORM_WINDOWS
static const char* getD3D12VertexShaderSource() {
return R"(
cbuffer Uniforms : register(b0) {
float4x4 projectionMatrix;
};
struct VSInput {
float2 position : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct PSInput {
float4 position : SV_Position;
float4 color : COLOR;
float2 uv : TEXCOORD0;
};
PSInput main(VSInput input) {
PSInput output;
// Column-major multiplication to match the CPU-side matrix format
// In HLSL: mul(vector, matrix) treats matrix as column-major
output.position = mul(float4(input.position.xy, 0, 1), projectionMatrix);
output.color = input.color;
output.uv = input.uv;
return output;
})";
}
static const char* getD3D12FragmentShaderSource() {
return R"(
struct PSInput {
float4 position : SV_Position;
float4 color : COLOR;
float2 uv : TEXCOORD0;
};
Texture2D tex : register(t0);
SamplerState uSampler : register(s0);
float4 main(PSInput input) : SV_Target {
return input.color * tex.Sample(uSampler, input.uv);
})";
}
#endif
static std::unique_ptr<igl::IShaderStages> getShaderStagesForBackend(igl::IDevice& device) {
igl::Result result;
switch (device.getBackendType()) {
case igl::BackendType::Invalid:
IGL_DEBUG_ASSERT_NOT_REACHED();
return nullptr;
case igl::BackendType::Vulkan: {
return igl::ShaderStagesCreator::fromModuleStringInput(device,
getVulkanVertexShaderSource(),
"main",
"Shader Module: imgui::vertex",
getVulkanFragmentShaderSource(),
"main",
"Shader Module: imgui::fragment",
&result);
}
// @fb-only
// @fb-only
// @fb-only
case igl::BackendType::Custom:
IGL_DEBUG_ABORT("IGLSamples not set up for Custom");
return nullptr;
case igl::BackendType::Metal: {
return igl::ShaderStagesCreator::fromLibraryStringInput(
device, metalShaderStr(), "vertex_main", "fragment_main", "", &result);
}
case igl::BackendType::OpenGL: {
auto shaderVersion = device.getShaderVersion();
const std::string vertexStr = getOpenGLVertexShaderSource(shaderVersion);
const std::string fragmentStr = getOpenGLFragmentShaderSource(shaderVersion);
return igl::ShaderStagesCreator::fromModuleStringInput(
device, vertexStr.c_str(), "main", "", fragmentStr.c_str(), "main", "", &result);
}
case igl::BackendType::D3D12: {
return igl::ShaderStagesCreator::fromModuleBinaryInput(device,
_tmp_imgui_vs_fxc_cso,
_tmp_imgui_vs_fxc_cso_len,
"main",
"Shader Module: imgui::vertex (D3D12)",
_tmp_imgui_ps_fxc_cso,
_tmp_imgui_ps_fxc_cso_len,
"main",
"Shader Module: imgui::fragment (D3D12)",
&result);
}
}
IGL_UNREACHABLE_RETURN(nullptr)
}
namespace {
struct DrawableData {
std::shared_ptr<iglu::vertexdata::VertexData> vertexData;
std::shared_ptr<iglu::drawable::Drawable> drawable;
DrawableData(igl::IDevice& device,
const std::shared_ptr<igl::IVertexInputState>& inputState,
const std::shared_ptr<iglu::material::Material>& material) {
IGL_DEBUG_ASSERT(sizeof(ImDrawIdx) == 2,
"The constants below may not work with the ImGui data.");
const size_t kMaxVertices = (1l << 16);
const size_t kMaxVertexBufferSize = kMaxVertices * sizeof(ImDrawVert);
const size_t kMaxIndexBufferSize = kMaxVertices * sizeof(ImDrawIdx);
const igl::BufferDesc vbDesc{.type = igl::BufferDesc::BufferTypeBits::Vertex,
.data = nullptr,
.length = kMaxVertexBufferSize,
.storage = igl::ResourceStorage::Shared,
.hint = 0,
.debugName = "vertex (" + material->name + ")"};
const igl::BufferDesc ibDesc{.type = igl::BufferDesc::BufferTypeBits::Index,
.data = nullptr,
.length = kMaxIndexBufferSize,
.storage = igl::ResourceStorage::Shared,
.hint = 0,
.debugName = "index (" + material->name + ")"};
iglu::vertexdata::PrimitiveDesc primitiveDesc;
primitiveDesc.numEntries = 0;
vertexData = std::make_shared<iglu::vertexdata::VertexData>(
inputState,
device.createBuffer(vbDesc, nullptr),
device.createBuffer(ibDesc, nullptr),
sizeof(ImDrawIdx) == sizeof(uint16_t) ? igl::IndexFormat::UInt16 : igl::IndexFormat::UInt32,
primitiveDesc);
drawable = std::make_shared<iglu::drawable::Drawable>(vertexData, material);
}
};
} // namespace
class Session::Renderer {
public:
explicit Renderer(igl::IDevice& device);
~Renderer();
Renderer(const Renderer&) = delete;
Renderer& operator=(const Renderer&) = delete;
Renderer(Renderer&&) = delete;
Renderer& operator=(Renderer&&) = delete;
void newFrame(const igl::FramebufferDesc& desc);
void renderDrawData(igl::IDevice& device,
igl::IRenderCommandEncoder& cmdEncoder,
ImDrawData* drawData);
bool dumpRenderDrawDataInfo{false};
private:
std::shared_ptr<igl::IVertexInputState> vertexInputState_;
std::shared_ptr<iglu::material::Material> material_;
std::vector<DrawableData> drawables_[3]; // list of drawables to be reused every 3 frames
size_t nextBufferingIndex_ = 0;
igl::RenderPipelineDesc renderPipelineDesc_;
std::shared_ptr<igl::ITexture> fontTexture_;
std::shared_ptr<igl::ISamplerState> linearSampler_;
};
Session::Renderer::Renderer(igl::IDevice& device) {
ImGuiIO& io = ImGui::GetIO();
io.BackendRendererName = "imgui_impl_igl";
linearSampler_ = device.createSamplerState(igl::SamplerStateDesc::newLinear(), nullptr);
{ // init fonts
unsigned char* pixels = nullptr;
int width = 0, height = 0;
io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
igl::TextureDesc desc = igl::TextureDesc::new2D(igl::TextureFormat::RGBA_UNorm8,
width,
height,
igl::TextureDesc::TextureUsageBits::Sampled);
desc.debugName = "IGLU/imgui/Session.cpp:Session::Renderer::_fontTexture";
fontTexture_ = device.createTexture(desc, nullptr);
fontTexture_->upload(igl::TextureRangeDesc::new2D(0, 0, width, height), pixels);
io.Fonts->TexID = reinterpret_cast<ImTextureID>(fontTexture_.get());
}
{
igl::VertexInputStateDesc inputDesc;
inputDesc.numAttributes = 3;
inputDesc.attributes[0] = igl::VertexAttribute{
.bufferIndex = 0,
.format = igl::VertexAttributeFormat::Float2,
.offset = offsetof(ImDrawVert, pos),
.name = "position",
.location = 0,
};
inputDesc.attributes[1] = igl::VertexAttribute{
.bufferIndex = 0,
.format = igl::VertexAttributeFormat::Float2,
.offset = offsetof(ImDrawVert, uv),
.name = "texCoords",
.location = 1,
};
inputDesc.attributes[2] = igl::VertexAttribute{
.bufferIndex = 0,
.format = igl::VertexAttributeFormat::UByte4Norm,
.offset = offsetof(ImDrawVert, col),
.name = "color",
.location = 2,
};
inputDesc.numInputBindings = 1;
inputDesc.inputBindings[0].stride = sizeof(ImDrawVert);
vertexInputState_ = device.createVertexInputState(inputDesc, nullptr);
}
{
auto stages = getShaderStagesForBackend(device);
auto program = std::make_shared<iglu::material::ShaderProgram>(
device, std::move(stages), vertexInputState_);
material_ = std::make_shared<iglu::material::Material>(device, "imgui");
material_->setShaderProgram(device, program);
material_->cullMode = igl::CullMode::Disabled;
material_->blendMode = iglu::material::BlendMode::Translucent();
// @fb-only
// D3D12 and Vulkan use direct slot binding, OpenGL/Metal use named binding
const bool usesDirectBinding = (device.getBackendType() == igl::BackendType::Vulkan ||
device.getBackendType() == igl::BackendType::D3D12);
if (!usesDirectBinding) {
material_->shaderUniforms().setTexture("texture", fontTexture_.get(), linearSampler_);
}
}
}
Session::Renderer::~Renderer() {
const ImGuiIO& io = ImGui::GetIO();
fontTexture_ = nullptr;
io.Fonts->TexID = 0;
}
void Session::Renderer::newFrame(const igl::FramebufferDesc& desc) {
IGL_DEBUG_ASSERT(desc.colorAttachments[0].texture);
renderPipelineDesc_.targetDesc.colorAttachments.resize(1);
renderPipelineDesc_.targetDesc.colorAttachments[0].textureFormat =
desc.colorAttachments[0].texture->getFormat();
renderPipelineDesc_.targetDesc.depthAttachmentFormat =
desc.depthAttachment.texture ? desc.depthAttachment.texture->getFormat()
: igl::TextureFormat::Invalid;
renderPipelineDesc_.targetDesc.stencilAttachmentFormat =
desc.stencilAttachment.texture ? desc.stencilAttachment.texture->getFormat()
: igl::TextureFormat::Invalid;
renderPipelineDesc_.sampleCount = desc.colorAttachments[0].texture->getSamples();
}
void Session::Renderer::renderDrawData(igl::IDevice& device,
igl::IRenderCommandEncoder& cmdEncoder,
ImDrawData* drawData) {
// Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates !=
// framebuffer coordinates)
const int fbWidth = (int)(drawData->DisplaySize.x * drawData->FramebufferScale.x);
const int fbHeight = (int)(drawData->DisplaySize.y * drawData->FramebufferScale.y);
if (dumpRenderDrawDataInfo) {
// throttle or turn off due to swamping other messages
IGL_LOG_INFO(
"ImGui renderDrawData: DisplaySize=(%.1f,%.1f), FramebufferScale=(%.1f,%.1f), fb=(%d,%d), "
"CmdLists=%d, TotalVtx=%d, TotalIdx=%d\n",
drawData->DisplaySize.x,
drawData->DisplaySize.y,
drawData->FramebufferScale.x,
drawData->FramebufferScale.y,
fbWidth,
fbHeight,
drawData->CmdListsCount,
drawData->TotalVtxCount,
drawData->TotalIdxCount);
}
if (fbWidth <= 0 || fbHeight <= 0 || drawData->CmdListsCount == 0) {
IGL_LOG_INFO("ImGui renderDrawData: Early return (invalid dimensions or no command lists)\n");
return;
}
cmdEncoder.pushDebugGroupLabel("ImGui Rendering", igl::Color(0, 1, 0));
const igl::Viewport viewport = {
/*.x = */ .x = 0.0,
/*.y = */ .y = 0.0,
/*.width = */ .width = (drawData->DisplaySize.x * drawData->FramebufferScale.x),
/*.height = */ .height = (drawData->DisplaySize.y * drawData->FramebufferScale.y),
};
cmdEncoder.bindViewport(viewport);
using namespace iglu::simdtypes;
float4x4 orthoProjection{};
{ // setup projection matrix
const float l = drawData->DisplayPos.x;
const float r = drawData->DisplayPos.x + drawData->DisplaySize.x;
const float t = drawData->DisplayPos.y;
const float b = drawData->DisplayPos.y + drawData->DisplaySize.y;
orthoProjection.columns[0] = float4{2.0f / (r - l), 0.0f, 0.0f, 0.0f};
orthoProjection.columns[1] = float4{0.0f, 2.0f / (t - b), 0.0f, 0.0f};
orthoProjection.columns[2] = float4{0.0f, 0.0f, -1.0f, 0.0f};
orthoProjection.columns[3] = float4{(r + l) / (l - r), (t + b) / (b - t), 0.0f, 1.0f};
// D3D12 and Vulkan use direct slot binding, OpenGL/Metal use named binding
const bool usesDirectBinding = (device.getBackendType() == igl::BackendType::Vulkan ||
device.getBackendType() == igl::BackendType::D3D12);
if (!usesDirectBinding) {
material_->shaderUniforms().setFloat4x4(igl::genNameHandle("projectionMatrix"),
orthoProjection);
}
}
const ImVec2 clipOff = drawData->DisplayPos; // (0,0) unless using multi-viewports
const ImVec2 clipScale =
drawData->FramebufferScale; // (1,1) unless using retina display which are often (2,2)
// Since vertex buffers are updated every frame, we must use triple buffering for Metal to work
std::vector<DrawableData>& curFrameDrawables = drawables_[nextBufferingIndex_];
nextBufferingIndex_ = (nextBufferingIndex_ + 1) % 3;
const bool isOpenGL = device.getBackendType() == igl::BackendType::OpenGL;
const bool isVulkan = device.getBackendType() == igl::BackendType::Vulkan;
const bool isD3D12 = device.getBackendType() == igl::BackendType::D3D12;
const bool usesDirectBinding = isVulkan || isD3D12;
ImTextureID lastBoundTextureId = 0;
for (int n = 0; n < drawData->CmdListsCount; n++) {
const ImDrawList* cmdList = drawData->CmdLists[n];
if (n >= curFrameDrawables.size()) {
curFrameDrawables.emplace_back(device, vertexInputState_, material_);
}
const DrawableData& drawableData = curFrameDrawables[n];
// Upload vertex/index buffers
drawableData.vertexData->vertexBuffer().upload(
cmdList->VtxBuffer.Data, {cmdList->VtxBuffer.Size * sizeof(ImDrawVert), 0});
drawableData.vertexData->indexBuffer().upload(cmdList->IdxBuffer.Data,
{cmdList->IdxBuffer.Size * sizeof(ImDrawIdx), 0});
for (int cmdI = 0; cmdI < cmdList->CmdBuffer.Size; cmdI++) {
const ImDrawCmd cmd = cmdList->CmdBuffer[cmdI];
IGL_DEBUG_ASSERT(cmd.UserCallback == nullptr);
const ImVec2 clipMin((cmd.ClipRect.x - clipOff.x) * clipScale.x,
(cmd.ClipRect.y - clipOff.y) * clipScale.y);
const ImVec2 clipMax((cmd.ClipRect.z - clipOff.x) * clipScale.x,
(cmd.ClipRect.w - clipOff.y) * clipScale.y);
if (clipMax.x <= clipMin.x || clipMax.y <= clipMin.y) {
continue;
}
// OpenGL Y-axis goes up (Vulkan and Metal are good)
// https://www.saschawillems.de/blog/2019/03/29/flipping-the-vulkan-viewport/
const igl::ScissorRect rect{.x = uint32_t(clipMin.x),
.y = isOpenGL ? uint32_t(viewport.height - clipMax.y)
: uint32_t(clipMin.y),
.width = uint32_t(clipMax.x - clipMin.x),
.height = uint32_t(clipMax.y - clipMin.y)};
cmdEncoder.bindScissorRect(rect);
if (cmd.TextureId != lastBoundTextureId) {
lastBoundTextureId = cmd.TextureId;
auto* tex = reinterpret_cast<igl::ITexture*>((ImTextureID)(intptr_t)cmd.TextureId);
if (usesDirectBinding) {
// D3D12 and Vulkan use direct slot binding
// @fb-only
// Add Vulkan support for texture reflection info in ShaderUniforms so we don't need to
// bind the texture directly
cmdEncoder.bindTexture(0, igl::BindTarget::kFragment, tex);
cmdEncoder.bindSamplerState(0, igl::BindTarget::kFragment, linearSampler_.get());
} else {
material_->shaderUniforms().setTexture(
"texture", tex ? tex : fontTexture_.get(), linearSampler_);
}
}
drawableData.vertexData->primitiveDesc().numEntries = cmd.ElemCount;
drawableData.vertexData->primitiveDesc().offset = cmd.IdxOffset * sizeof(ImDrawIdx);
drawableData.drawable->draw(device,
cmdEncoder,
renderPipelineDesc_,
usesDirectBinding ? sizeof(orthoProjection) : 0,
&orthoProjection);
}
}
if (isOpenGL) {
// disable scissor
cmdEncoder.bindScissorRect(igl::ScissorRect());
}
cmdEncoder.popDebugGroupLabel();
}
/* public API */
Session::Session(igl::IDevice& device,
igl::shell::InputDispatcher& inputDispatcher,
bool needInitializeSession /* = true */) :
inputDispatcher_(inputDispatcher) {
context_ = ImGui::CreateContext();
makeCurrentContext();
ImGuiStyle& style = ImGui::GetStyle();
style.TouchExtraPadding = ImVec2(5, 5); // adjust to make touches more accurate
if (needInitializeSession) {
initialize(device);
}
}
void Session::initialize(igl::IDevice& device) {
if (!isInitialized_) {
inputListener_ = std::make_shared<InputListener>(context_);
renderer_ = std::make_unique<Renderer>(device);
inputDispatcher_.addMouseListener(inputListener_);
inputDispatcher_.addTouchListener(inputListener_);
inputDispatcher_.addKeyListener(inputListener_);
isInitialized_ = true;
}
}
Session::~Session() {
makeCurrentContext();
inputDispatcher_.removeTouchListener(inputListener_);
inputDispatcher_.removeMouseListener(inputListener_);
inputDispatcher_.removeKeyListener(inputListener_);
renderer_ = nullptr;
inputListener_ = nullptr;
ImGui::DestroyContext();
}
void Session::beginFrame(const igl::FramebufferDesc& desc, float displayScale) {
makeCurrentContext();
IGL_DEBUG_ASSERT(desc.colorAttachments[0].texture);
const igl::Size size = desc.colorAttachments[0].texture->getSize();
ImGuiIO& io = ImGui::GetIO();
io.DisplaySize = ImVec2(size.width / displayScale, size.height / displayScale);
io.DisplayFramebufferScale = ImVec2(displayScale, displayScale);
io.IniFilename = nullptr;
renderer_->newFrame(desc);
ImGui::NewFrame();
}
void Session::endFrame(igl::IDevice& device, igl::IRenderCommandEncoder& cmdEncoder) {
makeCurrentContext();
ImGui::EndFrame();
ImGui::Render();
renderer_->renderDrawData(device, cmdEncoder, ImGui::GetDrawData());
}
void Session::makeCurrentContext() const {
ImGui::SetCurrentContext(context_);
}
void Session::drawFPS(float fps) const {
// a nice FPS counter
const ImGuiWindowFlags flags = ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_AlwaysAutoResize |
ImGuiWindowFlags_NoSavedSettings |
ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoNav |
ImGuiWindowFlags_NoMove;
const ImGuiViewport* v = ImGui::GetMainViewport();
IGL_DEBUG_ASSERT(v);
ImGui::SetNextWindowPos(
{
v->WorkPos.x + v->WorkSize.x - 15.0f,
v->WorkPos.y + 15.0f,
},
ImGuiCond_Always,
{1.0f, 0.0f});
ImGui::SetNextWindowBgAlpha(0.30f);
ImGui::SetNextWindowSize(ImVec2(ImGui::CalcTextSize("FPS : _______").x, 0));
if (ImGui::Begin("##FPS", nullptr, flags)) {
ImGui::Text("FPS : %i", (int)fps);
ImGui::Text("Ms : %.1f", 1000.0 / fps);
}
ImGui::End();
}
} // namespace iglu::imgui
================================================
FILE: IGLU/imgui/Session.h
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
// @fb-only
#pragma once
#include "imgui.h"
#include <IGLU/imgui/InputListener.h>
#include <memory>
#include <shell/shared/input/InputDispatcher.h>
#include <igl/CommandBuffer.h>
#include <igl/Core.h>
#include <igl/Device.h>
#include <igl/Framebuffer.h>
#include <igl/RenderCommandEncoder.h>
namespace iglu::imgui {
class Session {
public:
void beginFrame(const igl::FramebufferDesc& desc, float displayScale);
void endFrame(igl::IDevice& device, igl::IRenderCommandEncoder& cmdEncoder);
Session(igl::IDevice& device,
igl::shell::InputDispatcher& inputDispatcher,
bool needInitializeSession = true);
~Session();
void initialize(igl::IDevice& device);
void drawFPS(float fps) const;
private:
class Renderer;
igl::shell::InputDispatcher& inputDispatcher_;
std::shared_ptr<InputListener> inputListener_;
ImGuiContext* context_;
std::unique_ptr<Renderer> renderer_;
bool isInitialized_ = false;
void makeCurrentContext() const;
};
} // namespace iglu::imgui
================================================
FILE: IGLU/imgui/compile_shaders.bat
================================================
@REM Copyright (c) Meta Platforms, Inc. and affiliates.
@REM
@REM This source code is licensed under the MIT license found in the
@REM LICENSE file in the root directory of this source tree.
@echo off
REM Compile D3D12 ImGui shaders
set FXC="C:\Program Files (x86)\Windows Kits\10\bin\10.0.22621.0\x64\fxc.exe"
echo Compiling vertex shader...
%FXC% /T vs_5_0 /E main /Fo imgui_vs_d3d12_fxc.cso imgui_vs_d3d12.hlsl
if %ERRORLEVEL% NEQ 0 (
echo Vertex shader compilation failed!
exit /b 1
)
echo Compiling pixel shader...
%FXC% /T ps_5_0 /E main /Fo imgui_ps_d3d12_fxc.cso imgui_ps_d3d12.hlsl
if %ERRORLEVEL% NEQ 0 (
echo Pixel shader compilation failed!
exit /b 1
)
echo Converting to C header files...
python -c "import sys; data = open('imgui_vs_d3d12_fxc.cso', 'rb').read(); print('unsigned char _tmp_imgui_vs_fxc_cso[] = {'); print(', '.join(f'0x{b:02x}' for b in data)); print('};'); print(f'unsigned int _tmp_imgui_vs_fxc_cso_len = {len(data)};')" > imgui_vs_d3d12_fxc.h
python -c "import sys; data = open('imgui_ps_d3d12_fxc.cso', 'rb').read(); print('unsigned char _tmp_imgui_ps_fxc_cso[] = {'); print(', '.join(f'0x{b:02x}' for b in data)); print('};'); print(f'unsigned int _tmp_imgui_ps_fxc_cso_len = {len(data)};')" > imgui_ps_d3d12_fxc.h
echo Done!
================================================
FILE: IGLU/imgui/compile_shaders.py
================================================
#!/usr/bin/env fbpython
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
"""Compile D3D12 ImGui shaders"""
import os
import subprocess
import sys
FXC = r"C:\Program Files (x86)\Windows Kits\10\bin\10.0.22621.0\x64\fxc.exe"
def compile_shader(shader_file, profile, output_cso):
"""Compile HLSL shader to CSO"""
print(f"Compiling {shader_file}...")
cmd = [FXC, "/T", profile, "/E", "main", "/Fo", output_cso, shader_file]
result = subprocess.run(cmd, capture_output=True, text=True)
if result.returncode != 0:
print(f"ERROR: {result.stderr}")
return False
print(f" SUCCESS: {output_cso}")
return True
def cso_to_header(cso_file, header_file, var_name):
"""Convert CSO binary to C header"""
print(f"Converting {cso_file} to {header_file}...")
with open(cso_file, "rb") as f:
data = f.read()
with open(header_file, "w") as f:
f.write(f"unsigned char {var_name}[] = {{\n")
for i in range(0, len(data), 12):
chunk = data[i : i + 12]
hex_bytes = ", ".join(f"0x{b:02x}" for b in chunk)
f.write(f" {hex_bytes},\n")
f.write("};\n")
f.write(f"unsigned int {var_name}_len = {len(data)};\n")
print(f" SUCCESS: {header_file} ({len(data)} bytes)")
def main():
os.chdir(os.path.dirname(os.path.abspath(__file__)))
# Compile vertex shader
if not compile_shader("imgui_vs_d3d12.hlsl", "vs_5_0", "imgui_vs_d3d12_fxc.cso"):
return 1
# Compile pixel shader
if not compile_shader("imgui_ps_d3d12.hlsl", "ps_5_0", "imgui_ps_d3d12_fxc.cso"):
return 1
# Convert to headers
cso_to_header(
"imgui_vs_d3d12_fxc.cso", "imgui_vs_d3d12_fxc.h", "_tmp_imgui_vs_fxc_cso"
)
cso_to_header(
"imgui_ps_d3d12_fxc.cso", "imgui_ps_d3d12_fxc.h", "_tmp_imgui_ps_fxc_cso"
)
print("\nAll shaders compiled successfully!")
return 0
if __name__ == "__main__":
sys.exit(main())
================================================
FILE: IGLU/imgui/imgui_ps_d3d12.hlsl
================================================
struct PSInput {
float4 position : SV_Position;
float4 color : COLOR;
float2 uv : TEXCOORD0;
};
Texture2D tex : register(t0);
SamplerState uSampler : register(s0);
float4 main(PSInput input) : SV_Target {
return input.color * tex.Sample(uSampler, input.uv);
}
================================================
FILE: IGLU/imgui/imgui_ps_d3d12_fxc.h
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
unsigned char _tmp_imgui_ps_fxc_cso[] = {
0x44, 0x58, 0x42, 0x43, 0xc7, 0x1a, 0xe2, 0x1a, 0x98, 0xf2, 0xe6, 0x19, 0xb5, 0xee, 0x27, 0x5c,
0x23, 0xba, 0x44, 0xe8, 0x01, 0x00, 0x00, 0x00, 0xdc, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
0x34, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x64, 0x01, 0x00, 0x00, 0x98, 0x01, 0x00, 0x00,
0x40, 0x02, 0x00, 0x00, 0x52, 0x44, 0x45, 0x46, 0xb4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x05, 0xff, 0xff,
0x00, 0x01, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0x52, 0x44, 0x31, 0x31, 0x3c, 0x00, 0x00, 0x00,
0x18, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x85, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x75, 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72,
0x00, 0x74, 0x65, 0x78, 0x00, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x28,
0x52, 0x29, 0x20, 0x48, 0x4c, 0x53, 0x4c, 0x20, 0x53, 0x68, 0x61, 0x64, 0x65, 0x72, 0x20, 0x43,
0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x20, 0x31, 0x30, 0x2e, 0x31, 0x00, 0xab, 0xab, 0xab,
0x49, 0x53, 0x47, 0x4e, 0x6c, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00,
0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x53, 0x56, 0x5f, 0x50, 0x6f, 0x73, 0x69, 0x74,
0x69, 0x6f, 0x6e, 0x00, 0x43, 0x4f, 0x4c, 0x4f, 0x52, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f,
0x52, 0x44, 0x00, 0xab, 0x4f, 0x53, 0x47, 0x4e, 0x2c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x08, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x53, 0x56, 0x5f, 0x54,
0x61, 0x72, 0x67, 0x65, 0x74, 0x00, 0xab, 0xab, 0x53, 0x48, 0x45, 0x58, 0xa0, 0x00, 0x00, 0x00,
0x50, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x6a, 0x08, 0x00, 0x01, 0x5a, 0x00, 0x00, 0x03,
0x00, 0x60, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x18, 0x00, 0x04, 0x00, 0x70, 0x10, 0x00,
0x00, 0x00, 0x00, 0x00, 0x55, 0x55, 0x00, 0x00, 0x62, 0x10, 0x00, 0x03, 0xf2, 0x10, 0x10, 0x00,
0x01, 0x00, 0x00, 0x00, 0x62, 0x10, 0x00, 0x03, 0x32, 0x10, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00,
0x65, 0x00, 0x00, 0x03, 0xf2, 0x20, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x02,
0x01, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x8b, 0xc2, 0x00, 0x00, 0x80, 0x43, 0x55, 0x15, 0x00,
0xf2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x10, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00,
0x46, 0x7e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
0x38, 0x00, 0x00, 0x07, 0xf2, 0x20, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x0e, 0x10, 0x00,
0x00, 0x00, 0x00, 0x00, 0x46, 0x1e, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x01,
0x53, 0x54, 0x41, 0x54, 0x94, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
unsigned int _tmp_imgui_ps_fxc_cso_len = 732;
================================================
FILE: IGLU/imgui/imgui_vs_d3d12.hlsl
================================================
cbuffer PushConstants : register(b2) {
float4x4 projectionMatrix;
};
struct VSInput {
float2 position : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct PSInput {
float4 position : SV_Position;
float4 color : COLOR;
float2 uv : TEXCOORD0;
};
PSInput main(VSInput input) {
PSInput output;
output.position = mul(projectionMatrix, float4(input.position.xy, 0, 1));
output.color = input.color;
output.uv = input.uv;
return output;
}
================================================
FILE: IGLU/imgui/imgui_vs_d3d12_fxc.h
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
unsigned char _tmp_imgui_vs_fxc_cso[] = {
0x44, 0x58, 0x42, 0x43, 0x88, 0x6b, 0x5b, 0xc2, 0xa4, 0x0d, 0x87, 0x32, 0x35, 0x37, 0x7f, 0xab,
0x1e, 0xce, 0x0b, 0xbf, 0x01, 0x00, 0x00, 0x00, 0xdc, 0x03, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
0x34, 0x00, 0x00, 0x00, 0x50, 0x01, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0x34, 0x02, 0x00, 0x00,
0x40, 0x03, 0x00, 0x00, 0x52, 0x44, 0x45, 0x46, 0x14, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x6c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x05, 0xfe, 0xff,
0x00, 0x01, 0x00, 0x00, 0xec, 0x00, 0x00, 0x00, 0x52, 0x44, 0x31, 0x31, 0x3c, 0x00, 0x00, 0x00,
0x18, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x75, 0x73, 0x68, 0x43, 0x6f, 0x6e, 0x73,
0x74, 0x61, 0x6e, 0x74, 0x73, 0x00, 0xab, 0xab, 0x5c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x84, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xac, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0xc8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x4d, 0x61, 0x74, 0x72, 0x69, 0x78, 0x00, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x78,
0x34, 0x00, 0xab, 0xab, 0x03, 0x00, 0x03, 0x00, 0x04, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xbd, 0x00, 0x00, 0x00, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66,
0x74, 0x20, 0x28, 0x52, 0x29, 0x20, 0x48, 0x4c, 0x53, 0x4c, 0x20, 0x53, 0x68, 0x61, 0x64, 0x65,
0x72, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x20, 0x31, 0x30, 0x2e, 0x31, 0x00,
0x49, 0x53, 0x47, 0x4e, 0x68, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x59, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00,
0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0x50, 0x4f, 0x53, 0x49, 0x54, 0x49, 0x4f, 0x4e,
0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44, 0x00, 0x43, 0x4f, 0x4c, 0x4f, 0x52, 0x00,
0x4f, 0x53, 0x47, 0x4e, 0x6c, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0x03, 0x0c, 0x00, 0x00, 0x53, 0x56, 0x5f, 0x50, 0x6f, 0x73, 0x69, 0x74,
0x69, 0x6f, 0x6e, 0x00, 0x43, 0x4f, 0x4c, 0x4f, 0x52, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f,
0x52, 0x44, 0x00, 0xab, 0x53, 0x48, 0x45, 0x58, 0x04, 0x01, 0x00, 0x00, 0x50, 0x00, 0x01, 0x00,
0x41, 0x00, 0x00, 0x00, 0x6a, 0x08, 0x00, 0x01, 0x59, 0x00, 0x00, 0x04, 0x46, 0x8e, 0x20, 0x00,
0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x5f, 0x00, 0x00, 0x03, 0x32, 0x10, 0x10, 0x00,
0x00, 0x00, 0x00, 0x00, 0x5f, 0x00, 0x00, 0x03, 0x32, 0x10, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00,
0x5f, 0x00, 0x00, 0x03, 0xf2, 0x10, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x04,
0xf2, 0x20, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x65, 0x00, 0x00, 0x03,
0xf2, 0x20, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x65, 0x00, 0x00, 0x03, 0x32, 0x20, 0x10, 0x00,
0x02, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x08,
0xf2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x15, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
0x46, 0x8e, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x0a,
0xf2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x8e, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x06, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x0e, 0x10, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0xf2, 0x20, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
0x46, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x8e, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00,
0x03, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x05, 0xf2, 0x20, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00,
0x46, 0x1e, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x05, 0x32, 0x20, 0x10, 0x00,
0x02, 0x00, 0x00, 0x00, 0x46, 0x10, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x01,
0x53, 0x54, 0x41, 0x54, 0x94, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
unsigned int _tmp_imgui_vs_fxc_cso_len = 988;
================================================
FILE: IGLU/managedUniformBuffer/ManagedUniformBuffer.cpp
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#include <IGLU/managedUniformBuffer/ManagedUniformBuffer.h>
#include <cstdlib>
#include <igl/Macros.h>
#if defined(IGL_CMAKE_BUILD)
#include <igl/IGLSafeC.h>
#else
#include <secure_lib/secure_string.h>
#endif
#if IGL_PLATFORM_APPLE
#include <unistd.h>
#if IGL_PLATFORM_IOS_SIMULATOR
#include <mach/mach_init.h>
#include <mach/mach_types.h>
#include <mach/vm_map.h>
#endif
#endif
namespace iglu {
ManagedUniformBuffer::ManagedUniformBuffer(igl::IDevice& device,
const ManagedUniformBufferInfo& info) :
uniformInfo(info) {
igl::BufferDesc desc;
desc.length = info.length;
if (!IGL_DEBUG_VERIFY(desc.length != 0)) {
result.code = igl::Result::Code::ArgumentInvalid;
return;
}
// Currently, the OpenGL code path always uses individual uniforms so no need to allocate a
// buffer.
bool createBuffer = device.getBackendType() != igl::BackendType::OpenGL;
// Allocate memory
if (device.getBackendType() == igl::BackendType::Metal) {
#if IGL_PLATFORM_APPLE
// Metal must be page aligned
auto pageSize = getpagesize();
length_ = desc.length;
const int roundVal = 16;
// bindBytes requires specific alignment. Algin to 16b is a safe bet.
length_ = ((length_ + roundVal - 1) / roundVal) * roundVal;
useBindBytes_ = (length_ < pageSize);
if (useBindBytes_) {
data_ = malloc(length_);
createBuffer = false;
} else {
auto pagesRequired = desc.length / pageSize;
if (desc.length % pageSize != 0) {
pagesRequired++;
}
desc.length = pagesRequired * pageSize;
#if IGL_PLATFORM_IOS_SIMULATOR
// The simulator will crash if we use memory created with posix_memalign, so we use this
// per what documentation says here
// https://developer.apple.com/documentation/metal/gpu_selection_in_macos/selecting_device_objects_for_compute_processing?language=objc#3544751
vmAllocLength_ = desc.length;
kern_return_t err = vm_allocate(
(vm_map_t)mach_task_self(), (vm_address_t*)&data_, vmAllocLength_, VM_FLAGS_ANYWHERE);
if (err != KERN_SUCCESS) {
data_ = nullptr;
}
#else
auto failure = posix_memalign(&data_, pageSize, desc.length);
if (failure) {
data_ = nullptr;
}
#endif
}
#endif
} else {
data_ = malloc(desc.length);
}
if (data_ == nullptr) {
result.code = igl::Result::Code::RuntimeError;
return;
}
if (createBuffer) {
desc.data = data_;
desc.type = igl::BufferDesc::BufferTypeBits::Uniform;
desc.storage = igl::ResourceStorage::Shared;
if (device.hasFeature(igl::DeviceFeatures::BufferNoCopy)) {
desc.type |= igl::BufferDesc::BufferAPIHintBits::NoCopy;
}
buffer_ = device.createBuffer(desc, &result);
}
}
ManagedUniformBuffer::~ManagedUniformBuffer() {
#if IGL_PLATFORM_IOS_SIMULATOR
if (vmAllocLength_) {
// if vmAllocLength_ is nonzero it implies we used vm_alloc to allocate the memory
vm_deallocate((vm_map_t)mach_task_self(), (vm_address_t)data_, vmAllocLength_);
} else {
#endif
free(data_);
#if IGL_PLATFORM_IOS_SIMULATOR
}
#endif
}
void ManagedUniformBuffer::bind(const igl::IDevice& device,
const igl::IRenderPipelineState& pipelineState,
igl::IRenderCommandEncoder& encoder) {
if (device.getBackendType() == igl::BackendType::OpenGL) {
#if IGL_BACKEND_OPENGL && !IGL_PLATFORM_MACCATALYST
for (auto& uniform : uniformInfo.uniforms) {
// Since the backend is opengl, getIndexByName's igl::ShaderStage parameter is ignored and
// will work when binding vertex/fragment
// Might be optimized to use NameHandle
uniform.location = pipelineState.getIndexByName(igl::genNameHandle(uniform.name),
igl::ShaderStage::Fragment);
if (uniform.location >= 0) {
encoder.bindUniform(uniform, data_);
} else {
IGL_LOG_ERROR_ONCE("The uniform %s was not found in shader\n", uniform.name.c_str());
}
}
#else
IGL_DEBUG_ABORT("Should not use OpenGL backend on Mac Catalyst, use Metal instead\n");
#endif
} else {
if (useBindBytes_) {
encoder.bindBytes(uniformInfo.index, igl::BindTarget::kAllGraphics, data_, length_);
} else {
// Need to ensure the latest data is present in the buffer
// TODO: Have callers handle this when data has changed.
void* data = data_;
if (buffer_->acceptedApiHints() & igl::BufferDesc::BufferAPIHintBits::NoCopy) {
data = nullptr;
}
buffer_->upload(data, {buffer_->getSizeInBytes(), 0});
encoder.bindBuffer(uniformInfo.index, buffer_.get());
}
}
}
void ManagedUniformBuffer::bind(const igl::IDevice& device,
const igl::IComputePipelineState& pipelineState,
igl::IComputeCommandEncoder& encoder) {
if (device.getBackendType() == igl::BackendType::OpenGL) {
for (auto& uniform : uniformInfo.uniforms) {
uniform.location = pipelineState.getIndexByName(igl::genNameHandle(uniform.name));
if (uniform.location >= 0) {
encoder.bindUniform(uniform, data_);
} else {
IGL_LOG_ERROR_ONCE("The uniform %s was not found in shader\n", uniform.name.c_str());
}
}
} else {
if (useBindBytes_) {
encoder.bindBytes(uniformInfo.index, data_, length_);
} else {
// Need to ensure the latest data is present in the buffer
// TODO: Have callers handle this when data has changed.
void* data = data_;
if (buffer_->acceptedApiHints() & igl::BufferDesc::BufferAPIHintBits::NoCopy) {
data = nullptr;
}
buffer_->upload(data, {buffer_->getSizeInBytes(), 0});
encoder.bindBuffer(static_cast<uint32_t>(uniformInfo.index), buffer_.get());
}
}
}
void* ManagedUniformBuffer::getData() {
return data_;
}
void ManagedUniformBuffer::buildUniformLUT() {
uniformLUT_ = std::make_unique<std::unordered_map<std::string, size_t>>();
for (size_t i = 0; i < uniformInfo.uniforms.size(); ++i) {
auto& uniform = uniformInfo.uniforms[i];
uniformLUT_->insert({uniform.name, i});
}
}
static int findUniformByName(const std::vector<igl::UniformDesc>& uniforms, const char* name) {
for (size_t i = 0; i < uniforms.size(); ++i) {
if (strcmp(name, uniforms[i].name.c_str()) == 0) {
return i;
}
}
return -1;
}
int ManagedUniformBuffer::getIndex(const char* name) const {
if (uniformLUT_) {
auto search = uniformLUT_->find(name);
return search != uniformLUT_->end() ? (int)search->second : -1;
} else {
return findUniformByName(uniformInfo.uniforms, name);
}
}
bool ManagedUniformBuffer::updateData(const char* name, const void* data, size_t dataSize) {
IGL_DEBUG_ASSERT(name);
const int index = getIndex(name);
if (index >= 0) {
auto& uniform = uniformInfo.uniforms[index];
if (strcmp(name, uniform.name.c_str()) == 0) {
// If dataSize is smaller than the expected size, we will just update as client requested.
// This could mean the user knows only a portion of the uniform data needs updating
// However, if dataSize is larger than or equal to what we expect for this uniform, we will
// only copy data up to the expected data size for this uniform
const size_t uniformDataSize = getUniformDataSizeInternal(uniform);
if (dataSize > uniformDataSize) {
dataSize = uniformDataSize;
#if IGL_DEBUG
IGL_LOG_INFO_ONCE(
"IGLU/ManagedBufferBuffer/updateData: dataSize is larger than expected. This could be "
"benign. See comments in updateData for more details. \n");
#endif
}
char* ptr = reinterpret_cast<char*>(data_);
checked_memcpy(ptr + uniform.offset, uniformDataSize, data, dataSize);
return true;
}
}
#ifndef GTEST
IGL_DEBUG_ABORT("call to updateData: uniform with name %s not found, skipping update\n", name);
#endif
return false;
}
size_t ManagedUniformBuffer::getUniformDataSize(const char* name) {
for (auto& uniform : uniformInfo.uniforms) {
if (strcmp(name, uniform.name.c_str()) == 0) {
return getUniformDataSizeInternal(uniform);
}
}
return 0;
}
// return the type of the uniform
// return igl::UniformType::Invalid if name invalid
igl::UniformType ManagedUniformBuffer::getUniformType(const char* name) const {
auto index = findUniformByName(uniformInfo.uniforms, name);
if (index != -1) {
const auto& u = uniformInfo.uniforms.at(index);
return u.type;
}
return igl::UniformType::Invalid;
}
size_t ManagedUniformBuffer::getUniformDataSizeInternal(igl::UniformDesc& uniform) {
const size_t uniformDataSize = uniform.elementStride != 0
? uniform.numElements * uniform.elementStride
: uniform.numElements * igl::sizeForUniformType(uniform.type);
return uniformDataSize;
}
} // namespace iglu
================================================
FILE: IGLU/managedUniformBuffer/ManagedUniformBuffer.h
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include <vector>
#include <igl/IGL.h>
namespace iglu {
struct ManagedUniformBufferInfo {
int index = -1;
size_t length = 0;
std::vector<igl::UniformDesc> uniforms;
};
class ManagedUniformBuffer {
public:
igl::Result result;
ManagedUniformBufferInfo uniformInfo;
ManagedUniformBuffer(igl::IDevice& device, const ManagedUniformBufferInfo& info);
~ManagedUniformBuffer();
// This function takes a chunk of data and use it to update the value of uniform 'name'
bool updateData(const char* name, const void* data, size_t dataSize);
// This function returns the expected data size for uniform with given name
// If uniform has type UniformType::Float3, this function will return
// 3 * sizeof(float) if elementStride is zero and return elementStride otherwise
// if no uniform with given name exists, the function will return 0
size_t getUniformDataSize(const char* name);
// return the type of the uniform
// return igl::UniformType::Invalid if name invalid
igl::UniformType getUniformType(const char* name) const;
void bind(const igl::IDevice& device,
const igl::IRenderPipelineState& pipelineState,
igl::IRenderCommandEncoder& encoder);
void bind(const igl::IDevice& device,
const igl::IComputePipelineState& pipelineState,
igl::IComputeCommandEncoder& encoder);
void* getData();
void buildUniformLUT();
int getIndex(const char* name) const;
private:
size_t getUniformDataSizeInternal(igl::UniformDesc& uniform);
void* data_ = nullptr;
int length_ = 0;
std::shared_ptr<igl::IBuffer> buffer_ = nullptr;
std::unique_ptr<std::unordered_map<std::string, size_t>> uniformLUT_ = nullptr;
#if IGL_PLATFORM_IOS_SIMULATOR
/// If we're in the simulator we need to hold onto length so we can deallocate memory buffer
/// properly.
/// If this is non-zero implies that we used vm alloc to allocate the memory instead of malloc
/// since we don't hold onto the device to be able to use in the destructor
size_t vmAllocLength_ = 0;
#endif
bool useBindBytes_ = false;
};
} // namespace iglu
================================================
FILE: IGLU/sentinel/Assert.h
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include <igl/Assert.h>
#define IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert) \
IGL_DEBUG_ASSERT(!(shouldAssert), "Sentinel implementation should NOT be reached")
================================================
FILE: IGLU/sentinel/Buffer.cpp
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
// @MARK:COVERAGE_EXCLUDE_FILE
#include <IGLU/sentinel/Buffer.h>
#include <IGLU/sentinel/Assert.h>
#include <igl/IGL.h>
namespace iglu::sentinel {
Buffer::Buffer(bool shouldAssert, size_t size) : size_(size), shouldAssert_(shouldAssert) {}
igl::Result Buffer::upload(const void* IGL_NULLABLE /*data*/, const igl::BufferRange& /*range*/) {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return igl::Result(igl::Result::Code::Unimplemented, "Not Implemented");
}
void* IGL_NULLABLE Buffer::map(const igl::BufferRange& /*range*/,
igl::Result* IGL_NULLABLE /*outResult*/) {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return nullptr;
}
void Buffer::unmap() {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
}
igl::BufferDesc::BufferAPIHint Buffer::requestedApiHints() const noexcept {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return 0;
}
igl::BufferDesc::BufferAPIHint Buffer::acceptedApiHints() const noexcept {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return 0;
}
igl::ResourceStorage Buffer::storage() const noexcept {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return igl::ResourceStorage::Invalid;
}
size_t Buffer::getSizeInBytes() const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return size_;
}
uint64_t Buffer::gpuAddress(size_t /*offset*/) const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return 0;
}
igl::BufferDesc::BufferType Buffer::getBufferType() const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return 0;
}
} // namespace iglu::sentinel
================================================
FILE: IGLU/sentinel/Buffer.h
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include <igl/Buffer.h>
namespace iglu::sentinel {
/**
* Sentinel Buffer intended for safe use where access to a real buffer is not available.
* Use cases include returning a reference to a buffer from a raw pointer when a valid buffer is not
* available.
* All methods return nullptr, the default value or an error.
*/
class Buffer : public igl::IBuffer {
public:
explicit Buffer(bool shouldAssert = true, size_t size = 0);
[[nodiscard]] igl::Result upload(const void* IGL_NULLABLE data,
const igl::BufferRange& range) final;
void* IGL_NULLABLE map(const igl::BufferRange& range, igl::Result* IGL_NULLABLE outResult) final;
void unmap() final;
[[nodiscard]] igl::BufferDesc::BufferAPIHint requestedApiHints() const noexcept final;
[[nodiscard]] igl::BufferDesc::BufferAPIHint acceptedApiHints() const noexcept final;
[[nodiscard]] igl::ResourceStorage storage() const noexcept final;
[[nodiscard]] size_t getSizeInBytes() const final;
[[nodiscard]] uint64_t gpuAddress(size_t offset = 0) const final;
[[nodiscard]] igl::BufferDesc::BufferType getBufferType() const final;
private:
size_t size_;
[[maybe_unused]] bool shouldAssert_;
};
} // namespace iglu::sentinel
================================================
FILE: IGLU/sentinel/CommandBuffer.cpp
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
// @MARK:COVERAGE_EXCLUDE_FILE
#include <IGLU/sentinel/CommandBuffer.h>
#include <IGLU/sentinel/Assert.h>
#include <igl/IGL.h>
namespace iglu::sentinel {
CommandBuffer::CommandBuffer(bool shouldAssert) :
igl::ICommandBuffer({.debugName = "SentinelCommandBuffer"}), shouldAssert_(shouldAssert) {}
std::unique_ptr<igl::IRenderCommandEncoder> CommandBuffer::createRenderCommandEncoder(
const igl::RenderPassDesc& /*renderPass*/,
const std::shared_ptr<igl::IFramebuffer>& /*framebuffer*/,
const igl::Dependencies& /*dependencies*/,
igl::Result* IGL_NULLABLE /*outResult*/) {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return nullptr;
}
std::unique_ptr<igl::IComputeCommandEncoder> CommandBuffer::createComputeCommandEncoder() {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return nullptr;
}
void CommandBuffer::present(const std::shared_ptr<igl::ITexture>& /*surface*/) const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
}
void CommandBuffer::waitUntilScheduled() {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
}
void CommandBuffer::waitUntilCompleted() {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
}
void CommandBuffer::pushDebugGroupLabel(const char* /*label*/, const igl::Color& /*color*/) const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
}
void CommandBuffer::popDebugGroupLabel() const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
}
void CommandBuffer::copyBuffer(igl::IBuffer& src,
igl::IBuffer& dst,
uint64_t srcOffset,
uint64_t dstOffset,
uint64_t size) {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
}
void CommandBuffer::copyTextureToBuffer(igl::ITexture& src,
igl::IBuffer& dst,
uint64_t dstOffset,
uint32_t level,
uint32_t layer) {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
}
} // namespace iglu::sentinel
================================================
FILE: IGLU/sentinel/CommandBuffer.h
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include <igl/CommandBuffer.h>
namespace iglu::sentinel {
/**
* Sentinel CommandBuffer intended for safe use where access to a real command buffer is not
* available.
* Use cases include returning a reference to a command buffer from a raw pointer when a
* valid command buffer is not available.
* All methods return nullptr, the default value or an error.
*/
class CommandBuffer final : public igl::ICommandBuffer {
public:
explicit CommandBuffer(bool shouldAssert = true);
[[nodiscard]] std::unique_ptr<igl::IRenderCommandEncoder> createRenderCommandEncoder(
const igl::RenderPassDesc& /*renderPass*/,
const std::shared_ptr<igl::IFramebuffer>& /*framebuffer*/,
const igl::Dependencies& /*dependencies*/,
igl::Result* IGL_NULLABLE /*outResult*/) final;
[[nodiscard]] std::unique_ptr<igl::IComputeCommandEncoder> createComputeCommandEncoder() final;
void present(const std::shared_ptr<igl::ITexture>& /*surface*/) const final;
void waitUntilScheduled() final;
void waitUntilCompleted() final;
void pushDebugGroupLabel(const char* IGL_NONNULL /*label*/,
const igl::Color& /*color*/ = igl::Color(1, 1, 1, 1)) const final;
void popDebugGroupLabel() const final;
void copyBuffer(igl::IBuffer& src,
igl::IBuffer& dst,
uint64_t srcOffset,
uint64_t dstOffset,
uint64_t size) final;
void copyTextureToBuffer(igl::ITexture& src,
igl::IBuffer& dst,
uint64_t dstOffset,
uint32_t level,
uint32_t layer) final;
private:
[[maybe_unused]] bool shouldAssert_;
};
} // namespace iglu::sentinel
================================================
FILE: IGLU/sentinel/CommandQueue.cpp
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
// @MARK:COVERAGE_EXCLUDE_FILE
#include <IGLU/sentinel/CommandQueue.h>
#include <IGLU/sentinel/Assert.h>
namespace iglu::sentinel {
CommandQueue::CommandQueue(bool shouldAssert) : shouldAssert_(shouldAssert) {}
std::shared_ptr<igl::ICommandBuffer> CommandQueue::createCommandBuffer(
const igl::CommandBufferDesc& /*desc*/,
igl::Result* IGL_NULLABLE
/*outResult*/) {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return nullptr;
}
igl::SubmitHandle CommandQueue::submit(const igl::ICommandBuffer& /*commandBuffer*/,
bool /*endOfFrame*/) {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return 0;
}
} // namespace iglu::sentinel
================================================
FILE: IGLU/sentinel/CommandQueue.h
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include <igl/CommandQueue.h>
namespace iglu::sentinel {
/**
* Sentinel CommandQueue intended for safe use where access to a real command queue is not
* available.
* Use cases include returning a reference to a command queue from a raw pointer when a
* valid command queue is not available.
* All methods return nullptr, the default value or an error.
*/
class CommandQueue final : public igl::ICommandQueue {
public:
explicit CommandQueue(bool shouldAssert = true);
[[nodiscard]] std::shared_ptr<igl::ICommandBuffer> createCommandBuffer(
const igl::CommandBufferDesc& desc,
igl::Result* IGL_NULLABLE outResult) final;
igl::SubmitHandle submit(const igl::ICommandBuffer& commandBuffer, bool endOfFrame = false) final;
private:
[[maybe_unused]] bool shouldAssert_;
};
} // namespace iglu::sentinel
================================================
FILE: IGLU/sentinel/Device.cpp
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
// @MARK:COVERAGE_EXCLUDE_FILE
#include <IGLU/sentinel/Device.h>
#include <IGLU/sentinel/Assert.h>
#include <IGLU/sentinel/PlatformDevice.h>
#include <igl/IGL.h>
namespace iglu::sentinel {
Device::Device(bool shouldAssert) : platformDevice_(shouldAssert), shouldAssert_(shouldAssert) {}
bool Device::hasFeature(igl::DeviceFeatures /*feature*/) const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return false;
}
bool Device::hasRequirement(igl::DeviceRequirement /*requirement*/) const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return false;
}
igl::ICapabilities::TextureFormatCapabilities Device::getTextureFormatCapabilities(
igl::TextureFormat /*format*/) const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return TextureFormatCapabilityBits::Unsupported;
}
bool Device::getFeatureLimits(igl::DeviceFeatureLimits /*featureLimits*/,
size_t& /*result*/) const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return false;
}
igl::ShaderVersion Device::getShaderVersion() const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return {};
}
igl::BackendVersion Device::getBackendVersion() const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return {};
}
std::shared_ptr<igl::ICommandQueue> Device::createCommandQueue(
const igl::CommandQueueDesc& /*desc*/,
igl::Result* IGL_NULLABLE /*outResult*/) noexcept {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return nullptr;
}
std::unique_ptr<igl::IBuffer> Device::createBuffer(
const igl::BufferDesc& /*desc*/,
igl::Result* IGL_NULLABLE /*outResult*/) const noexcept {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return nullptr;
}
std::shared_ptr<igl::IDepthStencilState> Device::createDepthStencilState(
const igl::DepthStencilStateDesc& /*desc*/,
igl::Result* IGL_NULLABLE /*outResult*/) const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return nullptr;
}
std::shared_ptr<igl::ISamplerState> Device::createSamplerState(
const igl::SamplerStateDesc& /*desc*/,
igl::Result* IGL_NULLABLE
/*outResult*/) const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return nullptr;
}
std::shared_ptr<igl::ITexture> Device::createTexture(const igl::TextureDesc& /*desc*/,
igl::Result* IGL_NULLABLE
/*outResult*/) const noexcept {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return nullptr;
}
std::shared_ptr<igl::ITexture> Device::createTextureView(
std::shared_ptr<igl::ITexture> texture,
const igl::TextureViewDesc& desc,
igl::Result* IGL_NULLABLE /*outResult*/) const noexcept {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return nullptr;
}
std::shared_ptr<igl::IVertexInputState> Device::createVertexInputState(
const igl::VertexInputStateDesc& /*desc*/,
igl::Result* IGL_NULLABLE /*outResult*/) const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return nullptr;
}
std::shared_ptr<igl::IComputePipelineState> Device::createComputePipeline(
const igl::ComputePipelineDesc& /*desc*/,
igl::Result* IGL_NULLABLE /*outResult*/) const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return nullptr;
}
std::shared_ptr<igl::IRenderPipelineState> Device::createRenderPipeline(
const igl::RenderPipelineDesc& /*desc*/,
igl::Result* IGL_NULLABLE /*outResult*/) const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return nullptr;
}
std::shared_ptr<igl::IShaderModule> Device::createShaderModule(
const igl::ShaderModuleDesc& /*desc*/,
igl::Result* IGL_NULLABLE
/*outResult*/) const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return nullptr;
}
std::shared_ptr<igl::IFramebuffer> Device::createFramebuffer(
const igl::FramebufferDesc& /*desc*/,
igl::Result* IGL_NULLABLE /*outResult*/) {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return nullptr;
}
const igl::IPlatformDevice& Device::getPlatformDevice() const noexcept {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return platformDevice_;
}
bool Device::verifyScope() {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return false;
}
igl::BackendType Device::getBackendType() const {
return igl::BackendType::Invalid;
}
size_t Device::getCurrentDrawCount() const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return 0;
}
size_t Device::getShaderCompilationCount() const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return 0;
}
std::unique_ptr<igl::IShaderLibrary> Device::createShaderLibrary(
const igl::ShaderLibraryDesc& /*desc*/,
igl::Result* IGL_NULLABLE
/*outResult*/) const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return nullptr;
}
void Device::updateSurface(void* IGL_NONNULL /*nativeWindowType*/) {}
std::unique_ptr<igl::IShaderStages> Device::createShaderStages(
const igl::ShaderStagesDesc& /*desc*/,
igl::Result* IGL_NULLABLE
/*outResult*/) const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return nullptr;
}
igl::Holder<igl::BindGroupTextureHandle> Device::createBindGroup(
const igl::BindGroupTextureDesc& /*desc*/,
const igl::IRenderPipelineState* IGL_NULLABLE /*compatiblePipeline*/,
igl::Result* IGL_NULLABLE /*outResult*/) {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return {};
}
igl::Holder<igl::BindGroupBufferHandle> Device::createBindGroup(
const igl::BindGroupBufferDesc& /*desc*/,
igl::Result* IGL_NULLABLE /*outResult*/) {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return {};
}
std::shared_ptr<igl::ITimer> Device::createTimer(
igl::Result* IGL_NULLABLE /*outResult*/) const noexcept {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return {};
}
void Device::destroy(igl::BindGroupTextureHandle /*handle*/) {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
}
void Device::destroy(igl::BindGroupBufferHandle /*handle*/) {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
}
void Device::destroy(igl::SamplerHandle /*handle*/) {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
}
} // namespace iglu::sentinel
================================================
FILE: IGLU/sentinel/Device.h
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include <IGLU/sentinel/PlatformDevice.h>
#include <igl/Device.h>
namespace iglu::sentinel {
/**
* Sentinel Device intended for safe use where access to a real device is not available.
* Use cases include returning a reference to a device from a raw pointer when a valid device is not
* available.
* All methods return nullptr, the default value or an error.
*/
class Device final : public igl::IDevice {
public:
explicit Device(bool shouldAssert = true);
[[nodiscard]] igl::Holder<igl::BindGroupTextureHandle> createBindGroup(
const igl::BindGroupTextureDesc& desc,
const igl::IRenderPipelineState* IGL_NULLABLE compatiblePipeline,
igl::Result* IGL_NULLABLE outResult) final;
[[nodiscard]] igl::Holder<igl::BindGroupBufferHandle> createBindGroup(
const igl::BindGroupBufferDesc& desc,
igl::Result* IGL_NULLABLE outResult) final;
void destroy(igl::BindGroupTextureHandle handle) final;
void destroy(igl::BindGroupBufferHandle handle) final;
void destroy(igl::SamplerHandle handle) final;
[[nodiscard]] bool hasFeature(igl::DeviceFeatures feature) const final;
[[nodiscard]] bool hasRequirement(igl::DeviceRequirement requirement) const final;
[[nodiscard]] TextureFormatCapabilities getTextureFormatCapabilities(
igl::TextureFormat format) const final;
[[nodiscard]] bool getFeatureLimits(igl::DeviceFeatureLimits featureLimits,
size_t& result) const final;
[[nodiscard]] igl::ShaderVersion getShaderVersion() const final;
[[nodiscard]] igl::BackendVersion getBackendVersion() const final;
[[nodiscard]] std::shared_ptr<igl::ICommandQueue> createCommandQueue(
const igl::CommandQueueDesc& desc,
igl::Result* IGL_NULLABLE outResult) noexcept final;
[[nodiscard]] std::unique_ptr<igl::IBuffer> createBuffer(const igl::BufferDesc& desc,
igl::Result* IGL_NULLABLE
outResult) const noexcept final;
[[nodiscard]] std::shared_ptr<igl::IDepthStencilState> createDepthStencilState(
const igl::DepthStencilStateDesc& desc,
igl::Result* IGL_NULLABLE outResult) const final;
[[nodiscard]] std::shared_ptr<igl::ISamplerState> createSamplerState(
const igl::SamplerStateDesc& desc,
igl::Result* IGL_NULLABLE outResult) const final;
[[nodiscard]] std::shared_ptr<igl::ITexture> createTexture(const igl::TextureDesc& desc,
igl::Result* IGL_NULLABLE
outResult) const noexcept final;
[[nodiscard]] std::shared_ptr<igl::ITexture> createTextureView(
std::shared_ptr<igl::ITexture> texture,
const igl::TextureViewDesc& desc,
igl::Result* IGL_NULLABLE outResult) const noexcept final;
[[nodiscard]] std::shared_ptr<igl::IVertexInputState> createVertexInputState(
const igl::VertexInputStateDesc& desc,
igl::Result* IGL_NULLABLE outResult) const final;
[[nodiscard]] std::shared_ptr<igl::IComputePipelineState> createComputePipeline(
const igl::ComputePipelineDesc& desc,
igl::Result* IGL_NULLABLE outResult) const final;
[[nodiscard]] std::shared_ptr<igl::IRenderPipelineState> createRenderPipeline(
const igl::RenderPipelineDesc& desc,
igl::Result* IGL_NULLABLE outResult) const final;
[[nodiscard]] std::shared_ptr<igl::IShaderModule> createShaderModule(
const igl::ShaderModuleDesc& desc,
igl::Result* IGL_NULLABLE outResult) const final;
[[nodiscard]] std::shared_ptr<igl::IFramebuffer> createFramebuffer(
const igl::FramebufferDesc& desc,
igl::Result* IGL_NULLABLE outResult) final;
[[nodiscard]] std::shared_ptr<igl::ITimer> createTimer(
igl::Result* IGL_NULLABLE outResult) const noexcept final;
[[nodiscard]] const igl::IPlatformDevice& getPlatformDevice() const noexcept final;
[[nodiscard]] bool verifyScope() final;
[[nodiscard]] igl::BackendType getBackendType() const final;
[[nodiscard]] size_t getCurrentDrawCount() const final;
[[nodiscard]] size_t getShaderCompilationCount() const final;
[[nodiscard]] std::unique_ptr<igl::IShaderLibrary> createShaderLibrary(
const igl::ShaderLibraryDesc& desc,
igl::Result* IGL_NULLABLE outResult) const final;
void updateSurface(void* IGL_NONNULL nativeWindowType) final;
[[nodiscard]] std::unique_ptr<igl::IShaderStages> createShaderStages(
const igl::ShaderStagesDesc& desc,
igl::Result* IGL_NULLABLE outResult) const final;
[[nodiscard]] void* IGL_NULLABLE getNativeDevice() const override {
return nullptr;
}
private:
PlatformDevice platformDevice_;
[[maybe_unused]] bool shouldAssert_;
};
} // namespace iglu::sentinel
================================================
FILE: IGLU/sentinel/Framebuffer.cpp
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
// @MARK:COVERAGE_EXCLUDE_FILE
#include <IGLU/sentinel/Framebuffer.h>
#include <IGLU/sentinel/Assert.h>
namespace iglu::sentinel {
Framebuffer::Framebuffer(bool shouldAssert) : shouldAssert_(shouldAssert) {}
std::vector<size_t> Framebuffer::getColorAttachmentIndices() const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return {};
}
std::shared_ptr<igl::ITexture> Framebuffer::getColorAttachment(size_t /*index*/) const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return nullptr;
}
std::shared_ptr<igl::ITexture> Framebuffer::getResolveColorAttachment(size_t /*index*/) const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return nullptr;
}
std::shared_ptr<igl::ITexture> Framebuffer::getDepthAttachment() const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return nullptr;
}
std::shared_ptr<igl::ITexture> Framebuffer::getResolveDepthAttachment() const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return nullptr;
}
std::shared_ptr<igl::ITexture> Framebuffer::getStencilAttachment() const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return nullptr;
}
igl::FramebufferMode Framebuffer::getMode() const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return igl::FramebufferMode::Mono;
}
bool Framebuffer::isSwapchainBound() const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return false;
}
void Framebuffer::copyBytesColorAttachment(igl::ICommandQueue& /*cmdQueue*/,
size_t /*index*/,
void* /*pixelBytes*/,
const igl::TextureRangeDesc& /*range*/,
size_t /*bytesPerRow*/) const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
}
void Framebuffer::copyBytesDepthAttachment(igl::ICommandQueue& /*cmdQueue*/,
void* /*pixelBytes*/,
const igl::TextureRangeDesc& /*range*/,
size_t /*bytesPerRow*/) const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
}
void Framebuffer::copyBytesStencilAttachment(igl::ICommandQueue& /*cmdQueue*/,
void* /*pixelBytes*/,
const igl::TextureRangeDesc& /*range*/,
size_t /*bytesPerRow*/) const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
}
void Framebuffer::copyTextureColorAttachment(igl::ICommandQueue& /*cmdQueue*/,
size_t /*index*/,
std::shared_ptr<igl::ITexture> /*destTexture*/,
const igl::TextureRangeDesc& /*range*/) const {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
}
void Framebuffer::updateDrawable(std::shared_ptr<igl::ITexture> /*texture*/) {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
}
void Framebuffer::updateDrawable(igl::SurfaceTextures /*surfaceTextures*/) {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
}
void Framebuffer::updateResolveAttachment(std::shared_ptr<igl::ITexture> /*texture*/) {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
}
} // namespace iglu::sentinel
================================================
FILE: IGLU/sentinel/Framebuffer.h
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include <igl/Framebuffer.h>
namespace iglu::sentinel {
/**
* Sentinel Frambuffer intended for safe use where access to a real framebuffer is not available.
* Use cases include returning a reference to a framebuffer from a raw pointer when a
* valid framebuffer is not available.
* All methods return nullptr, the default value or an error.
*/
class Framebuffer : public igl::IFramebuffer {
public:
explicit Framebuffer(bool shouldAssert = true);
[[nodiscard]] std::vector<size_t> getColorAttachmentIndices() const final;
[[nodiscard]] std::shared_ptr<igl::ITexture> getColorAttachment(size_t index) const final;
[[nodiscard]] std::shared_ptr<igl::ITexture> getResolveColorAttachment(size_t index) const final;
[[nodiscard]] std::shared_ptr<igl::ITexture> getDepthAttachment() const final;
[[nodiscard]] std::shared_ptr<igl::ITexture> getResolveDepthAttachment() const final;
[[nodiscard]] std::shared_ptr<igl::ITexture> getStencilAttachment() const final;
[[nodiscard]] igl::FramebufferMode getMode() const final;
[[nodiscard]] bool isSwapchainBound() const final;
void copyBytesColorAttachment(igl::ICommandQueue& cmdQueue,
size_t index,
void* pixelBytes,
const igl::TextureRangeDesc& range,
size_t bytesPerRow = 0) const final;
void copyBytesDepthAttachment(igl::ICommandQueue& cmdQueue,
void* pixelBytes,
const igl::TextureRangeDesc& range,
size_t bytesPerRow = 0) const final;
void copyBytesStencilAttachment(igl::ICommandQueue& cmdQueue,
void* pixelBytes,
const igl::TextureRangeDesc& range,
size_t bytesPerRow = 0) const final;
void copyTextureColorAttachment(igl::ICommandQueue& cmdQueue,
size_t index,
std::shared_ptr<igl::ITexture> destTexture,
const igl::TextureRangeDesc& range) const final;
void updateDrawable(std::shared_ptr<igl::ITexture> texture) final;
void updateDrawable(igl::SurfaceTextures surfaceTextures) final;
void updateResolveAttachment(std::shared_ptr<igl::ITexture> texture) final;
private:
[[maybe_unused]] bool shouldAssert_;
};
} // namespace iglu::sentinel
================================================
FILE: IGLU/sentinel/PlatformDevice.cpp
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
// @MARK:COVERAGE_EXCLUDE_FILE
#include <IGLU/sentinel/PlatformDevice.h>
#include <IGLU/sentinel/Assert.h>
namespace iglu::sentinel {
PlatformDevice::PlatformDevice(bool shouldAssert) : shouldAssert_(shouldAssert) {}
bool PlatformDevice::isType(igl::PlatformDeviceType /*t*/) const noexcept {
IGLU_SENTINEL_ASSERT_IF_NOT(shouldAssert_);
return false;
}
} // namespace iglu::sentinel
================================================
FILE: IGLU/sentinel/PlatformDevice.h
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include <igl/PlatformDevice.h>
namespace iglu::sentinel {
/**
* Sentinel PlatformDevice intended for safe use where access to a real platform device is not
* available.
* Use cases include returning a reference to a platform device from a raw pointer when a
* valid platform device is not available.
* All methods return nullptr, the default value or an error.
*/
class PlatformDevice final : public igl::IPlatformDevice {
public:
explicit PlatformDevice(bool shouldAssert = true);
[[nodiscard]] bool isType(igl::PlatformDeviceType t) const noexcept final;
private:
[[maybe_unused]] bool shouldAssert_;
};
} // namespace iglu::sentinel
================================================
FILE: IGLU/shaderCross/ShaderCross.cpp
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#include <IGLU/shaderCross/ShaderCross.h>
#include <algorithm>
#include <spirv_glsl.hpp>
#include <spirv_msl.hpp>
#include <vector>
#include <igl/glslang/GlslCompiler.h>
#include <igl/glslang/GlslangHelpers.h>
namespace iglu {
ShaderCross::ShaderCross(igl::IDevice& device) noexcept : device_(device) {
igl::glslang::initializeCompiler();
}
ShaderCross::~ShaderCross() noexcept {
igl::glslang::finalizeCompiler();
}
std::string ShaderCross::entryPointName(igl::ShaderStage /*stage*/) const noexcept {
if (device_.getBackendType() == igl::BackendType::Metal) {
return "main0";
}
if (device_.getBackendType() == igl::BackendType::OpenGL) {
return "main";
}
return {};
}
std::string ShaderCross::crossCompileFromVulkanSource(const char* source,
igl::ShaderStage stage,
igl::Result* IGL_NULLABLE
outResult) const noexcept {
if (device_.getBackendType() == igl::BackendType::Vulkan) {
return source;
}
// Compile to SPIR-V.
std::vector<uint32_t> spirvCode;
glslang_resource_t resource{};
glslangGetDefaultResource(&resource);
const auto result = igl::glslang::compileShader(stage, source, spirvCode, &resource);
if (!result.isOk()) {
if (outResult) {
*outResult = result;
}
return {};
}
// Cross-compile to MSL.
if (device_.getBackendType() == igl::BackendType::Metal) {
spirv_cross::CompilerMSL mslCompiler(std::move(spirvCode));
spirv_cross::CompilerMSL::Options options;
#if IGL_PLATFORM_MACOSX
options.platform = spirv_cross::CompilerMSL::Options::macOS;
#else
options.platform = spirv_cross::CompilerMSL::Options::iOS;
#endif
options.set_msl_version(2, 2);
options.enable_decoration_binding = true;
mslCompiler.set_msl_options(options);
try {
return mslCompiler.compile();
} catch (const spirv_cross::CompilerError& e) {
if (outResult) {
*outResult = igl::Result(igl::Result::Code::RuntimeError, e.what());
}
return {};
}
}
// Cross-compile to GLSL.
if (device_.getBackendType() == igl::BackendType::OpenGL) {
const auto shaderVersion = device_.getShaderVersion();
spirv_cross::CompilerGLSL glslCompiler(std::move(spirvCode));
spirv_cross::CompilerGLSL::Options options;
options.version =
static_cast<uint32_t>(shaderVersion.majorVersion * 100) + shaderVersion.minorVersion;
options.es = (shaderVersion.family == igl::ShaderFamily::GlslEs);
options.emit_push_constant_as_uniform_buffer = true;
options.emit_uniform_buffer_as_plain_uniforms = true;
options.enable_420pack_extension = device_.hasFeature(igl::DeviceFeatures::ExplicitBindingExt);
// In multiview mode in IGL, 2 views are always used.
const auto& exts = glslCompiler.get_declared_extensions();
const auto& caps = glslCompiler.get_declared_capabilities();
if (stage == igl::ShaderStage::Vertex &&
(std::any_of(std::begin(exts),
std::end(exts),
[](const std::string& ext) { return ext == "GL_OVR_multiview2"; }) ||
std::any_of(std::begin(caps), std::end(caps), [](const spv::Capability cap) {
return cap == spv::Capability::CapabilityMultiView;
}))) {
options.ovr_multiview_view_count = 2;
}
glslCompiler.set_common_options(options);
try {
return glslCompiler.compile();
} catch (const spirv_cross::CompilerError& e) {
if (outResult) {
*outResult = igl::Result(igl::Result::Code::RuntimeError, e.what());
}
return {};
}
}
if (outResult) {
*outResult =
igl::Result(igl::Result::Code::Unimplemented, "Cross-compilation is not implemented.");
}
return {};
}
} // namespace iglu
================================================
FILE: IGLU/shaderCross/ShaderCross.h
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include <string>
#include <igl/IGL.h>
namespace iglu {
/// Wrapper for SPIR-V cross compiler to generate IGL-compatible shader sources for different
/// backends.
class ShaderCross final {
public:
explicit ShaderCross(igl::IDevice& device) noexcept;
~ShaderCross() noexcept;
ShaderCross(const ShaderCross&) = delete;
ShaderCross& operator=(const ShaderCross&) = delete;
ShaderCross(ShaderCross&&) = delete;
ShaderCross& operator=(ShaderCross&&) = delete;
[[nodiscard]] std::string entryPointName(igl::ShaderStage stage) const noexcept;
[[nodiscard]] std::string crossCompileFromVulkanSource(const char* source,
igl::ShaderStage stage,
igl::Result* IGL_NULLABLE
outResult) const noexcept;
private:
igl::IDevice& device_;
};
} // namespace iglu
================================================
FILE: IGLU/shaderCross/ShaderCrossUniformBuffer.cpp
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#include <IGLU/shaderCross/ShaderCrossUniformBuffer.h>
namespace iglu {
namespace {
[[nodiscard]] ManagedUniformBufferInfo getSpirvCrossCompatibleManagedUniformBufferInfo(
const std::string& uboBlockName,
ManagedUniformBufferInfo info) noexcept {
for (auto& uniform : info.uniforms) {
uniform.name = uboBlockName + "." + uniform.name;
}
return info;
}
} // namespace
ShaderCrossUniformBuffer::ShaderCrossUniformBuffer(igl::IDevice& device,
const std::string& uboBlockName,
ManagedUniformBufferInfo info) :
ManagedUniformBuffer(
device,
getSpirvCrossCompatibleManagedUniformBufferInfo(uboBlockName, std::move(info))) {}
} // namespace iglu
================================================
FILE: IGLU/shaderCross/ShaderCrossUniformBuffer.h
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include <IGLU/managedUniformBuffer/ManagedUniformBuffer.h>
#include <string>
namespace iglu {
/// Extension for ManagedUniformBuffer that enables OpenGL bindings in the form
/// they implemented in SPIRV-Cross (UBOs are converted to plain uniforms).
class ShaderCrossUniformBuffer : public ManagedUniformBuffer {
public:
ShaderCrossUniformBuffer(igl::IDevice& device,
const std::string& uboBlockName,
ManagedUniformBufferInfo info);
};
} // namespace iglu
================================================
FILE: IGLU/simdtypes/SimdTypes.h
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include <cassert>
// This would use IGL defines, but we can avoid importing all of IGL by doing this
#if defined(__APPLE__)
#include <simd/simd.h>
#endif // defined(__APPLE__)
/// Polyfill to make it so we don't have to have ifdefs in code
namespace iglu::simdtypes {
// Use Apple-provided simd if available.
#if defined(__APPLE__)
using float4x4 = simd::float4x4;
using float3x3 = simd::float3x3;
using float3x4 = simd::float3x4;
using float2x2 = simd::float2x2;
using float4 = simd::float4;
using float3 = simd::float3;
using float2 = simd::float2;
using float1 = simd::float1;
using int1 = simd::int1;
using int2 = simd::int2;
using int3 = simd::int3;
using int4 = simd::int4;
using bool1 = simd_bool;
#else
// Apple simd is not available, make use custom.
#if defined(__clang__)
using float4 = float __attribute__((ext_vector_type(4)));
// simd/vector_types.h
// Vectors of this type are padded to have the same size and alignment as simd_float4.
using float3 = float __attribute__((ext_vector_type(4)));
using float2 = float __attribute__((ext_vector_type(2)));
using float1 = float;
using int1 = int;
using int2 = int __attribute__((ext_vector_type(2)));
// Vectors of this type are padded to have the same size and alignment as simd_float4.
using int3 = int __attribute__((ext_vector_type(4)));
using int4 = int __attribute__((ext_vector_type(4)));
using bool1 = bool;
#elif defined(__GNUC__)
using float4 = float __attribute__((vector_size(sizeof(float) * 4)));
// simd/vector_types.h
// Vectors of this type are padded to have the same size and alignment as simd_float4.
using float3 = float __attribute__((vector_size(sizeof(float) * 4)));
using float2 = float __attribute__((vector_size(sizeof(float) * 2)));
using float1 = float;
using int1 = int;
using int2 = int __attribute__((vector_size(sizeof(float) * 2)));
// Vectors of this type are padded to have the same size and alignment as simd_float4.
using int3 = int __attribute__((vector_size(sizeof(int) * 4)));
using int4 = int __attribute__((vector_size(sizeof(float) * 4)));
using bool1 = bool;
#else
// Not available clang or GCC vector extensions - create custom structs
struct float4 final {
float x;
float y;
float z;
float w;
float operator[](const unsigned index) const {
assert(index < 4);
return (&x)[index];
}
float& operator[](const unsigned index) {
assert(index < 4);
return (&x)[index];
}
};
static_assert(sizeof(float4) == 4 * sizeof(float));
// simd/vector_types.h
// Vectors of this type are padded to have the same size and alignment as simd_float4.
using float3 = float4;
struct float2 final {
float x;
float y;
float operator[](const unsigned index) const {
assert(index < 2);
return (&x)[index];
}
float& operator[](const unsigned index) {
assert(index < 2);
return (&x)[index];
}
};
static_assert(sizeof(float2) == 2 * sizeof(float));
using float1 = float;
struct int4 final {
int x;
int y;
int z;
int w;
int operator[](const unsigned index) const {
assert(index < 4);
return (&x)[index];
}
int& operator[](const unsigned index) {
assert(index < 4);
return (&x)[index];
}
};
static_assert(sizeof(int4) == 4 * sizeof(int));
// Vectors of this type are padded to have the same size and alignment as simd_int4.
using int3 = int4;
struct int2 final {
int x;
int y;
int operator[](const unsigned index) const {
assert(index < 2);
return (&x)[index];
}
int& operator[](const unsigned index) {
assert(index < 2);
return (&x)[index];
}
};
static_assert(sizeof(int2) == 2 * sizeof(int));
using int1 = int;
using bool1 = bool;
#endif
struct Float4x4 {
float4 columns[4];
Float4x4() = default;
explicit Float4x4(float val) {
columns[0] = float4{val, 0.0, 0.0, 0.0};
columns[1] = float4{0.0, val, 0.0, 0.0};
columns[2] = float4{0.0, 0.0, val, 0.0};
columns[3] = float4{0.0, 0.0, 0.0, val};
}
explicit Float4x4(float4 diag) {
columns[0] = float4{diag[0], 0.0, 0.0, 0.0};
columns[1] = float4{0.0, diag[1], 0.0, 0.0};
columns[2] = float4{0.0, 0.0, diag[2], 0.0};
columns[3] = float4{0.0, 0.0, 0.0, diag[3]};
}
Float4x4(float4 c0, float4 c1, float4 c2, float4 c3) {
columns[0] = c0;
columns[1] = c1;
columns[2] = c2;
columns[3] = c3;
}
// TODO BE remove this float*
explicit Float4x4(const float* vals) {
columns[0] = float4{vals[0], vals[1], vals[2], vals[3]};
columns[1] = float4{vals[4], vals[5], vals[6], vals[7]};
columns[2] = float4{vals[8], vals[9], vals[10], vals[11]};
columns[3] = float4{vals[12], vals[13], vals[14], vals[15]};
}
};
struct Float3x4 {
float4 columns[3];
Float3x4() = default;
explicit Float3x4(float val) {
columns[0] = float4{val, 0.0, 0.0, 0.0};
columns[1] = float4{0.0, val, 0.0, 0.0};
columns[2] = float4{0.0, 0.0, val, 0.0};
}
explicit Float3x4(float3 diag) {
columns[0] = float4{diag[0], 0.0, 0.0, 0.0};
columns[1] = float4{0.0, diag[1], 0.0, 0.0};
columns[2] = float4{0.0, 0.0, diag[2], 0.0};
}
Float3x4(float4 c0, float4 c1, float4 c2) {
columns[0] = c0;
columns[1] = c1;
columns[2] = c2;
}
// TODO BE remove this float*
explicit Float3x4(const float* vals) {
columns[0] = float4{vals[0], vals[1], vals[2], vals[3]};
columns[1] = float4{vals[4], vals[5], vals[6], vals[7]};
columns[2] = float4{vals[8], vals[9], vals[10], vals[11]};
}
};
struct Float3x3 {
float3 columns[3];
Float3x3() = default;
explicit Float3x3(float val) {
columns[0] = float3{val, 0.0, 0.0};
columns[1] = float3{0.0, val, 0.0};
columns[2] = float3{0.0, 0.0, val};
}
explicit Float3x3(float3 diag) {
columns[0] = float3{diag[0], 0.0, 0.0};
columns[1] = float3{0.0, diag[1], 0.0};
columns[2] = float3{0.0, 0.0, diag[2]};
}
Float3x3(float3 c0, float3 c1, float3 c2) {
columns[0] = c0;
columns[1] = c1;
columns[2] = c2;
}
};
struct Float2x2 {
float2 columns[2];
Float2x2() = default;
explicit Float2x2(float val) {
columns[0] = float2{val, 0.0};
columns[1] = float2{0.0, val};
}
explicit Float2x2(float2 diag) {
columns[0] = float2{diag[0], 0.0};
columns[1] = float2{0.0, diag[1]};
}
Float2x2(float2 c0, float2 c1) {
columns[0] = c0;
columns[1] = c1;
}
};
using float4x4 = Float4x4;
using float3x4 = Float3x4;
using float3x3 = Float3x3;
using float2x2 = Float2x2;
#endif // defined(__APPLE__)
} // namespace iglu::simdtypes
================================================
FILE: IGLU/simdtypes/SimdUtilities.h
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include <IGLU/simdtypes/SimdTypes.h>
#include <cmath>
namespace iglu::simdtypes {
#if defined(__APPLE__)
inline float1 clamp(float1 x, float1 min, float1 max) {
return simd_clamp(x, min, max);
}
inline float1 fract(float1 x) {
return simd_fract(x);
}
inline float4x4 inverse(const float4x4& m) {
return simd_inverse(m);
}
// result = m * v;
inline float4 multiply(const float4x4& m, const float4& v) {
return simd_mul(m, v);
}
// result = m1 * m2
inline float4x4 multiply(const float4x4& m1, const float4x4& m2) {
return simd_mul(m1, m2);
}
#else
inline float1 clamp(float1 x, float1 min, float1 max) {
if (x < min) {
return min;
}
if (x > max) {
return max;
}
return x;
}
inline float1 fract(float1 x) {
return x - floor(x);
}
inline float4x4 inverse(const float4x4& m) {
float4x4 result{};
result.columns[0][0] = m.columns[1][1] * m.columns[2][2] * m.columns[3][3] -
m.columns[1][1] * m.columns[2][3] * m.columns[3][2] -
m.columns[2][1] * m.columns[1][2] * m.columns[3][3] +
m.columns[2][1] * m.columns[1][3] * m.columns[3][2] +
m.columns[3][1] * m.columns[1][2] * m.columns[2][3] -
m.columns[3][1] * m.columns[1][3] * m.columns[2][2];
result.columns[1][0] = -m.columns[1][0] * m.columns[2][2] * m.columns[3][3] +
m.columns[1][0] * m.columns[2][3] * m.columns[3][2] +
m.columns[2][0] * m.columns[1][2] * m.columns[3][3] -
m.columns[2][0] * m.columns[1][3] * m.columns[3][2] -
m.columns[3][0] * m.columns[1][2] * m.columns[2][3] +
m.columns[3][0] * m.columns[1][3] * m.columns[2][2];
result.columns[2][0] = m.columns[1][0] * m.columns[2][1] * m.columns[3][3] -
m.columns[1][0] * m.columns[2][3] * m.columns[3][1] -
m.columns[2][0] * m.columns[1][1] * m.columns[3][3] +
m.columns[2][0] * m.columns[1][3] * m.columns[3][1] +
m.columns[3][0] * m.columns[1][1] * m.columns[2][3] -
m.columns[3][0] * m.columns[1][3] * m.columns[2][1];
result.columns[3][0] = -m.columns[1][0] * m.columns[2][1] * m.columns[3][2] +
m.columns[1][0] * m.columns[2][2] * m.columns[3][1] +
m.columns[2][0] * m.columns[1][1] * m.columns[3][2] -
m.columns[2][0] * m.columns[1][2] * m.columns[3][1] -
m.columns[3][0] * m.columns[1][1] * m.columns[2][2] +
m.columns[3][0] * m.columns[1][2] * m.columns[2][1];
result.columns[0][1] = -m.columns[0][1] * m.columns[2][2] * m.columns[3][3] +
m.columns[0][1] * m.columns[2][3] * m.columns[3][2] +
m.columns[2][1] * m.columns[0][2] * m.columns[3][3] -
m.columns[2][1] * m.columns[0][3] * m.columns[3][2] -
m.columns[3][1] * m.columns[0][2] * m.columns[2][3] +
m.columns[3][1] * m.columns[0][3] * m.columns[2][2];
result.columns[1][1] = m.columns[0][0] * m.columns[2][2] * m.columns[3][3] -
m.columns[0][0] * m.columns[2][3] * m.columns[3][2] -
m.columns[2][0] * m.columns[0][2] * m.columns[3][3] +
m.columns[2][0] * m.columns[0][3] * m.columns[3][2] +
m.columns[3][0] * m.columns[0][2] * m.columns[2][3] -
m.columns[3][0] * m.columns[0][3] * m.columns[2][2];
result.columns[2][1] = -m.columns[0][0] * m.columns[2][1] * m.columns[3][3] +
m.columns[0][0] * m.columns[2][3] * m.columns[3][1] +
m.columns[2][0] * m.columns[0][1] * m.columns[3][3] -
m.columns[2][0] * m.columns[0][3] * m.columns[3][1] -
m.columns[3][0] * m.columns[0][1] * m.columns[2][3] +
m.columns[3][0] * m.columns[0][3] * m.columns[2][1];
result.columns[3][1] = m.columns[0][0] * m.columns[2][1] * m.columns[3][2] -
m.columns[0][0] * m.columns[2][2] * m.columns[3][1] -
m.columns[2][0] * m.columns[0][1] * m.columns[3][2] +
m.columns[2][0] * m.columns[0][2] * m.columns[3][1] +
m.columns[3][0] * m.columns[0][1] * m.columns[2][2] -
m.columns[3][0] * m.columns[0][2] * m.columns[2][1];
result.columns[0][2] = m.columns[0][1] * m.columns[1][2] * m.columns[3][3] -
m.columns[0][1] * m.columns[1][3] * m.columns[3][2] -
m.columns[1][1] * m.columns[0][2] * m.columns[3][3] +
m.columns[1][1] * m.columns[0][3] * m.columns[3][2] +
m.columns[3][1] * m.columns[0][2] * m.columns[1][3] -
m.columns[3][1] * m.columns[0][3] * m.columns[1][2];
result.columns[1][2] = -m.columns[0][0] * m.columns[1][2] * m.columns[3][3] +
m.columns[0][0] * m.columns[1][3] * m.columns[3][2] +
m.columns[1][0] * m.columns[0][2] * m.columns[3][3] -
m.columns[1][0] * m.columns[0][3] * m.columns[3][2] -
m.columns[3][0] * m.columns[0][2] * m.columns[1][3] +
m.columns[3][0] * m.columns[0][3] * m.columns[1][2];
result.columns[2][2] = m.columns[0][0] * m.columns[1][1] * m.columns[3][3] -
m.columns[0][0] * m.columns[1][3] * m.columns[3][1] -
m.columns[1][0] * m.columns[0][1] * m.columns[3][3] +
m.columns[1][0] * m.columns[0][3] * m.columns[3][1] +
m.columns[3][0] * m.columns[0][1] * m.columns[1][3] -
m.columns[3][0] * m.columns[0][3] * m.columns[1][1];
result.columns[3][2] = -m.columns[0][0] * m.columns[1][1] * m.columns[3][2] +
m.columns[0][0] * m.columns[1][2] * m.columns[3][1] +
m.columns[1][0] * m.columns[0][1] * m.columns[3][2] -
m.columns[1][0] * m.columns[0][2] * m.columns[3][1] -
m.columns[3][0] * m.columns[0][1] * m.columns[1][2] +
m.columns[3][0] * m.columns[0][2] * m.columns[1][1];
result.columns[0][3] = -m.columns[0][1] * m.columns[1][2] * m.columns[2][3] +
m.columns[0][1] * m.columns[1][3] * m.columns[2][2] +
m.columns[1][1] * m.columns[0][2] * m.columns[2][3] -
m.columns[1][1] * m.columns[0][3] * m.columns[2][2] -
m.columns[2][1] * m.columns[0][2] * m.columns[1][3] +
m.columns[2][1] * m.columns[0][3] * m.columns[1][2];
result.columns[1][3] = m.columns[0][0] * m.columns[1][2] * m.columns[2][3] -
m.columns[0][0] * m.columns[1][3] * m.columns[2][2] -
m.columns[1][0] * m.columns[0][2] * m.columns[2][3] +
m.columns[1][0] * m.columns[0][3] * m.columns[2][2] +
m.columns[2][0] * m.columns[0][2] * m.columns[1][3] -
m.columns[2][0] * m.columns[0][3] * m.columns[1][2];
result.columns[2][3] = -m.columns[0][0] * m.columns[1][1] * m.columns[2][3] +
m.columns[0][0] * m.columns[1][3] * m.columns[2][1] +
m.columns[1][0] * m.columns[0][1] * m.columns[2][3] -
m.columns[1][0] * m.columns[0][3] * m.columns[2][1] -
m.columns[2][0] * m.columns[0][1] * m.columns[1][3] +
m.columns[2][0] * m.columns[0][3] * m.columns[1][1];
result.columns[3][3] = m.columns[0][0] * m.columns[1][1] * m.columns[2][2] -
m.columns[0][0] * m.columns[1][2] * m.columns[2][1] -
m.columns[1][0] * m.columns[0][1] * m.columns[2][2] +
m.columns[1][0] * m.columns[0][2] * m.columns[2][1] +
m.columns[2][0] * m.columns[0][1] * m.columns[1][2] -
m.columns[2][0] * m.columns[0][2] * m.columns[1][1];
float det = m.columns[0][0] * result.columns[0][0] + m.columns[0][1] * result.columns[1][0] +
m.columns[0][2] * result.columns[2][0] + m.columns[0][3] * result.columns[3][0];
if (det == 0) {
return float4x4(1.0);
}
det = 1.0f / det;
for (auto& column : result.columns) {
for (int j = 0; j < 4; j++) {
column[j] *= det;
}
}
return result;
}
// result = m * v;
inline float4 multiply(const float4x4& m, const float4& v) {
float4 result;
result[0] = m.columns[0][0] * v[0] + m.columns[1][0] * v[1] + m.columns[2][0] * v[2] +
m.columns[3][0] * v[3];
result[1] = m.columns[0][1] * v[0] + m.columns[1][1] * v[1] + m.columns[2][1] * v[2] +
m.columns[3][1] * v[3];
result[2] = m.columns[0][2] * v[0] + m.columns[1][2] * v[1] + m.columns[2][2] * v[2] +
m.columns[3][2] * v[3];
result[3] = m.columns[0][3] * v[0] + m.columns[1][3] * v[1] + m.columns[2][3] * v[2] +
m.columns[3][3] * v[3];
return result;
}
// result = m1 * m2
inline float4x4 multiply(const float4x4& m1, const float4x4& m2) {
float4x4 result{};
result.columns[0] = multiply(m1, m2.columns[0]);
result.columns[1] = multiply(m1, m2.columns[1]);
result.columns[2] = multiply(m1, m2.columns[2]);
result.columns[3] = multiply(m1, m2.columns[3]);
return result;
}
#endif
} // namespace iglu::simdtypes
================================================
FILE: IGLU/simple_renderer/Drawable.cpp
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
// @MARK:COVERAGE_EXCLUDE_FILE
#include "Drawable.h"
#include <utility>
namespace iglu::drawable {
Drawable::Drawable(std::shared_ptr<vertexdata::VertexData> vertexData,
std::shared_ptr<material::Material> material) :
vertexData_(std::move(vertexData)), material_(std::move(material)) {}
void Drawable::draw(igl::IDevice& device,
igl::IRenderCommandEncoder& commandEncoder,
const igl::RenderPipelineDesc& pipelineDesc,
size_t pushConstantsDataSize,
const void* pushConstantsData) {
// Assumption: _vertexData and _material are immutable
const size_t pipelineDescHash = std::hash<igl::RenderPipelineDesc>()(pipelineDesc);
if (!pipelineState_ || pipelineDescHash != lastPipelineDescHash_) {
igl::RenderPipelineDesc mutablePipelineDesc = pipelineDesc;
vertexData_->populatePipelineDescriptor(mutablePipelineDesc);
material_->populatePipelineDescriptor(mutablePipelineDesc);
pipelineState_ = device.createRenderPipeline(mutablePipelineDesc, nullptr);
lastPipelineDescHash_ = pipelineDescHash;
}
commandEncoder.bindRenderPipelineState(pipelineState_);
material_->bind(device, *pipelineState_, commandEncoder);
if (pushConstantsData && pushConstantsDataSize) {
commandEncoder.bindPushConstants(pushConstantsData, pushConstantsDataSize);
}
vertexData_->draw(commandEncoder);
}
} // namespace iglu::drawable
================================================
FILE: IGLU/simple_renderer/Drawable.h
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
// @MARK:COVERAGE_EXCLUDE_FILE
#pragma once
#include <IGLU/simple_renderer/Material.h>
#include <IGLU/simple_renderer/VertexData.h>
#include <memory>
namespace iglu::drawable {
/// A drawable aggregates all the data and configurations for a single draw call.
///
class Drawable final {
public:
/// Binds all relevant states and issues a draw call on 'commandEncoder'.
/// It takes a render pipeline descriptor as input, which is expected to be
/// populated with accurate framebuffer information; all other "draw call"
/// related configurations will be handled internally.
void draw(igl::IDevice& device,
igl::IRenderCommandEncoder& commandEncoder,
const igl::RenderPipelineDesc& pipelineDesc,
size_t pushConstantsDataSize = 0,
const void* pushConstantsData = nullptr);
/// A Drawable is "immutable" in that there's no API to modify its inputs after
/// creation. They're lightweight objects and should be recreated instead of updated.
Drawable(std::shared_ptr<vertexdata::VertexData> vertexData,
std::shared_ptr<material::Material> material);
~Drawable() = default;
private:
std::shared_ptr<vertexdata::VertexData> vertexData_;
std::shared_ptr<material::Material> material_;
std::shared_ptr<igl::IRenderPipelineState> pipelineState_;
size_t lastPipelineDescHash_ = 0;
};
} // namespace iglu::drawable
================================================
FILE: IGLU/simple_renderer/ForwardRenderPass.cpp
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
// @MARK:COVERAGE_EXCLUDE_FILE
#include "ForwardRenderPass.h"
#include <utility>
namespace iglu::renderpass {
ForwardRenderPass::ForwardRenderPass(igl::IDevice& device) {
const igl::CommandQueueDesc desc{};
commandQueue_ = device.createCommandQueue(desc, nullptr);
backendType_ = device.getBackendType();
}
void ForwardRenderPass::begin(std::shared_ptr<igl::IFramebuffer> target,
const igl::RenderPassDesc* renderPassDescOverride) {
IGL_DEBUG_ASSERT(!isActive(), "Drawing already in progress");
framebuffer_ = std::move(target);
renderPipelineDesc_.targetDesc.colorAttachments.resize(1);
renderPipelineDesc_.targetDesc.colorAttachments[0].textureFormat =
framebuffer_->getColorAttachment(0)->getFormat();
auto depthAttachment = framebuffer_->getDepthAttachment();
renderPipelineDesc_.targetDesc.depthAttachmentFormat =
depthAttachment ? depthAttachment->getFormat() : igl::TextureFormat::Invalid;
auto stencilAttachment = framebuffer_->getStencilAttachment();
renderPipelineDesc_.targetDesc.stencilAttachmentFormat =
stencilAttachment ? stencilAttachment->getFormat() : igl::TextureFormat::Invalid;
igl::RenderPassDesc defaultRenderPassDesc;
defaultRenderPassDesc.colorAttachments.resize(1);
defaultRenderPassDesc.colorAttachments[0].loadAction = igl::LoadAction::Clear;
defaultRenderPassDesc.colorAttachments[0].storeAction = igl::StoreAction::Store;
defaultRenderPassDesc.colorAttachments[0].clearColor = {0.0, 0.0, 0.0, 1.0};
defaultRenderPassDesc.depthAttachment.clearDepth = 1.0f;
const igl::RenderPassDesc* finalDesc = renderPassDescOverride ? renderPassDescOverride
: &defaultRenderPassDesc;
const igl::CommandBufferDesc cbDesc;
commandBuffer_ = commandQueue_->createCommandBuffer(cbDesc, nullptr);
commandEncoder_ =
commandBuffer_->createRenderCommandEncoder(*finalDesc, framebuffer_, {}, nullptr);
}
void ForwardRenderPass::draw(drawable::Drawable& drawable, igl::IDevice& device) const {
IGL_DEBUG_ASSERT(isActive(), "Drawing not in progress");
drawable.draw(device, *commandEncoder_, renderPipelineDesc_);
}
void ForwardRenderPass::end(bool shouldPresent) {
IGL_DEBUG_ASSERT(isActive(), "Drawing not in progress");
commandEncoder_->endEncoding();
if (shouldPresent) {
commandBuffer_->present(framebuffer_->getColorAttachment(0));
}
commandQueue_->submit(*commandBuffer_);
commandEncoder_ = nullptr;
commandBuffer_ = nullptr;
framebuffer_ = nullptr;
}
void ForwardRenderPass::bindViewport(const igl::Viewport& viewport, const igl::Size& surfaceSize) {
IGL_DEBUG_ASSERT(isActive(), "Drawing not in progress");
if (backendType_ == igl::BackendType::Metal) {
// In Metal, framebuffer origin is top left but the argument assumes bottom left
igl::Viewport flippedViewport = viewport;
flippedViewport.y = surfaceSize.height - viewport.y - viewport.height;
commandEncoder_->bindViewport(flippedViewport);
} else {
commandEncoder_->bindViewport(viewport);
}
}
bool ForwardRenderPass::isActive() const {
return framebuffer_ != nullptr;
}
igl::IFramebuffer& ForwardRenderPass::activeTarget() {
IGL_DEBUG_ASSERT(isActive(), "No valid target when not active");
return *framebuffer_;
}
igl::IRenderCommandEncoder& ForwardRenderPass::activeCommandEncoder() {
IGL_DEBUG_ASSERT(isActive(), "No valid command encoder when not active");
return *commandEncoder_;
}
} // namespace iglu::renderpass
================================================
FILE: IGLU/simple_renderer/ForwardRenderPass.h
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
// @MARK:COVERAGE_EXCLUDE_FILE
#pragma once
#include <IGLU/simple_renderer/Drawable.h>
#include <memory>
#include <string>
#include <vector>
#include <igl/IGL.h>
namespace iglu::renderpass {
/// A simple "render pass" abstraction that hides low level graphics API details
/// like command queue, command encoder, render pipeline state and presentation.
///
/// An application frame will always have one render pass targeting the "onscreen"
/// framebuffer, but it can have multiple intermediate offscreen render passes.
class ForwardRenderPass final {
public:
/// Call before any graphics bind/draw calls to this render pass.
void begin(std::shared_ptr<igl::IFramebuffer> target,
const igl::RenderPassDesc* renderPassDescOverride = nullptr);
/// Call once per drawable.
void draw(drawable::Drawable& drawable, igl::IDevice& device) const;
/// Call after all drawing within this render pass is finished. The 'present'
/// parameter controls whether to present the target framebuffer and must be set
/// to true exactly once per frame, when targeting the "onscreen" framebuffer.
void end(bool present = false);
/// Optional. By default, a viewport matching the size of the target framebuffer
/// will be used.
///
/// [Convention] Framebuffer origin is bottom left corner.
void bindViewport(const igl::Viewport& viewport, const igl::Size& surfaceSize);
//// The render pass is considered active when in between begin() and end() calls.
bool isActive() const;
igl::IFramebuffer& activeTarget();
igl::IRenderCommandEncoder& activeCommandEncoder();
explicit ForwardRenderPass(igl::IDevice& device);
~ForwardRenderPass() = default;
private:
igl::BackendType backendType_;
std::shared_ptr<igl::ICommandQueue> commandQueue_;
std::shared_ptr<igl::IFramebuffer> framebuffer_;
igl::RenderPipelineDesc renderPipelineDesc_;
std::shared_ptr<igl::ICommandBuffer> commandBuffer_;
std::unique_ptr<igl::IRenderCommandEncoder> commandEncoder_;
};
} // namespace iglu::renderpass
================================================
FILE: IGLU/simple_renderer/Material.cpp
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
// @MARK:COVERAGE_EXCLUDE_FILE
#include "Material.h"
#include <utility>
namespace iglu::material {
Material::Material(igl::IDevice& device, std::string name) : name(std::move(name)) {
setDepthTestConfig(device, depthTestConfig_);
}
std::shared_ptr<ShaderProgram> Material::shaderProgram() const {
return shaderProgram_;
}
void Material::setShaderProgram(igl::IDevice& device,
const std::shared_ptr<ShaderProgram>& program) {
shaderProgram_ = program;
shaderUniforms_ =
std::make_unique<ShaderUniforms>(device, shaderProgram_->renderPipelineReflection());
}
ShaderUniforms& Material::shaderUniforms() const {
return *shaderUniforms_;
}
DepthTestConfig Material::depthTestConfig() const {
return depthTestConfig_;
}
void Material::setDepthTestConfig(igl::IDevice& device, const DepthTestConfig& config) {
depthTestConfig_ = config;
igl::DepthStencilStateDesc depthDesc{
.compareFunction = (depthTestConfig_ != DepthTestConfig::Disable)
? igl::CompareFunction::Less
: igl::CompareFunction::AlwaysPass,
.isDepthWriteEnabled = (depthTestConfig_ == DepthTestConfig::Enable),
};
depthState_ = device.createDepthStencilState(depthDesc, nullptr);
}
void Material::populatePipelineDescriptor(igl::RenderPipelineDesc& pipelineDesc) const {
// Assumption: 'blendMode' only applies to the first color attachment
if (!pipelineDesc.targetDesc.colorAttachments.empty()) {
auto& colorAttachment = pipelineDesc.targetDesc.colorAttachments[0];
if (blendMode == BlendMode::Opaque()) {
colorAttachment.blendEnabled = false;
} else {
colorAttachment.blendEnabled = true;
colorAttachment.srcRGBBlendFactor = blendMode.srcRGB;
colorAttachment.dstRGBBlendFactor = blendMode.dstRGB;
colorAttachment.rgbBlendOp = blendMode.opRGB;
colorAttachment.srcAlphaBlendFactor = blendMode.srcAlpha;
colorAttachment.dstAlphaBlendFactor = blendMode.dstAlpha;
colorAttachment.alphaBlendOp = blendMode.opAlpha;
}
}
pipelineDesc.cullMode = cullMode;
shaderProgram_->populatePipelineDescriptor(pipelineDesc);
}
void Material::bind(igl::IDevice& device,
igl::IRenderPipelineState& pipelineState,
igl::IRenderCommandEncoder& commandEncoder) {
shaderUniforms_->bind(device, pipelineState, commandEncoder);
commandEncoder.bindDepthStencilState(depthState_);
}
} // namespace iglu::material
================================================
FILE: IGLU/simple_renderer/Material.h
================================================
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
// @MARK:COVERAGE_EXCLUDE_FILE
#pragma once
#include "ShaderProgram.h"
#include "ShaderUniforms.h"
#include <string>
#include <igl/IGL.h>
namespace iglu::material {
enum class DepthTestConfig {
Disable,
Enable,
EnableNoWrite,
};
//
gitextract_czmiq_qe/
├── .clang-format
├── .claude/
│ └── CLAUDE.md
├── .cmake-format
├── .github/
│ ├── pull_request_template.md
│ └── workflows/
│ ├── c-cpp.yml
│ ├── cmake-install-test.yml
│ └── doc-build.yml
├── .gitignore
├── CMakeLists.txt
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── IGLU/
│ ├── CMakeLists.txt
│ ├── bitmap/
│ │ ├── BitmapWriter.cpp
│ │ └── BitmapWriter.h
│ ├── command_buffer_allocator/
│ │ ├── ICommandBufferAllocator.cpp
│ │ └── ICommandBufferAllocator.h
│ ├── imgui/
│ │ ├── InputListener.cpp
│ │ ├── InputListener.h
│ │ ├── KeyCodeTranslator.cpp
│ │ ├── KeyCodeTranslator.h
│ │ ├── Session.cpp
│ │ ├── Session.h
│ │ ├── compile_shaders.bat
│ │ ├── compile_shaders.py
│ │ ├── imgui_ps_d3d12.hlsl
│ │ ├── imgui_ps_d3d12_fxc.h
│ │ ├── imgui_vs_d3d12.hlsl
│ │ └── imgui_vs_d3d12_fxc.h
│ ├── managedUniformBuffer/
│ │ ├── ManagedUniformBuffer.cpp
│ │ └── ManagedUniformBuffer.h
│ ├── sentinel/
│ │ ├── Assert.h
│ │ ├── Buffer.cpp
│ │ ├── Buffer.h
│ │ ├── CommandBuffer.cpp
│ │ ├── CommandBuffer.h
│ │ ├── CommandQueue.cpp
│ │ ├── CommandQueue.h
│ │ ├── Device.cpp
│ │ ├── Device.h
│ │ ├── Framebuffer.cpp
│ │ ├── Framebuffer.h
│ │ ├── PlatformDevice.cpp
│ │ └── PlatformDevice.h
│ ├── shaderCross/
│ │ ├── ShaderCross.cpp
│ │ ├── ShaderCross.h
│ │ ├── ShaderCrossUniformBuffer.cpp
│ │ └── ShaderCrossUniformBuffer.h
│ ├── simdtypes/
│ │ ├── SimdTypes.h
│ │ └── SimdUtilities.h
│ ├── simple_renderer/
│ │ ├── Drawable.cpp
│ │ ├── Drawable.h
│ │ ├── ForwardRenderPass.cpp
│ │ ├── ForwardRenderPass.h
│ │ ├── Material.cpp
│ │ ├── Material.h
│ │ ├── ParametricVertexData.cpp
│ │ ├── ParametricVertexData.h
│ │ ├── ShaderProgram.cpp
│ │ ├── ShaderProgram.h
│ │ ├── ShaderUniforms.cpp
│ │ ├── ShaderUniforms.h
│ │ ├── VertexData.cpp
│ │ └── VertexData.h
│ ├── state_pool/
│ │ ├── ComputePipelineStatePool.cpp
│ │ ├── ComputePipelineStatePool.h
│ │ ├── DepthStencilStatePool.cpp
│ │ ├── DepthStencilStatePool.h
│ │ ├── RenderPipelineStatePool.cpp
│ │ ├── RenderPipelineStatePool.h
│ │ ├── StatePool.h
│ │ ├── VertexInputStatePool.cpp
│ │ └── VertexInputStatePool.h
│ ├── texture_accessor/
│ │ ├── ITextureAccessor.h
│ │ ├── MetalTextureAccessor.h
│ │ ├── MetalTextureAccessor.mm
│ │ ├── OpenGLTextureAccessor.cpp
│ │ ├── OpenGLTextureAccessor.h
│ │ ├── TextureAccessorFactory.cpp
│ │ ├── TextureAccessorFactory.h
│ │ ├── VulkanTextureAccessor.cpp
│ │ └── VulkanTextureAccessor.h
│ ├── texture_loader/
│ │ ├── DataReader.cpp
│ │ ├── DataReader.h
│ │ ├── IData.cpp
│ │ ├── IData.h
│ │ ├── ITextureLoader.cpp
│ │ ├── ITextureLoader.h
│ │ ├── ITextureLoaderFactory.cpp
│ │ ├── ITextureLoaderFactory.h
│ │ ├── TextureLoaderFactory.cpp
│ │ ├── TextureLoaderFactory.h
│ │ ├── ktx/
│ │ │ ├── TextureLoaderFactory.cpp
│ │ │ └── TextureLoaderFactory.h
│ │ ├── ktx1/
│ │ │ ├── Header.cpp
│ │ │ ├── Header.h
│ │ │ ├── TextureLoaderFactory.cpp
│ │ │ └── TextureLoaderFactory.h
│ │ ├── ktx2/
│ │ │ ├── Header.cpp
│ │ │ ├── Header.h
│ │ │ ├── TextureLoaderFactory.cpp
│ │ │ └── TextureLoaderFactory.h
│ │ ├── stb_hdr/
│ │ │ ├── Header.cpp
│ │ │ ├── Header.h
│ │ │ ├── TextureLoaderFactory.cpp
│ │ │ └── TextureLoaderFactory.h
│ │ ├── stb_image/
│ │ │ ├── TextureLoaderFactory.cpp
│ │ │ └── TextureLoaderFactory.h
│ │ ├── stb_jpeg/
│ │ │ ├── Header.cpp
│ │ │ ├── Header.h
│ │ │ ├── TextureLoaderFactory.cpp
│ │ │ └── TextureLoaderFactory.h
│ │ ├── stb_png/
│ │ │ ├── Header.cpp
│ │ │ ├── Header.h
│ │ │ ├── TextureLoaderFactory.cpp
│ │ │ └── TextureLoaderFactory.h
│ │ └── xtc1/
│ │ ├── Header.cpp
│ │ ├── Header.h
│ │ ├── TextureLoaderFactory.cpp
│ │ └── TextureLoaderFactory.h
│ └── uniform/
│ ├── Collection.cpp
│ ├── Collection.h
│ ├── CollectionEncoder.cpp
│ ├── CollectionEncoder.h
│ ├── Descriptor.cpp
│ ├── Descriptor.h
│ ├── Encoder.cpp
│ ├── Encoder.h
│ └── Trait.h
├── LICENSE.md
├── README.md
├── ROADMAP.md
├── build/
│ └── .gitignore
├── cmake/
│ ├── IGLConfig.cmake.in
│ └── install.cmake
├── deploy_content.py
├── deploy_deps.py
├── docs/
│ ├── .gitignore
│ ├── Makefile
│ ├── README.md
│ ├── make.bat
│ ├── requirements.txt
│ └── source/
│ ├── _extensions/
│ │ └── style.py
│ ├── conf.py
│ ├── data/
│ │ └── placeholder
│ ├── getting-started/
│ │ └── index.md
│ ├── index.md
│ ├── introduction.md
│ ├── theme/
│ │ ├── extra.css
│ │ └── sphinx_literate.css
│ └── video/
│ └── placeholder
├── getting-started.md
├── samples/
│ ├── android/
│ │ ├── opengl/
│ │ │ ├── java/
│ │ │ │ └── com/
│ │ │ │ └── facebook/
│ │ │ │ └── igl/
│ │ │ │ └── sample/
│ │ │ │ ├── AndroidManifest.xml
│ │ │ │ ├── SampleActivity.java
│ │ │ │ ├── SampleLib.java
│ │ │ │ └── SampleView.java
│ │ │ └── jni/
│ │ │ ├── Jni.cpp
│ │ │ ├── TinyRenderer.cpp
│ │ │ └── TinyRenderer.h
│ │ └── vulkan/
│ │ ├── java/
│ │ │ └── com/
│ │ │ └── facebook/
│ │ │ └── igl/
│ │ │ └── sample/
│ │ │ ├── AndroidManifest.xml
│ │ │ └── SampleActivity.java
│ │ └── jni/
│ │ └── Tiny.cpp
│ ├── desktop/
│ │ ├── CMakeLists.txt
│ │ └── Tiny/
│ │ ├── Tiny.cpp
│ │ ├── Tiny_Mesh.cpp
│ │ └── Tiny_MeshLarge.cpp
│ ├── ios/
│ │ └── snapshot_test_support/
│ │ ├── IGLBytesToUIImage.h
│ │ ├── IGLBytesToUIImage.mm
│ │ ├── IGLSnapshotTestCase.h
│ │ ├── IGLSnapshotTestCase.mm
│ │ ├── TinyRenderable.cpp
│ │ └── TinyRenderable.hpp
│ └── wasm/
│ ├── CMakeLists.txt
│ ├── Common.cpp
│ ├── Common.h
│ ├── Tiny_Mesh.cpp
│ ├── Triangle.cpp
│ └── igl.html
├── shell/
│ ├── CMakeLists.txt
│ ├── android/
│ │ ├── CMakeLists.txt
│ │ ├── java/
│ │ │ └── com/
│ │ │ └── facebook/
│ │ │ └── igl/
│ │ │ └── sample/
│ │ │ ├── AndroidManifest.xml
│ │ │ ├── SampleActivity.java
│ │ │ ├── SampleLib.java
│ │ │ ├── SampleView.java
│ │ │ └── VulkanView.java
│ │ └── jni/
│ │ ├── Jni.cpp
│ │ ├── TinyRenderer.cpp
│ │ └── TinyRenderer.h
│ ├── apps/
│ │ └── SessionApp.cpp
│ ├── ios/
│ │ ├── AppDelegate.h
│ │ ├── AppDelegate.mm
│ │ ├── BackendVersion.h
│ │ ├── BackendVersion.mm
│ │ ├── CMakeLists.txt
│ │ ├── IglShellPlatformAdapter.h
│ │ ├── IglShellPlatformAdapterInternal.hpp
│ │ ├── IglSurfaceTexturesAdapter.h
│ │ ├── IglSurfaceTexturesAdapterInternal.hpp
│ │ ├── RenderSessionController.h
│ │ ├── RenderSessionController.mm
│ │ ├── RenderSessionFactoryAdapter.h
│ │ ├── RenderSessionFactoryAdapterInternal.hpp
│ │ ├── RenderSessionFactoryProvider.h
│ │ ├── RenderSessionFactoryProvider.mm
│ │ ├── View.h
│ │ ├── View.m
│ │ ├── ViewController.h
│ │ ├── ViewController.mm
│ │ └── main.mm
│ ├── mac/
│ │ ├── AppDelegate.h
│ │ ├── AppDelegate.mm
│ │ ├── CMakeLists.txt
│ │ ├── GLView.h
│ │ ├── GLView.mm
│ │ ├── HeadlessView.h
│ │ ├── HeadlessView.mm
│ │ ├── MetalView.h
│ │ ├── MetalView.m
│ │ ├── ViewController.h
│ │ ├── ViewController.mm
│ │ ├── VulkanView.h
│ │ ├── VulkanView.mm
│ │ └── main.mm
│ ├── openxr/
│ │ ├── CMakeLists.txt
│ │ ├── XrApp.h
│ │ ├── XrComposition.cpp
│ │ ├── XrComposition.h
│ │ ├── XrCompositionProjection.cpp
│ │ ├── XrCompositionProjection.h
│ │ ├── XrCompositionQuad.cpp
│ │ ├── XrCompositionQuad.h
│ │ ├── XrHands.cpp
│ │ ├── XrHands.h
│ │ ├── XrLog.cpp
│ │ ├── XrLog.h
│ │ ├── XrPassthrough.cpp
│ │ ├── XrPassthrough.h
│ │ ├── XrPlatform.h
│ │ ├── XrRefreshRate.cpp
│ │ ├── XrRefreshRate.h
│ │ ├── XrSwapchainProvider.cpp
│ │ ├── XrSwapchainProvider.h
│ │ ├── impl/
│ │ │ ├── XrAppImpl.h
│ │ │ └── XrSwapchainProviderImpl.h
│ │ └── mobile/
│ │ ├── AndroidMain.cpp
│ │ ├── XrApp.cpp
│ │ ├── java/
│ │ │ └── com/
│ │ │ └── facebook/
│ │ │ └── igl/
│ │ │ └── shell/
│ │ │ └── openxr/
│ │ │ ├── gles/
│ │ │ │ ├── AndroidManifest.xml
│ │ │ │ └── MainActivity.java
│ │ │ └── vulkan/
│ │ │ ├── AndroidManifest.xml
│ │ │ └── MainActivity.java
│ │ ├── opengl/
│ │ │ ├── XrAppImplGLES.cpp
│ │ │ ├── XrAppImplGLES.h
│ │ │ ├── XrSwapchainProviderImplGLES.cpp
│ │ │ └── XrSwapchainProviderImplGLES.h
│ │ └── vulkan/
│ │ ├── XrAppImplVulkan.cpp
│ │ ├── XrAppImplVulkan.h
│ │ ├── XrSwapchainProviderImplVulkan.cpp
│ │ └── XrSwapchainProviderImplVulkan.h
│ ├── renderSessionTests/
│ │ ├── BasicFramebufferTests.cpp
│ │ └── IGLSampleTests.cpp
│ ├── renderSessions/
│ │ ├── BasicFramebufferSession.cpp
│ │ ├── BasicFramebufferSession.h
│ │ ├── BindGroupSession.cpp
│ │ ├── BindGroupSession.h
│ │ ├── BindlessBufferSession.cpp
│ │ ├── BindlessBufferSession.h
│ │ ├── BufferMappingSession.cpp
│ │ ├── BufferMappingSession.h
│ │ ├── CheckerboardMipmapSession.cpp
│ │ ├── CheckerboardMipmapSession.h
│ │ ├── ColorSession.cpp
│ │ ├── ColorSession.h
│ │ ├── CopyOperationsSession.cpp
│ │ ├── CopyOperationsSession.h
│ │ ├── DepthBiasSession.cpp
│ │ ├── DepthBiasSession.h
│ │ ├── DrawInstancedSession.cpp
│ │ ├── DrawInstancedSession.h
│ │ ├── EmptySession.cpp
│ │ ├── EmptySession.h
│ │ ├── FireworksSession.cpp
│ │ ├── FireworksSession.h
│ │ ├── GPUStressSession.cpp
│ │ ├── GPUStressSession.h
│ │ ├── GPUTimerSession.cpp
│ │ ├── GPUTimerSession.h
│ │ ├── HandsOpenXRSession.cpp
│ │ ├── HandsOpenXRSession.h
│ │ ├── HelloOpenXRSession.cpp
│ │ ├── HelloOpenXRSession.h
│ │ ├── HelloWorldSession.cpp
│ │ ├── HelloWorldSession.h
│ │ ├── ImguiSession.cpp
│ │ ├── ImguiSession.h
│ │ ├── MRTSession.cpp
│ │ ├── MRTSession.h
│ │ ├── MeshShaderTriangleSession.cpp
│ │ ├── MeshShaderTriangleSession.h
│ │ ├── MultiDrawIndexedIndirectSession.cpp
│ │ ├── MultiDrawIndexedIndirectSession.h
│ │ ├── ScissorTestSession.cpp
│ │ ├── ScissorTestSession.h
│ │ ├── StencilOutlineSession.cpp
│ │ ├── StencilOutlineSession.h
│ │ ├── TQMultiRenderPassSession.cpp
│ │ ├── TQMultiRenderPassSession.h
│ │ ├── TQSession.cpp
│ │ ├── TQSession.h
│ │ ├── TextureViewSession.cpp
│ │ ├── TextureViewSession.h
│ │ ├── Textured3DCubeSession.cpp
│ │ ├── Textured3DCubeSession.h
│ │ ├── TinyMeshBindGroupSession.cpp
│ │ ├── TinyMeshBindGroupSession.h
│ │ ├── TinyMeshSession.cpp
│ │ ├── TinyMeshSession.h
│ │ ├── WireframeSession.cpp
│ │ ├── WireframeSession.h
│ │ ├── YUVColorSession.cpp
│ │ └── YUVColorSession.h
│ ├── resources/
│ │ ├── images/
│ │ │ ├── macbeth.ktx
│ │ │ ├── macbeth.ktx2
│ │ │ ├── output_frame_900.420p.txt
│ │ │ ├── output_frame_900.420p.yuv
│ │ │ ├── output_frame_900.nv12.txt
│ │ │ └── output_frame_900.nv12.yuv
│ │ ├── mac/
│ │ │ ├── Assets.xcassets/
│ │ │ │ ├── AppIcon.appiconset/
│ │ │ │ │ └── Contents.json
│ │ │ │ └── Contents.json
│ │ │ ├── Base.lproj/
│ │ │ │ └── MainMenu.xib
│ │ │ ├── Entitlements.plist
│ │ │ └── Info.plist
│ │ ├── models/
│ │ │ └── DamagedHelmet.gltf
│ │ └── shaders/
│ │ ├── ShaderLibraryTest-ios.metallib
│ │ ├── ShaderLibraryTest-macos.metallib
│ │ └── ShaderLibraryTest.metal
│ ├── shared/
│ │ ├── extension/
│ │ │ ├── Extension.h
│ │ │ ├── ExtensionLoader.cpp
│ │ │ ├── ExtensionLoader.h
│ │ │ ├── SymbolFactoryLoader.cpp
│ │ │ └── SymbolFactoryLoader.h
│ │ ├── fileLoader/
│ │ │ ├── FileLoader.cpp
│ │ │ ├── FileLoader.h
│ │ │ ├── android/
│ │ │ │ ├── FileLoaderAndroid.cpp
│ │ │ │ └── FileLoaderAndroid.h
│ │ │ ├── apple/
│ │ │ │ ├── FileLoaderApple.h
│ │ │ │ └── FileLoaderApple.mm
│ │ │ ├── linux/
│ │ │ │ ├── FileLoaderLinux.cpp
│ │ │ │ └── FileLoaderLinux.h
│ │ │ └── win/
│ │ │ ├── FileLoaderWin.cpp
│ │ │ └── FileLoaderWin.h
│ │ ├── imageLoader/
│ │ │ ├── ImageLoader.cpp
│ │ │ ├── ImageLoader.h
│ │ │ └── tests/
│ │ │ └── ImageLoaderTest.cpp
│ │ ├── imageWriter/
│ │ │ ├── ImageWriter.h
│ │ │ ├── android/
│ │ │ │ └── ImageWriterAndroid.h
│ │ │ ├── ios/
│ │ │ │ ├── ImageWriterIos.h
│ │ │ │ └── ImageWriterIos.mm
│ │ │ ├── linux/
│ │ │ │ └── ImageWriterLinux.h
│ │ │ ├── mac/
│ │ │ │ └── ImageWriterMac.h
│ │ │ ├── stb/
│ │ │ │ ├── ImageWriterSTB.cpp
│ │ │ │ └── ImageWriterSTB.h
│ │ │ └── win/
│ │ │ └── ImageWriterWin.h
│ │ ├── input/
│ │ │ ├── InputDispatcher.cpp
│ │ │ ├── InputDispatcher.h
│ │ │ ├── IntentListener.h
│ │ │ ├── KeyListener.h
│ │ │ ├── MouseListener.h
│ │ │ ├── RayListener.h
│ │ │ └── TouchListener.h
│ │ ├── netservice/
│ │ │ ├── NetService.h
│ │ │ ├── NetServiceExtension.cpp
│ │ │ ├── NetServiceExtension.h
│ │ │ ├── NetServiceFactory.h
│ │ │ ├── Stream.h
│ │ │ ├── apple/
│ │ │ │ ├── NetServiceApple.h
│ │ │ │ ├── NetServiceApple.mm
│ │ │ │ ├── NetServiceExtensionApple.h
│ │ │ │ ├── NetServiceExtensionApple.mm
│ │ │ │ ├── StreamApple.h
│ │ │ │ └── StreamApple.mm
│ │ │ └── zeromq/
│ │ │ ├── NetServiceExtensionZeroMQ.h
│ │ │ ├── NetServiceZeroMQ.h
│ │ │ └── StreamZeroMQ.h
│ │ ├── platform/
│ │ │ ├── DisplayContext.h
│ │ │ ├── Factory.cpp
│ │ │ ├── Factory.h
│ │ │ ├── Platform.cpp
│ │ │ ├── Platform.h
│ │ │ ├── android/
│ │ │ │ ├── PlatformAndroid.cpp
│ │ │ │ └── PlatformAndroid.h
│ │ │ ├── ios/
│ │ │ │ ├── PlatformIos.h
│ │ │ │ └── PlatformIos.mm
│ │ │ ├── linux/
│ │ │ │ ├── PlatformLinux.cpp
│ │ │ │ └── PlatformLinux.h
│ │ │ ├── mac/
│ │ │ │ ├── PlatformMac.cpp
│ │ │ │ └── PlatformMac.h
│ │ │ └── win/
│ │ │ ├── PlatformWin.cpp
│ │ │ └── PlatformWin.h
│ │ ├── renderSession/
│ │ │ ├── AppParams.h
│ │ │ ├── BenchmarkTracker.cpp
│ │ │ ├── BenchmarkTracker.h
│ │ │ ├── DefaultRenderSessionFactory.h
│ │ │ ├── DefaultSession.h
│ │ │ ├── DepthParams.h
│ │ │ ├── Fov.h
│ │ │ ├── Hands.h
│ │ │ ├── IRenderSessionFactory.h
│ │ │ ├── QuadLayerParams.h
│ │ │ ├── RenderMode.h
│ │ │ ├── RenderSession.cpp
│ │ │ ├── RenderSession.h
│ │ │ ├── RenderSessionConfig.h
│ │ │ ├── RenderSessionLoader.hpp
│ │ │ ├── RenderSessionRegistry.cpp
│ │ │ ├── RenderSessionRegistry.hpp
│ │ │ ├── RenderSessionWindowConfig.h
│ │ │ ├── ScreenshotTestRenderSessionHelper.cpp
│ │ │ ├── ScreenshotTestRenderSessionHelper.h
│ │ │ ├── ShaderProvider.h
│ │ │ ├── ShaderStagesCreator.cpp
│ │ │ ├── ShaderStagesCreator.h
│ │ │ ├── ShellParams.cpp
│ │ │ ├── ShellParams.h
│ │ │ ├── ShellType.h
│ │ │ └── ViewParams.h
│ │ └── testShell/
│ │ ├── TestShell.cpp
│ │ └── TestShell.h
│ └── windows/
│ ├── CMakeLists.txt
│ ├── common/
│ │ ├── GlfwShell.cpp
│ │ └── GlfwShell.h
│ ├── d3d12/
│ │ └── App.cpp
│ ├── opengl/
│ │ ├── App.cpp
│ │ └── AutoContextReleaseDevice.h
│ ├── opengles/
│ │ └── App.cpp
│ └── vulkan/
│ └── App.cpp
├── src/
│ └── igl/
│ ├── Assert.cpp
│ ├── Assert.h
│ ├── Buffer.h
│ ├── CMakeLists.txt
│ ├── Color.h
│ ├── ColorSpace.h
│ ├── CommandBuffer.h
│ ├── CommandEncoder.h
│ ├── CommandQueue.h
│ ├── Common.cpp
│ ├── Common.h
│ ├── ComputeCommandEncoder.h
│ ├── ComputePipelineState.h
│ ├── Config.h
│ ├── Core.h
│ ├── DebugMacros.h
│ ├── DepthStencilState.cpp
│ ├── DepthStencilState.h
│ ├── Device.cpp
│ ├── Device.h
│ ├── DeviceFeatures.h
│ ├── FPSCounter.h
│ ├── Format.h
│ ├── Framebuffer.h
│ ├── FramebufferWrapper.cpp
│ ├── FramebufferWrapper.h
│ ├── HWDevice.h
│ ├── IGL.h
│ ├── IGLFolly.h
│ ├── IGLSafeC.h
│ ├── IResourceTracker.h
│ ├── ITrackedResource.h
│ ├── Log.cpp
│ ├── Log.h
│ ├── Macros.h
│ ├── NameHandle.cpp
│ ├── NameHandle.h
│ ├── PlatformDevice.h
│ ├── RenderCommandEncoder.h
│ ├── RenderPass.h
│ ├── RenderPipelineReflection.h
│ ├── RenderPipelineState.cpp
│ ├── RenderPipelineState.h
│ ├── SamplerState.cpp
│ ├── SamplerState.h
│ ├── Shader.cpp
│ ├── Shader.h
│ ├── ShaderCreator.cpp
│ ├── ShaderCreator.h
│ ├── Texture.cpp
│ ├── Texture.h
│ ├── TextureFormat.h
│ ├── Timer.h
│ ├── TimestampQueries.h
│ ├── Uniform.cpp
│ ├── Uniform.h
│ ├── VertexInputState.cpp
│ ├── VertexInputState.h
│ ├── android/
│ │ ├── LogDefault.cpp
│ │ ├── LogDefault.h
│ │ ├── NativeHWBuffer.cpp
│ │ └── NativeHWBuffer.h
│ ├── apple/
│ │ ├── LogDefault.cpp
│ │ └── LogDefault.h
│ ├── base/
│ │ ├── Common.h
│ │ ├── IAttachmentInterop.h
│ │ ├── IDeviceBase.h
│ │ ├── IFramebufferInterop.h
│ │ └── IStagingBufferInterop.h
│ ├── d3d12/
│ │ ├── Buffer.cpp
│ │ ├── Buffer.h
│ │ ├── CMakeLists.txt
│ │ ├── CommandBuffer.cpp
│ │ ├── CommandBuffer.h
│ │ ├── CommandQueue.cpp
│ │ ├── CommandQueue.h
│ │ ├── Common.cpp
│ │ ├── Common.h
│ │ ├── ComputeCommandEncoder.cpp
│ │ ├── ComputeCommandEncoder.h
│ │ ├── ComputePipelineState.cpp
│ │ ├── ComputePipelineState.h
│ │ ├── D3D12AllocatorPool.cpp
│ │ ├── D3D12AllocatorPool.h
│ │ ├── D3D12Context.cpp
│ │ ├── D3D12Context.h
│ │ ├── D3D12DeviceCapabilities.cpp
│ │ ├── D3D12DeviceCapabilities.h
│ │ ├── D3D12FenceWaiter.cpp
│ │ ├── D3D12FenceWaiter.h
│ │ ├── D3D12FrameManager.cpp
│ │ ├── D3D12FrameManager.h
│ │ ├── D3D12Headers.h
│ │ ├── D3D12ImmediateCommands.cpp
│ │ ├── D3D12ImmediateCommands.h
│ │ ├── D3D12PipelineBuilder.cpp
│ │ ├── D3D12PipelineBuilder.h
│ │ ├── D3D12PipelineCache.cpp
│ │ ├── D3D12PipelineCache.h
│ │ ├── D3D12PresentManager.cpp
│ │ ├── D3D12PresentManager.h
│ │ ├── D3D12ReflectionUtils.cpp
│ │ ├── D3D12ReflectionUtils.h
│ │ ├── D3D12ResourcesBinder.cpp
│ │ ├── D3D12ResourcesBinder.h
│ │ ├── D3D12RootSignatureKey.h
│ │ ├── D3D12SamplerCache.h
│ │ ├── D3D12StagingDevice.cpp
│ │ ├── D3D12StagingDevice.h
│ │ ├── D3D12StateTransition.h
│ │ ├── D3D12Telemetry.h
│ │ ├── DXCCompiler.cpp
│ │ ├── DXCCompiler.h
│ │ ├── DepthStencilState.h
│ │ ├── DescriptorHeapManager.cpp
│ │ ├── DescriptorHeapManager.h
│ │ ├── Device.cpp
│ │ ├── Device.h
│ │ ├── Framebuffer.cpp
│ │ ├── Framebuffer.h
│ │ ├── HeadlessContext.cpp
│ │ ├── HeadlessContext.h
│ │ ├── PlatformDevice.cpp
│ │ ├── PlatformDevice.h
│ │ ├── RenderCommandEncoder.cpp
│ │ ├── RenderCommandEncoder.h
│ │ ├── RenderPipelineState.cpp
│ │ ├── RenderPipelineState.h
│ │ ├── SamplerState.cpp
│ │ ├── SamplerState.h
│ │ ├── ShaderModule.cpp
│ │ ├── ShaderModule.h
│ │ ├── Texture.cpp
│ │ ├── Texture.h
│ │ ├── TextureCopyUtils.cpp
│ │ ├── TextureCopyUtils.h
│ │ ├── Timer.cpp
│ │ ├── Timer.h
│ │ ├── UploadRingBuffer.cpp
│ │ ├── UploadRingBuffer.h
│ │ └── VertexInputState.h
│ ├── glslang/
│ │ ├── CMakeLists.txt
│ │ ├── GlslCompiler.cpp
│ │ ├── GlslCompiler.h
│ │ ├── GlslangHelpers.c
│ │ └── GlslangHelpers.h
│ ├── metal/
│ │ ├── Buffer.h
│ │ ├── Buffer.mm
│ │ ├── BufferSynchronizationManager.h
│ │ ├── BufferSynchronizationManager.mm
│ │ ├── CMakeLists.txt
│ │ ├── ColorSpace.h
│ │ ├── ColorSpace.mm
│ │ ├── CommandBuffer.h
│ │ ├── CommandBuffer.mm
│ │ ├── CommandQueue.h
│ │ ├── CommandQueue.mm
│ │ ├── ComputeCommandEncoder.h
│ │ ├── ComputeCommandEncoder.mm
│ │ ├── ComputePipelineState.h
│ │ ├── ComputePipelineState.mm
│ │ ├── DepthStencilState.h
│ │ ├── DepthStencilState.mm
│ │ ├── Device.h
│ │ ├── Device.mm
│ │ ├── DeviceFeatureSet.h
│ │ ├── DeviceFeatureSet.mm
│ │ ├── DeviceStatistics.h
│ │ ├── DeviceStatistics.mm
│ │ ├── Framebuffer.h
│ │ ├── Framebuffer.mm
│ │ ├── HWDevice.h
│ │ ├── HWDevice.mm
│ │ ├── PlatformDevice.h
│ │ ├── PlatformDevice.mm
│ │ ├── RenderCommandEncoder.h
│ │ ├── RenderCommandEncoder.mm
│ │ ├── RenderPipelineReflection.h
│ │ ├── RenderPipelineReflection.mm
│ │ ├── RenderPipelineState.h
│ │ ├── RenderPipelineState.mm
│ │ ├── Result.h
│ │ ├── SamplerState.h
│ │ ├── SamplerState.mm
│ │ ├── Shader.h
│ │ ├── Shader.mm
│ │ ├── Texture.h
│ │ ├── Texture.mm
│ │ ├── Timer.h
│ │ ├── TimestampQueries.h
│ │ ├── TimestampQueries.mm
│ │ ├── VertexInputState.h
│ │ ├── VertexInputState.mm
│ │ ├── ios/
│ │ │ ├── Device.h
│ │ │ ├── Device.mm
│ │ │ ├── Framebuffer.h
│ │ │ └── Framebuffer.mm
│ │ └── macos/
│ │ ├── Device.h
│ │ ├── Device.mm
│ │ ├── Framebuffer.h
│ │ └── Framebuffer.mm
│ ├── opengl/
│ │ ├── Buffer.cpp
│ │ ├── Buffer.h
│ │ ├── CMakeLists.txt
│ │ ├── CommandBuffer.cpp
│ │ ├── CommandBuffer.h
│ │ ├── CommandQueue.cpp
│ │ ├── CommandQueue.h
│ │ ├── ComputeCommandAdapter.cpp
│ │ ├── ComputeCommandAdapter.h
│ │ ├── ComputeCommandEncoder.cpp
│ │ ├── ComputeCommandEncoder.h
│ │ ├── ComputePipelineState.cpp
│ │ ├── ComputePipelineState.h
│ │ ├── Config.h
│ │ ├── DepthStencilState.cpp
│ │ ├── DepthStencilState.h
│ │ ├── DestructionGuard.cpp
│ │ ├── DestructionGuard.h
│ │ ├── Device.cpp
│ │ ├── Device.h
│ │ ├── DeviceFeatureSet.cpp
│ │ ├── DeviceFeatureSet.h
│ │ ├── DummyTexture.h
│ │ ├── Framebuffer.cpp
│ │ ├── Framebuffer.h
│ │ ├── FramebufferWrapper.h
│ │ ├── GLFunc.cpp
│ │ ├── GLFunc.h
│ │ ├── GLIncludes.h
│ │ ├── HWDevice.cpp
│ │ ├── HWDevice.h
│ │ ├── IContext.cpp
│ │ ├── IContext.h
│ │ ├── PlatformDevice.cpp
│ │ ├── PlatformDevice.h
│ │ ├── RenderCommandAdapter.cpp
│ │ ├── RenderCommandAdapter.h
│ │ ├── RenderCommandEncoder.cpp
│ │ ├── RenderCommandEncoder.h
│ │ ├── RenderPipelineReflection.cpp
│ │ ├── RenderPipelineReflection.h
│ │ ├── RenderPipelineState.cpp
│ │ ├── RenderPipelineState.h
│ │ ├── SamplerState.cpp
│ │ ├── SamplerState.h
│ │ ├── Shader.cpp
│ │ ├── Shader.h
│ │ ├── Texture.cpp
│ │ ├── Texture.h
│ │ ├── TextureBuffer.cpp
│ │ ├── TextureBuffer.h
│ │ ├── TextureBufferBase.cpp
│ │ ├── TextureBufferBase.h
│ │ ├── TextureBufferExternal.cpp
│ │ ├── TextureBufferExternal.h
│ │ ├── TextureTarget.cpp
│ │ ├── TextureTarget.h
│ │ ├── Timer.cpp
│ │ ├── Timer.h
│ │ ├── TimestampQueries.cpp
│ │ ├── TimestampQueries.h
│ │ ├── UnbindPolicy.h
│ │ ├── UniformAdapter.cpp
│ │ ├── UniformAdapter.h
│ │ ├── UniformBuffer.cpp
│ │ ├── UniformBuffer.h
│ │ ├── Version.cpp
│ │ ├── Version.h
│ │ ├── VertexArrayObject.cpp
│ │ ├── VertexArrayObject.h
│ │ ├── VertexInputState.cpp
│ │ ├── VertexInputState.h
│ │ ├── ViewTextureTarget.cpp
│ │ ├── ViewTextureTarget.h
│ │ ├── WithContext.cpp
│ │ ├── WithContext.h
│ │ ├── egl/
│ │ │ ├── Context.cpp
│ │ │ ├── Context.h
│ │ │ ├── Device.cpp
│ │ │ ├── Device.h
│ │ │ ├── HWDevice.cpp
│ │ │ ├── HWDevice.h
│ │ │ ├── PlatformDevice.cpp
│ │ │ ├── PlatformDevice.h
│ │ │ └── android/
│ │ │ ├── NativeHWBuffer.cpp
│ │ │ └── NativeHWBuffer.h
│ │ ├── empty/
│ │ │ ├── Context.cpp
│ │ │ ├── Context.h
│ │ │ ├── Device.cpp
│ │ │ ├── Device.h
│ │ │ ├── HWDevice.cpp
│ │ │ └── HWDevice.h
│ │ ├── glx/
│ │ │ ├── Context.cpp
│ │ │ ├── Context.h
│ │ │ ├── Device.cpp
│ │ │ ├── Device.h
│ │ │ ├── HWDevice.cpp
│ │ │ ├── HWDevice.h
│ │ │ ├── PlatformDevice.cpp
│ │ │ └── PlatformDevice.h
│ │ ├── ios/
│ │ │ ├── Context.h
│ │ │ ├── Context.mm
│ │ │ ├── Device.h
│ │ │ ├── Device.mm
│ │ │ ├── HWDevice.h
│ │ │ ├── HWDevice.mm
│ │ │ ├── PlatformDevice.h
│ │ │ ├── PlatformDevice.mm
│ │ │ ├── TextureBuffer.h
│ │ │ └── TextureBuffer.mm
│ │ ├── macos/
│ │ │ ├── Context.h
│ │ │ ├── Context.mm
│ │ │ ├── Device.h
│ │ │ ├── Device.mm
│ │ │ ├── HWDevice.h
│ │ │ ├── HWDevice.mm
│ │ │ ├── PlatformDevice.h
│ │ │ ├── PlatformDevice.mm
│ │ │ ├── TextureBuffer.h
│ │ │ └── TextureBuffer.mm
│ │ ├── util/
│ │ │ ├── TextureFormat.cpp
│ │ │ └── TextureFormat.h
│ │ ├── webgl/
│ │ │ ├── Context.cpp
│ │ │ ├── Context.h
│ │ │ ├── Device.cpp
│ │ │ ├── Device.h
│ │ │ ├── HWDevice.cpp
│ │ │ ├── HWDevice.h
│ │ │ ├── PlatformDevice.cpp
│ │ │ └── PlatformDevice.h
│ │ └── wgl/
│ │ ├── Context.cpp
│ │ ├── Context.h
│ │ ├── Device.cpp
│ │ ├── Device.h
│ │ ├── HWDevice.cpp
│ │ ├── HWDevice.h
│ │ ├── PlatformDevice.cpp
│ │ └── PlatformDevice.h
│ ├── tests/
│ │ ├── Assert.cpp
│ │ ├── Backend.cpp
│ │ ├── Blending.cpp
│ │ ├── Buffer.cpp
│ │ ├── CMakeLists.txt
│ │ ├── Color.cpp
│ │ ├── ColorSpace.cpp
│ │ ├── CommandBuffer.cpp
│ │ ├── Common.cpp
│ │ ├── ComputeCommandEncoder.cpp
│ │ ├── Device.cpp
│ │ ├── DeviceFeatureSet.cpp
│ │ ├── Framebuffer.cpp
│ │ ├── FramebufferInterop.cpp
│ │ ├── Hash.cpp
│ │ ├── IglTestsTSANSuppressions.txt
│ │ ├── Log.cpp
│ │ ├── Multiview.cpp
│ │ ├── NameHandleTests.cpp
│ │ ├── RenderCommandEncoder.cpp
│ │ ├── Resource.cpp
│ │ ├── ShaderLibrary.cpp
│ │ ├── ShaderModule.cpp
│ │ ├── Texture.cpp
│ │ ├── Texture.h
│ │ ├── TextureArray.cpp
│ │ ├── TextureArrayFloat.cpp
│ │ ├── TextureCube.cpp
│ │ ├── TextureFloat.cpp
│ │ ├── TextureFormat.cpp
│ │ ├── TextureFormatProperties.cpp
│ │ ├── TextureHalfFloat.cpp
│ │ ├── TextureMipmap.cpp
│ │ ├── TextureRangeDesc.cpp
│ │ ├── TexturesRGB.cpp
│ │ ├── VertexInputState.cpp
│ │ ├── android/
│ │ │ └── NativeHWBuffer.cpp
│ │ ├── data/
│ │ │ ├── ShaderData.h
│ │ │ ├── TextureData.h
│ │ │ └── VertexIndexData.h
│ │ ├── iglu/
│ │ │ ├── ManagedUniformBuffer.cpp
│ │ │ ├── ShaderCrossTest.cpp
│ │ │ ├── ShaderUniformsTest.cpp
│ │ │ ├── StatePool.cpp
│ │ │ ├── TextureAccessor.cpp
│ │ │ ├── UniformCollection.cpp
│ │ │ ├── UniformDescriptor.cpp
│ │ │ ├── UniformTests.h
│ │ │ ├── bitmap/
│ │ │ │ └── BitmapWriterTest.cpp
│ │ │ └── texture_loader/
│ │ │ ├── BaseTextureLoader.cpp
│ │ │ ├── IDataTest.cpp
│ │ │ ├── Ktx1TextureLoaderTest.cpp
│ │ │ ├── Ktx2TextureLoaderTest.cpp
│ │ │ ├── StbHdrTextureLoaderTest.cpp
│ │ │ ├── StbJpegTextureLoaderTest.cpp
│ │ │ ├── StbPngTextureLoaderTest.cpp
│ │ │ ├── TextureLoaderFactoryTest.cpp
│ │ │ └── Xtc1TextureLoaderTest.cpp
│ │ ├── main.cpp
│ │ ├── metal/
│ │ │ ├── BindGroup.mm
│ │ │ ├── Buffer.mm
│ │ │ ├── BufferSynchronizationManager.mm
│ │ │ ├── BytesBinding.mm
│ │ │ ├── ColorSpace.mm
│ │ │ ├── CommandBuffer.mm
│ │ │ ├── CommandBufferOps.mm
│ │ │ ├── CommandQueue.mm
│ │ │ ├── ComputeCommandEncoder.mm
│ │ │ ├── ComputePipelineState.mm
│ │ │ ├── DepthStencilCreation.mm
│ │ │ ├── DepthStencilState.mm
│ │ │ ├── Device.mm
│ │ │ ├── DeviceFeatureSet.mm
│ │ │ ├── DeviceStatistics.mm
│ │ │ ├── DrawCall.mm
│ │ │ ├── ErrorPaths.mm
│ │ │ ├── Framebuffer.mm
│ │ │ ├── HWDevice.mm
│ │ │ ├── IndirectDraw.mm
│ │ │ ├── MeshShader.mm
│ │ │ ├── PlatformDevice.mm
│ │ │ ├── RenderCommandEncoder.mm
│ │ │ ├── RenderEncoderState.mm
│ │ │ ├── RenderPass.mm
│ │ │ ├── RenderPipelineCreation.mm
│ │ │ ├── RenderPipelineReflection.mm
│ │ │ ├── RenderPipelineState.mm
│ │ │ ├── SamplerCreation.mm
│ │ │ ├── SamplerState.mm
│ │ │ ├── ShaderLibrary.mm
│ │ │ ├── StorageMode.mm
│ │ │ ├── Texture.mm
│ │ │ ├── TextureDataRoundtrip.mm
│ │ │ ├── Timer.mm
│ │ │ └── VertexInputState.mm
│ │ ├── ogl/
│ │ │ ├── BindlessTextures.cpp
│ │ │ ├── BlendModeConversion.cpp
│ │ │ ├── BufferMapping.cpp
│ │ │ ├── CommandBufferOGL.cpp
│ │ │ ├── CompressedTexture.cpp
│ │ │ ├── ComputeCommandAdapter.cpp
│ │ │ ├── ComputePipelineStateOGL.cpp
│ │ │ ├── Context.cpp
│ │ │ ├── CopyTexSubImage.cpp
│ │ │ ├── CubeMapAttachment.cpp
│ │ │ ├── DebugOutput.cpp
│ │ │ ├── DepthRange.cpp
│ │ │ ├── DepthStencilState.cpp
│ │ │ ├── DestructionGuard.cpp
│ │ │ ├── Device.cpp
│ │ │ ├── DeviceFeatureSetFull.cpp
│ │ │ ├── ExtensionDetection.cpp
│ │ │ ├── FeatureLimits.cpp
│ │ │ ├── FramebufferBlit.cpp
│ │ │ ├── HWDevice.cpp
│ │ │ ├── ImageLoadStore.cpp
│ │ │ ├── InvalidateFramebuffer.cpp
│ │ │ ├── MSAATextureAttachment.cpp
│ │ │ ├── Memcpy.cpp
│ │ │ ├── MemoryObjectImport.cpp
│ │ │ ├── MultiviewFramebuffer.cpp
│ │ │ ├── PipelineState.cpp
│ │ │ ├── PlatformDevice.cpp
│ │ │ ├── RenderCommandAdapter.cpp
│ │ │ ├── RenderPipelineReflection.cpp
│ │ │ ├── RenderStateApplication.cpp
│ │ │ ├── Resource.cpp
│ │ │ ├── SRGBWriteControl.cpp
│ │ │ ├── SamplerState.cpp
│ │ │ ├── SyncObjects.cpp
│ │ │ ├── Texture.cpp
│ │ │ ├── Texture3D.cpp
│ │ │ ├── TextureBuffer.cpp
│ │ │ ├── TextureBufferBase.cpp
│ │ │ ├── TextureTarget.cpp
│ │ │ ├── Timer.cpp
│ │ │ ├── UniformAdapter.cpp
│ │ │ ├── UniformBlockBuffer.cpp
│ │ │ ├── UniformBuffer.cpp
│ │ │ ├── Version.cpp
│ │ │ ├── VertexArrayObjectOGL.cpp
│ │ │ ├── VertexInputState.cpp
│ │ │ ├── ViewTextureTarget.cpp
│ │ │ ├── ios/
│ │ │ │ └── TextureBuffer.mm
│ │ │ └── macos/
│ │ │ └── TextureBuffer.mm
│ │ ├── util/
│ │ │ ├── Color.h
│ │ │ ├── Common.cpp
│ │ │ ├── Common.h
│ │ │ ├── Half.h
│ │ │ ├── SpvModules.cpp
│ │ │ ├── SpvModules.h
│ │ │ ├── TestDevice.cpp
│ │ │ ├── TestDevice.h
│ │ │ ├── TestErrorGuard.cpp
│ │ │ ├── TestErrorGuard.h
│ │ │ ├── TextureFormatTestBase.cpp
│ │ │ ├── TextureFormatTestBase.h
│ │ │ ├── TextureValidationHelpers.h
│ │ │ ├── device/
│ │ │ │ ├── MetalTestDevice.h
│ │ │ │ ├── MetalTestDevice.mm
│ │ │ │ ├── TestDevice.cpp
│ │ │ │ ├── TestDevice.h
│ │ │ │ ├── d3d12/
│ │ │ │ │ ├── TestDevice.cpp
│ │ │ │ │ └── TestDevice.h
│ │ │ │ ├── metal/
│ │ │ │ │ ├── TestDevice.h
│ │ │ │ │ └── TestDevice.mm
│ │ │ │ ├── opengl/
│ │ │ │ │ ├── TestDevice.cpp
│ │ │ │ │ └── TestDevice.h
│ │ │ │ └── vulkan/
│ │ │ │ ├── TestDevice.cpp
│ │ │ │ └── TestDevice.h
│ │ │ └── simdstub.h
│ │ └── vulkan/
│ │ ├── ColorSpace.cpp
│ │ ├── CommandBufferVulkanTest.cpp
│ │ ├── CommonTest.cpp
│ │ ├── ComputeCommandEncoderVulkanTest.cpp
│ │ ├── DescriptorPoolArenaTest.cpp
│ │ ├── Device.cpp
│ │ ├── DeviceExtendedVulkanTest.cpp
│ │ ├── FramebufferVulkanTest.cpp
│ │ ├── ImageLayoutTransitionTest.cpp
│ │ ├── PipelineStateTest.cpp
│ │ ├── RenderCommandEncoderVulkanTest.cpp
│ │ ├── RenderPipelineStateTest.cpp
│ │ ├── ResourcesBinderTest.cpp
│ │ ├── SpvConstantSpecializationExtendedTest.cpp
│ │ ├── SpvConstantSpecializationTest.cpp
│ │ ├── SpvReflectionTest.cpp
│ │ ├── Texture.cpp
│ │ ├── TextureFormat.cpp
│ │ ├── TextureVulkanExtendedTest.cpp
│ │ ├── VulkanBufferTest.cpp
│ │ ├── VulkanContextExtendedTest.cpp
│ │ ├── VulkanDescriptorSetLayoutTest.cpp
│ │ ├── VulkanFeaturesTest.cpp
│ │ ├── VulkanFenceTest.cpp
│ │ ├── VulkanHelpersTest.cpp
│ │ ├── VulkanImageTest.cpp
│ │ ├── VulkanImageViewTest.cpp
│ │ ├── VulkanImmediateCommandsTest.cpp
│ │ ├── VulkanPipelineBuilderTest.cpp
│ │ ├── VulkanQueuePool.cpp
│ │ ├── VulkanRenderPassBuilderTest.cpp
│ │ ├── VulkanSemaphoreExtendedTest.cpp
│ │ ├── VulkanStagingDeviceTest.cpp
│ │ ├── VulkanSwapchainExtendedTest.cpp
│ │ └── VulkanSwapchainTest.cpp
│ ├── vulkan/
│ │ ├── Buffer.cpp
│ │ ├── Buffer.h
│ │ ├── CMakeLists.txt
│ │ ├── CommandBuffer.cpp
│ │ ├── CommandBuffer.h
│ │ ├── CommandQueue.cpp
│ │ ├── CommandQueue.h
│ │ ├── Common.cpp
│ │ ├── Common.h
│ │ ├── ComputeCommandEncoder.cpp
│ │ ├── ComputeCommandEncoder.h
│ │ ├── ComputePipelineState.cpp
│ │ ├── ComputePipelineState.h
│ │ ├── Device.cpp
│ │ ├── Device.h
│ │ ├── Framebuffer.cpp
│ │ ├── Framebuffer.h
│ │ ├── HWDevice.cpp
│ │ ├── HWDevice.h
│ │ ├── PipelineState.cpp
│ │ ├── PipelineState.h
│ │ ├── PlatformDevice.cpp
│ │ ├── PlatformDevice.h
│ │ ├── RenderCommandEncoder.cpp
│ │ ├── RenderCommandEncoder.h
│ │ ├── RenderPipelineReflection.cpp
│ │ ├── RenderPipelineReflection.h
│ │ ├── RenderPipelineState.cpp
│ │ ├── RenderPipelineState.h
│ │ ├── ResourcesBinder.cpp
│ │ ├── ResourcesBinder.h
│ │ ├── SamplerState.cpp
│ │ ├── SamplerState.h
│ │ ├── ShaderModule.cpp
│ │ ├── ShaderModule.h
│ │ ├── Texture.cpp
│ │ ├── Texture.h
│ │ ├── VulkanBuffer.cpp
│ │ ├── VulkanBuffer.h
│ │ ├── VulkanContext.cpp
│ │ ├── VulkanContext.h
│ │ ├── VulkanDescriptorSetLayout.cpp
│ │ ├── VulkanDescriptorSetLayout.h
│ │ ├── VulkanFeatures.cpp
│ │ ├── VulkanFeatures.h
│ │ ├── VulkanFence.cpp
│ │ ├── VulkanFence.h
│ │ ├── VulkanFramebuffer.cpp
│ │ ├── VulkanFramebuffer.h
│ │ ├── VulkanFunctionTable.c
│ │ ├── VulkanFunctionTable.h
│ │ ├── VulkanHelpers.c
│ │ ├── VulkanHelpers.h
│ │ ├── VulkanImage.cpp
│ │ ├── VulkanImage.h
│ │ ├── VulkanImageView.cpp
│ │ ├── VulkanImageView.h
│ │ ├── VulkanImmediateCommands.cpp
│ │ ├── VulkanImmediateCommands.h
│ │ ├── VulkanPipelineBuilder.cpp
│ │ ├── VulkanPipelineBuilder.h
│ │ ├── VulkanQueuePool.cpp
│ │ ├── VulkanQueuePool.h
│ │ ├── VulkanRenderPassBuilder.cpp
│ │ ├── VulkanRenderPassBuilder.h
│ │ ├── VulkanSemaphore.cpp
│ │ ├── VulkanSemaphore.h
│ │ ├── VulkanShaderModule.cpp
│ │ ├── VulkanShaderModule.h
│ │ ├── VulkanStagingDevice.cpp
│ │ ├── VulkanStagingDevice.h
│ │ ├── VulkanSwapchain.cpp
│ │ ├── VulkanSwapchain.h
│ │ ├── VulkanTexture.cpp
│ │ ├── VulkanTexture.h
│ │ ├── VulkanVma.h
│ │ ├── android/
│ │ │ ├── NativeHWBuffer.cpp
│ │ │ └── NativeHWBuffer.h
│ │ ├── moltenvk/
│ │ │ ├── MoltenVkHelpers.h
│ │ │ └── MoltenVkHelpers.mm
│ │ └── util/
│ │ ├── SpvConstantSpecialization.cpp
│ │ ├── SpvConstantSpecialization.h
│ │ ├── SpvReflection.cpp
│ │ ├── SpvReflection.h
│ │ ├── TextureFormat.cpp
│ │ └── TextureFormat.h
│ └── win/
│ ├── LogDefault.cpp
│ └── LogDefault.h
└── third-party/
├── .gitignore
├── bootstrap-content.json
├── bootstrap-deps.json
└── bootstrap.py
Showing preview only (331K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (3637 symbols across 862 files)
FILE: IGLU/bitmap/BitmapWriter.cpp
type igl::iglu (line 14) | namespace igl::iglu {
type BMPHeader (line 21) | struct BMPHeader {
type BufferOffsets (line 51) | struct BufferOffsets {
function BufferOffsets (line 57) | BufferOffsets getBufferOffsets(TextureFormat format) {
function isSupportedBitmapTextureFormat (line 78) | bool isSupportedBitmapTextureFormat(TextureFormat format) {
function writeBitmap (line 92) | void writeBitmap(std::ostream& stream,
function writeBitmap (line 144) | void writeBitmap(std::ostream& stream, const uint8_t* imageData, uint3...
FILE: IGLU/bitmap/BitmapWriter.h
function namespace (line 13) | namespace igl::iglu {
FILE: IGLU/command_buffer_allocator/ICommandBufferAllocator.cpp
type iglu::command_buffer_allocator (line 12) | namespace iglu::command_buffer_allocator {
FILE: IGLU/command_buffer_allocator/ICommandBufferAllocator.h
function namespace (line 12) | namespace iglu::command_buffer_allocator {
FILE: IGLU/imgui/InputListener.cpp
type iglu::imgui (line 25) | namespace iglu::imgui {
FILE: IGLU/imgui/InputListener.h
function namespace (line 18) | namespace iglu::imgui {
FILE: IGLU/imgui/KeyCodeTranslator.cpp
type KeyModifiers (line 16) | enum KeyModifiers {
function ImGuiKey (line 35) | [[maybe_unused]] ImGuiKey keyFromShellKeyEventApple(igl::shell::KeyEvent...
type iglu::imgui (line 78) | namespace iglu::imgui {
function ImGuiKey (line 79) | ImGuiKey keyFromShellKeyEvent(igl::shell::KeyEvent event) {
FILE: IGLU/imgui/KeyCodeTranslator.h
function namespace (line 16) | namespace iglu::imgui {
FILE: IGLU/imgui/Session.cpp
type iglu::imgui (line 20) | namespace iglu::imgui {
type Uniforms (line 31) | struct Uniforms { float4x4 projectionMatrix; }
type VertexIn (line 33) | struct VertexIn {
type VertexOut (line 39) | struct VertexOut {
function vertex (line 45) | vertex VertexOut vertex_main(VertexIn in [[stage_in]],
function fragment (line 54) | fragment half4 fragment_main(VertexOut in [[stage_in]],
function getOpenGLVertexShaderSource (line 65) | static std::string getOpenGLVertexShaderSource(igl::ShaderVersion shad...
function getOpenGLFragmentShaderSource (line 108) | static std::string getOpenGLFragmentShaderSource(igl::ShaderVersion sh...
function getShaderStagesForBackend (line 184) | static std::unique_ptr<igl::IShaderStages> getShaderStagesForBackend(i...
type DrawableData (line 234) | struct DrawableData {
method DrawableData (line 238) | DrawableData(igl::IDevice& device,
class Session::Renderer (line 275) | class Session::Renderer {
method Renderer (line 279) | Renderer(const Renderer&) = delete;
method Renderer (line 280) | Renderer& operator=(const Renderer&) = delete;
method Renderer (line 281) | Renderer(Renderer&&) = delete;
method Renderer (line 282) | Renderer& operator=(Renderer&&) = delete;
FILE: IGLU/imgui/Session.h
function namespace (line 23) | namespace iglu::imgui {
FILE: IGLU/imgui/compile_shaders.py
function compile_shader (line 16) | def compile_shader(shader_file, profile, output_cso):
function cso_to_header (line 28) | def cso_to_header(cso_file, header_file, var_name):
function main (line 46) | def main():
FILE: IGLU/managedUniformBuffer/ManagedUniformBuffer.cpp
type iglu (line 28) | namespace iglu {
function findUniformByName (line 193) | static int findUniformByName(const std::vector<igl::UniformDesc>& unif...
FILE: IGLU/managedUniformBuffer/ManagedUniformBuffer.h
function namespace (line 13) | namespace iglu {
FILE: IGLU/sentinel/Buffer.cpp
type iglu::sentinel (line 15) | namespace iglu::sentinel {
FILE: IGLU/sentinel/Buffer.h
function namespace (line 12) | namespace iglu::sentinel {
FILE: IGLU/sentinel/CommandBuffer.cpp
type iglu::sentinel (line 15) | namespace iglu::sentinel {
FILE: IGLU/sentinel/CommandBuffer.h
function namespace (line 12) | namespace iglu::sentinel {
FILE: IGLU/sentinel/CommandQueue.cpp
type iglu::sentinel (line 14) | namespace iglu::sentinel {
FILE: IGLU/sentinel/CommandQueue.h
function namespace (line 12) | namespace iglu::sentinel {
FILE: IGLU/sentinel/Device.cpp
type iglu::sentinel (line 16) | namespace iglu::sentinel {
FILE: IGLU/sentinel/Device.h
function namespace (line 13) | namespace iglu::sentinel {
FILE: IGLU/sentinel/Framebuffer.cpp
type iglu::sentinel (line 14) | namespace iglu::sentinel {
FILE: IGLU/sentinel/Framebuffer.h
function namespace (line 12) | namespace iglu::sentinel {
FILE: IGLU/sentinel/PlatformDevice.cpp
type iglu::sentinel (line 14) | namespace iglu::sentinel {
FILE: IGLU/sentinel/PlatformDevice.h
function namespace (line 12) | namespace iglu::sentinel {
FILE: IGLU/shaderCross/ShaderCross.cpp
type iglu (line 17) | namespace iglu {
FILE: IGLU/shaderCross/ShaderCross.h
function namespace (line 13) | namespace iglu {
FILE: IGLU/shaderCross/ShaderCrossUniformBuffer.cpp
type iglu (line 10) | namespace iglu {
function ManagedUniformBufferInfo (line 12) | [[nodiscard]] ManagedUniformBufferInfo getSpirvCrossCompatibleManagedU...
FILE: IGLU/shaderCross/ShaderCrossUniformBuffer.h
function namespace (line 13) | namespace iglu {
FILE: IGLU/simdtypes/SimdTypes.h
function final (line 83) | struct float4 final {
function final (line 105) | struct float2 final {
function final (line 123) | struct int4 final {
function final (line 144) | struct int2 final {
type Float4x4 (line 166) | struct Float4x4 {
type Float3x4 (line 196) | struct Float3x4 {
type Float3x3 (line 222) | struct Float3x3 {
function explicit (line 230) | explicit Float3x3(float3 diag) {
FILE: IGLU/simdtypes/SimdUtilities.h
function namespace (line 13) | namespace iglu::simdtypes {
function float4 (line 189) | inline float4 multiply(const float4x4& m, const float4& v) {
function float4x4 (line 203) | inline float4x4 multiply(const float4x4& m1, const float4x4& m2) {
FILE: IGLU/simple_renderer/Drawable.cpp
type iglu::drawable (line 14) | namespace iglu::drawable {
FILE: IGLU/simple_renderer/Drawable.h
function namespace (line 16) | namespace iglu::drawable {
FILE: IGLU/simple_renderer/ForwardRenderPass.cpp
type iglu::renderpass (line 14) | namespace iglu::renderpass {
FILE: IGLU/simple_renderer/ForwardRenderPass.h
function namespace (line 18) | namespace iglu::renderpass {
FILE: IGLU/simple_renderer/Material.cpp
type iglu::material (line 14) | namespace iglu::material {
function ShaderUniforms (line 31) | ShaderUniforms& Material::shaderUniforms() const {
function DepthTestConfig (line 35) | DepthTestConfig Material::depthTestConfig() const {
FILE: IGLU/simple_renderer/Material.h
type class (line 20) | enum class
function BlendMode (line 63) | static BlendMode Additive() {
FILE: IGLU/simple_renderer/ParametricVertexData.cpp
type iglu::vertexdata (line 14) | namespace iglu::vertexdata {
type Quad (line 20) | namespace Quad {
function inputStateDesc (line 22) | igl::VertexInputStateDesc inputStateDesc() {
function create (line 45) | std::shared_ptr<VertexData> create(igl::IDevice& device,
type RenderToTextureQuad (line 90) | namespace RenderToTextureQuad {
function inputStateDesc (line 92) | igl::VertexInputStateDesc inputStateDesc() {
function create (line 96) | std::shared_ptr<VertexData> create(igl::IDevice& device,
FILE: IGLU/simple_renderer/ParametricVertexData.h
function namespace (line 17) | namespace iglu::vertexdata {
FILE: IGLU/simple_renderer/ShaderProgram.cpp
type iglu::material (line 15) | namespace iglu::material {
FILE: IGLU/simple_renderer/ShaderProgram.h
function namespace (line 16) | namespace iglu::material {
FILE: IGLU/simple_renderer/ShaderUniforms.cpp
function bindTargetForShaderStage (line 35) | uint8_t bindTargetForShaderStage(igl::ShaderStage stage) {
type iglu::material (line 50) | namespace iglu::material {
FILE: IGLU/simple_renderer/ShaderUniforms.h
function namespace (line 20) | namespace iglu::material {
FILE: IGLU/simple_renderer/VertexData.cpp
type iglu::vertexdata (line 14) | namespace iglu::vertexdata {
function PrimitiveDesc (line 88) | PrimitiveDesc& VertexData::primitiveDesc() {
FILE: IGLU/simple_renderer/VertexData.h
function namespace (line 16) | namespace iglu::vertexdata {
FILE: IGLU/state_pool/ComputePipelineStatePool.cpp
type iglu::state_pool (line 12) | namespace iglu::state_pool {
FILE: IGLU/state_pool/ComputePipelineStatePool.h
function namespace (line 13) | namespace igl {
function namespace (line 17) | namespace iglu::state_pool {
FILE: IGLU/state_pool/DepthStencilStatePool.cpp
type iglu::state_pool (line 12) | namespace iglu::state_pool {
FILE: IGLU/state_pool/DepthStencilStatePool.h
function namespace (line 13) | namespace igl {
function namespace (line 17) | namespace iglu::state_pool {
FILE: IGLU/state_pool/RenderPipelineStatePool.cpp
type iglu::state_pool (line 14) | namespace iglu::state_pool {
FILE: IGLU/state_pool/RenderPipelineStatePool.h
function namespace (line 13) | namespace igl {
function namespace (line 17) | namespace iglu::state_pool {
FILE: IGLU/state_pool/StatePool.h
function namespace (line 16) | namespace igl {
function namespace (line 20) | namespace iglu::state_pool {
FILE: IGLU/state_pool/VertexInputStatePool.cpp
type iglu::state_pool (line 12) | namespace iglu::state_pool {
FILE: IGLU/state_pool/VertexInputStatePool.h
function namespace (line 13) | namespace igl {
function namespace (line 17) | namespace iglu::state_pool {
FILE: IGLU/texture_accessor/ITextureAccessor.h
function namespace (line 14) | namespace iglu::textureaccessor {
FILE: IGLU/texture_accessor/MetalTextureAccessor.h
function namespace (line 17) | namespace iglu::textureaccessor {
FILE: IGLU/texture_accessor/OpenGLTextureAccessor.cpp
type iglu::textureaccessor (line 27) | namespace iglu::textureaccessor {
function RequestStatus (line 114) | RequestStatus OpenGLTextureAccessor::getRequestStatus() {
FILE: IGLU/texture_accessor/OpenGLTextureAccessor.h
function namespace (line 21) | namespace iglu::textureaccessor {
FILE: IGLU/texture_accessor/TextureAccessorFactory.cpp
type iglu::textureaccessor (line 22) | namespace iglu::textureaccessor {
FILE: IGLU/texture_accessor/TextureAccessorFactory.h
function namespace (line 16) | namespace iglu::textureaccessor {
FILE: IGLU/texture_accessor/VulkanTextureAccessor.cpp
type iglu::textureaccessor (line 25) | namespace iglu::textureaccessor {
function RequestStatus (line 95) | RequestStatus VulkanTextureAccessor::getRequestStatus() {
FILE: IGLU/texture_accessor/VulkanTextureAccessor.h
function namespace (line 19) | namespace iglu::textureaccessor {
FILE: IGLU/texture_loader/DataReader.cpp
type iglu::textureloader (line 10) | namespace iglu::textureloader {
FILE: IGLU/texture_loader/DataReader.h
function namespace (line 14) | namespace igl {
function namespace (line 18) | namespace iglu::textureloader {
FILE: IGLU/texture_loader/IData.cpp
type iglu::textureloader (line 10) | namespace iglu::textureloader {
class ByteData (line 12) | class ByteData final : public IData {
FILE: IGLU/texture_loader/IData.h
function namespace (line 13) | namespace iglu::textureloader {
FILE: IGLU/texture_loader/ITextureLoader.cpp
type iglu::textureloader (line 14) | namespace iglu::textureloader {
function DataReader (line 152) | DataReader& ITextureLoader::reader() noexcept {
function DataReader (line 156) | const DataReader& ITextureLoader::reader() const noexcept {
FILE: IGLU/texture_loader/ITextureLoader.h
function namespace (line 14) | namespace igl {
function namespace (line 19) | namespace iglu::textureloader {
FILE: IGLU/texture_loader/ITextureLoaderFactory.cpp
type iglu::textureloader (line 10) | namespace iglu::textureloader {
FILE: IGLU/texture_loader/ITextureLoaderFactory.h
function namespace (line 15) | namespace iglu::textureloader {
FILE: IGLU/texture_loader/TextureLoaderFactory.cpp
type iglu::textureloader (line 10) | namespace iglu::textureloader {
FILE: IGLU/texture_loader/TextureLoaderFactory.h
function namespace (line 13) | namespace iglu::textureloader {
FILE: IGLU/texture_loader/ktx/TextureLoaderFactory.cpp
type iglu::textureloader::ktx (line 17) | namespace iglu::textureloader::ktx {
type KtxDeleter (line 20) | struct KtxDeleter {
class TextureLoader (line 26) | class TextureLoader : public ITextureLoader {
method getMemorySizeInBytesFromFile (line 38) | [[nodiscard]] size_t getMemorySizeInBytesFromFile(uint32_t miplevel)...
method mipLevelBytes (line 72) | [[nodiscard]] std::vector<uint32_t> mipLevelBytes() const noexcept o...
FILE: IGLU/texture_loader/ktx/TextureLoaderFactory.h
type ktxTexture (line 12) | struct ktxTexture
function namespace (line 14) | namespace iglu::textureloader::ktx {
FILE: IGLU/texture_loader/ktx1/Header.cpp
type iglu::textureloader::ktx1 (line 12) | namespace iglu::textureloader::ktx1 {
FILE: IGLU/texture_loader/ktx1/Header.h
function namespace (line 13) | namespace iglu::textureloader::ktx1 {
FILE: IGLU/texture_loader/ktx1/TextureLoaderFactory.cpp
type iglu::textureloader::ktx1 (line 14) | namespace iglu::textureloader::ktx1 {
FILE: IGLU/texture_loader/ktx1/TextureLoaderFactory.h
function namespace (line 12) | namespace iglu::textureloader::ktx1 {
FILE: IGLU/texture_loader/ktx2/Header.cpp
type iglu::textureloader::ktx2 (line 12) | namespace iglu::textureloader::ktx2 {
FILE: IGLU/texture_loader/ktx2/Header.h
function namespace (line 13) | namespace iglu::textureloader::ktx2 {
FILE: IGLU/texture_loader/ktx2/TextureLoaderFactory.cpp
type igl::vulkan::util (line 17) | namespace igl::vulkan::util {
function vkTextureFormatToTextureFormat (line 18) | inline igl::TextureFormat vkTextureFormatToTextureFormat(int32_t /*vkF...
type iglu::textureloader::ktx2 (line 28) | namespace iglu::textureloader::ktx2 {
function T (line 31) | T align(T offset, T alignment) {
FILE: IGLU/texture_loader/ktx2/TextureLoaderFactory.h
function namespace (line 12) | namespace iglu::textureloader::ktx2 {
FILE: IGLU/texture_loader/stb_hdr/Header.cpp
type iglu::textureloader::stb::hdr (line 12) | namespace iglu::textureloader::stb::hdr {
FILE: IGLU/texture_loader/stb_hdr/Header.h
function namespace (line 13) | namespace iglu::textureloader::stb::hdr {
FILE: IGLU/texture_loader/stb_hdr/TextureLoaderFactory.cpp
type iglu::textureloader::stb::hdr (line 12) | namespace iglu::textureloader::stb::hdr {
FILE: IGLU/texture_loader/stb_hdr/TextureLoaderFactory.h
function namespace (line 12) | namespace iglu::textureloader::stb::hdr {
FILE: IGLU/texture_loader/stb_image/TextureLoaderFactory.cpp
type iglu::textureloader::stb::image (line 18) | namespace iglu::textureloader::stb::image {
type StbImageDeleter (line 19) | struct StbImageDeleter {
class StbImageData (line 26) | class StbImageData : public IData {
class TextureLoader (line 60) | class TextureLoader : public ITextureLoader {
FILE: IGLU/texture_loader/stb_image/TextureLoaderFactory.h
function namespace (line 12) | namespace iglu::textureloader::stb::image {
FILE: IGLU/texture_loader/stb_jpeg/Header.cpp
type iglu::textureloader::stb::jpeg (line 12) | namespace iglu::textureloader::stb::jpeg {
FILE: IGLU/texture_loader/stb_jpeg/Header.h
function namespace (line 13) | namespace iglu::textureloader::stb::jpeg {
FILE: IGLU/texture_loader/stb_jpeg/TextureLoaderFactory.cpp
type iglu::textureloader::stb::jpeg (line 12) | namespace iglu::textureloader::stb::jpeg {
FILE: IGLU/texture_loader/stb_jpeg/TextureLoaderFactory.h
function namespace (line 12) | namespace iglu::textureloader::stb::jpeg {
FILE: IGLU/texture_loader/stb_png/Header.cpp
type iglu::textureloader::stb::png (line 12) | namespace iglu::textureloader::stb::png {
FILE: IGLU/texture_loader/stb_png/Header.h
function namespace (line 13) | namespace iglu::textureloader::stb::png {
FILE: IGLU/texture_loader/stb_png/TextureLoaderFactory.cpp
type iglu::textureloader::stb::png (line 12) | namespace iglu::textureloader::stb::png {
FILE: IGLU/texture_loader/stb_png/TextureLoaderFactory.h
function namespace (line 12) | namespace iglu::textureloader::stb::png {
FILE: IGLU/texture_loader/xtc1/Header.cpp
type iglu::textureloader::xtc1 (line 12) | namespace iglu::textureloader::xtc1 {
FILE: IGLU/texture_loader/xtc1/Header.h
function namespace (line 13) | namespace iglu::textureloader::xtc1 {
FILE: IGLU/texture_loader/xtc1/TextureLoaderFactory.cpp
type iglu::textureloader::xtc1 (line 19) | namespace iglu::textureloader::xtc1 {
function getXTC1Format (line 25) | igl::TextureFormat getXTC1Format(uint32_t numChannels) {
class TextureLoader (line 38) | class TextureLoader final : public ITextureLoader {
method TextureLoader (line 40) | explicit TextureLoader(DataReader reader) noexcept : ITextureLoader(...
method loadInternal (line 53) | [[nodiscard]] std::unique_ptr<IData> loadInternal(
FILE: IGLU/texture_loader/xtc1/TextureLoaderFactory.h
function namespace (line 12) | namespace iglu::textureloader::xtc1 {
FILE: IGLU/uniform/Collection.cpp
type iglu::uniform (line 13) | namespace iglu::uniform {
function Descriptor (line 52) | const Descriptor& Collection::get(const igl::NameHandle& name) const {
function Descriptor (line 59) | Descriptor& Collection::get(const igl::NameHandle& name) {
FILE: IGLU/uniform/Collection.h
function namespace (line 16) | namespace iglu::uniform {
FILE: IGLU/uniform/CollectionEncoder.cpp
type iglu::uniform (line 13) | namespace iglu::uniform {
FILE: IGLU/uniform/CollectionEncoder.h
function namespace (line 14) | namespace igl {
function namespace (line 18) | namespace iglu::uniform {
FILE: IGLU/uniform/Descriptor.cpp
type iglu::uniform (line 10) | namespace iglu::uniform {
FILE: IGLU/uniform/Descriptor.h
function Alignment (line 24) | enum class Alignment { Packed, Aligned };
function getType (line 134) | struct Descriptor {
function setIndices (line 158) | void setIndices(Indices indices) noexcept {
function explicit (line 195) | explicit DescriptorValue(T value) : Descriptor(Trait<T>::kValue), elemen...
function numBytes (line 201) | [[nodiscard]] size_t numBytes(Alignment alignment) const noexcept overri...
type PackedContainer (line 246) | struct PackedContainer {
function elementSize (line 259) | [[nodiscard]] size_t elementSize(Alignment /*unused*/) const noexcept {
type DualContainer (line 266) | struct DualContainer {
function noexcept (line 294) | const noexcept {
function explicit (line 305) | explicit DescriptorVector(Vector values) :
function numBytes (line 312) | [[nodiscard]] size_t numBytes(Alignment alignment) const noexcept overri...
FILE: IGLU/uniform/Encoder.cpp
type iglu::uniform (line 13) | namespace iglu::uniform {
function bindRenderUniform (line 20) | void bindRenderUniform(igl::IRenderCommandEncoder& encoder,
function bindComputeUniform (line 31) | void bindComputeUniform(igl::IComputeCommandEncoder& encoder,
function encodeRenderUniform (line 43) | void encodeRenderUniform(igl::IRenderCommandEncoder& encoder,
function encodeAlignedCompute (line 55) | void encodeAlignedCompute(igl::IComputeCommandEncoder& encoder,
FILE: IGLU/uniform/Encoder.h
function namespace (line 14) | namespace igl {
function namespace (line 19) | namespace iglu::uniform {
FILE: IGLU/uniform/Trait.h
function namespace (line 15) | namespace iglu::uniform {
FILE: docs/source/_extensions/style.py
function setup (line 7) | def setup(app):
FILE: samples/android/opengl/java/com/facebook/igl/sample/SampleActivity.java
class SampleActivity (line 15) | public class SampleActivity extends Activity {
method onCreate (line 19) | @Override
method onPause (line 26) | @Override
method onResume (line 32) | @Override
FILE: samples/android/opengl/java/com/facebook/igl/sample/SampleLib.java
class SampleLib (line 11) | public class SampleLib {
method init (line 17) | public static native void init();
method surfaceChanged (line 19) | public static native void surfaceChanged();
method render (line 21) | public static native void render();
FILE: samples/android/opengl/java/com/facebook/igl/sample/SampleView.java
class SampleView (line 23) | class SampleView extends GLSurfaceView {
method SampleView (line 26) | public SampleView(Context context) {
class ContextFactory (line 40) | private static class ContextFactory implements GLSurfaceView.EGLContex...
method createContext (line 42) | public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLCo...
method destroyContext (line 51) | public void destroyContext(EGL10 egl, EGLDisplay display, EGLContext...
method checkEglError (line 56) | private static void checkEglError(String prompt, EGL10 egl) {
class ConfigChooser (line 65) | private static class ConfigChooser implements GLSurfaceView.EGLConfigC...
method chooseConfig (line 67) | public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {
class Renderer (line 95) | private static class Renderer implements GLSurfaceView.Renderer {
method onSurfaceCreated (line 97) | public void onSurfaceCreated(GL10 gl, EGLConfig config) {
method onSurfaceChanged (line 101) | public void onSurfaceChanged(GL10 gl, int width, int height) {
method onDrawFrame (line 105) | public void onDrawFrame(GL10 gl) {
FILE: samples/android/opengl/jni/Jni.cpp
type igl_samples::android (line 16) | namespace igl_samples::android {
function JNIEXPORT (line 30) | JNIEXPORT void JNICALL Java_com_facebook_igl_sample_opengl_SampleLib_i...
function JNIEXPORT (line 36) | JNIEXPORT void JNICALL
function JNIEXPORT (line 41) | JNIEXPORT void JNICALL Java_com_facebook_igl_sample_opengl_SampleLib_r...
FILE: samples/android/opengl/jni/TinyRenderer.cpp
type igl_samples::android (line 26) | namespace igl_samples::android {
function throwOnBadResult (line 32) | void throwOnBadResult(const Result& result) {
type VertexPosUv (line 76) | struct VertexPosUv {
FILE: samples/android/opengl/jni/TinyRenderer.h
function namespace (line 15) | namespace igl_samples::android {
FILE: samples/android/vulkan/java/com/facebook/igl/sample/SampleActivity.java
class SampleActivity (line 15) | public class SampleActivity extends NativeActivity {
method onCreate (line 17) | @Override
FILE: samples/android/vulkan/jni/Tiny.cpp
type igl_samples::android (line 24) | namespace igl_samples::android {
function initWindow (line 68) | void initWindow(ANativeWindow* nativeWindow) {
function initIGL (line 82) | void initIGL() {
function createFramebuffer (line 102) | void createFramebuffer(const std::shared_ptr<ITexture>& nativeDrawable) {
function createRenderPipeline (line 109) | void createRenderPipeline() {
function getVulkanNativeDrawable (line 132) | std::shared_ptr<ITexture> getVulkanNativeDrawable() {
function render (line 144) | void render() {
function initialize (line 183) | void initialize(android_app* app) {
function handleCmd (line 199) | void handleCmd(struct android_app* app, int32_t cmd) {}
function handleAppCmd (line 200) | static void handleAppCmd(struct android_app* app, int32_t appCmd) {
function android_main (line 225) | void android_main(struct android_app* app) {
FILE: samples/desktop/Tiny/Tiny.cpp
function GLFWwindow (line 138) | static GLFWwindow* initIGL(bool isHeadless, bool enableVulkanValidationL...
function createRenderPipeline (line 268) | static void createRenderPipeline() {
function getNativeDrawable (line 301) | static std::shared_ptr<ITexture> getNativeDrawable() {
function createFramebuffer (line 323) | static void createFramebuffer(const std::shared_ptr<ITexture>& nativeDra...
function render (line 345) | static void render(const std::shared_ptr<ITexture>& nativeDrawable) {
function main (line 386) | int main(int argc, char* argv[]) {
FILE: samples/desktop/Tiny/Tiny_Mesh.cpp
type VertexPosUvw (line 149) | struct VertexPosUvw {
type UniformsPerFrame (line 155) | struct UniformsPerFrame {
type UniformsPerObject (line 159) | struct UniformsPerObject {
function GLFWwindow (line 206) | GLFWwindow* initIGL(bool isHeadless, bool enableVulkanValidationLayers) {
function createRenderPipeline (line 465) | void createRenderPipeline() {
function getVulkanNativeDrawable (line 495) | std::shared_ptr<ITexture> getVulkanNativeDrawable() {
function getVulkanNativeDepth (line 507) | std::shared_ptr<ITexture> getVulkanNativeDepth() {
function createFramebuffer (line 520) | void createFramebuffer(const std::shared_ptr<ITexture>& nativeDrawable) {
function render (line 531) | void render(const std::shared_ptr<ITexture>& nativeDrawable, uint32_t fr...
function main (line 650) | int main(int argc, char* argv[]) {
FILE: samples/desktop/Tiny/Tiny_MeshLarge.cpp
function loadKtxTexture (line 160) | void loadKtxTexture(const igl::IDevice& device,
type VertexData (line 694) | struct VertexData {
type UniformsPerFrame (line 705) | struct UniformsPerFrame {
type UniformsPerObject (line 714) | struct UniformsPerObject {
type CachedMaterial (line 719) | struct CachedMaterial {
type GPUMaterial (line 729) | struct GPUMaterial {
type MaterialTextures (line 743) | struct MaterialTextures {
type LoadedImage (line 751) | struct LoadedImage {
type LoadedMaterial (line 760) | struct LoadedMaterial {
function convertFileName (line 780) | std::string convertFileName(std::string fileName) {
function stringReplaceAll (line 797) | [[maybe_unused]] void stringReplaceAll(std::string& s,
function GLFWwindow (line 806) | GLFWwindow* initIGL(bool isHeadless, bool enableVulkanValidationLayers) {
function normalizeName (line 1003) | void normalizeName(std::string& name) {
function loadAndCache (line 1010) | bool loadAndCache(const char* cacheFileName) {
function loadFromCache (line 1175) | bool loadFromCache(const char* cacheFileName) {
function initModel (line 1224) | void initModel(int numSamplesMSAA) {
function createComputePipeline (line 1446) | void createComputePipeline() {
function createRenderPipelines (line 1462) | void createRenderPipelines(int numSamplesMSAA) {
function createRenderPipelineSkybox (line 1658) | void createRenderPipelineSkybox(int numSamplesMSAA) {
function getNativeDrawable (line 1745) | std::shared_ptr<ITexture> getNativeDrawable() {
function getNativeDepthDrawable (line 1769) | std::shared_ptr<ITexture> getNativeDepthDrawable() {
function createFramebuffer (line 1793) | void createFramebuffer(const std::shared_ptr<ITexture>& nativeDrawable) {
function createShadowMap (line 1801) | void createShadowMap() {
function createOffscreenFramebuffer (line 1821) | void createOffscreenFramebuffer(int numSamplesMSAA) {
function render (line 1875) | void render(const std::shared_ptr<ITexture>& nativeDrawable,
function generateCompressedTexture (line 2131) | void generateCompressedTexture(const LoadedImage& img) {
function LoadedImage (line 2199) | LoadedImage loadImage(const char* fileName, int channels) {
function loadMaterial (line 2235) | void loadMaterial(size_t i) {
function loadMaterials (line 2270) | void loadMaterials(bool isHeadless) {
function loadCubemapTexture (line 2282) | void loadCubemapTexture(const std::string& fileNameKTX, std::shared_ptr<...
function ktxTexture2 (line 2337) | ktxTexture2* bitmapToCube(Bitmap& bmp) {
function generateMipmaps (line 2392) | void generateMipmaps(const std::string& outFilename, ktxTexture2* cubema...
function processCubemap (line 2440) | void processCubemap(const std::string& inFilename,
function loadSkyboxTexture (line 2483) | void loadSkyboxTexture() {
function createTexture (line 2504) | std::shared_ptr<ITexture> createTexture(const LoadedImage& img) {
function processLoadedMaterials (line 2561) | void processLoadedMaterials() {
function main (line 2604) | int main(int argc, char* argv[]) {
FILE: samples/ios/snapshot_test_support/TinyRenderable.cpp
function createCheckerboardTexture (line 19) | std::shared_ptr<igl::ITexture> createCheckerboardTexture(igl::IDevice& d...
function getShaderStagesForBackend (line 104) | std::unique_ptr<igl::IShaderStages> getShaderStagesForBackend(igl::IDevi...
type iglu::kit (line 151) | namespace iglu::kit {
type VertexPosUv (line 175) | struct VertexPosUv {
FILE: samples/ios/snapshot_test_support/TinyRenderable.hpp
type igl (line 13) | namespace igl {
class IRenderPipelineState (line 14) | class IRenderPipelineState
class IVertexInputState (line 15) | class IVertexInputState
class IShaderStages (line 16) | class IShaderStages
class IBuffer (line 17) | class IBuffer
class IBuffer (line 18) | class IBuffer
class ITexture (line 19) | class ITexture
class ISamplerState (line 20) | class ISamplerState
type iglu::kit (line 23) | namespace iglu::kit {
class TinyRenderable (line 25) | class TinyRenderable : public IRenderable {
FILE: samples/wasm/Common.cpp
function getRenderingBufferSize (line 15) | void getRenderingBufferSize(int& width, int& height) {
FILE: samples/wasm/Tiny_Mesh.cpp
type VertexPosUvw (line 97) | struct VertexPosUvw {
type UniformsPerFrame (line 103) | struct UniformsPerFrame {
type UniformsPerObject (line 107) | struct alignas(256) UniformsPerObject {
function getNativeDrawable (line 154) | static std::shared_ptr<ITexture> getNativeDrawable() {
function createFramebuffer (line 171) | static void createFramebuffer(const std::shared_ptr<ITexture>& nativeDra...
function initialize (line 179) | bool initialize() {
function createRenderPipeline (line 336) | static void createRenderPipeline() {
function onDraw (line 366) | void onDraw(void*) {
function main (line 428) | int main(int argc, char* argv[]) {
FILE: samples/wasm/Triangle.cpp
function initWindow (line 66) | static bool initWindow(GLFWwindow** outWindow) {
function initIGL (line 110) | static void initIGL() {
function createRenderPipeline (line 131) | static void createRenderPipeline() {
function getNativeDrawable (line 158) | static std::shared_ptr<ITexture> getNativeDrawable() {
function createFramebuffer (line 173) | static void createFramebuffer(const std::shared_ptr<ITexture>& nativeDra...
function render (line 189) | static void render(const std::shared_ptr<ITexture>& nativeDrawable) {
function emscriptenMainLoopCallback (line 220) | void emscriptenMainLoopCallback() {
function main (line 225) | int main(int argc, char* argv[]) {
FILE: shell/android/java/com/facebook/igl/sample/SampleActivity.java
class SampleActivity (line 23) | public class SampleActivity extends Activity implements View.OnClickList...
method onCreate (line 39) | @Override
method onClick (line 107) | @Override
method onPause (line 137) | @Override
method onResume (line 145) | @Override
FILE: shell/android/java/com/facebook/igl/sample/SampleLib.java
class SampleLib (line 17) | public class SampleLib {
type BackendFlavor (line 24) | public static enum BackendFlavor {
class BackendVersion (line 34) | public static class BackendVersion {
method BackendVersion (line 39) | public BackendVersion(BackendFlavor flavor, byte majorVersion, byte ...
method getRenderSessionConfigs (line 46) | public static native RenderSessionConfig[] getRenderSessionConfigs();
method init (line 48) | public static native void init(
method setActiveBackendVersion (line 55) | public static native void setActiveBackendVersion(BackendVersion backe...
method surfaceChanged (line 57) | public static native void surfaceChanged(Surface surface, int width, i...
method render (line 59) | public static native boolean render(float displayScale);
method touchEvent (line 61) | public static native void touchEvent(boolean isDown, float x, float y,...
method setClearColorValue (line 63) | public static native void setClearColorValue(float r, float g, float b...
method isSRGBTextureFormat (line 65) | public static native boolean isSRGBTextureFormat(int textureFormat);
method surfaceDestroyed (line 67) | public static native void surfaceDestroyed(Surface surface);
class RenderSessionConfig (line 69) | public static class RenderSessionConfig {
method RenderSessionConfig (line 74) | public RenderSessionConfig(
FILE: shell/android/java/com/facebook/igl/sample/SampleView.java
class SampleView (line 28) | public class SampleView extends GLSurfaceView {
method SampleView (line 35) | public SampleView(
method SampleView (line 45) | public SampleView(
method init (line 54) | private void init(
method isRenderSessionInitialized (line 80) | public boolean isRenderSessionInitialized() {
method awaitRenderSessionInitialization (line 84) | public void awaitRenderSessionInitialization() throws InterruptedExcep...
method setBackgroundColor (line 88) | @Override
method onTouchEvent (line 97) | @Override
class ContextFactory (line 125) | private static class ContextFactory implements GLSurfaceView.EGLContex...
method ContextFactory (line 129) | public ContextFactory(SampleLib.BackendVersion version) {
method createContext (line 133) | public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLCo...
method destroyContext (line 144) | public void destroyContext(EGL10 egl, EGLDisplay display, EGLContext...
method checkEglError (line 149) | private static void checkEglError(String prompt, EGL10 egl) {
class SurfaceFactory (line 156) | private static class SurfaceFactory implements GLSurfaceView.EGLWindow...
method SurfaceFactory (line 163) | SurfaceFactory(boolean isSRGB) {
method createWindowSurface (line 167) | @Override
method destroySurface (line 183) | @Override
class ConfigChooser (line 191) | private static class ConfigChooser implements GLSurfaceView.EGLConfigC...
method ConfigChooser (line 197) | public ConfigChooser(SampleLib.BackendVersion version, boolean enabl...
method chooseConfig (line 202) | public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {
class Renderer (line 235) | private static class Renderer implements GLSurfaceView.Renderer {
method Renderer (line 242) | Renderer(
method onSurfaceCreated (line 255) | public void onSurfaceCreated(GL10 gl, EGLConfig config) {
method onSurfaceChanged (line 263) | public void onSurfaceChanged(GL10 gl, int width, int height) {
method onDrawFrame (line 267) | public void onDrawFrame(GL10 gl) {
FILE: shell/android/java/com/facebook/igl/sample/VulkanView.java
class VulkanView (line 26) | public class VulkanView extends SurfaceView
method VulkanView (line 37) | public VulkanView(
method onTouchEvent (line 55) | @Override
method surfaceRedrawNeeded (line 82) | @Override
method surfaceCreated (line 85) | @Override
method surfaceChanged (line 102) | @Override
method surfaceDestroyed (line 110) | @Override
method doFrame (line 135) | @Override
class RenderThread (line 145) | private class RenderThread extends Thread {
method RenderThread (line 155) | public RenderThread(
method getHandler (line 166) | public RenderHandler getHandler() {
method run (line 170) | @Override
method waitUntilReady (line 189) | public void waitUntilReady() {
method surfaceCreated (line 201) | public void surfaceCreated() {
method surfaceChanged (line 208) | public void surfaceChanged(int width, int height) {
method doFrame (line 214) | private void doFrame(long timeStampNanos) {
method shutdown (line 244) | private void shutdown() {
class RenderHandler (line 256) | private static class RenderHandler extends Handler {
method RenderHandler (line 264) | public RenderHandler(RenderThread rt) {
method sendSurfaceCreated (line 268) | public void sendSurfaceCreated() {
method sendSurfaceChanged (line 272) | public void sendSurfaceChanged(@SuppressWarnings("unused") int forma...
method sendDoFrame (line 277) | public void sendDoFrame(long frameTimeNanos) {
method sendShutdown (line 283) | public void sendShutdown() {
method handleMessage (line 287) | @Override // runs on RenderThread
FILE: shell/android/jni/Jni.cpp
type igl::samples (line 19) | namespace igl::samples {
function toString (line 22) | [[maybe_unused]] std::string toString(std::optional<BackendVersion> ba...
function toString (line 57) | [[maybe_unused]] std::string toString(std::optional<size_t> rendererIn...
function toTypeSignature (line 74) | std::string toTypeSignature(const char* className) {
function BackendFlavor (line 78) | BackendFlavor toBackendFlavor(JNIEnv* env, jobject jbackendVersion) {
function jobject (line 85) | jobject toJava(JNIEnv* env, BackendFlavor backendFlavor) {
function toBackendVersion (line 98) | std::optional<BackendVersion> toBackendVersion(JNIEnv* env, jobject jb...
function jobject (line 115) | jobject toJava(JNIEnv* env, BackendVersion backendVersion) {
function jobject (line 131) | jobject toJava(JNIEnv* env, const shell::RenderSessionConfig& config) {
function jobjectArray (line 147) | jobjectArray toJava(JNIEnv* env, const std::vector<shell::RenderSessio...
function findRendererIndex (line 158) | std::optional<size_t> findRendererIndex(std::optional<BackendVersion> ...
function JNIEXPORT (line 217) | JNIEXPORT jobjectArray JNICALL
function extractIntentExtras (line 258) | [[maybe_unused]] static std::vector<std::string> extractIntentExtras(J...
function JNIEXPORT (line 397) | JNIEXPORT void JNICALL Java_com_facebook_igl_shell_SampleLib_init(JNIE...
function JNIEXPORT (line 434) | JNIEXPORT jboolean JNICALL
function JNIEXPORT (line 454) | JNIEXPORT void JNICALL
function JNIEXPORT (line 464) | JNIEXPORT void JNICALL Java_com_facebook_igl_shell_SampleLib_surfaceCh...
function JNIEXPORT (line 481) | JNIEXPORT jboolean JNICALL Java_com_facebook_igl_shell_SampleLib_rende...
function JNIEXPORT (line 493) | JNIEXPORT void JNICALL Java_com_facebook_igl_shell_SampleLib_surfaceDe...
function JNIEXPORT (line 497) | JNIEXPORT void JNICALL Java_com_facebook_igl_shell_SampleLib_touchEven...
function JNIEXPORT (line 512) | JNIEXPORT void JNICALL Java_com_facebook_igl_shell_SampleLib_setClearC...
function JNIEXPORT (line 526) | JNIEXPORT bool JNICALL
FILE: shell/android/jni/TinyRenderer.cpp
function getAndroidSystemProperty (line 37) | std::optional<std::string> getAndroidSystemProperty(const char* keyName)...
function getAndroidSystemPropertyBool (line 46) | std::optional<bool> getAndroidSystemPropertyBool(const char* keyName) no...
function getAndroidSystemPropertyInt (line 61) | std::optional<int> getAndroidSystemPropertyInt(const char* keyName) noex...
function getAndroidSystemPropertySizeT (line 73) | std::optional<size_t> getAndroidSystemPropertySizeT(const char* keyName)...
function readShellParamsFromAndroidProps (line 86) | void readShellParamsFromAndroidProps(igl::shell::ShellParams& shellParams,
type ContextGuard (line 275) | struct ContextGuard {
method ContextGuard (line 276) | ContextGuard(const igl::IDevice& device) {
method ContextGuard (line 295) | ContextGuard(const ContextGuard&) = delete;
method ContextGuard (line 296) | ContextGuard& operator=(const ContextGuard&) = delete;
method ContextGuard (line 297) | ContextGuard(ContextGuard&&) = delete;
method ContextGuard (line 298) | ContextGuard& operator=(ContextGuard&&) = delete;
type igl::samples (line 312) | namespace igl::samples {
FILE: shell/android/jni/TinyRenderer.h
function namespace (line 21) | namespace igl::samples {
FILE: shell/apps/SessionApp.cpp
type igl::shell (line 21) | namespace igl::shell {
class RenderSessionFactory (line 23) | class RenderSessionFactory final : public IRenderSessionFactory {
function createDefaultRenderSessionFactory (line 28) | std::unique_ptr<IRenderSessionFactory> createDefaultRenderSessionFacto...
FILE: shell/ios/BackendVersion.h
type kBackendFlavorInvalid (line 15) | typedef NS_ENUM(NSUInteger, BackendFlavor) {
FILE: shell/ios/IglShellPlatformAdapter.h
type IglShellPlatformAdapter (line 14) | struct IglShellPlatformAdapter
FILE: shell/ios/IglShellPlatformAdapterInternal.hpp
type IglShellPlatformAdapter (line 17) | struct IglShellPlatformAdapter {
FILE: shell/ios/IglSurfaceTexturesAdapter.h
type IglSurfaceTexturesAdapter (line 13) | struct IglSurfaceTexturesAdapter
FILE: shell/ios/IglSurfaceTexturesAdapterInternal.hpp
type IglSurfaceTexturesAdapter (line 17) | struct IglSurfaceTexturesAdapter {
FILE: shell/ios/RenderSessionController.h
type IglBackendFlavor (line 20) | typedef int IglBackendFlavor;
type IglOpenglRenderingAPI (line 21) | typedef int IglOpenglRenderingAPI;
FILE: shell/ios/RenderSessionFactoryAdapter.h
type RenderSessionFactoryAdapter (line 14) | struct RenderSessionFactoryAdapter
FILE: shell/ios/RenderSessionFactoryAdapterInternal.hpp
type RenderSessionFactoryAdapter (line 17) | struct RenderSessionFactoryAdapter {
FILE: shell/ios/RenderSessionFactoryProvider.h
type IglBackendFlavor (line 16) | typedef int IglBackendFlavor;
type IglOpenglRenderingAPI (line 17) | typedef int IglOpenglRenderingAPI;
FILE: shell/mac/GLView.h
function interface (line 10) | interface GLView : NSOpenGLView {
FILE: shell/mac/HeadlessView.h
function interface (line 10) | interface HeadlessView : NSView {
FILE: shell/mac/MetalView.h
function interface (line 10) | interface MetalView : MTKView {
FILE: shell/mac/VulkanView.h
function interface (line 12) | interface VulkanView : NSView {
FILE: shell/openxr/XrApp.h
type android_app (line 26) | struct android_app
type AAssetManager (line 27) | struct AAssetManager
function namespace (line 30) | namespace igl::shell::openxr {
function namespace (line 39) | namespace igl::shell::openxr {
FILE: shell/openxr/XrComposition.cpp
type igl::shell::openxr (line 14) | namespace igl::shell::openxr {
function copyFov (line 16) | inline void copyFov(Fov& dst, const XrFovf& src) {
function SurfaceTextures (line 71) | SurfaceTextures XrComposition::beginRendering(
FILE: shell/openxr/XrComposition.h
function namespace (line 21) | namespace igl::shell::openxr {
FILE: shell/openxr/XrCompositionProjection.cpp
type igl::shell::openxr (line 12) | namespace igl::shell::openxr {
FILE: shell/openxr/XrCompositionProjection.h
function namespace (line 12) | namespace igl::shell::openxr {
FILE: shell/openxr/XrCompositionQuad.cpp
type igl::shell::openxr (line 14) | namespace igl::shell::openxr {
function XrBlendFactorFB (line 17) | inline XrBlendFactorFB iglToOpenXR(BlendFactor factor) noexcept {
FILE: shell/openxr/XrCompositionQuad.h
function namespace (line 13) | namespace igl::shell::openxr {
FILE: shell/openxr/XrHands.cpp
type igl::shell::openxr (line 17) | namespace igl::shell::openxr {
function glmQuatFromXrQuat (line 20) | inline glm::quat glmQuatFromXrQuat(const XrQuaternionf& quat) noexcept {
function glmVecFromXrVec (line 24) | inline glm::vec4 glmVecFromXrVec(const XrVector4f& vec) noexcept {
function glmVecFromXrVec (line 28) | inline glm::vec4 glmVecFromXrVec(const XrVector4sFB& vec) noexcept {
function glmVecFromXrVec (line 32) | inline glm::vec3 glmVecFromXrVec(const XrVector3f& vec) noexcept {
function glmVecFromXrVec (line 36) | inline glm::vec2 glmVecFromXrVec(const XrVector2f& vec) noexcept {
function Pose (line 40) | inline Pose poseFromXrPose(const XrPosef& pose) noexcept {
function currentTimeInNs (line 47) | inline int64_t currentTimeInNs() {
FILE: shell/openxr/XrHands.h
function namespace (line 15) | namespace igl::shell::openxr {
FILE: shell/openxr/XrLog.cpp
type igl::shell::openxr (line 13) | namespace igl::shell::openxr {
function checkXRErrors (line 15) | void checkXRErrors(XrResult result, const char* function) {
FILE: shell/openxr/XrLog.h
function namespace (line 13) | namespace igl::shell::openxr {
FILE: shell/openxr/XrPassthrough.cpp
type igl::shell::openxr (line 15) | namespace igl::shell::openxr {
FILE: shell/openxr/XrPassthrough.h
function namespace (line 13) | namespace igl::shell::openxr {
FILE: shell/openxr/XrRefreshRate.cpp
type igl::shell::openxr (line 16) | namespace igl::shell::openxr {
FILE: shell/openxr/XrRefreshRate.h
function namespace (line 14) | namespace igl::shell::openxr {
FILE: shell/openxr/XrSwapchainProvider.cpp
type igl::shell::openxr (line 18) | namespace igl::shell::openxr {
function findFormat (line 21) | [[nodiscard]] int64_t findFormat(const std::vector<int64_t>& sortedSwa...
function XrSwapchain (line 93) | XrSwapchain XrSwapchainProvider::createXrSwapchain(XrSwapchainUsageFla...
function SurfaceTextures (line 116) | SurfaceTextures XrSwapchainProvider::getSurfaceTextures() const noexce...
FILE: shell/openxr/XrSwapchainProvider.h
function namespace (line 20) | namespace igl::shell::openxr {
FILE: shell/openxr/impl/XrAppImpl.h
function namespace (line 16) | namespace igl::shell::openxr::impl {
FILE: shell/openxr/impl/XrSwapchainProviderImpl.h
function namespace (line 17) | namespace igl::shell::openxr::impl {
function class (line 32) | class XrSwapchainProviderImpl {
FILE: shell/openxr/mobile/AndroidMain.cpp
function XrInstance (line 41) | XrInstance getXrInstance() {
function processActionView (line 51) | void processActionView(JNIEnv* env, jstring data) {
function JNIEXPORT (line 64) | JNIEXPORT void JNICALL
function JNIEXPORT (line 71) | JNIEXPORT void JNICALL
function handleInitWindow (line 81) | static void handleInitWindow(const struct android_app* app) {
function handleTermWindow (line 87) | static void handleTermWindow(const struct android_app* app) {
function handleResume (line 94) | static void handleResume(const struct android_app* app) {
function handlePause (line 101) | static void handlePause(const struct android_app* app) {
function handleDestroy (line 108) | static void handleDestroy(const struct android_app* app) {
function handleAppCmd (line 115) | static void handleAppCmd(struct android_app* app, int32_t appCmd) {
function android_main (line 143) | void android_main(struct android_app* app) {
function main (line 198) | int main(int argc, const char* argv[]) {
FILE: shell/openxr/mobile/XrApp.cpp
type android_app (line 49) | struct android_app {}
type AAssetManager (line 50) | struct AAssetManager {}
type igl::shell::openxr (line 53) | namespace igl::shell::openxr {
function XrInstance (line 94) | XrInstance XrApp::instance() const {
function XrSession (line 98) | XrSession XrApp::session() const {
type android_app (line 379) | struct android_app
function XrFrameState (line 697) | XrFrameState XrApp::beginFrame() {
FILE: shell/openxr/mobile/java/com/facebook/igl/shell/openxr/gles/MainActivity.java
class MainActivity (line 14) | public class MainActivity extends android.app.NativeActivity {
method onNewIntent (line 19) | @Override
method onActionView (line 27) | private native void onActionView(String data);
FILE: shell/openxr/mobile/java/com/facebook/igl/shell/openxr/vulkan/MainActivity.java
class MainActivity (line 14) | public class MainActivity extends android.app.NativeActivity {
method onNewIntent (line 19) | @Override
method onActionView (line 27) | private native void onActionView(String data);
FILE: shell/openxr/mobile/opengl/XrAppImplGLES.cpp
type igl::shell::openxr::mobile (line 25) | namespace igl::shell::openxr::mobile {
function RenderSessionConfig (line 26) | RenderSessionConfig XrAppImplGLES::suggestedSessionConfig() const {
function XrSession (line 75) | XrSession XrAppImplGLES::initXrSession(XrInstance instance,
FILE: shell/openxr/mobile/opengl/XrAppImplGLES.h
function namespace (line 14) | namespace igl::shell::openxr::mobile {
FILE: shell/openxr/mobile/opengl/XrSwapchainProviderImplGLES.cpp
type igl::shell::openxr::mobile (line 19) | namespace igl::shell::openxr::mobile {
function enumerateSwapchainImages (line 21) | void enumerateSwapchainImages(XrSwapchain swapchain, std::vector<uint3...
function getSurfaceTexture (line 51) | std::shared_ptr<ITexture> getSurfaceTexture(IDevice& device,
function SurfaceTextures (line 118) | SurfaceTextures XrSwapchainProviderImplGLES::getSurfaceTextures(
FILE: shell/openxr/mobile/opengl/XrSwapchainProviderImplGLES.h
function namespace (line 15) | namespace igl::shell::openxr::mobile {
FILE: shell/openxr/mobile/vulkan/XrAppImplVulkan.cpp
type igl::shell::openxr::mobile (line 19) | namespace igl::shell::openxr::mobile {
function RenderSessionConfig (line 20) | RenderSessionConfig XrAppImplVulkan::suggestedSessionConfig() const {
function XrSession (line 134) | XrSession XrAppImplVulkan::initXrSession(XrInstance instance,
FILE: shell/openxr/mobile/vulkan/XrAppImplVulkan.h
function namespace (line 15) | namespace igl::shell::openxr::mobile {
FILE: shell/openxr/mobile/vulkan/XrSwapchainProviderImplVulkan.cpp
type igl::shell::openxr::mobile (line 20) | namespace igl::shell::openxr::mobile {
function enumerateSwapchainImages (line 22) | void enumerateSwapchainImages(
function getSurfaceTexture (line 74) | std::shared_ptr<ITexture> getSurfaceTexture(
function SurfaceTextures (line 164) | SurfaceTextures XrSwapchainProviderImplVulkan::getSurfaceTextures(
FILE: shell/openxr/mobile/vulkan/XrSwapchainProviderImplVulkan.h
function namespace (line 14) | namespace igl::shell::openxr::mobile {
FILE: shell/renderSessionTests/BasicFramebufferTests.cpp
class BasicFrameBufferTests (line 11) | class BasicFrameBufferTests : public igl::shell::TestShell {}
function TEST_F (line 13) | TEST_F(BasicFrameBufferTests, BasicFramebufferSession) {
FILE: shell/renderSessionTests/IGLSampleTests.cpp
class IGLSampleTests (line 26) | class IGLSampleTests : public igl::shell::TestShell {}
function TEST_F (line 28) | TEST_F(IGLSampleTests, ColorSession) {
function TEST_F (line 33) | TEST_F(IGLSampleTests, EmptySession) {
function TEST_F (line 38) | TEST_F(IGLSampleTests, GraphSampleSession) {
function TEST_F (line 43) | TEST_F(IGLSampleTests, MSAASession) {
function TEST_F (line 48) | TEST_F(IGLSampleTests, TextureAccessorSession) {
function TEST_F (line 53) | TEST_F(IGLSampleTests, TextureRotationSession) {
function TEST_F (line 58) | TEST_F(IGLSampleTests, Textured3DCubeSession) {
function TEST_F (line 63) | TEST_F(IGLSampleTests, TQSession) {
function TEST_F (line 68) | TEST_F(IGLSampleTests, ComputeSession) {
function TEST_F (line 73) | TEST_F(IGLSampleTests, MRTSession) {
function TEST_F (line 78) | TEST_F(IGLSampleTests, TQMultiRenderPassSession) {
function TEST_F (line 83) | TEST_F(IGLSampleTests, UniformTestSession) {
function TEST_F (line 88) | TEST_F(IGLSampleTests, UniformPackedTestSession) {
function TEST_F (line 93) | TEST_F(IGLSampleTests, UniformArrayTestSession) {
function TEST_F (line 98) | TEST_F(IGLSampleTests, ResourceTrackerSession) {
function TEST_F (line 108) | TEST_F(IGLSampleTests, ShaderCompilationTestSession) {
FILE: shell/renderSessions/BasicFramebufferSession.cpp
type igl::shell (line 16) | namespace igl::shell {
FILE: shell/renderSessions/BasicFramebufferSession.h
function namespace (line 16) | namespace igl::shell {
FILE: shell/renderSessions/BindGroupSession.cpp
type VertexPosUvw (line 25) | struct VertexPosUvw {
function getProlog (line 71) | std::string getProlog(igl::IDevice& device) {
function getMetalShaderSource (line 85) | std::string getMetalShaderSource() {
function getOpenGLFragmentShaderSource (line 130) | std::string getOpenGLFragmentShaderSource(igl::IDevice& device) {
function getOpenGLVertexShaderSource (line 143) | std::string getOpenGLVertexShaderSource(igl::IDevice& device) {
function getShaderStagesForBackend (line 196) | std::unique_ptr<igl::IShaderStages> getShaderStagesForBackend(igl::IDevi...
type igl::shell (line 286) | namespace igl::shell {
FILE: shell/renderSessions/BindGroupSession.h
function namespace (line 19) | namespace igl::shell {
FILE: shell/renderSessions/BindlessBufferSession.cpp
type igl::shell (line 16) | namespace igl::shell {
type VertexPosColor (line 20) | struct VertexPosColor {
type PushConstantData (line 39) | struct PushConstantData {
function getVersion (line 45) | std::string getVersion() {
function getMetalShaderSource (line 49) | std::string getMetalShaderSource() {
function getOpenGLVertexShaderSource (line 78) | std::string getOpenGLVertexShaderSource() {
function getOpenGLFragmentShaderSource (line 92) | std::string getOpenGLFragmentShaderSource() {
function getVulkanBindlessVertexShaderSource (line 105) | std::string getVulkanBindlessVertexShaderSource() {
function getVulkanStandardVertexShaderSource (line 141) | std::string getVulkanStandardVertexShaderSource() {
function getVulkanFragmentShaderSource (line 154) | std::string getVulkanFragmentShaderSource() {
function getShaderStagesForBackend (line 165) | std::unique_ptr<IShaderStages> getShaderStagesForBackend(IDevice& devi...
FILE: shell/renderSessions/BindlessBufferSession.h
function namespace (line 17) | namespace igl::shell {
FILE: shell/renderSessions/BufferMappingSession.cpp
type igl::shell (line 17) | namespace igl::shell {
type VertexPosColor (line 20) | struct VertexPosColor {
function getVersion (line 31) | std::string getVersion() {
function getMetalShaderSource (line 35) | std::string getMetalShaderSource() {
function getOpenGLVertexShaderSource (line 64) | std::string getOpenGLVertexShaderSource() {
function getOpenGLFragmentShaderSource (line 78) | std::string getOpenGLFragmentShaderSource() {
function getVulkanVertexShaderSource (line 89) | std::string getVulkanVertexShaderSource() {
function getVulkanFragmentShaderSource (line 102) | std::string getVulkanFragmentShaderSource() {
function getShaderStagesForBackend (line 113) | std::unique_ptr<IShaderStages> getShaderStagesForBackend(IDevice& devi...
FILE: shell/renderSessions/BufferMappingSession.h
function namespace (line 17) | namespace igl::shell {
FILE: shell/renderSessions/CheckerboardMipmapSession.cpp
type igl::shell (line 26) | namespace igl::shell {
type VertexPosUv (line 30) | struct VertexPosUv {
function getMVP (line 54) | glm::mat4 getMVP(float aspectRatio) noexcept {
function BufferDesc (line 66) | BufferDesc getVertexBufferDesc(const igl::IDevice& device) {
function getVertexBufferIndex (line 84) | uint32_t getVertexBufferIndex(const igl::IDevice& device) {
function ResourceStorage (line 93) | ResourceStorage getIndexBufferResourceStorage(const igl::IDevice& devi...
function getVersion (line 102) | std::string getVersion() {
function getMetalShaderSource (line 106) | std::string getMetalShaderSource() {
function getOpenGLVertexShaderSource (line 144) | std::string getOpenGLVertexShaderSource() {
function getOpenGLFragmentShaderSource (line 161) | std::string getOpenGLFragmentShaderSource() {
function getVulkanVertexShaderSource (line 172) | std::string getVulkanVertexShaderSource() {
function getVulkanFragmentShaderSource (line 191) | std::string getVulkanFragmentShaderSource() {
function getShaderStagesForBackend (line 204) | std::unique_ptr<IShaderStages> getShaderStagesForBackend(IDevice& devi...
FILE: shell/renderSessions/CheckerboardMipmapSession.h
function namespace (line 17) | namespace igl::shell {
FILE: shell/renderSessions/ColorSession.cpp
type igl::shell (line 24) | namespace igl::shell {
type VertexPosUv (line 28) | struct VertexPosUv {
function BufferDesc (line 51) | BufferDesc getVertexBufferDesc(const igl::IDevice& device) {
function getVertexBufferIndex (line 70) | uint32_t getVertexBufferIndex(const igl::IDevice& device) {
function ResourceStorage (line 79) | ResourceStorage getIndexBufferResourceStorage(const igl::IDevice& devi...
function getVersion (line 88) | std::string getVersion() {
function getMetalShaderSource (line 92) | std::string getMetalShaderSource() {
function getMetalShaderSourceGradient (line 132) | std::string getMetalShaderSourceGradient() {
function getOpenGLVertexShaderSource (line 181) | std::string getOpenGLVertexShaderSource() {
function getOpenGLFragmentShaderSource (line 201) | std::string getOpenGLFragmentShaderSource() {
function getOpenGLFragmentShaderSourceGradient (line 216) | std::string getOpenGLFragmentShaderSourceGradient() {
function getVulkanVertexShaderSource (line 242) | std::string getVulkanVertexShaderSource() {
function getVulkanFragmentShaderSource (line 262) | std::string getVulkanFragmentShaderSource() {
function getVulkanFragmentShaderSourceGradient (line 276) | std::string getVulkanFragmentShaderSourceGradient() {
FILE: shell/renderSessions/ColorSession.h
function namespace (line 17) | namespace igl::shell {
FILE: shell/renderSessions/CopyOperationsSession.cpp
type igl::shell (line 18) | namespace igl::shell {
type VertexPosColor (line 21) | struct VertexPosColor {
function getVersion (line 36) | std::string getVersion() {
function getMetalShaderSource (line 40) | std::string getMetalShaderSource() {
function getOpenGLVertexShaderSource (line 69) | std::string getOpenGLVertexShaderSource() {
function getOpenGLFragmentShaderSource (line 83) | std::string getOpenGLFragmentShaderSource() {
function getVulkanVertexShaderSource (line 94) | std::string getVulkanVertexShaderSource() {
function getVulkanFragmentShaderSource (line 107) | std::string getVulkanFragmentShaderSource() {
function getShaderStagesForBackend (line 118) | std::unique_ptr<IShaderStages> getShaderStagesForBackend(IDevice& devi...
FILE: shell/renderSessions/CopyOperationsSession.h
function namespace (line 17) | namespace igl::shell {
FILE: shell/renderSessions/DepthBiasSession.cpp
type igl::shell (line 16) | namespace igl::shell {
type VertexPosNormal (line 23) | struct VertexPosNormal {
function getShadowMetalShaderSource (line 63) | std::string getShadowMetalShaderSource() {
function getShadowOpenGLVertexShaderSource (line 93) | std::string getShadowOpenGLVertexShaderSource() {
function getShadowOpenGLFragmentShaderSource (line 106) | std::string getShadowOpenGLFragmentShaderSource() {
function getShadowVulkanVertexShaderSource (line 115) | std::string getShadowVulkanVertexShaderSource() {
function getShadowVulkanFragmentShaderSource (line 128) | std::string getShadowVulkanFragmentShaderSource() {
function getShadowShaderStagesForBackend (line 138) | std::unique_ptr<IShaderStages> getShadowShaderStagesForBackend(IDevice...
function getMainMetalShaderSource (line 205) | std::string getMainMetalShaderSource() {
function getMainOpenGLVertexShaderSource (line 256) | std::string getMainOpenGLVertexShaderSource() {
function getMainOpenGLFragmentShaderSource (line 277) | std::string getMainOpenGLFragmentShaderSource() {
function getMainVulkanVertexShaderSource (line 304) | std::string getMainVulkanVertexShaderSource() {
function getMainVulkanFragmentShaderSource (line 324) | std::string getMainVulkanFragmentShaderSource() {
function getMainShaderStagesForBackend (line 350) | std::unique_ptr<IShaderStages> getMainShaderStagesForBackend(IDevice& ...
FILE: shell/renderSessions/DepthBiasSession.h
function namespace (line 17) | namespace igl::shell {
FILE: shell/renderSessions/DrawInstancedSession.cpp
type igl::shell (line 17) | namespace igl::shell {
function stringReplaceAll (line 21) | [[maybe_unused]] void stringReplaceAll(std::string& s,
function getShaderStagesForBackend (line 118) | std::unique_ptr<IShaderStages> getShaderStagesForBackend(IDevice& devi...
FILE: shell/renderSessions/DrawInstancedSession.h
function namespace (line 16) | namespace igl::shell {
FILE: shell/renderSessions/EmptySession.cpp
type igl::shell (line 12) | namespace igl::shell {
FILE: shell/renderSessions/EmptySession.h
function namespace (line 15) | namespace igl::shell {
FILE: shell/renderSessions/FireworksSession.cpp
type igl::shell (line 33) | namespace igl::shell {
type Uniforms (line 38) | struct Uniforms {
function perspectiveAsymmetricFovRH (line 42) | [[maybe_unused]] glm::mat4 perspectiveAsymmetricFovRH(const igl::shell...
function stringReplaceAll (line 73) | [[maybe_unused]] void stringReplaceAll(std::string& s,
function getVulkanVertexShaderSource (line 149) | [[nodiscard]] std::string getVulkanVertexShaderSource(bool stereoRende...
type InterleavedVertex (line 313) | struct InterleavedVertex {
FILE: shell/renderSessions/FireworksSession.h
type class (line 41) | enum class
type Particle (line 47) | struct Particle {
function ttl (line 52) | int32_t ttl{0}
function initialLifetime (line 53) | int32_t initialLifetime{1}
function fadingOut (line 57) | bool fadingOut{false};
type GpuVertex (line 76) | struct GpuVertex {
function sceneAnchored_ (line 102) | bool sceneAnchored_{false};
FILE: shell/renderSessions/GPUStressSession.cpp
function customArc4random (line 32) | uint32_t customArc4random() {
type igl::shell (line 43) | namespace igl::shell {
function getLightingFunc (line 89) | std::string getLightingFunc(const char* matrixProj, const char* matrix...
function getVulkanVertexShaderSource (line 149) | std::string getVulkanVertexShaderSource(bool multiView) {
function isDeviceCompatible (line 268) | bool isDeviceCompatible(IDevice& device) noexcept {
function setCurrentThreadAffinityMask (line 283) | int setCurrentThreadAffinityMask(int mask) {
function calcPi (line 301) | double calcPi(int numberOfDivisions, int core) {
type AnimationInfo (line 465) | struct AnimationInfo {
FILE: shell/renderSessions/GPUStressSession.h
function namespace (line 22) | namespace igl::shell {
FILE: shell/renderSessions/GPUTimerSession.cpp
type igl::shell (line 16) | namespace igl::shell {
type VertexPosColor (line 19) | struct VertexPosColor {
function getVersion (line 34) | std::string getVersion() {
function getMetalShaderSource (line 38) | std::string getMetalShaderSource() {
function getOpenGLVertexShaderSource (line 67) | std::string getOpenGLVertexShaderSource() {
function getOpenGLFragmentShaderSource (line 81) | std::string getOpenGLFragmentShaderSource() {
function getVulkanVertexShaderSource (line 92) | std::string getVulkanVertexShaderSource() {
function getVulkanFragmentShaderSource (line 105) | std::string getVulkanFragmentShaderSource() {
function getShaderStagesForBackend (line 116) | std::unique_ptr<IShaderStages> getShaderStagesForBackend(IDevice& devi...
FILE: shell/renderSessions/GPUTimerSession.h
function namespace (line 18) | namespace igl::shell {
FILE: shell/renderSessions/HandsOpenXRSession.cpp
type igl::shell (line 27) | namespace igl::shell {
type Vertex (line 31) | struct Vertex {
function getVertexShaderProlog (line 49) | [[nodiscard]] std::string getVertexShaderProlog(bool stereoRendering) {
function getVulkanVertexShaderSource (line 64) | [[nodiscard]] std::string getVulkanVertexShaderSource(bool stereoRende...
function getShaderStagesForBackend (line 91) | [[nodiscard]] std::unique_ptr<IShaderStages> getShaderStagesForBackend(
function isDeviceCompatible (line 138) | [[nodiscard]] bool isDeviceCompatible(IDevice& device) noexcept {
function perspectiveAsymmetricFovRH (line 142) | [[nodiscard]] glm::mat4 perspectiveAsymmetricFovRH(const igl::shell::F...
function poseToMat4 (line 178) | [[nodiscard]] inline glm::mat4 poseToMat4(const Pose& pose) noexcept {
FILE: shell/renderSessions/HandsOpenXRSession.h
function namespace (line 19) | namespace igl::shell {
function class (line 29) | class HandsOpenXRSession : public RenderSession {
FILE: shell/renderSessions/HelloOpenXRSession.cpp
type igl::shell (line 24) | namespace igl::shell {
type VertexPosUvw (line 28) | struct VertexPosUvw {
function getVertexShaderProlog (line 62) | [[nodiscard]] std::string getVertexShaderProlog(bool stereoRendering) {
function getVulkanVertexShaderSource (line 77) | [[nodiscard]] std::string getVulkanVertexShaderSource(bool stereoRende...
function getShaderStagesForBackend (line 99) | [[nodiscard]] std::unique_ptr<IShaderStages> getShaderStagesForBackend(
function isDeviceCompatible (line 146) | [[nodiscard]] bool isDeviceCompatible(IDevice& device) noexcept {
function perspectiveAsymmetricFovRH (line 150) | [[nodiscard]] glm::mat4 perspectiveAsymmetricFovRH(const igl::shell::F...
FILE: shell/renderSessions/HelloOpenXRSession.h
function namespace (line 18) | namespace igl::shell {
function class (line 27) | class HelloOpenXRSession : public RenderSession {
FILE: shell/renderSessions/HelloWorldSession.cpp
type igl::shell (line 16) | namespace igl::shell {
type VertexPosColor (line 19) | struct VertexPosColor {
function getVersion (line 34) | std::string getVersion() {
function getMetalShaderSource (line 38) | std::string getMetalShaderSource() {
function getOpenGLVertexShaderSource (line 67) | std::string getOpenGLVertexShaderSource() {
function getOpenGLFragmentShaderSource (line 81) | std::string getOpenGLFragmentShaderSource() {
function getVulkanVertexShaderSource (line 92) | std::string getVulkanVertexShaderSource() {
function getVulkanFragmentShaderSource (line 105) | std::string getVulkanFragmentShaderSource() {
function getShaderStagesForBackend (line 116) | std::unique_ptr<IShaderStages> getShaderStagesForBackend(IDevice& devi...
FILE: shell/renderSessions/HelloWorldSession.h
function namespace (line 17) | namespace igl::shell {
FILE: shell/renderSessions/ImguiSession.cpp
type igl::shell (line 17) | namespace igl::shell {
FILE: shell/renderSessions/ImguiSession.h
function namespace (line 18) | namespace igl::shell {
FILE: shell/renderSessions/MRTSession.cpp
type igl::shell (line 24) | namespace igl::shell {
type VertexPosUv (line 25) | struct VertexPosUv {
type ShaderPrecision (line 50) | enum class ShaderPrecision { Low, Medium, High }
function getPrecisionProlog (line 52) | static std::string getPrecisionProlog(ShaderPrecision precision) {
function getVersionProlog (line 67) | static std::string getVersionProlog() {
function getMetalShaderSource (line 79) | static std::string getMetalShaderSource(int metalShaderIdx) {
function getOpenGLVertexShaderSource (line 166) | static std::string getOpenGLVertexShaderSource() {
function getOpenGLFragmentShaderSource (line 178) | static std::string getOpenGLFragmentShaderSource(int programIndex) {
function getVulkanVertexShaderSource (line 202) | static std::string getVulkanVertexShaderSource() {
function getVulkanFragmentShaderSource (line 214) | static std::string getVulkanFragmentShaderSource(int programIndex) {
function createShaderStagesForBackend (line 243) | static std::unique_ptr<IShaderStages> createShaderStagesForBackend(con...
function isDeviceCompatible (line 322) | static bool isDeviceCompatible(IDevice& device) noexcept {
FILE: shell/renderSessions/MRTSession.h
function namespace (line 16) | namespace igl::shell {
FILE: shell/renderSessions/MeshShaderTriangleSession.cpp
type igl::shell (line 16) | namespace igl::shell {
function getMetalTaskShaderSource (line 20) | std::string getMetalTaskShaderSource() {
function getMetalMeshShaderSource (line 31) | std::string getMetalMeshShaderSource() {
function getMetalFragmentShaderSource (line 67) | std::string getMetalFragmentShaderSource() {
function getVulkanTaskShaderSource (line 81) | std::string getVulkanTaskShaderSource() {
function getVulkanMeshShaderSource (line 94) | std::string getVulkanMeshShaderSource() {
function getVulkanFragmentShaderSource (line 125) | std::string getVulkanFragmentShaderSource() {
function getShaderStagesForBackend (line 138) | std::unique_ptr<IShaderStages> getShaderStagesForBackend(IDevice& devi...
FILE: shell/renderSessions/MeshShaderTriangleSession.h
function namespace (line 17) | namespace igl::shell {
FILE: shell/renderSessions/MultiDrawIndexedIndirectSession.cpp
type igl::shell (line 16) | namespace igl::shell {
type DrawElementsIndirectCommand (line 20) | struct DrawElementsIndirectCommand {
type VertexPosColor (line 28) | struct VertexPosColor {
function getVersion (line 77) | std::string getVersion() {
function getMetalShaderSource (line 81) | std::string getMetalShaderSource() {
function getOpenGLVertexShaderSource (line 110) | std::string getOpenGLVertexShaderSource() {
function getOpenGLFragmentShaderSource (line 124) | std::string getOpenGLFragmentShaderSource() {
function getVulkanVertexShaderSource (line 135) | std::string getVulkanVertexShaderSource() {
function getVulkanFragmentShaderSource (line 148) | std::string getVulkanFragmentShaderSource() {
function getShaderStagesForBackend (line 159) | std::unique_ptr<IShaderStages> getShaderStagesForBackend(IDevice& devi...
FILE: shell/renderSessions/MultiDrawIndexedIndirectSession.h
function namespace (line 17) | namespace igl::shell {
FILE: shell/renderSessions/ScissorTestSession.cpp
type igl::shell (line 16) | namespace igl::shell {
type VertexPosColor (line 19) | struct VertexPosColor {
function getVersion (line 70) | std::string getVersion() {
function getMetalShaderSource (line 74) | std::string getMetalShaderSource() {
function getOpenGLVertexShaderSource (line 103) | std::string getOpenGLVertexShaderSource() {
function getOpenGLFragmentShaderSource (line 117) | std::string getOpenGLFragmentShaderSource() {
function getVulkanVertexShaderSource (line 128) | std::string getVulkanVertexShaderSource() {
function getVulkanFragmentShaderSource (line 141) | std::string getVulkanFragmentShaderSource() {
function getShaderStagesForBackend (line 152) | std::unique_ptr<IShaderStages> getShaderStagesForBackend(IDevice& devi...
FILE: shell/renderSessions/ScissorTestSession.h
function namespace (line 17) | namespace igl::shell {
FILE: shell/renderSessions/StencilOutlineSession.cpp
type igl::shell (line 16) | namespace igl::shell {
type VertexPosColor (line 19) | struct VertexPosColor {
function getVersion (line 63) | std::string getVersion() {
function getMetalShaderSource (line 67) | std::string getMetalShaderSource() {
function getOpenGLVertexShaderSource (line 96) | std::string getOpenGLVertexShaderSource() {
function getOpenGLFragmentShaderSource (line 110) | std::string getOpenGLFragmentShaderSource() {
function getVulkanVertexShaderSource (line 121) | std::string getVulkanVertexShaderSource() {
function getVulkanFragmentShaderSource (line 134) | std::string getVulkanFragmentShaderSource() {
function getShaderStagesForBackend (line 145) | std::unique_ptr<IShaderStages> getShaderStagesForBackend(IDevice& devi...
function getOutlineMetalShaderSource (line 197) | std::string getOutlineMetalShaderSource() {
function getOutlineOpenGLVertexShaderSource (line 224) | std::string getOutlineOpenGLVertexShaderSource() {
function getOutlineOpenGLFragmentShaderSource (line 235) | std::string getOutlineOpenGLFragmentShaderSource() {
function getOutlineVulkanVertexShaderSource (line 244) | std::string getOutlineVulkanVertexShaderSource() {
function getOutlineVulkanFragmentShaderSource (line 255) | std::string getOutlineVulkanFragmentShaderSource() {
function getOutlineShaderStagesForBackend (line 265) | std::unique_ptr<IShaderStages> getOutlineShaderStagesForBackend(IDevic...
FILE: shell/renderSessions/StencilOutlineSession.h
function namespace (line 17) | namespace igl::shell {
FILE: shell/renderSessions/TQMultiRenderPassSession.cpp
type igl::shell (line 17) | namespace igl::shell {
type VertexPosUv (line 18) | struct VertexPosUv {
function getMetalShaderSource (line 38) | static std::string getMetalShaderSource() {
function getOpenGLVertexShaderSource (line 74) | static std::string getOpenGLVertexShaderSource() {
function getOpenGLFragmentShaderSource (line 87) | static std::string getOpenGLFragmentShaderSource() {
function getD3D12VertexShaderSource (line 102) | static std::string getD3D12VertexShaderSource() {
function getD3D12FragmentShaderSource (line 123) | static std::string getD3D12FragmentShaderSource() {
function getShaderStagesForBackend (line 144) | static std::unique_ptr<IShaderStages> getShaderStagesForBackend(IDevic...
function render (line 183) | static void render(std::shared_ptr<ICommandBuffer>& buffer,
FILE: shell/renderSessions/TQMultiRenderPassSession.h
function namespace (line 16) | namespace igl::shell {
FILE: shell/renderSessions/TQSession.cpp
type igl::shell (line 21) | namespace igl::shell {
type VertexPosUv (line 23) | struct VertexPosUv {
function getVersion (line 28) | std::string getVersion() {
function getMetalShaderSource (line 32) | std::string getMetalShaderSource() {
function getD3D12VertexShaderSource (line 68) | std::string getD3D12VertexShaderSource() {
function getD3D12FragmentShaderSource (line 99) | std::string getD3D12FragmentShaderSource() {
function getOpenGLVertexShaderSource (line 116) | std::string getOpenGLVertexShaderSource() {
function getOpenGLFragmentShaderSource (line 130) | std::string getOpenGLFragmentShaderSource() {
function getVulkanVertexShaderSource (line 144) | std::string getVulkanVertexShaderSource() {
function getVulkanFragmentShaderSource (line 167) | std::string getVulkanFragmentShaderSource() {
function getShaderStagesForBackend (line 181) | std::unique_ptr<IShaderStages> getShaderStagesForBackend(IDevice& devi...
function BufferDesc (line 242) | BufferDesc getVertexBufferDesc(const igl::IDevice& device, const Verte...
function getVertexBufferIndex (line 260) | uint32_t getVertexBufferIndex(const igl::IDevice& device) {
function ResourceStorage (line 269) | ResourceStorage getIndexBufferResourceStorage(const igl::IDevice& devi...
FILE: shell/renderSessions/TQSession.h
function namespace (line 17) | namespace igl::shell {
FILE: shell/renderSessions/TextureViewSession.cpp
type VertexPosUvw (line 25) | struct VertexPosUvw {
function getMetalShaderSource (line 70) | std::string getMetalShaderSource() {
function getShaderStagesForBackend (line 136) | std::unique_ptr<igl::IShaderStages> getShaderStagesForBackend(igl::IDevi...
type igl::shell (line 189) | namespace igl::shell {
FILE: shell/renderSessions/TextureViewSession.h
function namespace (line 18) | namespace igl::shell {
FILE: shell/renderSessions/Textured3DCubeSession.cpp
type igl::shell (line 19) | namespace igl::shell {
type VertexPosUvw (line 23) | struct VertexPosUvw {
function getProlog (line 42) | std::string getProlog(IDevice& device) {
function getMetalShaderSource (line 54) | std::string getMetalShaderSource() {
function getOpenGLFragmentShaderSource (line 99) | std::string getOpenGLFragmentShaderSource(IDevice& device) {
function getOpenGLVertexShaderSource (line 110) | std::string getOpenGLVertexShaderSource(IDevice& device) {
function getShaderStagesForBackend (line 157) | std::unique_ptr<IShaderStages> getShaderStagesForBackend(IDevice& devi...
function isDeviceCompatible (line 213) | bool isDeviceCompatible(IDevice& device) noexcept {
FILE: shell/renderSessions/Textured3DCubeSession.h
function namespace (line 18) | namespace igl::shell {
FILE: shell/renderSessions/TinyMeshBindGroupSession.cpp
type igl::shell (line 57) | namespace igl::shell {
function stringReplaceAll (line 69) | [[maybe_unused]] std::string stringReplaceAll(const char* input,
type VertexPosUvw (line 88) | struct VertexPosUvw {
type UniformsPerFrame (line 94) | struct UniformsPerFrame {
type UniformsPerObject (line 98) | struct UniformsPerObject {
function getMetalShaderSource (line 147) | [[nodiscard]] std::string getMetalShaderSource() {
function getShaderStagesForBackend (line 246) | [[nodiscard]] std::unique_ptr<IShaderStages> getShaderStagesForBackend...
FILE: shell/renderSessions/TinyMeshBindGroupSession.h
function namespace (line 18) | namespace igl::shell {
FILE: shell/renderSessions/TinyMeshSession.cpp
type igl::shell (line 37) | namespace igl::shell {
function stringReplaceAll (line 41) | [[maybe_unused, nodiscard]] std::string stringReplaceAll(const char* i...
type VertexPosUvw (line 60) | struct VertexPosUvw {
type UniformsPerFrame (line 66) | struct UniformsPerFrame {
type UniformsPerObject (line 70) | struct UniformsPerObject {
function getShaderStagesForBackend (line 219) | [[nodiscard]] std::unique_ptr<IShaderStages> getShaderStagesForBackend...
FILE: shell/renderSessions/TinyMeshSession.h
function namespace (line 18) | namespace igl::shell {
FILE: shell/renderSessions/WireframeSession.cpp
type igl::shell (line 16) | namespace igl::shell {
type VertexPosColor (line 19) | struct VertexPosColor {
function getVersion (line 64) | std::string getVersion() {
function getMetalShaderSource (line 72) | std::string getMetalShaderSource() {
function getOpenGLVertexShaderSource (line 101) | std::string getOpenGLVertexShaderSource() {
function getOpenGLFragmentShaderSource (line 115) | std::string getOpenGLFragmentShaderSource() {
function getVulkanVertexShaderSource (line 126) | std::string getVulkanVertexShaderSource() {
function getVulkanFragmentShaderSource (line 139) | std::string getVulkanFragmentShaderSource() {
function getWireframeMetalShaderSource (line 154) | std::string getWireframeMetalShaderSource() {
function getWireframeOpenGLVertexShaderSource (line 181) | std::string getWireframeOpenGLVertexShaderSource() {
function getWireframeOpenGLFragmentShaderSource (line 192) | std::string getWireframeOpenGLFragmentShaderSource() {
function getWireframeVulkanVertexShaderSource (line 201) | std::string getWireframeVulkanVertexShaderSource() {
function getWireframeVulkanFragmentShaderSource (line 212) | std::string getWireframeVulkanFragmentShaderSource() {
function getShaderStagesForBackend (line 226) | std::unique_ptr<IShaderStages> getShaderStagesForBackend(IDevice& devi...
function getWireframeShaderStagesForBackend (line 274) | std::unique_ptr<IShaderStages> getWireframeShaderStagesForBackend(IDev...
FILE: shell/renderSessions/WireframeSession.h
function namespace (line 17) | namespace igl::shell {
FILE: shell/renderSessions/YUVColorSession.cpp
type igl::shell (line 20) | namespace igl::shell {
type VertexPosUv (line 22) | struct VertexPosUv {
function getOpenGLVertexShaderSource (line 37) | std::string getOpenGLVertexShaderSource() {
function getOpenGLFragmentShaderSource (line 52) | std::string getOpenGLFragmentShaderSource() {
function getVulkanVertexShaderSource (line 67) | std::string getVulkanVertexShaderSource() {
function getVulkanFragmentShaderSource (line 80) | std::string getVulkanFragmentShaderSource() {
function getShaderStagesForBackend (line 93) | std::unique_ptr<IShaderStages> getShaderStagesForBackend(IDevice& devi...
FILE: shell/renderSessions/YUVColorSession.h
function namespace (line 18) | namespace igl::shell {
FILE: shell/shared/extension/Extension.h
type IGLShellExtension (line 13) | struct IGLShellExtension {}
function namespace (line 27) | namespace igl::shell {
FILE: shell/shared/extension/ExtensionLoader.cpp
type igl::shell (line 14) | namespace igl::shell {
function Extension (line 22) | Extension* ExtensionLoader::create(const std::string& name) noexcept {
function Extension (line 31) | Extension* ExtensionLoader::createAndInitialize(const std::string& name,
FILE: shell/shared/extension/ExtensionLoader.h
function namespace (line 12) | namespace igl::shell {
FILE: shell/shared/extension/SymbolFactoryLoader.cpp
type igl::shell (line 37) | namespace igl::shell {
function IGLShellSymbol_NewCFunction (line 39) | IGLShellSymbol_NewCFunction SymbolFactoryLoader::find(const char* name...
function IGLShellSymbol_NewCFunction (line 56) | IGLShellSymbol_NewCFunction SymbolFactoryLoader::find(const std::strin...
FILE: shell/shared/extension/SymbolFactoryLoader.h
function namespace (line 17) | namespace igl::shell {
FILE: shell/shared/fileLoader/FileLoader.cpp
type igl::shell (line 25) | namespace igl::shell {
function createFileLoader (line 55) | std::unique_ptr<FileLoader> createFileLoader() {
FILE: shell/shared/fileLoader/FileLoader.h
function namespace (line 14) | namespace igl::shell {
FILE: shell/shared/fileLoader/android/FileLoaderAndroid.cpp
type igl::shell (line 19) | namespace igl::shell {
FILE: shell/shared/fileLoader/android/FileLoaderAndroid.h
type AAssetManager (line 16) | struct AAssetManager
function namespace (line 18) | namespace igl::shell {
FILE: shell/shared/fileLoader/apple/FileLoaderApple.h
function namespace (line 12) | namespace igl::shell {
FILE: shell/shared/fileLoader/linux/FileLoaderLinux.cpp
function findSubdir (line 21) | std::string findSubdir(const char* subdir, const std::string& fileName) {
type igl::shell (line 46) | namespace igl::shell {
FILE: shell/shared/fileLoader/linux/FileLoaderLinux.h
function namespace (line 12) | namespace igl::shell {
FILE: shell/shared/fileLoader/win/FileLoaderWin.cpp
function findSubdir (line 25) | std::string findSubdir(const char* subdir, const std::string& fileName) {
type igl::shell (line 50) | namespace igl::shell {
FILE: shell/shared/fileLoader/win/FileLoaderWin.h
function namespace (line 12) | namespace igl::shell {
FILE: shell/shared/imageLoader/ImageLoader.cpp
type igl::shell (line 19) | namespace igl::shell {
function createLoaderFactories (line 21) | std::vector<std::unique_ptr<iglu::textureloader::ITextureLoaderFactory...
class CheckerboardData (line 54) | class CheckerboardData : public iglu::textureloader::IData {
class WhiteData (line 68) | class WhiteData : public iglu::textureloader::IData {
function ImageData (line 87) | ImageData ImageLoader::defaultLoadImageData(const std::string& imageName,
function ImageData (line 94) | ImageData ImageLoader::loadImageDataFromFile(
function ImageData (line 105) | ImageData ImageLoader::loadImageDataFromMemory(
function ImageData (line 133) | ImageData ImageLoader::checkerboard() noexcept {
function ImageData (line 146) | ImageData ImageLoader::white() noexcept {
FILE: shell/shared/imageLoader/ImageLoader.h
function namespace (line 18) | namespace igl::shell {
FILE: shell/shared/imageLoader/tests/ImageLoaderTest.cpp
type igl::shell::tests (line 14) | namespace igl::shell::tests {
class ImageLoaderTest (line 16) | class ImageLoaderTest : public ::testing::Test {
method SetUp (line 18) | void SetUp() override {}
method TearDown (line 19) | void TearDown() override {}
function TEST_F (line 22) | TEST_F(ImageLoaderTest, CheckerboardReturnsValidData) {
function TEST_F (line 32) | TEST_F(ImageLoaderTest, WhiteReturnsValidData) {
function TEST_F (line 42) | TEST_F(ImageLoaderTest, CheckerboardDataIsReadable) {
function TEST_F (line 54) | TEST_F(ImageLoaderTest, WhiteDataIsAllWhite) {
FILE: shell/shared/imageWriter/ImageWriter.h
function namespace (line 15) | namespace igl::shell {
FILE: shell/shared/imageWriter/android/ImageWriterAndroid.h
function namespace (line 12) | namespace igl::shell {
FILE: shell/shared/imageWriter/ios/ImageWriterIos.h
function namespace (line 13) | namespace igl::shell {
FILE: shell/shared/imageWriter/linux/ImageWriterLinux.h
function namespace (line 12) | namespace igl::shell {
FILE: shell/shared/imageWriter/mac/ImageWriterMac.h
function namespace (line 12) | namespace igl::shell {
FILE: shell/shared/imageWriter/stb/ImageWriterSTB.cpp
type igl::shell (line 19) | namespace igl::shell {
FILE: shell/shared/imageWriter/stb/ImageWriterSTB.h
function namespace (line 13) | namespace igl::shell {
FILE: shell/shared/imageWriter/win/ImageWriterWin.h
function namespace (line 12) | namespace igl::shell {
FILE: shell/shared/input/InputDispatcher.cpp
type igl::shell (line 15) | namespace igl::shell {
FILE: shell/shared/input/InputDispatcher.h
function namespace (line 21) | namespace igl::shell {
FILE: shell/shared/input/IntentListener.h
function namespace (line 13) | namespace igl::shell {
FILE: shell/shared/input/KeyListener.h
function namespace (line 13) | namespace igl::shell {
FILE: shell/shared/input/MouseListener.h
type MouseButton (line 12) | enum MouseButton {
type MouseMotionEvent (line 29) | struct MouseMotionEvent {
FILE: shell/shared/input/RayListener.h
function namespace (line 12) | namespace igl::shell {
FILE: shell/shared/input/TouchListener.h
function namespace (line 10) | namespace igl::shell {
FILE: shell/shared/netservice/NetService.h
function namespace (line 15) | namespace igl::shell::netservice {
FILE: shell/shared/netservice/NetServiceExtension.cpp
type igl::shell::netservice (line 10) | namespace igl::shell::netservice {
FILE: shell/shared/netservice/NetServiceExtension.h
function namespace (line 16) | namespace igl::shell::netservice {
FILE: shell/shared/netservice/NetServiceFactory.h
function namespace (line 13) | namespace igl::shell::netservice {
FILE: shell/shared/netservice/Stream.h
function namespace (line 15) | namespace igl::shell::netservice {
function Stream (line 62) | struct InputStream : Stream {
FILE: shell/shared/netservice/apple/NetServiceApple.h
function namespace (line 18) | namespace igl::shell::netservice {
FILE: shell/shared/netservice/apple/NetServiceExtensionApple.h
function namespace (line 14) | namespace igl::shell::netservice {
FILE: shell/shared/netservice/apple/StreamApple.h
function namespace (line 15) | namespace igl::shell::netservice {
FILE: shell/shared/netservice/zeromq/NetServiceExtensionZeroMQ.h
function namespace (line 13) | namespace igl::shell::netservice {
FILE: shell/shared/netservice/zeromq/NetServiceZeroMQ.h
function namespace (line 17) | namespace igl::shell::netservice {
FILE: shell/shared/netservice/zeromq/StreamZeroMQ.h
function namespace (line 21) | namespace igl::shell::netservice {
FILE: shell/shared/platform/DisplayContext.h
function namespace (line 12) | namespace igl::shell {
FILE: shell/shared/platform/Factory.cpp
type igl::shell (line 22) | namespace igl::shell {
function createPlatform (line 24) | std::unique_ptr<Platform> createPlatform(std::shared_ptr<IDevice> devi...
FILE: shell/shared/platform/Factory.h
function namespace (line 12) | namespace igl::shell {
FILE: shell/shared/platform/Platform.cpp
type igl::shell (line 28) | namespace igl::shell {
type Platform::State (line 30) | struct Platform::State {
function Extension (line 40) | Extension* Platform::createAndInitializeExtension(const char* name) no...
function InputDispatcher (line 44) | InputDispatcher& Platform::getInputDispatcher() noexcept {
function DisplayContext (line 48) | [[nodiscard]] DisplayContext& Platform::getDisplayContext() noexcept {
FILE: shell/shared/platform/Platform.h
function namespace (line 13) | namespace igl::shell {
FILE: shell/shared/platform/android/PlatformAndroid.cpp
type igl::shell (line 22) | namespace igl::shell {
function IDevice (line 62) | IDevice& PlatformAndroid::getDevice() noexcept {
function ImageLoader (line 70) | ImageLoader& PlatformAndroid::getImageLoader() noexcept {
function ImageWriter (line 74) | const ImageWriter& PlatformAndroid::getImageWriter() const noexcept {
function FileLoader (line 78) | FileLoader& PlatformAndroid::getFileLoader() const noexcept {
FILE: shell/shared/platform/android/PlatformAndroid.h
function namespace (line 15) | namespace igl::shell {
FILE: shell/shared/platform/ios/PlatformIos.h
function namespace (line 15) | namespace igl::shell {
FILE: shell/shared/platform/linux/PlatformLinux.cpp
type igl::shell (line 14) | namespace igl::shell {
function IDevice (line 22) | IDevice& PlatformLinux::getDevice() noexcept {
function ImageLoader (line 30) | ImageLoader& PlatformLinux::getImageLoader() noexcept {
function ImageWriter (line 34) | const ImageWriter& PlatformLinux::getImageWriter() const noexcept {
function FileLoader (line 38) | FileLoader& PlatformLinux::getFileLoader() const noexcept {
FILE: shell/shared/platform/linux/PlatformLinux.h
function namespace (line 12) | namespace igl::shell {
FILE: shell/shared/platform/mac/PlatformMac.cpp
type igl::shell (line 14) | namespace igl::shell {
function IDevice (line 22) | IDevice& PlatformMac::getDevice() noexcept {
function ImageLoader (line 30) | ImageLoader& PlatformMac::getImageLoader() noexcept {
function ImageWriter (line 34) | const ImageWriter& PlatformMac::getImageWriter() const noexcept {
function FileLoader (line 38) | FileLoader& PlatformMac::getFileLoader() const noexcept {
FILE: shell/shared/platform/mac/PlatformMac.h
function namespace (line 12) | namespace igl::shell {
FILE: shell/shared/platform/win/PlatformWin.cpp
type igl::shell (line 14) | namespace igl::shell {
function IDevice (line 22) | IDevice& PlatformWin::getDevice() noexcept {
function ImageLoader (line 30) | ImageLoader& PlatformWin::getImageLoader() noexcept {
function ImageWriter (line 34) | const ImageWriter& PlatformWin::getImageWriter() const noexcept {
function FileLoader (line 38) | FileLoader& PlatformWin::getFileLoader() const noexcept {
FILE: shell/shared/platform/win/PlatformWin.h
function namespace (line 13) | namespace igl::shell {
FILE: shell/shared/renderSession/AppParams.h
function namespace (line 13) | namespace igl::shell {
FILE: shell/shared/renderSession/BenchmarkTracker.cpp
type igl::shell (line 15) | namespace igl::shell {
function RenderTimeStats (line 80) | RenderTimeStats BenchmarkTracker::computeStats() const {
function RenderTimeStats (line 122) | RenderTimeStats BenchmarkTracker::computeRecentStats() const {
function formatBenchmarkStats (line 217) | std::string formatBenchmarkStats(const RenderTimeStats& stats, const c...
function generateFinalBenchmarkReport (line 236) | std::string generateFinalBenchmarkReport(const BenchmarkTracker& track...
FILE: shell/shared/renderSession/BenchmarkTracker.h
function namespace (line 15) | namespace igl::shell {
FILE: shell/shared/renderSession/DefaultRenderSessionFactory.h
function namespace (line 14) | namespace igl::shell {
FILE: shell/shared/renderSession/DefaultSession.h
function namespace (line 12) | namespace igl::shell {
FILE: shell/shared/renderSession/DepthParams.h
function namespace (line 10) | namespace igl::shell {
FILE: shell/shared/renderSession/Fov.h
function namespace (line 10) | namespace igl::shell {
FILE: shell/shared/renderSession/Hands.h
function namespace (line 17) | namespace igl::shell {
FILE: shell/shared/renderSession/IRenderSessionFactory.h
function namespace (line 16) | namespace igl::shell {
function virtual (line 50) | [[nodiscard]] virtual const char* getAndroidSystemPropsPrefix() const no...
FILE: shell/shared/renderSession/QuadLayerParams.h
function namespace (line 15) | namespace igl::shell {
FILE: shell/shared/renderSession/RenderMode.h
function namespace (line 10) | namespace igl::shell {
FILE: shell/shared/renderSession/RenderSession.cpp
type igl::shell (line 18) | namespace igl::shell {
function ShellParams (line 35) | const ShellParams& RenderSession::shellParams() const noexcept {
function AppParams (line 40) | const AppParams& RenderSession::appParams() const noexcept {
function AppParams (line 44) | AppParams& RenderSession::appParamsRef() noexcept {
function Platform (line 48) | Platform& RenderSession::getPlatform() noexcept {
function Platform (line 51) | const Platform& RenderSession::getPlatform() const noexcept {
function Color (line 75) | Color RenderSession::getPreferredClearColor() noexcept {
FILE: shell/shared/renderSession/RenderSession.h
function namespace (line 15) | namespace igl::shell {
FILE: shell/shared/renderSession/RenderSessionConfig.h
function namespace (line 13) | namespace igl::shell {
FILE: shell/shared/renderSession/RenderSessionLoader.hpp
type igl::shell (line 13) | namespace igl::shell {
class RenderSession (line 14) | class RenderSession
class Platform (line 15) | class Platform
FILE: shell/shared/renderSession/RenderSessionRegistry.cpp
type igl::shell (line 13) | namespace igl::shell {
function RenderSessionLoader (line 27) | RenderSessionLoader& RenderSessionRegistry::findLoader(const std::stri...
FILE: shell/shared/renderSession/RenderSessionRegistry.hpp
type igl::shell (line 14) | namespace igl::shell {
class RenderSessionRegistry (line 16) | class RenderSessionRegistry {
FILE: shell/shared/renderSession/RenderSessionWindowConfig.h
function namespace (line 12) | namespace igl::shell {
FILE: shell/shared/renderSession/ScreenshotTestRenderSessionHelper.cpp
type igl::shell (line 13) | namespace igl::shell {
function saveFrameBufferToPng (line 15) | void saveFrameBufferToPng(const char* absoluteFilename,
FILE: shell/shared/renderSession/ScreenshotTestRenderSessionHelper.h
function namespace (line 13) | namespace igl {
function namespace (line 17) | namespace igl::shell {
FILE: shell/shared/renderSession/ShaderProvider.h
function namespace (line 16) | namespace igl::shell {
FILE: shell/shared/renderSession/ShaderStagesCreator.cpp
type igl::shell (line 10) | namespace igl::shell {
function ShaderModuleInfo (line 35) | ShaderModuleInfo getShaderModuleInfo(ShaderStage stage, BackendType ba...
function createRenderPipelineStages (line 40) | std::unique_ptr<IShaderStages> createRenderPipelineStages(
function createComputePipelineStages (line 83) | std::unique_ptr<IShaderStages> createComputePipelineStages(
FILE: shell/shared/renderSession/ShaderStagesCreator.h
function namespace (line 15) | namespace igl::shell {
FILE: shell/shared/renderSession/ShellParams.cpp
type igl::shell (line 15) | namespace igl::shell {
function parseBenchmarkRenderSessionParams (line 17) | std::optional<BenchmarkRenderSessionParams> parseBenchmarkRenderSessio...
function convertArgvToParams (line 103) | std::vector<std::string> convertArgvToParams(int argc, char** argv) {
function parseShellParams (line 112) | void parseShellParams(const std::vector<std::string>& args, ShellParam...
FILE: shell/shared/renderSession/ShellParams.h
function namespace (line 21) | namespace igl::shell {
FILE: shell/shared/renderSession/ShellType.h
function namespace (line 10) | namespace igl::shell {
FILE: shell/shared/renderSession/ViewParams.h
function namespace (line 13) | namespace igl::shell {
FILE: shell/shared/testShell/TestShell.cpp
type igl::shell (line 29) | namespace igl::shell {
function createTestDevice (line 33) | std::shared_ptr<IDevice> createTestDevice() {
function ensureCommandLineArgsInitialized (line 56) | void ensureCommandLineArgsInitialized() {
FILE: shell/shared/testShell/TestShell.h
function namespace (line 14) | namespace igl::shell {
FILE: shell/windows/common/GlfwShell.cpp
type igl::shell (line 24) | namespace igl::shell {
function glfwErrorHandler (line 26) | void glfwErrorHandler(int error, const char* description) {
function MouseButton (line 30) | MouseButton getIGLMouseButton(int button) {
function ShellParams (line 45) | ShellParams& GlfwShell::shellParams() noexcept {
function ShellParams (line 49) | const ShellParams& GlfwShell::shellParams() const noexcept {
function GLFWwindow (line 53) | GLFWwindow* GlfwShell::window() noexcept {
function GLFWwindow (line 57) | const GLFWwindow* GlfwShell::window() const noexcept {
function Platform (line 61) | Platform& GlfwShell::platform() noexcept {
function Platform (line 65) | const Platform& GlfwShell::platform() const noexcept {
function RenderSessionWindowConfig (line 69) | const RenderSessionWindowConfig& GlfwShell::windowConfig() const noexc...
function RenderSessionConfig (line 73) | const RenderSessionConfig& GlfwShell::sessionConfig() const noexcept {
FILE: shell/windows/common/GlfwShell.h
function namespace (line 41) | namespace igl::shell {
FILE: shell/windows/d3d12/App.cpp
type igl::shell (line 20) | namespace igl::shell {
class D3D12Shell (line 23) | class D3D12Shell final : public GlfwShell {
function SurfaceTextures (line 55) | SurfaceTextures D3D12Shell::createSurfaceTextures() noexcept {
function main (line 77) | int main(int argc, char* argv[]) {
FILE: shell/windows/opengl/App.cpp
type igl::shell (line 45) | namespace igl::shell {
class OpenGlShell (line 47) | class OpenGlShell final : public GlfwShell {
function SurfaceTextures (line 57) | SurfaceTextures OpenGlShell::createSurfaceTextures() noexcept {
function main (line 145) | int main(int argc, char* argv[]) {
FILE: shell/windows/opengl/AutoContextReleaseDevice.h
function namespace (line 22) | namespace igl::shell::util {
FILE: shell/windows/opengles/App.cpp
type igl::shell (line 27) | namespace igl::shell {
class OpenGlEsShell (line 29) | class OpenGlEsShell final : public GlfwShell {
class EGLDevice (line 39) | class EGLDevice final : public ::igl::opengl::Device {
method EGLDevice (line 42) | explicit EGLDevice(std::unique_ptr<::igl::opengl::IContext> context) :
function SurfaceTextures (line 74) | SurfaceTextures OpenGlEsShell::createSurfaceTextures() noexcept {
function main (line 111) | int main(int argc, char* argv[]) {
FILE: shell/windows/vulkan/App.cpp
type igl::shell (line 21) | namespace igl::shell {
class VulkanShell (line 23) | class VulkanShell final : public GlfwShell {
function SurfaceTextures (line 77) | SurfaceTextures VulkanShell::createSurfaceTextures() noexcept {
function main (line 97) | int main(int argc, char* argv[]) {
FILE: src/igl/Assert.cpp
function IGLErrorHandlerFunc (line 14) | IGLErrorHandlerFunc& getDebugAbortListener() {
function IGL_API (line 20) | IGL_API void iglSetDebugAbortListener(IGLErrorHandlerFunc listener) {
function IGL_API (line 24) | IGL_API IGLErrorHandlerFunc iglGetDebugAbortListener(void) {
type igl (line 28) | namespace igl {
function isDebugBreakEnabled (line 37) | bool isDebugBreakEnabled() {
function setDebugBreakEnabled (line 41) | void setDebugBreakEnabled(bool enabled) {
function iglDebugBreak (line 55) | void iglDebugBreak() {
function IGLErrorHandlerFunc (line 76) | IGLErrorHandlerFunc& getSoftErrorHandler() {
function IGL_API (line 82) | IGL_API void iglSetSoftErrorHandler(IGLErrorHandlerFunc handler) {
function IGL_API (line 86) | IGL_API IGLErrorHandlerFunc iglGetSoftErrorHandler(void) {
FILE: src/igl/Assert.h
function namespace (line 75) | namespace igl {
function namespace (line 197) | namespace igl {
FILE: src/igl/Buffer.h
function namespace (line 15) | namespace igl {
FILE: src/igl/Color.h
function namespace (line 12) | namespace igl {
FILE: src/igl/ColorSpace.h
function namespace (line 14) | namespace igl {
FILE: src/igl/CommandBuffer.h
function namespace (line 15) | namespace igl {
FILE: src/igl/CommandEncoder.h
function namespace (line 14) | namespace igl {
type BindGroupBufferDesc (line 48) | struct BindGroupBufferDesc {
function class (line 57) | class ICommandEncoder {
FILE: src/igl/CommandQueue.h
function namespace (line 13) | namespace igl {
FILE: src/igl/Common.cpp
type igl (line 15) | namespace igl {
function BackendTypeToString (line 21) | std::string BackendTypeToString(BackendType backendType) {
function optimizedMemcpy (line 41) | void optimizedMemcpy(void* IGL_NULLABLE dst, const void* IGL_NULLABLE ...
FILE: src/igl/Common.h
type class (line 58) | enum class
function CullMode (line 67) | enum class CullMode : uint8_t { Disabled, Front, Back };
FILE: src/igl/ComputeCommandEncoder.h
function namespace (line 16) | namespace igl {
FILE: src/igl/ComputePipelineState.h
function namespace (line 18) | namespace igl {
function class (line 52) | class IComputePipelineState {
function namespace (line 66) | namespace std {
FILE: src/igl/DepthStencilState.h
type class (line 28) | enum class
function StencilOperation (line 55) | enum class StencilOperation : uint8_t {
function namespace (line 175) | namespace std {
FILE: src/igl/Device.cpp
type igl (line 13) | namespace igl {
function TextureDesc (line 19) | TextureDesc IDevice::sanitize(const TextureDesc& desc) const {
function Color (line 43) | Color IDevice::backendDebugColor() const noexcept {
FILE: src/igl/Device.h
function namespace (line 18) | namespace igl {
function virtual (line 290) | [[nodiscard]] virtual const IPlatformDevice& getPlatformDevice() const n...
function BackendType (line 313) | [[nodiscard]] BackendType getBackendType() const override = 0;
function virtual (line 338) | [[nodiscard]] virtual NormalizedZRange getNormalizedZRange() const {
function virtual (line 379) | virtual void updateSurface(void* IGL_NONNULL /*nativeWindowType*/) {}
function setResourceTracker (line 398) | void setResourceTracker(std::shared_ptr<IResourceTracker> tracker) noexc...
function noexcept (line 407) | const noexcept {
function Color (line 426) | [[nodiscard]] Color backendDebugColor() const noexcept;
function setDevelopmentFlags (line 451) | void setDevelopmentFlags(InDevelopementFeatures featureEnum, bool val) {
function virtual (line 466) | virtual void setCurrentThread() {
function virtual (line 473) | virtual void endScope() {
function final (line 505) | struct DeviceScope final {
FILE: src/igl/DeviceFeatures.h
type class (line 75) | enum class
type class (line 148) | enum class
function DeviceFeatureLimits (line 185) | enum class DeviceFeatureLimits {
function class (line 265) | class ICapabilities {
FILE: src/igl/FPSCounter.h
function namespace (line 12) | namespace igl {
function updateFPS (line 38) | void updateFPS(double seconds) {
FILE: src/igl/Framebuffer.h
function namespace (line 15) | namespace igl {
FILE: src/igl/FramebufferWrapper.cpp
type igl (line 10) | namespace igl {
FILE: src/igl/FramebufferWrapper.h
function namespace (line 14) | namespace igl {
FILE: src/igl/HWDevice.h
type class (line 20) | enum class
type HWDeviceDesc (line 54) | struct HWDeviceDesc {
FILE: src/igl/IGLSafeC.h
function try_checked_memcpy (line 20) | inline int try_checked_memcpy(void* destination,
function checked_strncmp (line 74) | inline int checked_strncmp(const char* str1,
FILE: src/igl/IResourceTracker.h
function namespace (line 13) | namespace igl {
FILE: src/igl/ITrackedResource.h
function namespace (line 14) | namespace igl {
FILE: src/igl/Log.cpp
function IGLLogHandlerFunc (line 26) | static IGLLogHandlerFunc* getHandle() {
function IGL_API (line 39) | IGL_API int IGLLog(IGLLogLevel logLevel, const char* IGL_RESTRICT format...
function IGL_API (line 47) | IGL_API int IGLLogOnce(IGLLogLevel logLevel, const char* IGL_RESTRICT fo...
function IGL_API (line 77) | IGL_API int IGLLogV(IGLLogLevel logLevel, const char* IGL_RESTRICT forma...
function IGL_API (line 81) | IGL_API int IGLLogDefaultHandler(IGLLogLevel /*logLevel*/,
function IGL_API (line 90) | IGL_API void IGLLogSetHandler(IGLLogHandlerFunc handler) {
function IGL_API (line 94) | IGL_API IGLLogHandlerFunc IGLLogGetHandler() {
FILE: src/igl/Log.h
type IGLLogLevel (line 17) | enum IGLLogLevel {
FILE: src/igl/NameHandle.cpp
type igl (line 10) | namespace igl {
function iglCrc32Fallback (line 14) | uint32_t iglCrc32Fallback(const char* p) {
function iglCrc32Impl (line 24) | uint32_t iglCrc32Impl(const char* p) {
function isAligned (line 39) | bool isAligned(const void* p) {
function iglCrc32ImplARM8 (line 43) | uint32_t iglCrc32ImplARM8(const char* s, size_t length) {
function detectCrc32 (line 68) | bool detectCrc32() {
function detectCrc32 (line 73) | bool detectCrc32() {
function detectCrc32 (line 78) | bool detectCrc32() {
function iglCrc32 (line 84) | uint32_t iglCrc32(const char* data, size_t length) {
function iglCrc32 (line 90) | uint32_t iglCrc32(const char* data, size_t /*length*/) {
FILE: src/igl/NameHandle.h
function namespace (line 18) | namespace igl {
function iglStringlength (line 224) | inline size_t iglStringlength(const char* str) {
function namespace (line 259) | namespace std {
FILE: src/igl/PlatformDevice.h
function namespace (line 12) | namespace igl {
FILE: src/igl/RenderCommandEncoder.h
function namespace (line 15) | namespace igl {
FILE: src/igl/RenderPass.h
function namespace (line 14) | namespace igl {
FILE: src/igl/RenderPipelineReflection.h
function namespace (line 17) | namespace igl {
FILE: src/igl/RenderPipelineState.h
type class (line 37) | enum class
type class (line 72) | enum class
type ColorWriteBits (line 100) | enum ColorWriteBits : uint8_t {
function PolygonFillMode (line 115) | enum class PolygonFillMode : uint8_t {
function namespace (line 249) | namespace std {
FILE: src/igl/SamplerState.cpp
type igl (line 12) | namespace igl {
FILE: src/igl/SamplerState.h
type class (line 25) | enum class
function SamplerMipFilter (line 35) | enum class SamplerMipFilter : uint8_t { Disabled = 0, Nearest, Linear };
function namespace (line 215) | namespace std {
FILE: src/igl/Shader.cpp
function safeDataCompare (line 14) | bool safeDataCompare(const void* IGL_NULLABLE a,
function safeDataHash (line 29) | size_t safeDataHash(const void* IGL_NULLABLE ptr, size_t length) {
function safeCStrCompare (line 40) | bool safeCStrCompare(const char* IGL_NULLABLE a, const char* IGL_NULLABL...
function safeCStrHash (line 50) | size_t safeCStrHash(const char* IGL_NULLABLE s) {
type igl (line 59) | namespace igl {
function ShaderModuleDesc (line 98) | ShaderModuleDesc ShaderModuleDesc::fromStringInput(const char* IGL_NON...
function ShaderModuleDesc (line 109) | ShaderModuleDesc ShaderModuleDesc::fromBinaryInput(const void* IGL_NON...
function ShaderLibraryDesc (line 130) | ShaderLibraryDesc ShaderLibraryDesc::fromStringInput(const char* IGL_N...
function ShaderLibraryDesc (line 145) | ShaderLibraryDesc ShaderLibraryDesc::fromBinaryInput(const void* IGL_N...
function ShaderModuleInfo (line 172) | const ShaderModuleInfo& IShaderModule::info() const noexcept {
function modules_ (line 177) | modules_(std::move(modules)) {}
function ShaderStagesDesc (line 201) | ShaderStagesDesc ShaderStagesDesc::fromRenderModules(
function ShaderStagesDesc (line 214) | ShaderStagesDesc ShaderStagesDesc::fromMeshRenderModules(
function ShaderStagesDesc (line 230) | ShaderStagesDesc ShaderStagesDesc::fromComputeModule(std::shared_ptr<I...
function ShaderStagesType (line 241) | ShaderStagesType IShaderStages::getType() const noexcept {
type std (line 279) | namespace std {
FILE: src/igl/Shader.h
type class (line 20) | enum class
type ShaderCompilerOptions (line 36) | struct ShaderCompilerOptions {
type ShaderModuleInfo (line 48) | struct ShaderModuleInfo {
type class (line 63) | enum class
type ShaderInput (line 73) | struct ShaderInput {
type ShaderModuleDesc (line 120) | struct ShaderModuleDesc {
type ShaderLibraryDesc (line 158) | struct ShaderLibraryDesc {
function class (line 194) | class IShaderModule : public ITrackedResource<IShaderModule> {
function class (line 210) | class IShaderLibrary : public ITrackedResource<IShaderLibrary> {
type class (line 238) | enum class
type ShaderStagesDesc (line 251) | struct ShaderStagesDesc {
function std (line 310) | const std::shared_ptr<IShaderModule>& getVertexModule() const noexcept;
FILE: src/igl/ShaderCreator.cpp
type igl (line 12) | namespace igl {
function fromLibraryDesc (line 331) | std::unique_ptr<IShaderStages> fromLibraryDesc(const IDevice& device,
FILE: src/igl/ShaderCreator.h
function namespace (line 13) | namespace igl {
FILE: src/igl/Texture.cpp
type igl (line 19) | namespace igl {
function TextureRangeDesc (line 21) | TextureRangeDesc TextureRangeDesc::new1D(uint32_t x,
function TextureRangeDesc (line 28) | TextureRangeDesc TextureRangeDesc::new1DArray(uint32_t x,
function TextureRangeDesc (line 37) | TextureRangeDesc TextureRangeDesc::new2D(uint32_t x,
function TextureRangeDesc (line 46) | TextureRangeDesc TextureRangeDesc::new2DArray(uint32_t x,
function TextureRangeDesc (line 60) | TextureRangeDesc TextureRangeDesc::new3D(uint32_t x,
function TextureRangeDesc (line 80) | TextureRangeDesc TextureRangeDesc::newCube(uint32_t x,
function TextureRangeDesc (line 91) | TextureRangeDesc TextureRangeDesc::newCubeFace(uint32_t x,
function TextureRangeDesc (line 104) | TextureRangeDesc TextureRangeDesc::newCubeFace(uint32_t x,
function TextureRangeDesc (line 114) | TextureRangeDesc TextureRangeDesc::atMipLevel(uint32_t newMipLevel) co...
function TextureRangeDesc (line 135) | TextureRangeDesc TextureRangeDesc::withNumMipLevels(uint32_t newNumMip...
function TextureRangeDesc (line 142) | TextureRangeDesc TextureRangeDesc::atLayer(uint32_t newLayer) const no...
function TextureRangeDesc (line 150) | TextureRangeDesc TextureRangeDesc::withNumLayers(uint32_t newNumLayers...
function TextureRangeDesc (line 157) | TextureRangeDesc TextureRangeDesc::atFace(uint32_t newFace) const noex...
function TextureRangeDesc (line 165) | TextureRangeDesc TextureRangeDesc::atFace(TextureCubeFace newFace) con...
function TextureRangeDesc (line 169) | TextureRangeDesc TextureRangeDesc::withNumFaces(uint32_t newNumFaces) ...
function Result (line 176) | Result TextureRangeDesc::validate() const noexcept {
function TextureFormatProperties (line 252) | TextureFormatProperties TextureFormatProperties::fromTextureFormat(Tex...
function TextureRangeDesc (line 526) | TextureRangeDesc TextureDesc::asRange() const noexcept {
function Size (line 555) | Size ITexture::getSize() const {
function Result (line 573) | Result ITexture::validateRange(const igl::TextureRangeDesc& range) con...
function TextureRangeDesc (line 602) | TextureRangeDesc ITexture::getFullRange(size_t mipLevel, size_t numMip...
function TextureRangeDesc (line 618) | TextureRangeDesc ITexture::getFullMipRange() const noexcept {
function TextureRangeDesc (line 622) | TextureRangeDesc ITexture::getCubeFaceRange(size_t face,
function TextureRangeDesc (line 629) | TextureRangeDesc ITexture::getCubeFaceRange(TextureCubeFace face,
function TextureRangeDesc (line 636) | TextureRangeDesc ITexture::getLayerRange(size_t layer,
function Result (line 705) | Result ITexture::upload(const TextureRangeDesc& range,
FILE: src/igl/Texture.h
function namespace (line 17) | namespace igl {
type TextureDesc (line 499) | struct TextureDesc {
function TextureRangeDesc (line 721) | [[nodiscard]] TextureRangeDesc asRange() const noexcept;
function getAspectRatio (line 800) | [[nodiscard]] float getAspectRatio() const;
function virtual (line 1022) | [[nodiscard]] virtual bool needsRepacking(IGL_MAYBE_UNUSED const Texture...
type SurfaceTextures (line 1043) | struct SurfaceTextures {
function namespace (line 1052) | namespace std {
FILE: src/igl/TextureFormat.h
function namespace (line 12) | namespace igl {
FILE: src/igl/Timer.h
function namespace (line 12) | namespace igl {
FILE: src/igl/TimestampQueries.h
function namespace (line 12) | namespace igl {
FILE: src/igl/Uniform.cpp
type igl (line 12) | namespace igl {
function sizeForUniformType (line 14) | size_t sizeForUniformType(UniformType type) {
function sizeForUniformElementType (line 49) | size_t sizeForUniformElementType(UniformType type) {
FILE: src/igl/Uniform.h
function namespace (line 14) | namespace igl {
FILE: src/igl/VertexInputState.h
type class (line 19) | enum class
function VertexSampleFunction (line 89) | enum class VertexSampleFunction {
function namespace (line 153) | namespace std {
FILE: src/igl/android/LogDefault.cpp
function android_LogPriority (line 14) | android_LogPriority logPriorityFromLogLevel(IGLLogLevel logLevel) noexce...
function IGL_API (line 27) | IGL_API int IGLAndroidLogDefaultHandler(IGLLogLevel logLevel,
FILE: src/igl/android/NativeHWBuffer.cpp
type igl::android (line 15) | namespace igl::android {
function getNativeHWFormat (line 17) | uint32_t getNativeHWFormat(TextureFormat iglFormat) {
function getNativeHWBufferUsage (line 63) | uint32_t getNativeHWBufferUsage(TextureDesc::TextureUsage iglUsage) {
function TextureFormat (line 79) | TextureFormat getIglFormat(uint32_t nativeFormat) {
function getIglBufferUsage (line 126) | TextureDesc::TextureUsage getIglBufferUsage(uint32_t nativeUsage) {
function Result (line 143) | Result allocateNativeHWBuffer(const TextureDesc& desc,
function Result (line 181) | Result INativeHWTextureBuffer::createWithHWBuffer(AHardwareBuffer* buf...
function Result (line 199) | Result INativeHWTextureBuffer::createHWBuffer(const TextureDesc& desc,
function Result (line 260) | Result INativeHWTextureBuffer::lockHWBuffer(std::byte * IGL_NULLABLE *...
function Result (line 283) | Result INativeHWTextureBuffer::unlockHWBuffer() const {
function AHardwareBuffer (line 291) | AHardwareBuffer* INativeHWTextureBuffer::getHardwareBuffer() const {
function TextureDesc (line 295) | TextureDesc INativeHWTextureBuffer::getTextureDesc() const {
FILE: src/igl/android/NativeHWBuffer.h
function class (line 31) | class INativeHWTextureBuffer {
FILE: src/igl/apple/LogDefault.cpp
function IGL_API (line 17) | IGL_API int IGLAppleLogDefaultHandler(IGLLogLevel logLevel,
FILE: src/igl/base/Common.h
type class (line 16) | enum class
type class (line 115) | enum class
function TextureType (line 250) | enum class TextureType : uint8_t {
FILE: src/igl/base/IAttachmentInterop.h
function namespace (line 12) | namespace igl::base {
FILE: src/igl/base/IDeviceBase.h
function namespace (line 15) | namespace igl::base {
FILE: src/igl/base/IFramebufferInterop.h
function namespace (line 14) | namespace igl::base {
function class (line 27) | class IFramebufferInterop {
FILE: src/igl/base/IStagingBufferInterop.h
function namespace (line 13) | namespace igl::base {
FILE: src/igl/d3d12/Buffer.cpp
type igl::d3d12 (line 16) | namespace igl::d3d12 {
function D3D12_RESOURCE_DESC (line 19) | constexpr D3D12_RESOURCE_DESC makeBufferDesc(
function Result (line 80) | Result Buffer::upload(const void* data, const BufferRange& range) {
function ResourceStorage (line 565) | ResourceStorage Buffer::storage() const noexcept {
function D3D12_RESOURCE_STATES (line 585) | D3D12_RESOURCE_STATES Buffer::computeDefaultState(const BufferDesc& de...
FILE: src/igl/d3d12/Buffer.h
function namespace (line 14) | namespace igl::d3d12 {
FILE: src/igl/d3d12/CommandBuffer.cpp
type igl::d3d12 (line 19) | namespace igl::d3d12 {
function Result (line 99) | Result CommandBuffer::getNextCbvSrvUavDescriptor(uint32_t* outDescript...
function Result (line 201) | Result CommandBuffer::allocateCbvSrvUavRange(uint32_t count, uint32_t*...
function Result (line 413) | Result CommandBuffer::begin() {
function D3D12Context (line 502) | D3D12Context& CommandBuffer::getContext() {
function D3D12Context (line 506) | const D3D12Context& CommandBuffer::getContext() const {
FILE: src/igl/d3d12/CommandBuffer.h
function namespace (line 15) | namespace igl::d3d12 {
FILE: src/igl/d3d12/CommandQueue.cpp
type igl::d3d12 (line 22) | namespace igl::d3d12 {
function executeDeferredCopies (line 29) | void executeDeferredCopies(D3D12Context& ctx, Device& device, const Co...
function updateFrameFences (line 61) | void updateFrameFences(D3D12Context& ctx, UINT64 currentFenceValue) {
function SubmitHandle (line 130) | SubmitHandle CommandQueue::submit(const ICommandBuffer& commandBuffer,...
FILE: src/igl/d3d12/CommandQueue.h
function namespace (line 14) | namespace igl::d3d12 {
FILE: src/igl/d3d12/Common.cpp
type igl::d3d12 (line 10) | namespace igl::d3d12 {
function DXGI_FORMAT (line 12) | DXGI_FORMAT textureFormatToDXGIFormat(TextureFormat format) {
function isDepthOrStencilFormat (line 99) | bool isDepthOrStencilFormat(TextureFormat format) {
function DXGI_FORMAT (line 113) | DXGI_FORMAT textureFormatToDXGIResourceFormat(TextureFormat format, bo...
function DXGI_FORMAT (line 133) | DXGI_FORMAT textureFormatToDXGIShaderResourceViewFormat(TextureFormat ...
function TextureFormat (line 154) | TextureFormat dxgiFormatToTextureFormat(DXGI_FORMAT format) {
FILE: src/igl/d3d12/Common.h
function namespace (line 28) | namespace igl::d3d12 {
function D3D12ContextConfig (line 153) | static D3D12ContextConfig defaultConfig() {
function D3D12ContextConfig (line 158) | static D3D12ContextConfig lowMemoryConfig() {
function D3D12ContextConfig (line 172) | static D3D12ContextConfig highPerformanceConfig() {
function Result (line 283) | inline Result getResultFromHRESULT(HRESULT hr) {
function T (line 328) | T AlignUp(T value, T alignment) {
function std (line 360) | inline std::string getShaderTarget(D3D_SHADER_MODEL shaderModel, ShaderS...
FILE: src/igl/d3d12/ComputeCommandEncoder.cpp
type igl::d3d12 (line 18) | namespace igl::d3d12 {
FILE: src/igl/d3d12/ComputeCommandEncoder.h
function namespace (line 14) | namespace igl::d3d12 {
FILE: src/igl/d3d12/ComputePipelineState.cpp
type igl::d3d12 (line 16) | namespace igl::d3d12 {
type ReflectionImpl (line 46) | struct ReflectionImpl final : public IComputePipelineReflection {
FILE: src/igl/d3d12/ComputePipelineState.h
function namespace (line 13) | namespace igl::d3d12 {
FILE: src/igl/d3d12/D3D12AllocatorPool.cpp
type igl::d3d12 (line 17) | namespace igl::d3d12 {
FILE: src/igl/d3d12/D3D12AllocatorPool.h
function namespace (line 15) | namespace igl {
function namespace (line 19) | namespace igl::d3d12 {
FILE: src/igl/d3d12/D3D12Context.cpp
type igl::d3d12 (line 15) | namespace igl::d3d12 {
function D3D_FEATURE_LEVEL (line 68) | D3D_FEATURE_LEVEL D3D12Context::getHighestFeatureLevel(IDXGIAdapter1* ...
function Result (line 143) | Result D3D12Context::initialize(HWND hwnd,
function Result (line 241) | Result D3D12Context::resize(uint32_t width, uint32_t height) {
function Result (line 320) | Result D3D12Context::recreateSwapChain(uint32_t width, uint32_t height) {
function Result (line 394) | Result D3D12Context::createDevice() {
function Result (line 744) | Result D3D12Context::enumerateAndSelectAdapter() {
function Result (line 1042) | Result D3D12Context::createCommandQueue() {
function Result (line 1058) | Result D3D12Context::createSwapChain(HWND hwnd, uint32_t width, uint32...
function Result (line 1195) | Result D3D12Context::createRTVHeap() {
function Result (line 1214) | Result D3D12Context::createBackBuffers() {
function Result (line 1239) | Result D3D12Context::createDescriptorHeaps() {
function Result (line 1369) | Result D3D12Context::createCommandSignatures() {
function ID3D12Resource (line 1442) | ID3D12Resource* D3D12Context::getCurrentBackBuffer() const {
function D3D12_CPU_DESCRIPTOR_HANDLE (line 1456) | D3D12_CPU_DESCRIPTOR_HANDLE D3D12Context::getCurrentRTV() const {
function Result (line 1533) | Result D3D12Context::allocateDescriptorHeapPage(D3D12_DESCRIPTOR_HEAP_...
FILE: src/igl/d3d12/D3D12Context.h
function namespace (line 15) | namespace igl {
function namespace (line 19) | namespace igl::d3d12 {
FILE: src/igl/d3d12/D3D12DeviceCapabilities.cpp
type igl::d3d12 (line 12) | namespace igl::d3d12 {
FILE: src/igl/d3d12/D3D12DeviceCapabilities.h
function namespace (line 12) | namespace igl::d3d12 {
FILE: src/igl/d3d12/D3D12FenceWaiter.cpp
type igl::d3d12 (line 10) | namespace igl::d3d12 {
function Result (line 60) | Result FenceWaiter::wait(DWORD timeoutMs) {
FILE: src/igl/d3d12/D3D12FenceWaiter.h
function namespace (line 12) | namespace igl::d3d12 {
FILE: src/igl/d3d12/D3D12FrameManager.cpp
type igl::d3d12 (line 13) | namespace igl::d3d12 {
FILE: src/igl/d3d12/D3D12FrameManager.h
function namespace (line 12) | namespace igl::d3d12 {
FILE: src/igl/d3d12/D3D12Headers.h
function namespace (line 73) | namespace igl {
function namespace (line 254) | namespace Microsoft {
FILE: src/igl/d3d12/D3D12ImmediateCommands.cpp
type igl::d3d12 (line 14) | namespace igl::d3d12 {
function ID3D12GraphicsCommandList (line 49) | ID3D12GraphicsCommandList* D3D12ImmediateCommands::begin(Result* outRe...
function Result (line 150) | Result D3D12ImmediateCommands::waitForFence(uint64_t fenceValue) {
function Result (line 183) | Result D3D12ImmediateCommands::getOrCreateAllocator(
FILE: src/igl/d3d12/D3D12ImmediateCommands.h
function namespace (line 16) | namespace igl::d3d12 {
FILE: src/igl/d3d12/D3D12PipelineBuilder.cpp
type igl::d3d12 (line 12) | namespace igl::d3d12 {
function getRootSignatureDwordSize (line 17) | uint32_t getRootSignatureDwordSize(const D3D12_ROOT_SIGNATURE_DESC& de...
function D3D12_BLEND (line 42) | D3D12_BLEND toD3D12Blend(BlendFactor f) {
function D3D12_BLEND_OP (line 88) | D3D12_BLEND_OP toD3D12BlendOp(BlendOp op) {
function D3D12GraphicsPipelineBuilder (line 171) | D3D12GraphicsPipelineBuilder& D3D12GraphicsPipelineBuilder::vertexShader(
function D3D12GraphicsPipelineBuilder (line 178) | D3D12GraphicsPipelineBuilder& D3D12GraphicsPipelineBuilder::pixelShader(
function D3D12GraphicsPipelineBuilder (line 185) | D3D12GraphicsPipelineBuilder& D3D12GraphicsPipelineBuilder::shaderByte...
function D3D12GraphicsPipelineBuilder (line 191) | D3D12GraphicsPipelineBuilder& D3D12GraphicsPipelineBuilder::vertexInpu...
function D3D12GraphicsPipelineBuilder (line 198) | D3D12GraphicsPipelineBuilder& D3D12GraphicsPipelineBuilder::blendState(
function D3D12GraphicsPipelineBuilder (line 204) | D3D12GraphicsPipelineBuilder& D3D12GraphicsPipelineBuilder::blendState...
function D3D12GraphicsPipelineBuilder (line 244) | D3D12GraphicsPipelineBuilder& D3D12GraphicsPipelineBuilder::rasterizer...
function D3D12GraphicsPipelineBuilder (line 250) | D3D12GraphicsPipelineBuilder& D3D12GraphicsPipelineBuilder::cullMode(C...
function D3D12GraphicsPipelineBuilder (line 266) | D3D12GraphicsPipelineBuilder& D3D12GraphicsPipelineBuilder::frontFaceW...
function D3D12GraphicsPipelineBuilder (line 272) | D3D12GraphicsPipelineBuilder& D3D12GraphicsPipelineBuilder::polygonFil...
function D3D12GraphicsPipelineBuilder (line 278) | D3D12GraphicsPipelineBuilder& D3D12GraphicsPipelineBuilder::depthStenc...
function D3D12GraphicsPipelineBuilder (line 284) | D3D12GraphicsPipelineBuilder& D3D12GraphicsPipelineBuilder::depthTestE...
function D3D12GraphicsPipelineBuilder (line 289) | D3D12GraphicsPipelineBuilder& D3D12GraphicsPipelineBuilder::depthWrite...
function D3D12GraphicsPipelineBuilder (line 295) | D3D12GraphicsPipelineBuilder& D3D12GraphicsPipelineBuilder::depthCompa...
function D3D12GraphicsPipelineBuilder (line 301) | D3D12GraphicsPipelineBuilder& D3D12GraphicsPipelineBuilder::renderTarg...
function D3D12GraphicsPipelineBuilder (line 315) | D3D12GraphicsPipelineBuilder& D3D12GraphicsPipelineBuilder::renderTarg...
function D3D12GraphicsPipelineBuilder (line 328) | D3D12GraphicsPipelineBuilder& D3D12GraphicsPipelineBuilder::depthStenc...
function D3D12GraphicsPipelineBuilder (line 333) | D3D12GraphicsPipelineBuilder& D3D12GraphicsPipelineBuilder::numRenderT...
function D3D12GraphicsPipelineBuilder (line 341) | D3D12GraphicsPipelineBuilder& D3D12GraphicsPipelineBuilder::sampleCoun...
function D3D12GraphicsPipelineBuilder (line 347) | D3D12GraphicsPipelineBuilder& D3D12GraphicsPipelineBuilder::sampleMask...
function D3D12GraphicsPipelineBuilder (line 352) | D3D12GraphicsPipelineBuilder& D3D12GraphicsPipelineBuilder::primitiveT...
function D3D12GraphicsPipelineBuilder (line 358) | D3D12GraphicsPipelineBuilder& D3D12GraphicsPipelineBuilder::streamOutput(
function Result (line 364) | Result D3D12GraphicsPipelineBuilder::build(ID3D12Device* device,
function D3D12ComputePipelineBuilder (line 429) | D3D12ComputePipelineBuilder& D3D12ComputePipelineBuilder::shaderBytecode(
function Result (line 437) | Result D3D12ComputePipelineBuilder::build(ID3D12Device* device,
function D3D12RootSignatureBuilder (line 494) | D3D12RootSignatureBuilder& D3D12RootSignatureBuilder::addRootConstants...
function D3D12RootSignatureBuilder (line 507) | D3D12RootSignatureBuilder& D3D12RootSignatureBuilder::addRootCBV(UINT ...
function D3D12RootSignatureBuilder (line 518) | D3D12RootSignatureBuilder& D3D12RootSignatureBuilder::addRootSRV(UINT ...
function D3D12RootSignatureBuilder (line 529) | D3D12RootSignatureBuilder& D3D12RootSignatureBuilder::addRootUAV(UINT ...
function D3D12RootSignatureBuilder (line 540) | D3D12RootSignatureBuilder& D3D12RootSignatureBuilder::addDescriptorTable(
function D3D12RootSignatureBuilder (line 562) | D3D12RootSignatureBuilder& D3D12RootSignatureBuilder::flags(D3D12_ROOT...
function Result (line 567) | Result D3D12RootSignatureBuilder::build(ID3D12Device* device,
function UINT (line 669) | UINT D3D12RootSignatureBuilder::getMaxDescriptorCount(const D3D12Conte...
FILE: src/igl/d3d12/D3D12PipelineBuilder.h
function namespace (line 15) | namespace igl::d3d12 {
FILE: src/igl/d3d12/D3D12PipelineCache.cpp
type igl::d3d12 (line 15) | namespace igl::d3d12 {
FILE: src/igl/d3d12/D3D12PipelineCache.h
function namespace (line 21) | namespace igl::d3d12 {
FILE: src/igl/d3d12/D3D12PresentManager.cpp
type igl::d3d12 (line 14) | namespace igl::d3d12 {
FILE: src/igl/d3d12/D3D12PresentManager.h
function namespace (line 12) | namespace igl::d3d12 {
FILE: src/igl/d3d12/D3D12ReflectionUtils.cpp
type igl::d3d12::ReflectionUtils (line 10) | namespace igl::d3d12::ReflectionUtils {
function mapUniformType (line 12) | igl::UniformType mapUniformType(const D3D12_SHADER_TYPE_DESC& td) {
FILE: src/igl/d3d12/D3D12ReflectionUtils.h
function namespace (line 13) | namespace igl::d3d12::ReflectionUtils {
FILE: src/igl/d3d12/D3D12ResourcesBinder.cpp
type igl::d3d12 (line 19) | namespace igl::d3d12 {
FILE: src/igl/d3d12/D3D12ResourcesBinder.h
function namespace (line 17) | namespace igl::d3d12 {
type BindingsSamplers (line 42) | struct BindingsSamplers {
type BindingsBuffers (line 59) | struct BindingsBuffers {
type BindingsUAVs (line 75) | struct BindingsUAVs {
function class (line 162) | class D3D12ResourcesBinder final {
FILE: src/igl/d3d12/D3D12RootSignatureKey.h
function namespace (line 15) | namespace igl::d3d12 {
function D3D12RootSignatureKey (line 252) | inline D3D12RootSignatureKey D3D12RootSignatureKey::fromShaderReflection(
FILE: src/igl/d3d12/D3D12SamplerCache.h
type SamplerCacheStats (line 19) | struct SamplerCacheStats {
function toD3D12Address (line 64) | auto toD3D12Address = [](SamplerAddressMode m) {
function toD3D12Compare (line 77) | auto toD3D12Compare = [](CompareFunction f) {
FILE: src/igl/d3d12/D3D12StagingDevice.cpp
type igl::d3d12 (line 15) | namespace igl::d3d12 {
function Result (line 182) | Result D3D12StagingDevice::createStagingBuffer(size_t size,
FILE: src/igl/d3d12/D3D12StagingDevice.h
function namespace (line 16) | namespace igl::d3d12 {
FILE: src/igl/d3d12/D3D12StateTransition.h
function namespace (line 13) | namespace igl::d3d12 {
FILE: src/igl/d3d12/D3D12Telemetry.h
function namespace (line 14) | namespace igl::d3d12 {
FILE: src/igl/d3d12/DXCCompiler.cpp
type igl::d3d12 (line 20) | namespace igl::d3d12 {
function loadDxcLibrary (line 35) | bool loadDxcLibrary() {
function HRESULT (line 62) | HRESULT DxcCreateInstanceDynamic(REFCLSID rclsid, REFIID riid, LPVOID*...
function Result (line 74) | Result DXCCompiler::initialize() {
function Result (line 119) | Result DXCCompiler::compile(const char* source,
FILE: src/igl/d3d12/DXCCompiler.h
function namespace (line 16) | namespace igl::d3d12 {
FILE: src/igl/d3d12/DepthStencilState.h
function namespace (line 13) | namespace igl::d3d12 {
FILE: src/igl/d3d12/DescriptorHeapManager.cpp
type igl::d3d12 (line 12) | namespace igl::d3d12 {
function Result (line 14) | Result DescriptorHeapManager::initialize(ID3D12Device* device, const S...
FILE: src/igl/d3d12/DescriptorHeapManager.h
function namespace (line 15) | namespace igl::d3d12 {
FILE: src/igl/d3d12/Device.cpp
type igl::d3d12 (line 45) | namespace igl::d3d12 {
function DxcCreateInstanceProc (line 56) | DxcCreateInstanceProc getDxcCreateInstance() {
function captureInfoQueueForDevice (line 74) | void captureInfoQueueForDevice(ID3D12Device* device) {
function logInfoQueuesForDevice (line 170) | void logInfoQueuesForDevice(ID3D12Device* device, const char* context) {
function getRootSignatureDwordSize (line 309) | static uint32_t getRootSignatureDwordSize(const D3D12_ROOT_SIGNATURE_D...
function validateShaderBindingsAndLayout (line 378) | static void validateShaderBindingsAndLayout(
function Result (line 675) | Result Device::checkDeviceRemoval() const {
function Result (line 2902) | Result compileShaderFXC(const char* source,
function IPlatformDevice (line 3416) | const IPlatformDevice& Device::getPlatformDevice() const noexcept {
function ShaderVersion (line 3832) | ShaderVersion Device::getShaderVersion() const {
function BackendVersion (line 3851) | BackendVersion Device::getBackendVersion() const {
function BackendType (line 3890) | BackendType Device::getBackendType() const {
function SamplerCacheStats (line 3895) | SamplerCacheStats Device::getSamplerCacheStats() const {
function Result (line 3938) | Result Device::waitForUploadFence(UINT64 fenceValue) const {
FILE: src/igl/d3d12/Device.h
function namespace (line 29) | namespace igl::d3d12 {
FILE: src/igl/d3d12/Framebuffer.cpp
type igl::d3d12 (line 21) | namespace igl::d3d12 {
function FramebufferMode (line 72) | FramebufferMode Framebuffer::getMode() const {
FILE: src/igl/d3d12/Framebuffer.h
function namespace (line 16) | namespace igl::d3d12 {
FILE: src/igl/d3d12/HeadlessContext.cpp
type igl::d3d12 (line 17) | namespace igl::d3d12 {
function Result (line 27) | Result HeadlessD3D12Context::initializeHeadless(uint32_t width,
FILE: src/igl/d3d12/HeadlessContext.h
function namespace (line 18) | namespace igl::d3d12 {
FILE: src/igl/d3d12/PlatformDevice.cpp
type igl::d3d12 (line 14) | namespace igl::d3d12 {
FILE: src/igl/d3d12/PlatformDevice.h
function namespace (line 13) | namespace igl::d3d12 {
FILE: src/igl/d3d12/RenderCommandEncoder.cpp
type igl::d3d12 (line 21) | namespace igl::d3d12 {
FILE: src/igl/d3d12/RenderCommandEncoder.h
function namespace (line 18) | namespace igl::d3d12 {
FILE: src/igl/d3d12/RenderPipelineState.cpp
type igl::d3d12 (line 19) | namespace igl::d3d12 {
type ReflectionImpl (line 191) | struct ReflectionImpl final : public IRenderPipelineReflection {
function ID3D12PipelineState (line 311) | ID3D12PipelineState* RenderPipelineState::getPipelineState(
FILE: src/igl/d3d12/RenderPipelineState.h
function namespace (line 15) | namespace igl::d3d12 {
function ID3D12PipelineState (line 75) | ID3D12PipelineState* getPipelineState() const {
function ID3D12RootSignature (line 93) | ID3D12RootSignature* getRootSignature() const {
function getVertexStride (line 99) | uint32_t getVertexStride(size_t slot) const {
FILE: src/igl/d3d12/SamplerState.cpp
type igl::d3d12 (line 12) | namespace igl::d3d12 {
FILE: src/igl/d3d12/SamplerState.h
function namespace (line 13) | namespace igl::d3d12 {
FILE: src/igl/d3d12/ShaderModule.cpp
type igl::d3d12 (line 13) | namespace igl::d3d12 {
function UINT (line 230) | UINT ShaderModule::getResourceBindPoint(const std::string& name) const {
FILE: src/igl/d3d12/ShaderModule.h
function namespace (line 17) | namespace igl::d3d12 {
FILE: src/igl/d3d12/Texture.cpp
type igl::d3d12 (line 19) | namespace igl::d3d12 {
function Result (line 177) | Result Texture::upload(const TextureRangeDesc& range, const void* data...
function Result (line 544) | Result Texture::uploadCube(const TextureRangeDesc& range,
function Result (line 565) | Result Texture::uploadInternal(TextureType type,
function Dimensions (line 579) | Dimensions Texture::getDimensions() const {
function TextureType (line 587) | TextureType Texture::getType() const {
function TextureFormat (line 607) | TextureFormat Texture::getFormat() const {
function D3D12_RESOURCE_STATES (line 1444) | D3D12_RESOURCE_STATES Texture::getSubresourceState(uint32_t mipLevel, ...
FILE: src/igl/d3d12/Texture.h
function namespace (line 14) | namespace igl::d3d12 {
FILE: src/igl/d3d12/TextureCopyUtils.cpp
type igl::d3d12::TextureCopyUtils (line 20) | namespace igl::d3d12::TextureCopyUtils {
function Result (line 22) | Result executeCopyTextureToBuffer(D3D12Context& ctx,
FILE: src/igl/d3d12/TextureCopyUtils.h
type ID3D12Device (line 13) | struct ID3D12Device
type ID3D12CommandQueue (line 14) | struct ID3D12CommandQueue
type ID3D12Resource (line 15) | struct ID3D12Resource
function namespace (line 17) | namespace igl::d3d12 {
FILE: src/igl/d3d12/Timer.cpp
type igl::d3d12 (line 13) | namespace igl::d3d12 {
FILE: src/igl/d3d12/Timer.h
function namespace (line 14) | namespace igl::d3d12 {
FILE: src/igl/d3d12/UploadRingBuffer.cpp
type igl::d3d12 (line 12) | namespace igl::d3d12 {
FILE: src/igl/d3d12/UploadRingBuffer.h
function namespace (line 14) | namespace igl::d3d12 {
FILE: src/igl/d3d12/VertexInputState.h
function namespace (line 13) | namespace igl::d3d12 {
FILE: src/igl/glslang/GlslCompiler.cpp
type igl::glslang (line 15) | namespace igl::glslang {
function glslang_stage_t (line 17) | [[nodiscard]] glslang_stage_t getGLSLangShaderStage(ShaderStage stage)...
function logShaderSource (line 36) | void logShaderSource(const char* text) {
function initializeCompiler (line 75) | void initializeCompiler() noexcept {
function Result (line 79) | Result compileShader(ShaderStage stage,
function finalizeCompiler (line 150) | void finalizeCompiler() noexcept {
FILE: src/igl/glslang/GlslCompiler.h
function namespace (line 15) | namespace igl::glslang {
FILE: src/igl/glslang/GlslangHelpers.c
function glslangGetDefaultInput (line 10) | void glslangGetDefaultInput(const char* shaderCode,
function glslangGetDefaultResource (line 34) | void glslangGetDefaultResource(glslang_resource_t* resource) {
FILE: src/igl/metal/Buffer.h
function namespace (line 15) | namespace igl::metal {
FILE: src/igl/metal/BufferSynchronizationManager.h
function namespace (line 13) | namespace igl::metal {
FILE: src/igl/metal/ColorSpace.h
function namespace (line 12) | namespace igl::metal {
FILE: src/igl/metal/CommandBuffer.h
function namespace (line 14) | namespace igl::metal {
FILE: src/igl/metal/CommandQueue.h
function namespace (line 14) | namespace igl::metal {
FILE: src/igl/metal/ComputeCommandEncoder.h
function namespace (line 13) | namespace igl::metal {
FILE: src/igl/metal/ComputePipelineState.h
function namespace (line 15) | namespace igl::metal {
FILE: src/igl/metal/DepthStencilState.h
function namespace (line 13) | namespace igl::metal {
FILE: src/igl/metal/Device.h
function namespace (line 18) | namespace igl::metal {
FILE: src/igl/metal/DeviceFeatureSet.h
function namespace (line 13) | namespace igl::metal {
FILE: src/igl/metal/DeviceStatistics.h
function namespace (line 14) | namespace igl::metal {
FILE: src/igl/metal/Framebuffer.h
function namespace (line 14) | namespace igl::metal {
FILE: src/igl/metal/HWDevice.h
function namespace (line 19) | namespace igl::metal {
FILE: src/igl/metal/PlatformDevice.h
function namespace (line 20) | namespace igl {
FILE: src/igl/metal/RenderCommandEncoder.h
function namespace (line 18) | namespace igl::metal {
FILE: src/igl/metal/RenderPipelineState.h
function namespace (line 14) | namespace igl::metal {
FILE: src/igl/metal/Result.h
function namespace (line 13) | namespace igl::metal {
FILE: src/igl/metal/SamplerState.h
function namespace (line 13) | namespace igl::metal {
FILE: src/igl/metal/Shader.h
function namespace (line 15) | namespace igl::metal {
FILE: src/igl/metal/Texture.h
function Dimensions (line 47) | [[nodiscard]] Dimensions getDimensions() const override;
FILE: src/igl/metal/Timer.h
function namespace (line 12) | namespace igl::metal {
FILE: src/igl/metal/TimestampQueries.h
function namespace (line 18) | namespace igl::metal {
FILE: src/igl/metal/VertexInputState.h
function namespace (line 13) | namespace igl::metal {
FILE: src/igl/metal/ios/Device.h
function namespace (line 13) | namespace igl::metal::ios {
FILE: src/igl/metal/ios/Framebuffer.h
function namespace (line 13) | namespace igl::metal::ios {
FILE: src/igl/metal/macos/Device.h
function namespace (line 13) | namespace igl::metal::macos {
FILE: src/igl/metal/macos/Framebuffer.h
function namespace (line 12) | namespace igl::metal::macos {
FILE: src/igl/opengl/Buffer.cpp
type igl::opengl (line 13) | namespace igl::opengl {
function Result (line 122) | Result ArrayBuffer::upload(const void* data, const BufferRange& range) {
FILE: src/igl/opengl/Buffer.h
function namespace (line 15) | namespace igl {
FILE: src/igl/opengl/CommandBuffer.cpp
type igl::opengl (line 15) | namespace igl::opengl {
function IContext (line 99) | IContext& CommandBuffer::getContext() const {
FILE: src/igl/opengl/CommandBuffer.h
function namespace (line 12) | namespace igl::opengl {
FILE: src/igl/opengl/CommandQueue.cpp
type igl::opengl (line 14) | namespace igl::opengl {
function SubmitHandle (line 37) | SubmitHandle CommandQueue::submit(const ICommandBuffer& commandBuffer,...
FILE: src/igl/opengl/CommandQueue.h
function namespace (line 12) | namespace igl::opengl {
FILE: src/igl/opengl/ComputeCommandAdapter.cpp
type igl::opengl (line 20) | namespace igl::opengl {
FILE: src/igl/opengl/ComputeCommandAdapter.h
function namespace (line 19) | namespace igl {
FILE: src/igl/opengl/ComputeCommandEncoder.cpp
type igl::opengl (line 18) | namespace igl::opengl {
FILE: src/igl/opengl/ComputeCommandEncoder.h
function namespace (line 16) | namespace igl {
FILE: src/igl/opengl/ComputePipelineState.cpp
type igl::opengl (line 14) | namespace igl::opengl {
function Result (line 18) | Result ComputePipelineState::create(const ComputePipelineDesc& desc) {
function Result (line 99) | Result ComputePipelineState::bindTextureUnit(const size_t unit, Textur...
function Result (line 119) | Result ComputePipelineState::bindBuffer(const size_t unit, Buffer* buf...
FILE: src/igl/opengl/ComputePipelineState.h
function namespace (line 17) | namespace igl::opengl {
FILE: src/igl/opengl/DepthStencilState.cpp
type igl::opengl (line 10) | namespace igl::opengl {
function Result (line 14) | Result DepthStencilState::create(const DepthStencilStateDesc& desc) {
function GLenum (line 20) | GLenum DepthStencilState::convertCompareFunction(CompareFunction value) {
function GLenum (line 42) | GLenum DepthStencilState::convertStencilOperation(StencilOperation val...
FILE: src/igl/opengl/DepthStencilState.h
function namespace (line 15) | namespace igl {
FILE: src/igl/opengl/DestructionGuard.cpp
type igl::opengl (line 12) | namespace igl::opengl {
FILE: src/igl/opengl/DestructionGuard.h
function namespace (line 12) | namespace igl::opengl {
FILE: src/igl/opengl/Device.cpp
type igl::opengl (line 29) | namespace igl::opengl {
function allocateBuffer (line 32) | std::unique_ptr<Buffer> allocateBuffer(BufferDesc::BufferType bufferType,
function Ptr (line 57) | Ptr verifyResult(Ptr resource, Result inResult, Result* outResult) noe...
function Ptr (line 71) | Ptr createResource(const Desc& desc, Result* outResult, Params&&... co...
function createSharedResource (line 83) | std::shared_ptr<T> createSharedResource(const Desc& desc,
function createUniqueResource (line 91) | std::unique_ptr<T> createUniqueResource(const Desc& desc,
function ShaderVersion (line 313) | ShaderVersion Device::getShaderVersion() const {
function BackendVersion (line 318) | BackendVersion Device::getBackendVersion() const {
function noexcept (line 401) | const noexcept {
FILE: src/igl/opengl/Device.h
function namespace (line 16) | namespace igl::opengl {
FILE: src/igl/opengl/DeviceFeatureSet.cpp
type igl::opengl (line 14) | namespace igl::opengl {
function hasVersion (line 16) | bool hasVersion(const DeviceFeatureSet& dfs, bool usesOpenGLES, GLVers...
function hasVersionOrExtension (line 21) | bool hasVersionOrExtension(const DeviceFeatureSet& dfs,
function hasDesktopVersion (line 28) | bool hasDesktopVersion(const DeviceFeatureSet& dfs, GLVersion minSuppo...
function hasESVersion (line 32) | bool hasESVersion(const DeviceFeatureSet& dfs, GLVersion minSupportedV...
function hasESExtension (line 36) | bool hasESExtension(const DeviceFeatureSet& dfs, const char* extension) {
function hasDesktopExtension (line 40) | bool hasDesktopExtension(const DeviceFeatureSet& dfs, const char* exte...
function hasDesktopOrESVersion (line 44) | bool hasDesktopOrESVersion(const DeviceFeatureSet& dfs,
function hasDesktopVersionOrExtension (line 51) | bool hasDesktopVersionOrExtension(const DeviceFeatureSet& dfs,
function hasESVersionOrExtension (line 57) | bool hasESVersionOrExtension(const DeviceFeatureSet& dfs,
function hasDesktopOrESVersionOrExtension (line 63) | bool hasDesktopOrESVersionOrExtension(const DeviceFeatureSet& dfs,
function hasDesktopOrESVersionOrExtension (line 72) | bool hasDesktopOrESVersionOrExtension(const DeviceFeatureSet& dfs,
function hasDesktopOrESExtension (line 80) | bool hasDesktopOrESExtension(const DeviceFeatureSet& dfs,
function hasDesktopOrESExtension (line 87) | bool hasDesktopOrESExtension(const DeviceFeatureSet& dfs, const char* ...
function GLVersion (line 112) | GLVersion DeviceFeatureSet::getGLVersion() const noexcept {
function ShaderVersion (line 116) | ShaderVersion DeviceFeatureSet::getShaderVersion() const {
function BackendVersion (line 120) | BackendVersion DeviceFeatureSet::getBackendVersion() const {
FILE: src/igl/opengl/DeviceFeatureSet.h
type class (line 22) | enum class
type class (line 67) | enum class
type class (line 97) | enum class
type class (line 162) | enum class
FILE: src/igl/opengl/DummyTexture.h
function namespace (line 14) | namespace igl::opengl {
FILE: src/igl/opengl/Framebuffer.cpp
type std (line 21) | namespace std {
function string (line 25) | string to_string(const T& t) {
type igl::opengl (line 35) | namespace igl::opengl {
function Result (line 39) | Result checkFramebufferStatus(IContext& context, bool read) {
function toAttachmentParams (line 73) | Texture::AttachmentParams toAttachmentParams(const RenderPassDesc::Att...
function defaultWriteAttachmentParams (line 84) | Texture::AttachmentParams defaultWriteAttachmentParams(FramebufferMode...
function toReadAttachmentParams (line 94) | Texture::AttachmentParams toReadAttachmentParams(const TextureRangeDes...
function FramebufferMode (line 461) | FramebufferMode CustomFramebuffer::getMode() const {
function Viewport (line 669) | Viewport CustomFramebuffer::getViewport() const {
function Viewport (line 882) | Viewport CurrentFramebuffer::getViewport() const {
function FramebufferMode (line 928) | FramebufferMode CurrentFramebuffer::getMode() const {
FILE: src/igl/opengl/Framebuffer.h
function class (line 23) | class FramebufferBindingGuard {
function virtual (line 40) | virtual Viewport getViewport() const = 0;
function isSwapchainBound (line 74) | [[nodiscard]] bool isSwapchainBound() const override;
FILE: src/igl/opengl/FramebufferWrapper.h
function namespace (line 13) | namespace igl::opengl {
FILE: src/igl/opengl/GLFunc.cpp
function glQueryCounterEXT (line 32) | void glQueryCounterEXT(GLuint, GLenum) {}
function iglDebugMessageCallback (line 214) | void iglDebugMessageCallback(PFNIGLDEBUGPROC callback, const void* userP...
function iglDebugMessageInsert (line 222) | void iglDebugMessageInsert(GLenum source,
function iglCompressedTexImage3D (line 248) | void iglCompressedTexImage3D(GLenum target,
function iglCompressedTexSubImage3D (line 271) | void iglCompressedTexSubImage3D(GLenum target,
function iglDrawBuffers (line 298) | void iglDrawBuffers(GLsizei n, const GLenum* bufs) {
function GLuint (line 302) | GLuint iglGetDebugMessageLog(GLuint count,
function GLubyte (line 324) | const GLubyte* iglGetStringi(GLenum name, GLuint index) {
function iglObjectLabel (line 334) | void iglObjectLabel(GLenum identifier, GLuint name, GLsizei length, cons...
function iglPopDebugGroup (line 344) | void iglPopDebugGroup() {
function iglPushDebugGroup (line 348) | void iglPushDebugGroup(GLenum source, GLuint id, GLsizei length, const G...
function iglTexImage3D (line 358) | void iglTexImage3D(GLenum target,
function iglTexSubImage3D (line 383) | void iglTexSubImage3D(GLenum target,
function iglUnmapBuffer (line 410) | void iglUnmapBuffer(GLenum target) {
function iglVertexAttribDivisor (line 414) | void iglVertexAttribDivisor(GLuint index, GLuint divisor) {
function iglDrawElementsInstanced (line 422) | void iglDrawElementsInstanced(GLenum mode,
function iglDrawArraysInstanced (line 437) | void iglDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLs...
function iglRenderbufferStorageMultisampleAPPLE (line 456) | void iglRenderbufferStorageMultisampleAPPLE(GLenum target,
function iglDeleteSyncAPPLE (line 484) | void iglDeleteSyncAPPLE(GLsync sync) {
function GLsync (line 489) | GLsync iglFenceSyncAPPLE(GLenum condition, GLbitfield flags) {
function iglGetSyncivAPPLE (line 494) | void iglGetSyncivAPPLE(GLsync sync, GLenum pname, GLsizei bufSize, GLsiz...
function GLuint64 (line 518) | GLuint64 iglGetTextureHandleARB(GLuint texture) {
function iglMakeTextureHandleResidentARB (line 526) | void iglMakeTextureHandleResidentARB(GLuint64 handle) {
function iglMakeTextureHandleNonResidentARB (line 533) | void iglMakeTextureHandleNonResidentARB(GLuint64 handle) {
function iglDispatchCompute (line 549) | void iglDispatchCompute(GLuint numGroupsX, GLuint numGroupsY, GLuint num...
function iglDrawElementsIndirect (line 569) | void iglDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid* ind...
function iglDrawArraysIndirect (line 578) | void iglDrawArraysIndirect(GLenum mode, const GLvoid* indirect) {
function iglMultiDrawArraysIndirect (line 597) | void iglMultiDrawArraysIndirect(GLenum mode,
function iglMultiDrawElementsIndirect (line 610) | void iglMultiDrawElementsIndirect(GLenum mode,
function iglBindFramebuffer (line 684) | void iglBindFramebuffer(GLenum target, GLuint framebuffer) {
function iglBindRenderbuffer (line 692) | void iglBindRenderbuffer(GLenum target, GLuint renderbuffer) {
function iglBlitFramebuffer (line 700) | void iglBlitFramebuffer(GLint srcX0,
function GLenum (line 725) | GLenum iglCheckFramebufferStatus(GLenum target) {
function iglDeleteFramebuffers (line 733) | void iglDeleteFramebuffers(GLsizei n, const GLuint* framebuffers) {
function iglDeleteRenderbuffers (line 741) | void iglDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) {
function iglFramebufferRenderbuffer (line 749) | void iglFramebufferRenderbuffer(GLenum target,
function iglFramebufferTexture2D (line 762) | void iglFramebufferTexture2D(GLenum target,
function iglFramebufferTextureLayer (line 777) | void iglFramebufferTextureLayer(GLenum target,
function iglGenerateMipmap (line 792) | void iglGenerateMipmap(GLenum target) {
function iglGenFramebuffers (line 797) | void iglGenFramebuffers(GLsizei n, GLuint* framebuffers) {
function iglGenRenderbuffers (line 802) | void iglGenRenderbuffers(GLsizei n, GLuint* renderbuffers) {
function iglGetFramebufferAttachmentParameteriv (line 810) | void iglGetFramebufferAttachmentParameteriv(GLenum target,
function iglGetRenderbufferParameteriv (line 823) | void iglGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* p...
function GLboolean (line 832) | GLboolean iglIsFramebuffer(GLuint framebuffer) {
function GLboolean (line 837) | GLboolean iglIsRenderbuffer(GLuint renderbuffer) {
function iglRenderbufferStorage (line 845) | void iglRenderbufferStorage(GLenum target, GLenum internalformat, GLsize...
function iglInvalidateFramebuffer (line 877) | void iglInvalidateFramebuffer(GLenum target, GLsizei numAttachments, con...
function iglGetProgramInterfaceiv (line 921) | void iglGetProgramInterfaceiv(GLuint program,
function GLuint (line 934) | GLuint iglGetProgramResourceIndex(GLuint program, GLenum programInterfac...
function iglBindImageTexture (line 991) | void iglBindImageTexture(GLuint unit,
function iglMemoryBarrier (line 1010) | void iglMemoryBarrier(GLbitfield barriers) {
function iglDeleteSync (line 1028) | void iglDeleteSync(GLsync sync) {
function GLsync (line 1032) | GLsync iglFenceSync(GLenum condition, GLbitfield flags) {
function iglGetSynciv (line 1037) | void iglGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* l...
function iglTexStorage1D (line 1059) | void iglTexStorage1D(GLenum target, GLsizei levels, GLenum internalforma...
function iglTexStorage2D (line 1069) | void iglTexStorage2D(GLenum target,
function iglTexStorage3D (line 1084) | void iglTexStorage3D(GLenum target,
function iglBindBufferBase (line 1122) | void iglBindBufferBase(GLenum target, GLuint index, GLuint buffer) {
function iglBindBufferRange (line 1127) | void iglBindBufferRange(GLenum target,
function iglGetActiveUniformsiv (line 1142) | void iglGetActiveUniformsiv(GLuint program,
function iglGetActiveUniformBlockiv (line 1157) | void iglGetActiveUniformBlockiv(GLuint program, GLuint index, GLenum pna...
function iglGetActiveUniformBlockName (line 1167) | void iglGetActiveUniformBlockName(GLuint program,
function GLuint (line 1182) | GLuint iglGetUniformBlockIndex(GLuint program, const GLchar* name) {
function iglUniformBlockBinding (line 1191) | void iglUniformBlockBinding(GLuint pid, GLuint uniformBlockIndex, GLuint...
function iglBindVertexArray (line 1213) | void iglBindVertexArray(GLuint vao) {
function iglDeleteVertexArrays (line 1218) | void iglDeleteVertexArrays(GLsizei n, const GLuint* vertexArrays) {
function iglGenVertexArrays (line 1226) | void iglGenVertexArrays(GLsizei n, GLuint* vertexArrays) {
function iglPolygonOffsetClamp (line 1240) | void iglPolygonOffsetClamp(float factor, float units, float clamp) {
function iglLabelObjectEXT (line 1258) | void iglLabelObjectEXT(GLenum identifier, GLuint name, GLsizei length, c...
function iglInsertEventMarkerEXT (line 1281) | void iglInsertEventMarkerEXT(GLenum /*source*/,
function iglPopGroupMarkerEXT (line 1294) | void iglPopGroupMarkerEXT() {
function iglPushGroupMarkerEXT (line 1299) | void iglPushGroupMarkerEXT(GLenum /*source*/,
function iglDiscardFramebufferEXT (line 1319) | void iglDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, con...
function iglDrawBuffersEXT (line 1337) | void iglDrawBuffersEXT(GLsizei n, const GLenum* bufs) {
function iglBlitFramebufferEXT (line 1351) | void iglBlitFramebufferEXT(GLint srcX0,
function iglCreateMemoryObjectsEXT (line 1411) | void iglCreateMemoryObjectsEXT(GLsizei n, GLuint* memoryObjects) {
function iglDeleteMemoryObjectsEXT (line 1419) | void iglDeleteMemoryObjectsEXT(GLsizei n, const GLuint* memoryObjects) {
function iglTexStorageMem2DEXT (line 1427) | void iglTexStorageMem2DEXT(GLenum target,
function iglTexStorageMem3DEXT (line 1446) | void iglTexStorageMem3DEXT(GLenum target,
function iglImportMemoryFdEXT (line 1476) | void iglImportMemoryFdEXT(GLuint memory, GLuint64 size, GLenum handleTyp...
function iglBindImageTextureEXT (line 1538) | void iglBindImageTextureEXT(GLuint unit,
function iglMemoryBarrierEXT (line 1557) | void iglMemoryBarrierEXT(GLbitfield barriers) {
function iglDebugMessageCallbackKHR (line 1694) | void iglDebugMessageCallbackKHR(PFNIGLDEBUGPROC callback, const void* us...
function iglDebugMessageInsertKHR (line 1702) | void iglDebugMessageInsertKHR(GLenum source,
function GLuint (line 1719) | GLuint iglGetDebugMessageLogKHR(GLuint count,
function iglObjectLabelKHR (line 1741) | void iglObjectLabelKHR(GLenum identifier, GLuint name, GLsizei length, c...
function iglPopDebugGroupKHR (line 1751) | void iglPopDebugGroupKHR() {
function iglPushDebugGroupKHR (line 1754) | void iglPushDebugGroupKHR(GLenum source, GLuint id, GLsizei length, cons...
function GLuint64 (line 1777) | GLuint64 iglGetTextureHandleNV(GLuint texture) {
function iglMakeTextureHandleResidentNV (line 1785) | void iglMakeTextureHandleResidentNV(GLuint64 handle) {
function iglMakeTextureHandleNonResidentNV (line 1792) | void iglMakeTextureHandleNonResidentNV(GLuint64 handle) {
function iglVertexAttribDivisorNV (line 1808) | void iglVertexAttribDivisorNV(GLuint index, GLuint divisor) {
function iglUnmapBufferOES (line 1883) | void iglUnmapBufferOES(GLenum target) {
function iglCompressedTexImage3DOES (line 1903) | void iglCompressedTexImage3DOES(GLenum target,
function iglCompressedTexSubImage3DOES (line 1926) | void iglCompressedTexSubImage3DOES(GLenum target,
function iglTexImage3DOES (line 1953) | void iglTexImage3DOES(GLenum target,
function iglTexSubImage3DOES (line 1978) | void iglTexSubImage3DOES(GLenum target,
function iglBindVertexArrayOES (line 2018) | void iglBindVertexArrayOES(GLuint vao) {
function iglDeleteVertexArraysOES (line 2023) | void iglDeleteVertexArraysOES(GLsizei n, const GLuint* vertexArrays) {
function iglGenVertexArraysOES (line 2031) | void iglGenVertexArraysOES(GLsizei n, GLuint* vertexArrays) {
function iglBeginQuery (line 2060) | void iglBeginQuery(GLenum target, GLuint id) {
function iglDeleteQueries (line 2068) | void iglDeleteQueries(GLsizei n, GLuint* queries) {
function iglEndQuery (line 2078) | void iglEndQuery(GLenum target) {
function iglGenQueries (line 2086) | void iglGenQueries(GLsizei n, GLuint* queries) {
function iglGetQueryObjectiv (line 2094) | void iglGetQueryObjectiv(GLuint id, GLenum pname, GLint* params) {
function iglGetQueryObjectui64v (line 2112) | void iglGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64* params) {
function iglQueryCounter (line 2130) | void iglQueryCounter(GLuint id, GLenum target) {
FILE: src/igl/opengl/HWDevice.cpp
type igl::opengl (line 12) | namespace igl::opengl {
FILE: src/igl/opengl/HWDevice.h
function namespace (line 31) | namespace igl::opengl {
FILE: src/igl/opengl/IContext.cpp
function logSourceChunk (line 39) | uint32_t logSourceChunk(uint32_t line, const char* string, size_t length) {
function logSource (line 61) | void logSource(const int count, const char** string, const int* length) {
function GLboolToString (line 146) | std::string GLboolToString(GLboolean val) {
function GLenumToString (line 150) | std::string GLenumToString(GLenum code) {
function clearBitsToString (line 593) | std::string clearBitsToString(GLbitfield bits) {
function mapBufferRangeBitsToString (line 611) | std::string mapBufferRangeBitsToString(GLbitfield bits) {
function memoryBarrierBitsToString (line 649) | std::string memoryBarrierBitsToString(GLbitfield bits) {
function isTextureUniform (line 722) | bool isTextureUniform(GLenum type) {
function isTextureImageUniform (line 737) | bool isTextureImageUniform(GLenum type) {
function logDebugMessage (line 797) | void logDebugMessage(GLenum source,
function logOpenGlDebugMessage (line 816) | void logOpenGlDebugMessage(GLenum source,
type igl::opengl (line 831) | namespace igl::opengl {
function GLerrorToCode (line 848) | Result::Code GLerrorToCode(GLenum error) {
function GLuint (line 917) | GLuint IContext::boundTexture(GLenum target) const {
function GLuint (line 977) | GLuint IContext::boundBuffer(GLenum target) const {
function GLuint (line 1022) | GLuint IContext::boundFramebuffer(GLenum target) const {
function GLuint (line 1109) | GLuint IContext::framebufferAttachment(GLenum target, GLenum attachmen...
function GLuint (line 1135) | GLuint IContext::framebufferAttachment(GLenum target, GLenum buffer, G...
function GLuint (line 1161) | GLuint IContext::framebufferReadBuffer(GLenum target) const {
function GLuint (line 1444) | GLuint IContext::boundBufferByIndex(GLenum target, GLuint index) const {
function GLenum (line 1821) | GLenum IContext::checkFramebufferStatus(GLenum target) {
function GLuint (line 2106) | GLuint IContext::createProgram() {
function GLuint (line 2125) | GLuint IContext::createShader(GLenum shaderType) {
function GLsync (line 2632) | GLsync IContext::fenceSync(GLenum condition, GLbitfield flags) {
function GLint (line 3011) | GLint IContext::getAttribLocation(GLuint program, const GLchar* name) ...
function GLenum (line 3044) | GLenum IContext::getError() const {
function GLuint (line 3050) | GLuint IContext::getDebugMessageLog(GLuint count,
function GLuint (line 3169) | GLuint IContext::getProgramResourceIndex(GLuint program,
function GLubyte (line 3278) | const GLubyte* IContext::getString(GLenum name) const {
function GLubyte (line 3289) | const GLubyte* IContext::getStringi(GLenum name, GLuint index) const {
function GLint (line 3343) | GLint IContext::getUniformLocation(GLuint program, const GLchar* name)...
function GLboolean (line 3389) | GLboolean IContext::isEnabled(GLenum cap) {
function GLboolean (line 3400) | GLboolean IContext::isTexture(GLuint texture) {
function GLuint64 (line 4357) | GLuint64 IContext::getTextureHandle(GLuint texture) {
function Result (line 4487) | Result IContext::getLastError() const {
function GLenum (line 4491) | GLenum IContext::checkForErrors(IGL_MAYBE_UNUSED const char* callerName,
function UnbindPolicy (line 4567) | UnbindPolicy IContext::getUnbindPolicy() const {
function DeviceFeatureSet (line 4662) | const DeviceFeatureSet& IContext::deviceFeatures() const {
FILE: src/igl/opengl/IContext.h
function namespace (line 29) | namespace igl::opengl {
type FramebufferAttachment (line 648) | struct FramebufferAttachment {
type ProgramUniform (line 670) | struct ProgramUniform {
type SynchronizedDeletionQueues (line 743) | struct SynchronizedDeletionQueues {
FILE: src/igl/opengl/PlatformDevice.cpp
type igl::opengl (line 16) | namespace igl::opengl {
function DestructionGuard (line 55) | DestructionGuard PlatformDevice::getDestructionGuard() const {
function IContext (line 59) | IContext& PlatformDevice::getContext() const {
FILE: src/igl/opengl/PlatformDevice.h
function namespace (line 15) | namespace igl {
FILE: src/igl/opengl/RenderCommandAdapter.cpp
type igl::opengl (line 29) | namespace igl::opengl {
function GLenum (line 480) | GLenum RenderCommandAdapter::toMockWireframeMode(GLenum mode) const {
FILE: src/igl/opengl/RenderCommandAdapter.h
function namespace (line 19) | namespace igl {
FILE: src/igl/opengl/RenderCommandEncoder.cpp
type igl::opengl (line 22) | namespace igl::opengl {
function GLenum (line 25) | GLenum toGlPrimitive(PrimitiveType primitiveType) {
function GLenum (line 46) | GLenum toGlType(IndexFormat format) {
function getIndexByteSize (line 58) | uint8_t getIndexByteSize(GLenum indexType) {
FILE: src/igl/opengl/RenderCommandEncoder.h
function namespace (line 18) | namespace igl {
FILE: src/igl/opengl/RenderPipelineReflection.cpp
function toIGLUniformType (line 15) | igl::UniformType toIGLUniformType(GLenum type) {
function toIGLTextureType (line 47) | igl::TextureType toIGLTextureType(GLenum type) {
type igl::opengl (line 83) | namespace igl::opengl {
FILE: src/igl/opengl/RenderPipelineReflection.h
function namespace (line 16) | namespace igl::opengl {
FILE: src/igl/opengl/RenderPipelineState.cpp
type igl::opengl (line 13) | namespace igl::opengl {
function logBlendFactorError (line 17) | void logBlendFactorError(IGL_MAYBE_UNUSED const char* value) {
function GLenum (line 37) | GLenum RenderPipelineState::convertBlendOp(BlendOp value) {
function GLenum (line 54) | GLenum RenderPipelineState::convertBlendFactor(BlendFactor value) {
function Result (line 102) | Result RenderPipelineState::create() {
function Result (line 342) | Result RenderPipelineState::bindTextureUnit(const size_t unit,
FILE: src/igl/opengl/RenderPipelineState.h
function namespace (line 19) | namespace igl::opengl {
FILE: src/igl/opengl/SamplerState.cpp
type igl::opengl (line 15) | namespace igl::opengl {
function isPowerOfTwo (line 17) | bool isPowerOfTwo(size_t number) {
function GLint (line 134) | GLint SamplerState::convertMinMipFilter(SamplerMinMagFilter minFilter,...
function GLint (line 151) | GLint SamplerState::convertMagFilter(SamplerMinMagFilter magFilter) {
function SamplerMinMagFilter (line 155) | SamplerMinMagFilter SamplerState::convertGLMagFilter(GLint glMagFilter) {
function SamplerMinMagFilter (line 159) | SamplerMinMagFilter SamplerState::convertGLMinFilter(GLint glMinFilter) {
function SamplerMipFilter (line 180) | SamplerMipFilter SamplerState::convertGLMipFilter(GLint glMinFilter) {
function GLint (line 201) | GLint SamplerState::convertAddressMode(SamplerAddressMode addressMode) {
function SamplerAddressMode (line 216) | SamplerAddressMode SamplerState::convertGLAddressMode(GLint glAddressM...
FILE: src/igl/opengl/SamplerState.h
function namespace (line 14) | namespace igl::opengl {
FILE: src/igl/opengl/Shader.cpp
type igl::opengl (line 21) | namespace igl::opengl {
function Result (line 153) | Result ShaderStages::create(const ShaderStagesDesc& /*desc*/) {
function Result (line 166) | Result ShaderStages::validate() const {
function Result (line 198) | Result ShaderModule::create(const ShaderModuleDesc& desc) {
FILE: src/igl/opengl/Shader.h
function namespace (line 16) | namespace igl {
FILE: src/igl/opengl/Texture.cpp
type igl::opengl (line 13) | namespace igl::opengl {
function Dimensions (line 15) | Dimensions Texture::getDimensions() const {
function Result (line 70) | Result Texture::create(const TextureDesc& desc, bool hasStorageAlready) {
function GLint (line 120) | GLint Texture::getAlignment(uint32_t stride, uint32_t mipLevel, uint32...
function GLenum (line 154) | GLenum Texture::toGLTarget(TextureType type) const {
function TextureFormat (line 189) | TextureFormat Texture::glInternalFormatToTextureFormat(GLuint glTexInt...
FILE: src/igl/opengl/Texture.h
function namespace (line 14) | namespace igl {
FILE: src/igl/opengl/TextureBuffer.cpp
type igl::opengl (line 13) | namespace igl::opengl {
function swapTextureChannelsForFormat (line 24) | void swapTextureChannelsForFormat(IContext& context, GLuint target, Te...
function Result (line 60) | Result TextureBuffer::create(const TextureDesc& desc, bool hasStorageA...
function Result (line 92) | Result TextureBuffer::createTexture(const TextureDesc& desc) {
function Result (line 138) | Result TextureBuffer::initialize(const std::string& debugName) const {
function Result (line 169) | Result TextureBuffer::initializeWithUpload() const {
function Result (line 175) | Result TextureBuffer::initializeWithTexStorage() const {
function Result (line 212) | Result TextureBuffer::upload2D(GLenum target,
function Result (line 268) | Result TextureBuffer::upload2DArray(GLenum target,
function Result (line 329) | Result TextureBuffer::upload3D(GLenum target,
function Result (line 423) | Result TextureBuffer::uploadInternal(TextureType /*type*/,
function Result (line 443) | Result TextureBuffer::uploadInternal(GLenum target,
FILE: src/igl/opengl/TextureBuffer.h
function namespace (line 12) | namespace igl::opengl {
FILE: src/igl/opengl/TextureBufferBase.cpp
type igl::opengl (line 10) | namespace igl::opengl {
function TextureType (line 12) | TextureType TextureBufferBase::getType() const {
FILE: src/igl/opengl/TextureBufferBase.h
function namespace (line 12) | namespace igl::opengl {
FILE: src/igl/opengl/TextureBufferExternal.cpp
type igl::opengl (line 10) | namespace igl::opengl {
FILE: src/igl/opengl/TextureBufferExternal.h
function namespace (line 12) | namespace igl::opengl {
FILE: src/igl/opengl/TextureTarget.cpp
type igl::opengl (line 10) | namespace igl::opengl {
function TextureType (line 18) | TextureType TextureTarget::getType() const {
function Result (line 31) | Result TextureTarget::create(const TextureDesc& desc, bool hasStorageA...
function Result (line 44) | Result TextureTarget::createRenderBuffer(const TextureDesc& desc, bool...
FILE: src/igl/opengl/TextureTarget.h
function namespace (line 12) | namespace igl::opengl {
FILE: src/igl/opengl/Timer.cpp
type igl::opengl (line 12) | namespace igl::opengl {
FILE: src/igl/opengl/Timer.h
function namespace (line 15) | namespace igl::opengl {
FILE: src/igl/opengl/TimestampQueries.cpp
type igl::opengl (line 24) | namespace igl::opengl {
FILE: src/igl/opengl/TimestampQueries.h
function namespace (line 16) | namespace igl::opengl {
FILE: src/igl/opengl/UnbindPolicy.h
function namespace (line 10) | namespace igl::opengl {
FILE: src/igl/opengl/UniformAdapter.cpp
type igl::opengl (line 13) | namespace igl::opengl {
FILE: src/igl/opengl/UniformAdapter.h
function namespace (line 16) | namespace igl::opengl {
FILE: src/igl/opengl/UniformBuffer.cpp
type igl::opengl (line 15) | namespace igl::opengl {
type UniformBaseType (line 20) | enum class UniformBaseType { Invalid = 0, Boolean, Int, Float, FloatMa...
function Result (line 77) | Result UniformBuffer::upload(const void* data, const BufferRange& rang...
FILE: src/igl/opengl/UniformBuffer.h
function namespace (line 15) | namespace igl {
FILE: src/igl/opengl/Version.cpp
type igl::opengl (line 14) | namespace igl::opengl {
function highestSupportedVersion (line 17) | std::pair<uint32_t, uint32_t> highestSupportedVersion() {
function constrainVersion (line 68) | std::pair<uint32_t, uint32_t> constrainVersion(uint32_t majorVersion, ...
function GLVersion (line 79) | GLVersion getGLVersionEnum(uint32_t majorVersion, uint32_t minorVersio...
function parseVersionString (line 166) | std::pair<uint32_t, uint32_t> parseVersionString(const char* version) {
function GLVersion (line 192) | GLVersion getGLVersion(const char* version, bool constrain) {
function ShaderVersion (line 226) | ShaderVersion getShaderVersion(GLVersion version) {
function getStringFromShaderVersion (line 271) | std::string getStringFromShaderVersion(ShaderVersion version) {
FILE: src/igl/opengl/Version.h
function namespace (line 15) | namespace igl::opengl {
FILE: src/igl/opengl/VertexArrayObject.cpp
type igl::opengl (line 13) | namespace igl::opengl {
function Result (line 15) | Result VertexArrayObject::create() {
FILE: src/igl/opengl/VertexArrayObject.h
function namespace (line 13) | namespace igl {
FILE: src/igl/opengl/VertexInputState.cpp
type igl::opengl (line 14) | namespace igl::opengl {
function toOGLAttribute (line 20) | static void toOGLAttribute(const VertexAttribute& attrib,
function Result (line 326) | Result VertexInputState::create(const VertexInputStateDesc& desc) {
FILE: src/igl/opengl/VertexInputState.h
function namespace (line 16) | namespace igl {
FILE: src/igl/opengl/ViewTextureTarget.cpp
type igl::opengl (line 10) | namespace igl::opengl {
function TextureType (line 12) | TextureType ViewTextureTarget::getType() const {
FILE: src/igl/opengl/ViewTextureTarget.h
function namespace (line 13) | namespace igl::opengl {
FILE: src/igl/opengl/WithContext.cpp
type igl::opengl (line 13) | namespace igl::opengl {
function IContext (line 30) | IContext& WithContext::getContext() const {
FILE: src/igl/opengl/WithContext.h
function namespace (line 12) | namespace igl::opengl {
FILE: src/igl/opengl/egl/Context.cpp
type error_checking (line 25) | namespace error_checking {
function EGLint (line 32) | static EGLint checkForEGLErrors(IGL_MAYBE_UNUSED const char* fileName,
type igl::opengl::egl (line 73) | namespace igl::opengl::egl {
function EGLDisplay (line 76) | EGLDisplay getDefaultEGLDisplay() {
function newEGLContext (line 129) | std::pair<EGLDisplay, EGLContext> newEGLContext(uint8_t contextMajorVe...
function EGLConfig (line 158) | EGLConfig chooseConfig(uint8_t contextMajorVersion, EGLDisplay display) {
function EGLSurface (line 423) | EGLSurface Context::createSurface(NativeWindowType window) {
function EGLContext (line 430) | EGLContext Context::get() const {
function EGLDisplay (line 434) | EGLDisplay Context::getDisplay() const {
function EGLSurface (line 438) | EGLSurface Context::getReadSurface() const {
function EGLSurface (line 442) | EGLSurface Context::getDrawSurface() const {
function EGLConfig (line 462) | EGLConfig Context::getConfig() const {
function EGLImageKHR (line 482) | EGLImageKHR Context::createImageFromAndroidHardwareBuffer(AHardwareBuf...
FILE: src/igl/opengl/egl/Context.h
function namespace (line 20) | namespace igl::opengl::egl {
FILE: src/igl/opengl/egl/Device.cpp
type igl::opengl::egl (line 14) | namespace igl::opengl::egl {
function PlatformDevice (line 20) | const PlatformDevice& Device::getPlatformDevice() const noexcept {
FILE: src/igl/opengl/egl/Device.h
function namespace (line 13) | namespace igl::opengl::egl {
FILE: src/igl/opengl/egl/HWDevice.cpp
type igl::opengl::egl (line 14) | namespace igl::opengl::egl {
FILE: src/igl/opengl/egl/HWDevice.h
function namespace (line 12) | namespace igl::opengl::egl {
FILE: src/igl/opengl/egl/PlatformDevice.cpp
type igl::opengl::egl (line 19) | namespace igl::opengl::egl {
function const (line 184) | std::shared_ptr<ITexture> PlatformDevice::createTextureWithSharedMemory(
function EGLSurface (line 231) | EGLSurface PlatformDevice::createSurface(NativeWindowType nativeWindow,
FILE: src/igl/opengl/egl/PlatformDevice.h
type AHardwareBuffer (line 15) | struct AHardwareBuffer
function namespace (line 18) | namespace igl::opengl {
FILE: src/igl/opengl/egl/android/NativeHWBuffer.cpp
type igl::opengl::egl::android (line 32) | namespace igl::opengl::egl::android {
type AHardwareBufferContext (line 34) | struct AHardwareBufferContext {
function Result (line 65) | Result NativeHWTextureBuffer::create(const TextureDesc& desc, bool has...
function Result (line 69) | Result NativeHWTextureBuffer::createTextureInternal(AHardwareBuffer* b...
function Result (line 162) | Result NativeHWTextureBuffer::uploadInternal(TextureType /*type*/,
FILE: src/igl/opengl/egl/android/NativeHWBuffer.h
function namespace (line 18) | namespace igl::opengl::egl::android {
FILE: src/igl/opengl/empty/Context.cpp
type igl::opengl::empty (line 12) | namespace igl::opengl::empty {
function GLenum (line 70) | GLenum Context::getError() const {
function GLenum (line 74) | GLenum Context::checkFramebufferStatus(GLenum /*target*/) {
function GLubyte (line 78) | const GLubyte* Context::getString(GLenum /*name*/) const {
FILE: src/igl/opengl/empty/Context.h
function namespace (line 12) | namespace igl::opengl::empty {
FILE: src/igl/opengl/empty/Device.cpp
type igl::opengl::empty (line 12) | namespace igl::opengl::empty {
function PlatformDevice (line 18) | const PlatformDevice& Device::getPlatformDevice() const noexcept {
FILE: src/igl/opengl/empty/Device.h
function namespace (line 13) | namespace igl::opengl::empty {
FILE: src/igl/opengl/empty/HWDevice.cpp
type igl::opengl::empty (line 13) | namespace igl::opengl::empty {
FILE: src/igl/opengl/empty/HWDevice.h
function namespace (line 12) | namespace igl::opengl::empty {
FILE: src/igl/opengl/glx/Context.cpp
function GetLastError (line 20) | [[maybe_unused]] int GetLastError() {
type igl::opengl::glx (line 26) | namespace igl::opengl::glx {
type __GLXFBConfig (line 35) | struct __GLXFBConfig
type GLXSharedModule (line 55) | struct GLXSharedModule {
method GLXSharedModule (line 56) | GLXSharedModule() {
method GLXSharedModule (line 97) | GLXSharedModule(const GLXSharedModule&) = delete;
method GLXSharedModule (line 98) | GLXSharedModule& operator=(const GLXSharedModule&) = delete;
method GLXSharedModule (line 99) | GLXSharedModule(GLXSharedModule&&) = delete;
method GLXSharedModule (line 100) | GLXSharedModule& operator=(GLXSharedModule&&) = delete;
method T (line 103) | T loadFunction(const char* func) {
method T (line 110) | T loadGlxFunction(const char* func) {
FILE: src/igl/opengl/glx/Context.h
function namespace (line 16) | namespace igl::opengl::glx {
FILE: src/igl/opengl/glx/Device.cpp
type igl::opengl::glx (line 10) | namespace igl::opengl::glx {
function PlatformDevice (line 16) | const PlatformDevice& Device::getPlatformDevice() const noexcept {
FILE: src/igl/opengl/glx/Device.h
function namespace (line 13) | namespace igl::opengl::glx {
FILE: src/igl/opengl/glx/HWDevice.cpp
type igl::opengl::glx (line 13) | namespace igl::opengl::glx {
FILE: src/igl/opengl/glx/HWDevice.h
function namespace (line 12) | namespace igl::opengl::glx {
FILE: src/igl/opengl/glx/PlatformDevice.cpp
type igl::opengl::glx (line 17) | namespace igl::opengl::glx {
FILE: src/igl/opengl/glx/PlatformDevice.h
function namespace (line 15) | namespace igl::opengl {
function namespace (line 19) | namespace igl::opengl::glx {
FILE: src/igl/opengl/ios/Context.h
function namespace (line 15) | namespace igl::opengl::ios {
FILE: src/igl/opengl/ios/Device.h
function namespace (line 13) | namespace igl::opengl::ios {
FILE: src/igl/opengl/ios/HWDevice.h
function namespace (line 13) | namespace igl::opengl::ios {
FILE: src/igl/opengl/ios/PlatformDevice.h
type CAEAGLLayer (line 15) | typedef void CAEAGLLayer;
function namespace (line 23) | namespace igl::opengl::ios {
FILE: src/igl/opengl/ios/TextureBuffer.h
function namespace (line 14) | namespace igl::opengl::ios {
FILE: src/igl/opengl/macos/Context.h
function namespace (line 17) | namespace igl::opengl::macos {
FILE: src/igl/opengl/macos/Device.h
function namespace (line 13) | namespace igl::opengl::macos {
FILE: src/igl/opengl/macos/HWDevice.h
function namespace (line 12) | namespace igl::opengl::macos {
FILE: src/igl/opengl/macos/PlatformDevice.h
function namespace (line 15) | namespace igl::opengl {
FILE: src/igl/opengl/macos/TextureBuffer.h
function namespace (line 14) | namespace igl::opengl::macos {
FILE: src/igl/opengl/util/TextureFormat.cpp
type igl::opengl::util (line 10) | namespace igl::opengl::util {
function TextureFormat (line 120) | TextureFormat glTextureFormatToTextureFormat(int32_t glInternalFormat,
FILE: src/igl/opengl/util/TextureFormat.h
function namespace (line 13) | namespace igl::opengl::util {
FILE: src/igl/opengl/webgl/Context.cpp
type igl::opengl::webgl (line 14) | namespace igl::opengl::webgl {
FILE: src/igl/opengl/webgl/Context.h
function namespace (line 20) | namespace igl {
FILE: src/igl/opengl/webgl/Device.cpp
type igl::opengl::webgl (line 15) | namespace igl::opengl::webgl {
function PlatformDevice (line 20) | const PlatformDevice& Device::getPlatformDevice() const noexcept {
FILE: src/igl/opengl/webgl/Device.h
function namespace (line 19) | namespace igl::opengl::webgl {
FILE: src/igl/opengl/webgl/HWDevice.cpp
type igl::opengl::webgl (line 15) | namespace igl::opengl::webgl {
FILE: src/igl/opengl/webgl/HWDevice.h
function namespace (line 18) | namespace igl::opengl::webgl {
FILE: src/igl/opengl/webgl/PlatformDevice.cpp
type igl::opengl::webgl (line 17) | namespace igl::opengl::webgl {
FILE: src/igl/opengl/webgl/PlatformDevice.h
function namespace (line 20) | namespace igl::opengl {
FILE: src/igl/opengl/wgl/Context.cpp
type igl::opengl::wgl (line 29) | namespace igl::opengl::wgl {
FILE: src/igl/opengl/wgl/Context.h
function namespace (line 17) | namespace igl {
FILE: src/igl/opengl/wgl/Device.cpp
type igl (line 13) | namespace igl {
type opengl (line 14) | namespace opengl {
type wgl (line 15) | namespace wgl {
function PlatformDevice (line 20) | const PlatformDevice& Device::getPlatformDevice() const noexcept {
FILE: src/igl/opengl/wgl/Device.h
function namespace (line 13) | namespace igl {
FILE: src/igl/opengl/wgl/HWDevice.cpp
type igl::opengl::wgl (line 13) | namespace igl::opengl::wgl {
FILE: src/igl/opengl/wgl/HWDevice.h
function namespace (line 12) | namespace igl::opengl::wgl {
FILE: src/igl/opengl/wgl/PlatformDevice.cpp
type igl (line 18) | namespace igl {
type opengl (line 19) | namespace opengl {
type wgl (line 20) | namespace wgl {
FILE: src/igl/opengl/wgl/PlatformDevice.h
function namespace (line 17) | namespace igl {
FILE: src/igl/tests/Assert.cpp
type igl::tests (line 16) | namespace igl::tests {
class AssertTest (line 22) | class AssertTest : public ::testing::Test {
method SetUp (line 24) | void SetUp() override {
method TearDown (line 42) | void TearDown() override {
function TEST_F (line 48) | TEST_F(AssertTest, DebugAbort) {
function TEST_F (line 105) | TEST_F(AssertTest, SoftError) {
FILE: src/igl/tests/Backend.cpp
type igl::tests (line 24) | namespace igl::tests {
class BackendTest (line 39) | class BackendTest : public ::testing::Test {
method BackendTest (line 42) | BackendTest() = default;
method SetUp (line 56) | void SetUp() override {
method TearDown (line 164) | void TearDown() override {}
function TEST_F (line 205) | TEST_F(BackendTest, DISABLED_CoordinateSystem) {
FILE: src/igl/tests/Blending.cpp
type igl::tests (line 25) | namespace igl::tests {
class BlendingTest (line 35) | class BlendingTest : public ::testing::Test {
method BlendingTest (line 38) | BlendingTest() = default;
method SetUp (line 52) | void SetUp() override {
method TearDown (line 176) | void TearDown() override {}
function TEST_F (line 212) | TEST_F(BlendingTest, RGBASrcAndDstAddTest) {
FILE: src/igl/tests/Buffer.cpp
type igl::tests (line 15) | namespace igl::tests {
class BufferTest (line 23) | class BufferTest : public ::testing::Test {
method BufferTest (line 25) | BufferTest() = default;
method SetUp (line 29) | void SetUp() override {
method TearDown (line 37) | void TearDown() override {}
function TEST_F (line 52) | TEST_F(BufferTest, sizeForUniformElementType) {
function TEST_F (line 81) | TEST_F(BufferTest, sizeForUniformType) {
function TEST_F (line 105) | TEST_F(BufferTest, createWithDebugLabel) {
function TEST_F (line 133) | TEST_F(BufferTest, mapIndexBuffer) {
function TEST_F (line 173) | TEST_F(BufferTest, mapBufferRangeIndexBuffer) {
function TEST_F (line 217) | TEST_F(BufferTest, copyBytesErrorsIndexBuffer) {
function TEST_F (line 253) | TEST_F(BufferTest, mapUniformBuffer) {
FILE: src/igl/tests/Color.cpp
type igl::tests (line 14) | namespace igl::tests {
function TEST (line 16) | TEST(ColorTest, ctor) {
function TEST (line 37) | TEST(sRGBColorTest, ctor) {
function TEST (line 52) | TEST(sRGBColorTest, toRGBA32) {
function TEST (line 57) | TEST(sRGBColorTest, fromRGBA32) {
FILE: src/igl/tests/ColorSpace.cpp
type igl::tests (line 12) | namespace igl::tests {
function TEST (line 14) | TEST(ColorSpaceTest, colorSpaceToString) {
FILE: src/igl/tests/CommandBuffer.cpp
type igl::tests (line 12) | namespace igl::tests {
class CommandBufferTest (line 24) | class CommandBufferTest : public ::testing::Test {
method CommandBufferTest (line 26) | CommandBufferTest() = default;
method SetUp (line 30) | void SetUp() override {
method TearDown (line 41) | void TearDown() override {}
function TEST_F (line 56) | TEST_F(CommandBufferTest, pushPopDebugGroupLabel) {
function TEST_F (line 62) | TEST_F(CommandBufferTest, debugName) {
FILE: src/igl/tests/Common.cpp
type igl::tests (line 14) | namespace igl::tests {
function TEST (line 16) | TEST(CommonTest, BackendTypeToStringTest) {
function TEST (line 24) | TEST(CommonTest, ResultTest) {
function TEST (line 44) | TEST(CommonTest, RectTest) {
function TEST (line 51) | TEST(CommonTest, SizeTest) {
function TEST (line 65) | TEST(CommonTest, DimensionTest) {
function TEST (line 81) | TEST(CommonTest, ViewportTest) {
function TEST (line 88) | TEST(CommonTest, EnumToValueTest) {
function TEST (line 93) | TEST(CommonTest, ScopeGuardTest) {
function TEST (line 101) | TEST(CommonTest, OptimizedMemCopyTest) {
function TEST (line 124) | TEST(CommonTest, HandleTest) {
function TEST (line 131) | TEST(CommonTest, PoolTest) {
FILE: src/igl/tests/ComputeCommandEncoder.cpp
type igl::tests (line 23) | namespace igl::tests {
class ComputeCommandEncoderTest (line 31) | class ComputeCommandEncoderTest : public ::testing::Test {
method ComputeCommandEncoderTest (line 34) | ComputeCommandEncoderTest() = default;
method SetUp (line 40) | void SetUp() override {
method encodeCompute (line 102) | void encodeCompute(const std::shared_ptr<ICommandBuffer>& cmdBuffer,
method TearDown (line 134) | void TearDown() override {}
function TEST_F (line 146) | TEST_F(ComputeCommandEncoderTest, canEncodeBasicBufferOperation) {
function TEST_F (line 181) | TEST_F(ComputeCommandEncoderTest, bindImageTexture) {
function TEST_F (line 196) | TEST_F(ComputeCommandEncoderTest, canUseOutputBufferFromOnePassAsInput...
function TEST_F (line 250) | TEST_F(ComputeCommandEncoderTest, bindSamplerState) {
function TEST_F (line 265) | TEST_F(ComputeCommandEncoderTest, copyBuffer) {
FILE: src/igl/tests/Device.cpp
type igl::tests (line 26) | namespace igl::tests {
class DeviceTest (line 35) | class DeviceTest : public ::testing::Test {
method DeviceTest (line 37) | DeviceTest() = default;
method SetUp (line 57) | void SetUp() override {
method TearDown (line 139) | void TearDown() override {}
function TEST_F (line 167) | TEST_F(DeviceTest, LastDrawStat) {
function TEST_F (line 206) | TEST_F(DeviceTest, InDevelopmentFeature) {
function TEST_F (line 221) | TEST_F(DeviceTest, GetBackendType) {
FILE: src/igl/tests/DeviceFeatureSet.cpp
type igl::tests (line 15) | namespace igl::tests {
class DeviceFeatureSetTest (line 20) | class DeviceFeatureSetTest : public ::testing::Test {
method DeviceFeatureSetTest (line 22) | DeviceFeatureSetTest() = default;
method SetUp (line 26) | void SetUp() override {
method TearDown (line 32) | void TearDown() override {}
function TEST_F (line 45) | TEST_F(DeviceFeatureSetTest, hasFeatureForMacOSOrWinOrAndroidTest) {
function TEST_F (line 304) | TEST_F(DeviceFeatureSetTest, getTextureFormatCapabilities) {
FILE: src/igl/tests/Framebuffer.cpp
type igl::tests (line 24) | namespace igl::tests {
class FramebufferTest (line 36) | class FramebufferTest : public ::testing::Test {
method FramebufferTest (line 39) | FramebufferTest() = default;
method SetUp (line 53) | void SetUp() override {
method TearDown (line 192) | void TearDown() override {}
function TEST_F (line 225) | TEST_F(FramebufferTest, Clear) {
function TEST_F (line 379) | TEST_F(FramebufferTest, blitFramebufferColor) {
function TEST_F (line 517) | TEST_F(FramebufferTest, DrawableUnbind) {
function TEST_F (line 548) | TEST_F(FramebufferTest, DrawableBindCount) {
function TEST_F (line 595) | TEST_F(FramebufferTest, UpdateDrawableWithDepthAndStencilTest) {
function TEST_F (line 642) | TEST_F(FramebufferTest, GetColorAttachmentTest) {
FILE: src/igl/tests/FramebufferInterop.cpp
type igl::tests (line 20) | namespace igl::tests {
class FramebufferInteropTest (line 22) | class FramebufferInteropTest : public ::testing::Test {
method FramebufferInteropTest (line 24) | FramebufferInteropTest() = default;
method SetUp (line 27) | void SetUp() override {
method TearDown (line 35) | void TearDown() override {}
function TEST_F (line 43) | TEST_F(FramebufferInteropTest, GetColorAttachment) {
function TEST_F (line 72) | TEST_F(FramebufferInteropTest, GetDepthAttachment) {
function TEST_F (line 119) | TEST_F(FramebufferInteropTest, GetNativeFramebuffer) {
function TEST_F (line 142) | TEST_F(FramebufferInteropTest, AttachmentGetNativeImage) {
function TEST_F (line 171) | TEST_F(FramebufferInteropTest, AttachmentDescProperties) {
function TEST_F (line 204) | TEST_F(FramebufferInteropTest, MultipleColorAttachments) {
function TEST_F (line 247) | TEST_F(FramebufferInteropTest, StereoFramebuffer) {
function TEST_F (line 280) | TEST_F(FramebufferInteropTest, MultipleFramebuffers) {
FILE: src/igl/tests/Hash.cpp
type igl::tests (line 19) | namespace igl::tests {
class TestShaderStages (line 21) | class TestShaderStages : public IShaderStages {
method TestShaderStages (line 23) | TestShaderStages() : IShaderStages(ShaderStagesDesc{}) {}
class HashTest (line 32) | class HashTest : public ::testing::Test {
method HashTest (line 34) | HashTest() = default;
method SetUp (line 39) | void SetUp() override {
method TearDown (line 50) | void TearDown() override {}
function TEST_F (line 67) | TEST_F(HashTest, GraphicsPipeline1) {
function TEST_F (line 104) | TEST_F(HashTest, GraphicsPipeline2) {
function TEST_F (line 127) | TEST_F(HashTest, GraphicsPipeline3) {
function TEST_F (line 168) | TEST_F(HashTest, VertexInputState1) {
function TEST_F (line 209) | TEST_F(HashTest, DepthStencilState1) {
FILE: src/igl/tests/Log.cpp
type igl::tests (line 15) | namespace igl::tests {
function TEST (line 17) | TEST(LogTest, LogOnceRaceCondition) {
FILE: src/igl/tests/Multiview.cpp
type igl::tests (line 18) | namespace igl::tests {
class MultiviewTest (line 32) | class MultiviewTest : public ::testing::Test {
method MultiviewTest (line 35) | MultiviewTest() = default;
method createVertexUniformBuffer (line 38) | std::shared_ptr<iglu::ManagedUniformBuffer> createVertexUniformBuffe...
method SetUp (line 73) | void SetUp() override {
method TearDown (line 187) | void TearDown() override {}
function TEST_F (line 213) | TEST_F(MultiviewTest, FramebufferMode) {
function TEST_F (line 224) | TEST_F(MultiviewTest, SinglePassStereo) {
FILE: src/igl/tests/NameHandleTests.cpp
type igl::tests (line 13) | namespace igl::tests {
function TEST (line 21) | TEST(NameHandleTests, string) {
function TEST (line 28) | TEST(NameHandleTests, crc32) {
function TEST (line 35) | TEST(NameHandleTests, equality) {
function TEST (line 42) | TEST(NameHandleTests, ordering) {
function TEST (line 58) | TEST(NameHandleTests, set) {
FILE: src/igl/tests/RenderCommandEncoder.cpp
type igl::tests (line 36) | namespace igl::tests {
class RenderCommandEncoderTest (line 46) | class RenderCommandEncoderTest : public ::testing::Test {
method RenderCommandEncoderTest (line 49) | RenderCommandEncoderTest() = default;
method SetUp (line 57) | void SetUp() override {
method encodeAndSubmit (line 212) | void encodeAndSubmit(
method verifyFrameBuffer (line 262) | void verifyFrameBuffer(const std::vector<uint32_t>& expectedPixels) {
method verifyFrameBuffer (line 283) | void verifyFrameBuffer(const std::function<void(const std::vector<ui...
method debugLog (line 299) | void debugLog(const std::vector<uint32_t>& pixels) {
method initializeBuffers (line 311) | void initializeBuffers(const std::vector<float>& verts,
method initialize8BitIndices (line 338) | void initialize8BitIndices(const std::vector<uint8_t>& indices) {
method TearDown (line 348) | void TearDown() override {}
function TEST_F (line 382) | TEST_F(RenderCommandEncoderTest, shouldDrawAPoint) {
function TEST_F (line 407) | TEST_F(RenderCommandEncoderTest, shouldDrawAPointNewBindTexture) {
function TEST_F (line 435) | TEST_F(RenderCommandEncoderTest, shouldDrawALine) {
function TEST_F (line 466) | TEST_F(RenderCommandEncoderTest, shouldDrawLineStrip) {
function TEST_F (line 501) | TEST_F(RenderCommandEncoderTest, drawIndexedFirstIndex) {
function TEST_F (line 543) | TEST_F(RenderCommandEncoderTest, drawIndexed8Bit) {
function TEST_F (line 584) | TEST_F(RenderCommandEncoderTest, drawInstanced) {
function TEST_F (line 628) | TEST_F(RenderCommandEncoderTest, shouldDrawATriangle) {
function TEST_F (line 660) | TEST_F(RenderCommandEncoderTest, shouldDrawTriangleStrip) {
function TEST_F (line 690) | TEST_F(RenderCommandEncoderTest, shouldDrawTriangleStripCopyTextureToB...
function TEST_F (line 769) | TEST_F(RenderCommandEncoderTest, shouldNotDraw) {
function TEST_F (line 810) | TEST_F(RenderCommandEncoderTest, shouldDrawATriangleBindGroup) {
function TEST_F (line 853) | TEST_F(RenderCommandEncoderTest, DepthBiasShouldDrawAPoint) {
function TEST_F (line 879) | TEST_F(RenderCommandEncoderTest, drawUsingBindPushConstants) {
FILE: src/igl/tests/Resource.cpp
type igl::tests (line 14) | namespace igl::tests {
class ResourceTest (line 22) | class ResourceTest : public ::testing::Test {
method ResourceTest (line 24) | ResourceTest() = default;
method SetUp (line 28) | void SetUp() override {
method TearDown (line 35) | void TearDown() override {}
type FragmentFormat (line 42) | struct FragmentFormat {
function TEST_F (line 55) | TEST_F(ResourceTest, CreateRenderPipelineReturnNull) {
function TEST_F (line 74) | TEST_F(ResourceTest, DepthStencilCreate) {
function TEST_F (line 91) | TEST_F(ResourceTest, VertexBuffer) {
function TEST_F (line 110) | TEST_F(ResourceTest, UninitializedVertexBuffer) {
function TEST_F (line 131) | TEST_F(ResourceTest, IndexBuffer) {
function TEST_F (line 157) | TEST_F(ResourceTest, UniformBuffer) {
FILE: src/igl/tests/ShaderLibrary.cpp
type igl::tests (line 15) | namespace igl::tests {
class ShaderLibraryTest (line 17) | class ShaderLibraryTest : public ::testing::Test {
method ShaderLibraryTest (line 20) | ShaderLibraryTest() = default;
method SetUp (line 26) | void SetUp() override {
method TearDown (line 35) | void TearDown() override {}
function TEST_F (line 42) | TEST_F(ShaderLibraryTest, CreateFromSource) {
function TEST_F (line 75) | TEST_F(ShaderLibraryTest, CreateFromSingleModuleReturnNullWithEmptyInp...
function TEST_F (line 88) | TEST_F(ShaderLibraryTest, CreateFromSourceMultipleModules) {
function TEST_F (line 131) | TEST_F(ShaderLibraryTest, CreateFromSourceNoResult) {
FILE: src/igl/tests/ShaderModule.cpp
type igl::tests (line 16) | namespace igl::tests {
class ShaderModuleTest (line 18) | class ShaderModuleTest : public ::testing::Test {
method ShaderModuleTest (line 21) | ShaderModuleTest() = default;
method SetUp (line 27) | void SetUp() override {
method TearDown (line 35) | void TearDown() override {}
function TEST_F (line 51) | TEST_F(ShaderModuleTest, CompileShaderModuleReturnNull) {
function TEST_F (line 71) | TEST_F(ShaderModuleTest, CompileShaderModuleReturnNullWithEmptyInput) {
function TEST_F (line 80) | TEST_F(ShaderModuleTest, CompileShaderModule) {
function TEST_F (line 116) | TEST_F(ShaderModuleTest, ShaderCompilerOptionsEquality) {
function TEST_F (line 135) | TEST_F(ShaderModuleTest, ShaderModuleDescEquality) {
function TEST_F (line 152) | TEST_F(ShaderModuleTest, ShaderLibraryDescEquality) {
function TEST_F (line 174) | TEST_F(ShaderModuleTest, CompileShaderModuleNoResult) {
FILE: src/igl/tests/Texture.cpp
type igl::tests (line 15) | namespace igl::tests {
function TEST_F (line 17) | TEST_F(TextureTest, Upload) {
function TEST_F (line 49) | TEST_F(TextureTest, Passthrough) {
function TEST_F (line 114) | TEST_F(TextureTest, PassthroughSubTexture) {
function TEST_F (line 192) | TEST_F(TextureTest, FBCopy) {
function TEST_F (line 369) | TEST_F(TextureTest, RepackData) {
function TEST_F (line 474) | TEST_F(TextureTest, UploadAlignment) {
function TEST_F (line 559) | TEST_F(TextureTest, Resize) {
function TEST_F (line 650) | TEST_F(TextureTest, ResizeTextureView) {
function TEST_F (line 759) | TEST_F(TextureTest, ValidateRange2D) {
function TEST_F (line 786) | TEST_F(TextureTest, ValidateRangeCube) {
function TEST_F (line 833) | TEST_F(TextureTest, ValidateRange3D) {
function TEST_F (line 867) | TEST_F(TextureTest, ExportableTexture) {
FILE: src/igl/tests/Texture.h
function namespace (line 24) | namespace igl::tests {
FILE: src/igl/tests/TextureArray.cpp
type igl::tests (line 21) | namespace igl::tests {
type VertexUniforms (line 32) | struct VertexUniforms {
class TextureArrayTest (line 41) | class TextureArrayTest : public ::testing::Test {
method TextureArrayTest (line 44) | TextureArrayTest() = default;
method createVertexUniformBuffer (line 47) | std::shared_ptr<iglu::ManagedUniformBuffer> createVertexUniformBuffe...
method SetUp (line 79) | void SetUp() override {
method TearDown (line 250) | void TearDown() override {}
function runUploadTest (line 336) | void runUploadTest(IDevice& device,
function TEST_F (line 411) | TEST_F(TextureArrayTest, Upload_SingleUpload) {
function TEST_F (line 415) | TEST_F(TextureArrayTest, Upload_LayerByLayer) {
function TEST_F (line 419) | TEST_F(TextureArrayTest, Upload_SingleUpload_ModifySubTexture) {
function TEST_F (line 423) | TEST_F(TextureArrayTest, Upload_LayerByLayer_ModifySubTexture) {
function runUploadToMipTest (line 428) | void runUploadToMipTest(IDevice& device, ICommandQueue& cmdQueue, bool...
function TEST_F (line 486) | TEST_F(TextureArrayTest, UploadToMip_SingleUpload) {
function TEST_F (line 490) | TEST_F(TextureArrayTest, UploadToMip_LayerByLayer) {
function TEST_F (line 504) | TEST_F(TextureArrayTest, Passthrough_SampleFromArray) {
function TEST_F (line 590) | TEST_F(TextureArrayTest, Passthrough_RenderToArray) {
function TEST_F (line 689) | TEST_F(TextureArrayTest, ValidateRange2DArray) {
function TEST_F (line 718) | TEST_F(TextureArrayTest, GetEstimatedSizeInBytes) {
function TEST_F (line 781) | TEST_F(TextureArrayTest, GetRange) {
FILE: src/igl/tests/TextureArrayFloat.cpp
type igl::tests (line 30) | namespace igl::tests {
type VertexUniforms (line 45) | struct VertexUniforms {
class TextureArrayFloatTest (line 54) | class TextureArrayFloatTest : public ::testing::Test {
method TextureArrayFloatTest (line 57) | TextureArrayFloatTest() = default;
method createVertexUniformBuffer (line 60) | std::shared_ptr<iglu::ManagedUniformBuffer> createVertexUniformBuffe...
method SetUp (line 92) | void SetUp() override {
method TearDown (line 265) | void TearDown() override {}
function runUploadTest (line 351) | void runUploadTest(IDevice& device,
function TEST_F (line 422) | TEST_F(TextureArrayFloatTest, Upload_SingleUpload) {
function TEST_F (line 426) | TEST_F(TextureArrayFloatTest, Upload_LayerByLayer) {
function TEST_F (line 430) | TEST_F(TextureArrayFloatTest, Upload_SingleUpload_ModifySubTexture) {
function TEST_F (line 434) | TEST_F(TextureArrayFloatTest, Upload_LayerByLayer_ModifySubTexture) {
function runUploadToMipTest (line 439) | void runUploadToMipTest(IDevice& device, ICommandQueue& cmdQueue, bool...
function TEST_F (line 493) | TEST_F(TextureArrayFloatTest, UploadToMip_SingleUpload) {
function TEST_F (line 497) | TEST_F(TextureArrayFloatTest, UploadToMip_LayerByLayer) {
function TEST_F (line 507) | TEST_F(TextureArrayFloatTest, Passthrough_SampleFromArray) {
function TEST_F (line 593) | TEST_F(TextureArrayFloatTest, Passthrough_RenderToArray) {
function TEST_F (line 692) | TEST_F(TextureArrayFloatTest, ValidateRange2DArray) {
function TEST_F (line 717) | TEST_F(TextureArrayFloatTest, GetEstimatedSizeInBytes) {
function TEST_F (line 774) | TEST_F(TextureArrayFloatTest, GetRange) {
FILE: src/igl/tests/TextureCube.cpp
type igl::tests (line 21) | namespace igl::tests {
type VertexUniforms (line 30) | struct VertexUniforms {
class TextureCubeTest (line 39) | class TextureCubeTest : public ::testing::Test {
method TextureCubeTest (line 42) | TextureCubeTest() = default;
method createVertexUniformBuffer (line 45) | std::shared_ptr<iglu::ManagedUniformBuffer> createVertexUniformBuffe...
method SetUp (line 78) | void SetUp() override {
method TearDown (line 216) | void TearDown() override {}
function runUploadTest (line 302) | void runUploadTest(IDevice& device, ICommandQueue& cmdQueue, bool sing...
function TEST_F (line 344) | TEST_F(TextureCubeTest, Upload_SingleUpload) {
function TEST_F (line 348) | TEST_F(TextureCubeTest, Upload_FaceByFace) {
function runUploadToMipTest (line 356) | void runUploadToMipTest(IDevice& device, ICommandQueue& cmdQueue, bool...
function TEST_F (line 398) | TEST_F(TextureCubeTest, UploadToMip_SingleUpload) {
function TEST_F (line 402) | TEST_F(TextureCubeTest, UploadToMip_LevelByLevel) {
function TEST_F (line 412) | TEST_F(TextureCubeTest, Passthrough_SampleFromCube) {
function TEST_F (line 507) | TEST_F(TextureCubeTest, Passthrough_RenderToCube) {
function TEST_F (line 612) | TEST_F(TextureCubeTest, GetEstimatedSizeInBytes) {
function TEST_F (line 645) | TEST_F(TextureCubeTest, GetRange) {
FILE: src/igl/tests/TextureFloat.cpp
type igl::tests (line 23) | namespace igl::tests {
type VertexUniforms (line 76) | struct VertexUniforms {
class TextureFloatTest (line 85) | class TextureFloatTest : public ::testing::Test {
method TextureFloatTest (line 88) | TextureFloatTest() = default;
method createVertexUniformBuffer (line 91) | std::shared_ptr<iglu::ManagedUniformBuffer> createVertexUniformBuffe...
method createPassthroughFrameBuffer (line 112) | void createPassthroughFrameBuffer(TextureFormat format) {
method createShaderStages (lin
Copy disabled (too large)
Download .json
Condensed preview — 1071 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (17,168K chars).
[
{
"path": ".clang-format",
"chars": 2548,
"preview": "---\nAccessModifierOffset: -1\nAlignAfterOpenBracket: Align\nAlignConsecutiveAssignments: false\nAlignConsecutiveDeclaration"
},
{
"path": ".claude/CLAUDE.md",
"chars": 1009,
"preview": "# IGL Project Instructions\n\n## Diff Formatting\n\n- Use Markdown formatting in diff summaries, titles, and test plans.\n- D"
},
{
"path": ".cmake-format",
"chars": 10976,
"preview": "{\n \"_help_parse\": \"Options affecting listfile parsing\",\n \"parse\": {\n \"_help_additional_commands\": [\n \"Specify "
},
{
"path": ".github/pull_request_template.md",
"chars": 1280,
"preview": "Our [contribution guidelines](https://github.com/facebook/igl/blob/main/CONTRIBUTING.md):\n\n## Pull Requests\nWe actively "
},
{
"path": ".github/workflows/c-cpp.yml",
"chars": 11543,
"preview": "name: C/C++ CI\n\non:\n push:\n branches: [ \"**\" ]\n pull_request:\n branches: [ \"**\" ]\n\n# https://github.com/git-lfs/"
},
{
"path": ".github/workflows/cmake-install-test.yml",
"chars": 10570,
"preview": "name: CMake Install Test\n\non:\n push:\n branches: [ \"**\" ]\n paths:\n - 'CMakeLists.txt'\n - 'cmake/**'\n "
},
{
"path": ".github/workflows/doc-build.yml",
"chars": 998,
"preview": "name: Doc Build\n\non:\n push:\n branches:\n - main\n paths:\n - 'docs/**'\n pull_request:\n types: opened\n "
},
{
"path": ".gitignore",
"chars": 14,
"preview": ".idea\n.vscode\n"
},
{
"path": "CMakeLists.txt",
"chars": 12852,
"preview": "# Copyright (c) Meta Platforms, Inc. and affiliates.\n#\n# This source code is licensed under the MIT license found in the"
},
{
"path": "CODE_OF_CONDUCT.md",
"chars": 3356,
"preview": "# Code of Conduct\n\n## Our Pledge\n\nIn the interest of fostering an open and welcoming environment, we as\ncontributors and"
},
{
"path": "CONTRIBUTING.md",
"chars": 1980,
"preview": "# Contributing to IGL\nWe want to make contributing to this project as easy and transparent as\npossible.\n\n## Pull Request"
},
{
"path": "IGLU/CMakeLists.txt",
"chars": 4193,
"preview": "# Copyright (c) Meta Platforms, Inc. and affiliates.\n#\n# This source code is licensed under the MIT license found in the"
},
{
"path": "IGLU/bitmap/BitmapWriter.cpp",
"chars": 4784,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/bitmap/BitmapWriter.h",
"chars": 733,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/command_buffer_allocator/ICommandBufferAllocator.cpp",
"chars": 1117,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/command_buffer_allocator/ICommandBufferAllocator.h",
"chars": 2078,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/imgui/InputListener.cpp",
"chars": 2638,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/imgui/InputListener.h",
"chars": 1195,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/imgui/KeyCodeTranslator.cpp",
"chars": 1976,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/imgui/KeyCodeTranslator.h",
"chars": 393,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/imgui/Session.cpp",
"chars": 23711,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/imgui/Session.h",
"chars": 1204,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/imgui/compile_shaders.bat",
"chars": 1284,
"preview": "@REM Copyright (c) Meta Platforms, Inc. and affiliates.\n@REM\n@REM This source code is licensed under the MIT license fou"
},
{
"path": "IGLU/imgui/compile_shaders.py",
"chars": 2103,
"preview": "#!/usr/bin/env fbpython\n# Copyright (c) Meta Platforms, Inc. and affiliates.\n#\n# This source code is licensed under the "
},
{
"path": "IGLU/imgui/imgui_ps_d3d12.hlsl",
"chars": 270,
"preview": "struct PSInput {\n float4 position : SV_Position;\n float4 color : COLOR;\n float2 uv : TEXCOORD0;\n};\n\nTexture2D tex : r"
},
{
"path": "IGLU/imgui/imgui_ps_d3d12_fxc.h",
"chars": 4856,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/imgui/imgui_vs_d3d12.hlsl",
"chars": 472,
"preview": "cbuffer PushConstants : register(b2) {\n float4x4 projectionMatrix;\n};\n\nstruct VSInput {\n float2 position : POSITION;\n "
},
{
"path": "IGLU/imgui/imgui_vs_d3d12_fxc.h",
"chars": 6456,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/managedUniformBuffer/ManagedUniformBuffer.cpp",
"chars": 9214,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/managedUniformBuffer/ManagedUniformBuffer.h",
"chars": 2303,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/sentinel/Assert.h",
"chars": 367,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/sentinel/Buffer.cpp",
"chars": 1728,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/sentinel/Buffer.h",
"chars": 1442,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/sentinel/CommandBuffer.cpp",
"chars": 2249,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/sentinel/CommandBuffer.h",
"chars": 1948,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/sentinel/CommandQueue.cpp",
"chars": 879,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/sentinel/CommandQueue.h",
"chars": 1035,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/sentinel/Device.cpp",
"chars": 6220,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/sentinel/Device.h",
"chars": 5017,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/sentinel/Framebuffer.cpp",
"chars": 3445,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/sentinel/Framebuffer.h",
"chars": 2670,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/sentinel/PlatformDevice.cpp",
"chars": 584,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/sentinel/PlatformDevice.h",
"chars": 860,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/shaderCross/ShaderCross.cpp",
"chars": 4065,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/shaderCross/ShaderCross.h",
"chars": 1148,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/shaderCross/ShaderCrossUniformBuffer.cpp",
"chars": 966,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/shaderCross/ShaderCrossUniformBuffer.h",
"chars": 720,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/simdtypes/SimdTypes.h",
"chars": 6719,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/simdtypes/SimdUtilities.h",
"chars": 10019,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/simple_renderer/Drawable.cpp",
"chars": 1645,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/simple_renderer/Drawable.h",
"chars": 1589,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/simple_renderer/ForwardRenderPass.cpp",
"chars": 3721,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/simple_renderer/ForwardRenderPass.h",
"chars": 2229,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/simple_renderer/Material.cpp",
"chars": 2694,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/simple_renderer/Material.h",
"chars": 3847,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/simple_renderer/ParametricVertexData.cpp",
"chars": 6493,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/simple_renderer/ParametricVertexData.h",
"chars": 2002,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/simple_renderer/ShaderProgram.cpp",
"chars": 2817,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/simple_renderer/ShaderProgram.h",
"chars": 1773,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/simple_renderer/ShaderUniforms.cpp",
"chars": 44062,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/simple_renderer/ShaderUniforms.h",
"chars": 15073,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/simple_renderer/VertexData.cpp",
"chars": 2838,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/simple_renderer/VertexData.h",
"chars": 2945,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/state_pool/ComputePipelineStatePool.cpp",
"chars": 573,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/state_pool/ComputePipelineStatePool.h",
"chars": 704,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/state_pool/DepthStencilStatePool.cpp",
"chars": 568,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/state_pool/DepthStencilStatePool.h",
"chars": 799,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/state_pool/RenderPipelineStatePool.cpp",
"chars": 1880,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/state_pool/RenderPipelineStatePool.h",
"chars": 1881,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/state_pool/StatePool.h",
"chars": 3439,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/state_pool/VertexInputStatePool.cpp",
"chars": 563,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/state_pool/VertexInputStatePool.h",
"chars": 791,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_accessor/ITextureAccessor.h",
"chars": 2773,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_accessor/MetalTextureAccessor.h",
"chars": 1236,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_accessor/MetalTextureAccessor.mm",
"chars": 4029,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_accessor/OpenGLTextureAccessor.cpp",
"chars": 5906,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_accessor/OpenGLTextureAccessor.h",
"chars": 1340,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_accessor/TextureAccessorFactory.cpp",
"chars": 1270,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_accessor/TextureAccessorFactory.h",
"chars": 613,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_accessor/VulkanTextureAccessor.cpp",
"chars": 3059,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_accessor/VulkanTextureAccessor.h",
"chars": 1470,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/DataReader.cpp",
"chars": 2144,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/DataReader.h",
"chars": 4485,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/IData.cpp",
"chars": 1785,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/IData.h",
"chars": 1585,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/ITextureLoader.cpp",
"chars": 7893,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/ITextureLoader.h",
"chars": 4654,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/ITextureLoaderFactory.cpp",
"chars": 3261,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/ITextureLoaderFactory.h",
"chars": 2969,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/TextureLoaderFactory.cpp",
"chars": 1914,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/TextureLoaderFactory.h",
"chars": 1318,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/ktx/TextureLoaderFactory.cpp",
"chars": 10217,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/ktx/TextureLoaderFactory.h",
"chars": 1253,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/ktx1/Header.cpp",
"chars": 625,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/ktx1/Header.h",
"chars": 1171,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/ktx1/TextureLoaderFactory.cpp",
"chars": 4523,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/ktx1/TextureLoaderFactory.h",
"chars": 1335,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/ktx2/Header.cpp",
"chars": 625,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/ktx2/Header.h",
"chars": 973,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/ktx2/TextureLoaderFactory.cpp",
"chars": 8314,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/ktx2/TextureLoaderFactory.h",
"chars": 1335,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/stb_hdr/Header.cpp",
"chars": 841,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/stb_hdr/Header.h",
"chars": 562,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/stb_hdr/TextureLoaderFactory.cpp",
"chars": 751,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/stb_hdr/TextureLoaderFactory.h",
"chars": 813,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/stb_image/TextureLoaderFactory.cpp",
"chars": 6255,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/stb_image/TextureLoaderFactory.h",
"chars": 1076,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/stb_jpeg/Header.cpp",
"chars": 580,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/stb_jpeg/Header.h",
"chars": 562,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/stb_jpeg/TextureLoaderFactory.cpp",
"chars": 661,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/stb_jpeg/TextureLoaderFactory.h",
"chars": 724,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/stb_png/Header.cpp",
"chars": 604,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/stb_png/Header.h",
"chars": 560,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/stb_png/TextureLoaderFactory.cpp",
"chars": 1052,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/stb_png/TextureLoaderFactory.h",
"chars": 721,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/xtc1/Header.cpp",
"chars": 576,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/xtc1/Header.h",
"chars": 1002,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/xtc1/TextureLoaderFactory.cpp",
"chars": 4254,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/texture_loader/xtc1/TextureLoaderFactory.h",
"chars": 913,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/uniform/Collection.cpp",
"chars": 2350,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/uniform/Collection.h",
"chars": 4107,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/uniform/CollectionEncoder.cpp",
"chars": 841,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/uniform/CollectionEncoder.h",
"chars": 895,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/uniform/Descriptor.cpp",
"chars": 984,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/uniform/Descriptor.h",
"chars": 10168,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/uniform/Encoder.cpp",
"chars": 4151,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/uniform/Encoder.h",
"chars": 1126,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "IGLU/uniform/Trait.h",
"chars": 3678,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "LICENSE.md",
"chars": 3058,
"preview": "MIT License\n\nCopyright (c) Meta Platforms, Inc. and affiliates.\n\nPermission is hereby granted, free of charge, to any pe"
},
{
"path": "README.md",
"chars": 4776,
"preview": "<div align=\"center\">\n <picture>\n <source media=\"(prefers-color-scheme: dark)\" srcset=\"https://github.com/facebook/ig"
},
{
"path": "ROADMAP.md",
"chars": 1748,
"preview": "We deeply appreciate and value the significance of Open Source projects. It is with great pleasure that we would like to"
},
{
"path": "build/.gitignore",
"chars": 59,
"preview": "*\n*.*\n!.gitignore\n!android/\n!android/**\nandroid/.gitignore\n"
},
{
"path": "cmake/IGLConfig.cmake.in",
"chars": 7466,
"preview": "# Copyright (c) Meta Platforms, Inc. and affiliates.\n#\n# This source code is licensed under the MIT license found in the"
},
{
"path": "cmake/install.cmake",
"chars": 16622,
"preview": "# Copyright (c) Meta Platforms, Inc. and affiliates.\n#\n# This source code is licensed under the MIT license found in the"
},
{
"path": "deploy_content.py",
"chars": 680,
"preview": "#!/usr/bin/python3\n# Copyright (c) Meta Platforms, Inc. and affiliates.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "deploy_deps.py",
"chars": 512,
"preview": "#!/usr/bin/python3\n# Copyright (c) Meta Platforms, Inc. and affiliates.\n#\n# This source code is licensed under the MIT l"
},
{
"path": "docs/.gitignore",
"chars": 13,
"preview": "venv/\nbuild/\n"
},
{
"path": "docs/Makefile",
"chars": 638,
"preview": "# Minimal makefile for Sphinx documentation\n#\n\n# You can set these variables from the command line, and also\n# from the "
},
{
"path": "docs/README.md",
"chars": 1715,
"preview": "<div align=\"center\">\n <picture>\n <source media=\"(prefers-color-scheme: dark)\" srcset=\"https://github.com/facebook/ig"
},
{
"path": "docs/make.bat",
"chars": 804,
"preview": "@ECHO OFF\r\n\r\npushd %~dp0\r\n\r\nREM Command file for Sphinx documentation\r\n\r\nif \"%SPHINXBUILD%\" == \"\" (\r\n\tset SPHINXBUILD=sp"
},
{
"path": "docs/requirements.txt",
"chars": 103,
"preview": "sphinx==5.3.0\nmyst-parser\nfuro\nsphinx-copybutton\nsphinxext-opengraph\nsphinx-favicon\nsphinx-inline-tabs\n"
},
{
"path": "docs/source/_extensions/style.py",
"chars": 473,
"preview": "from pygments.filters import VisibleWhitespaceFilter\nfrom pygments.lexers.compiled import CppLexer, RustLexer\nfrom pygme"
},
{
"path": "docs/source/conf.py",
"chars": 4463,
"preview": "# Copyright (c) Meta Platforms, Inc. and affiliates.\n#\n# This source code is licensed under the MIT license found in the"
},
{
"path": "docs/source/data/placeholder",
"chars": 53,
"preview": "delete this file once this folder has some real data\n"
},
{
"path": "docs/source/getting-started/index.md",
"chars": 64,
"preview": "Getting started\n===============\n\n```{toctree}\n:maxdepth: 2\n````\n"
},
{
"path": "docs/source/index.md",
"chars": 813,
"preview": " <!-- IGL documentation master file, created by\n sphinx-quickstart on Tue May 9 14:48:26 2023.\n You can adapt this "
},
{
"path": "docs/source/introduction.md",
"chars": 669,
"preview": "Introduction\n============\n\nSupported rendering backends\n----------------------------\n\n * Metal 2+\n * OpenGL 2.x (require"
},
{
"path": "docs/source/theme/extra.css",
"chars": 486,
"preview": "ul.simple,\nol.simple {\n padding-left: 1.6rem;\n}\n\nul.simple li:not(:last-child),\nol.simple li:not(:last-child) {\n m"
},
{
"path": "docs/source/theme/sphinx_literate.css",
"chars": 410,
"preview": ".lit-block-wrapper {\n position: relative;\n}\n\n.lit-block-wrapper .lit-block-footer {\n text-align: right;\n font-s"
},
{
"path": "docs/source/video/placeholder",
"chars": 53,
"preview": "delete this file once this folder has some real data\n"
},
{
"path": "getting-started.md",
"chars": 2225,
"preview": "# Examples\n\n1) [Tiny](./samples/desktop/Tiny/Tiny.cpp)\n\nA basic example showing how to render a triangle.\n\n![image](.git"
},
{
"path": "samples/android/opengl/java/com/facebook/igl/sample/AndroidManifest.xml",
"chars": 931,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<manifest xmlns:android=\"http://schemas.android.com/apk/res/android\"\n pa"
},
{
"path": "samples/android/opengl/java/com/facebook/igl/sample/SampleActivity.java",
"chars": 711,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "samples/android/opengl/java/com/facebook/igl/sample/SampleLib.java",
"chars": 519,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "samples/android/opengl/java/com/facebook/igl/sample/SampleView.java",
"chars": 3577,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "samples/android/opengl/jni/Jni.cpp",
"chars": 1556,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "samples/android/opengl/jni/TinyRenderer.cpp",
"chars": 6675,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "samples/android/opengl/jni/TinyRenderer.h",
"chars": 891,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "samples/android/vulkan/java/com/facebook/igl/sample/AndroidManifest.xml",
"chars": 1121,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<manifest xmlns:android=\"http://schemas.android.com/apk/res/android\"\n pa"
},
{
"path": "samples/android/vulkan/java/com/facebook/igl/sample/SampleActivity.java",
"chars": 530,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "samples/android/vulkan/jni/Tiny.cpp",
"chars": 6857,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "samples/desktop/CMakeLists.txt",
"chars": 2908,
"preview": "# Copyright (c) Meta Platforms, Inc. and affiliates.\n#\n# This source code is licensed under the MIT license found in the"
},
{
"path": "samples/desktop/Tiny/Tiny.cpp",
"chars": 14244,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "samples/desktop/Tiny/Tiny_Mesh.cpp",
"chars": 27262,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "samples/desktop/Tiny/Tiny_MeshLarge.cpp",
"chars": 97424,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "samples/ios/snapshot_test_support/IGLBytesToUIImage.h",
"chars": 737,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "samples/ios/snapshot_test_support/IGLBytesToUIImage.mm",
"chars": 2631,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "samples/ios/snapshot_test_support/IGLSnapshotTestCase.h",
"chars": 318,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "samples/ios/snapshot_test_support/IGLSnapshotTestCase.mm",
"chars": 4129,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "samples/ios/snapshot_test_support/TinyRenderable.cpp",
"chars": 9468,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "samples/ios/snapshot_test_support/TinyRenderable.hpp",
"chars": 1300,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "samples/wasm/CMakeLists.txt",
"chars": 915,
"preview": "# Copyright (c) Meta Platforms, Inc. and affiliates.\n#\n# This source code is licensed under the MIT license found in the"
},
{
"path": "samples/wasm/Common.cpp",
"chars": 675,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "samples/wasm/Common.h",
"chars": 259,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "samples/wasm/Tiny_Mesh.cpp",
"chars": 16391,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "samples/wasm/Triangle.cpp",
"chars": 7218,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "samples/wasm/igl.html",
"chars": 6043,
"preview": "<!doctype html>\n<html lang=\"en-us\" data-theme=\"cupcake\">\n\n<head>\n <meta charset=\"utf-8\">\n <meta http-equiv=\"Content-Ty"
},
{
"path": "shell/CMakeLists.txt",
"chars": 6957,
"preview": "# Copyright (c) Meta Platforms, Inc. and affiliates.\n#\n# This source code is licensed under the MIT license found in the"
},
{
"path": "shell/android/CMakeLists.txt",
"chars": 1750,
"preview": "# Copyright (c) Meta Platforms, Inc. and affiliates.\n#\n# This source code is licensed under the MIT license found in the"
},
{
"path": "shell/android/java/com/facebook/igl/sample/AndroidManifest.xml",
"chars": 889,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<manifest xmlns:android=\"http://schemas.android.com/apk/res/android\"\n pa"
},
{
"path": "shell/android/java/com/facebook/igl/sample/SampleActivity.java",
"chars": 4878,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "shell/android/java/com/facebook/igl/sample/SampleLib.java",
"chars": 2213,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "shell/android/java/com/facebook/igl/sample/SampleView.java",
"chars": 9331,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "shell/android/java/com/facebook/igl/sample/VulkanView.java",
"chars": 9232,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "shell/android/jni/Jni.cpp",
"chars": 22272,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "shell/android/jni/TinyRenderer.cpp",
"chars": 22929,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "shell/android/jni/TinyRenderer.h",
"chars": 2104,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "shell/apps/SessionApp.cpp",
"chars": 1154,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "shell/ios/AppDelegate.h",
"chars": 567,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "shell/ios/AppDelegate.mm",
"chars": 4839,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "shell/ios/BackendVersion.h",
"chars": 833,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "shell/ios/BackendVersion.mm",
"chars": 779,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "shell/ios/CMakeLists.txt",
"chars": 3013,
"preview": "# Copyright (c) Meta Platforms, Inc. and affiliates.\n#\n# This source code is licensed under the MIT license found in the"
},
{
"path": "shell/ios/IglShellPlatformAdapter.h",
"chars": 445,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "shell/ios/IglShellPlatformAdapterInternal.hpp",
"chars": 471,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "shell/ios/IglSurfaceTexturesAdapter.h",
"chars": 415,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "shell/ios/IglSurfaceTexturesAdapterInternal.hpp",
"chars": 462,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "shell/ios/RenderSessionController.h",
"chars": 1225,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "shell/ios/RenderSessionController.mm",
"chars": 4768,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
},
{
"path": "shell/ios/RenderSessionFactoryAdapter.h",
"chars": 453,
"preview": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found "
}
]
// ... and 871 more files (download for full content)
About this extraction
This page contains the full source code of the facebook/igl GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1071 files (16.0 MB), approximately 4.2M tokens, and a symbol index with 3637 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.