Make `gfx` compile to a DLL. (#1660)

* Make `gfx` compile to a DLL.

* Fix cuda

* Fix cuda build

* Bug gl screen capture bug.

1 files changed, 86 insertions, 0 deletions

diff --git a/tools/render-test/surface.h b/tools/render-test/surface.h
new file mode 100644
index 000000000..3e0f6f0aa
--- /dev/null
+++ b/tools/render-test/surface.h
@@ -0,0 +1,86 @@
+// surface.h
+#pragma once
+
+#include "render.h"
+
+namespace gfx {
+
+class Surface;
+
+class SurfaceAllocator
+{
+    public:
+    virtual Slang::Result allocate(int width, int height, Format format, int alignment, Surface& surface) = 0;
+    virtual void deallocate(Surface& surface) = 0;
+
+        /// Get the malloc allocator
+    static SurfaceAllocator* getMallocAllocator();
+};
+
+class Surface
+{
+    public:
+
+    enum
+    {
+        kDefaultAlignment = sizeof(void*)
+    };
+
+        /// Allocate
+    Slang::Result allocate(int width, int height, Format format, int alignment = kDefaultAlignment, SurfaceAllocator* allocator = nullptr);
+
+        /// Deallocate contents
+    void deallocate();
+        /// Initialize contents (zero sized, no data). Note that the allocator pointer is left as is
+    void init();
+
+        /// Set unowned
+    void setUnowned(int width, int height, Format format, int strideInBytes, void* data);
+
+        /// Set the contents - the memory will be owned by this surface (ie will be freed by the allocator when goes out of scope or is deallocated)
+    Slang::Result set(int width, int height, Format format, int strideInBytes, const void* data, SurfaceAllocator* allocator);
+
+    template <typename T>
+    T* calcNextRow(T* ptr) const { return (T*)calcNextRow((void*)ptr); }
+    template <typename T>
+    const T* calcNextRow(const T* ptr) const { return (const T*)calcNextRow((const void*)ptr); }
+
+    void* calcNextRow(void* ptr) const { return (void*)(((uint8_t*)ptr) + m_rowStrideInBytes); }
+    const void* calcNextRow(const void* ptr) const { return (const void*)(((const uint8_t*)ptr) + m_rowStrideInBytes); }
+
+        /// Writes zero to all of the contents
+    void zeroContents();
+
+        /// Flips the contents vertically in place
+    void flipInplaceVertically();
+
+        /// True if has some contents
+    bool hasContents() const { return m_data != nullptr; }
+
+        /// Ctor
+    Surface() :
+        m_allocator(nullptr)
+    {
+        init();
+    }
+        /// Dtor
+    ~Surface();
+
+        /// Get the size of the row in bytes
+    static int calcRowSize(Format format, int width);
+        /// Calculates the number of rows
+    static int calcNumRows(Format format, int height);
+
+    int m_width;
+    int m_height;
+    Format m_format;
+
+    uint8_t* m_data;                    /// The data that makes up the image. If nullptr, has no data. Pointer to first 'row' of the image.
+
+    int m_numRows;                      ///< Total amount of rows (typically same as height, but in compressed formats may be less)
+    int m_rowStrideInBytes;             ///< The number of bytes between rows
+
+    SurfaceAllocator* m_allocator;      ///< Can be null if so contents is 'unowned', if set
+};
+
+} // renderer_test