Initial commit

Author: nullcatalyst

.gitignore

@@ -0,0 +1,31 @@
+# Project
+build/
+tmp/
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+# Xcode
+xcuserdata/
+
+# VSCode
+.vscode/

CMakeLists.txt

@@ -0,0 +1,51 @@
+cmake_minimum_required(VERSION 3.10)
+
+project(graphics)
+set(CMAKE_CXX_STANDARD 17)
+
+# OPTIONS
+
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Release)
+endif()
+
+option(BACKEND_METAL    "Build the Metal backend"   ON)
+option(BACKEND_OPENGL   "Build the OpenGL backend"  OFF)
+
+# TARGET
+
+add_library(graphics STATIC)
+
+target_include_directories(graphics
+PUBLIC
+    include
+PRIVATE
+    src
+)
+
+# BACKENDS
+
+if(BACKEND_METAL)
+    target_compile_options(graphics
+    PUBLIC
+        "-fobjc-arc"
+    )
+
+    target_sources(graphics
+    PRIVATE
+        src/graphics/metal/context.mm
+        # src/graphics/metal/convert.mm
+        src/graphics/metal/rendertarget.mm
+        src/graphics/metal/state.mm
+        src/graphics/metal/staticbuffer.mm
+        src/graphics/metal/dynamicbuffer.mm
+        src/graphics/metal/texture.mm
+    )
+endif()
+
+if(BACKEND_OPENGL)
+    target_sources(graphics
+    PRIVATE
+        # src/graphics/opengl/*
+    )
+endif()

include/graphics/descriptors.hpp

@@ -0,0 +1,121 @@
+#ifndef graphics_descriptors_hpp
+#define graphics_descriptors_hpp
+
+#include <cstdint> // uint32_t
+
+namespace graphics {
+    enum class CompareFunction : uint32_t {
+        Never                   = 0,
+        Less                    = 1,
+        Equal                   = 2,
+        LessEqual               = 3,
+        Greater                 = 4,
+        NotEqual                = 5,
+        GreaterEqual            = 6,
+        Always                  = 7,
+    };
+
+    enum class CullMode : uint32_t {
+        None                    = 0,
+        Front                   = 1,
+        Back                    = 2,
+    };
+
+    enum class Winding : uint32_t {
+        Clockwise               = 0,
+        CounterClockwise        = 1,
+    };
+
+    enum class VertexFormat : uint32_t {
+        Invalid                 = 0,
+        Float                   = 1,
+        Float2                  = 2,
+        Float3                  = 3,
+        Float4                  = 4,
+    };
+
+    enum class StepFunction : uint32_t {
+        Constant                = 0,
+        PerVertex               = 1,
+        PerInstance             = 2,
+    };
+
+    enum class PixelFormat : uint32_t {
+        Invalid                 = 0,
+
+        RGB24u                  = 1,
+        RGB24s                  = 2,
+
+        RGBA32u                 = 3,
+        RGBA32s                 = 4,
+        BGRA32u                 = 5,
+
+        Depth16f                = 6,
+        Depth32f                = 7,
+//        Depth24f_Stencil8u      = 8,
+    };
+
+    enum class StorageHint : uint32_t {
+        None                    = 0,
+        MipMap                  = 1,
+        Memoryless              = 2,
+    };
+
+    struct VertexAttribute {
+        uint32_t                id;
+        VertexFormat            format;
+        uint32_t                offset;
+        uint32_t                bufferIndex;
+    };
+
+    struct BufferLayout {
+        uint32_t                bufferIndex;
+        uint32_t                stride;
+        uint32_t                stepRate;
+        StepFunction            stepFunction;
+    };
+
+    struct VertexDesc {
+        uint32_t                attributeCount;
+        uint32_t                layoutCount;
+        const VertexAttribute * attributes;
+        const BufferLayout *    layouts;
+    };
+
+    struct Attachment {
+        uint32_t                id;
+        void *                  texture;
+        bool                    clear;
+    };
+
+    struct RenderTargetDesc {
+        uint32_t                sampleCount;
+        uint32_t                colorAttachmentCount;
+        const Attachment *      colorAttachments;
+        Attachment              depthAttachment;
+    };
+
+    // This is used to create an initialized (opaque) State object
+    struct StateDesc {
+        const char *                vertexShader;
+        const char *                fragmentShader;
+        const VertexDesc *          vertexDesc;
+        const RenderTargetDesc *    targetDesc;
+        CullMode                    cullMode;
+        Winding                     winding;
+        bool                        depthWriteEnabled;
+        CompareFunction             depthCompareFunction;
+        float                       depthBias;
+        float                       depthSlopeScale;
+        float                       depthBiasClamp;
+    };
+
+    struct TextureDesc {
+        uint32_t    width;
+        uint32_t    height;
+        PixelFormat format;
+        StorageHint storage;
+    };
+}
+
+#endif /* graphics_descriptors_hpp */

include/graphics/graphics.hpp

@@ -0,0 +1,25 @@
+#ifndef graphics_graphics_hpp
+#define graphics_graphics_hpp
+
+#include "util/os.hpp"
+
+#if !(GRAPHICS_USE_METAL || GRAPHICS_USE_OPENGL)
+    // Try to determine best backend given the target platform
+    #if OS(mac) || OS(ios)
+        #define GRAPHICS_USE_METAL 1
+    #else
+        #define GRAPHICS_USE_OPENGL 1
+    #endif
+#endif
+
+#if GRAPHICS_USE_METAL
+    #include "graphics/metal/context.hpp"
+    namespace graphics = graphics::metal;
+#endif
+
+#if GRAPHICS_USE_OPENGL
+    #include "graphics/opengl/graphics.hpp"
+    namespace graphics = graphics::opengl;
+#endif
+
+#endif /* graphics_graphics_hpp */

include/graphics/metal/context.hpp

@@ -0,0 +1,79 @@
+#ifndef graphics_metal_context_hpp
+#define graphics_metal_context_hpp
+
+#ifdef __OBJC__
+    #include <Metal/Metal.h>
+    #include <MetalKit/MetalKit.h>
+#endif
+
+#include "graphics/metal/rendertarget.hpp"
+#include "graphics/metal/state.hpp"
+#include "graphics/metal/staticbuffer.hpp"
+#include "graphics/metal/dynamicbuffer.hpp"
+#include "graphics/metal/texture.hpp"
+
+namespace graphics::metal {
+    constexpr uint32_t BUFFER_COUNT = 3;
+
+    class Context {
+#ifdef __OBJC__
+        dispatch_semaphore_t        _inFlightSemaphore;
+        MTKView *                   _view;
+        id<MTLDevice>               _device;
+        id<MTLCommandQueue>         _commandQueue;
+        id<MTLCommandBuffer>        _commandBuffer;
+        id<MTLRenderCommandEncoder> _renderEncoder;
+#else
+        void *                      _inFlightSemaphore;
+        void *                      _view;
+        void *                      _device;
+        void *                      _commandQueue;
+        void *                      _commandBuffer;
+        void *                      _renderEncoder;
+#endif
+
+        uint32_t                    _frame;
+
+    public:
+#ifdef __OBJC__
+        Context(MTKView * view);
+#endif
+        ~Context();
+
+        constexpr uint32_t getFrame()       const { return _frame; }
+        constexpr uint32_t getNextFrame()   const { return (_frame + 1) % BUFFER_COUNT; }
+
+        StaticBuffer * createStaticBuffer(uint32_t size, uint32_t count, const void * data);
+        DynamicBuffer * createDynamicBuffer(uint32_t size, uint32_t capacity);
+
+        Texture * createTexture(const TextureDesc & textureDesc);
+        Texture * loadTexture(const char * textureName);
+
+        RenderTarget * createRenderTarget(const RenderTargetDesc & targetDesc);
+        void setRenderTarget(RenderTarget * target);
+        void changeColorAttachment(RenderTarget * target, uint32_t id, Texture * texture);
+        void changeDepthAttachment(RenderTarget * target, Texture * texture);
+
+        State * createState(const StateDesc & desc);
+        void setState(const State * state);
+
+        void startFrame();
+        void commitFrame();
+
+        void setBuffer(uint32_t id, StaticBuffer * buffer, uint32_t offset = 0, bool forFragmentShader = false);
+        void setBuffer(uint32_t id, DynamicBuffer * buffer, uint32_t offset = 0, bool forFragmentShader = false);
+        void setTexture(uint32_t id, Texture * texture, bool forFragmentShader = true);
+
+        void drawTriangles(uint32_t count);
+        void drawTriangleStrip(uint32_t count);
+        void drawIndexedTriangles(uint32_t count, StaticBuffer * indexBuffer);
+        void drawIndexedTriangleStrip(uint32_t count, StaticBuffer * indexBuffer);
+
+        void drawInstancedTriangles(uint32_t instanceCount, uint32_t vertexCount);
+        void drawInstancedTriangleStrip(uint32_t instanceCount, uint32_t vertexCount);
+        void drawInstancedIndexedTriangles(uint32_t instanceCount, uint32_t indexCount, StaticBuffer * indexBuffer);
+        void drawInstancedIndexedTriangleStrip(uint32_t instanceCount, uint32_t indexCount, StaticBuffer * indexBuffer);
+    };
+}
+
+#endif /* graphics_metal_context_hpp */

include/graphics/metal/dynamicbuffer.hpp

@@ -0,0 +1,51 @@
+#ifndef graphics_metal_dynamicbuffer_hpp
+#define graphics_metal_dynamicbuffer_hpp
+
+#ifdef __OBJC__
+    #include <Metal/Metal.h>
+#endif
+
+#include "util/os.hpp"
+
+namespace graphics::metal {
+    class Context;
+
+    class DynamicBuffer {
+        uint32_t        _size;
+        uint32_t        _count;
+        uint32_t        _capacity;
+
+#ifdef __OBJC__
+        id<MTLBuffer>   _buffer;
+#else 
+        void *          _buffer;
+#endif
+
+        friend class Context;
+
+        static constexpr uint32_t getBufferSize(uint32_t size, uint32_t capacity) {
+            return (((size * capacity) & ~0xff) + 0x100);
+        }
+
+    public:
+#ifdef __OBJC__
+        DynamicBuffer(uint32_t size, uint32_t capacity, id<MTLDevice> device);
+#endif
+        ~DynamicBuffer();
+
+        constexpr uint32_t getSize()     const { return _size;     }
+        constexpr uint32_t getCount()    const { return _count;    }
+        constexpr uint32_t getCapacity() const { return _capacity; }
+
+        constexpr uint32_t getOffset(uint32_t frame) const {
+            return frame * getBufferSize(_size, _capacity);
+        }
+
+        void update(uint32_t frame);
+        void update(uint32_t frame, uint32_t startByte, uint32_t endByte);
+
+        void * getData(uint32_t frame);
+    };
+}
+
+#endif /* graphics_metal_dynamicbuffer_hpp */

include/graphics/metal/rendertarget.hpp

@@ -0,0 +1,28 @@
+#ifndef graphics_metal_rendertarget_hpp
+#define graphics_metal_rendertarget_hpp
+
+#ifdef __OBJC__
+    #include <Metal/Metal.h>
+#endif
+
+namespace graphics::metal {
+    class Context;
+
+    class RenderTarget {
+#ifdef __OBJC__
+        MTLRenderPassDescriptor *   _renderPassDescriptor;
+#else
+        void *                      _renderPassDescriptor;
+#endif
+
+        friend class Context;
+
+    public:
+#ifdef __OBJC__
+        RenderTarget(MTLRenderPassDescriptor * renderPassDescriptor);
+#endif
+        ~RenderTarget();
+    };
+}
+
+#endif /* graphics_metal_rendertarget_hpp */