Fix typo in publish.sh.

Make more shell scripts.

Fix removed old function.

Add a workflow.

Add docker-compose.yaml version.

Update .gitea/workflows/build.yaml

Trying to see if this helps.

Add executable bit to shell scripts.

Where did my files go?

Fix executable bit of higher repository.

Change build scripts slightly to maybe fix CI?

Update .gitea/workflows/build.yaml

List all files in home directory of the runner.

Another silly push.

List stuff.

YEss another useless push.

Yet another attempt to fix CI builds.

This is getting out of hand.

Chnage build script.

Use unencrypted storage for the key because Nuget is nuget.

.gitea/workflows/build.yaml

@@ -1,24 +1,28 @@
 name: Build
-run-name: Building docker container.
+run-name: Building with docker container.
 on:
   workflow_dispatch:
   push:
-    branches: stable
+    tags:
+      - '*'
 
 jobs:
   build:
     runs-on: ubuntu-latest
-    env:
+    container:
-      QUIK_API_KEY: "${{secrets.QUIK_API_KEY}}"
+      image: git.mixedup.dev/refuel/docker-cross-compiler
+      env:
+        REFUEL_API_KEY: "${{secrets.REFUEL_API_KEY}}"
+        NUGET_USER_NAME: "${{vars.NUGET_USER_NAME}}"
+        NUGET_INDEX: "${{vars.NUGET_INDEX}}"
+      volumes:
+        - ${{ gitea.workspace }}:/home/refuel/src
     steps:
-      - name: Update Package Repository.
-        run: apt update -y
-      - name: Gather dependencies.
-        run: apt install -y docker.io docker-compose
       - name: Check repository out.
         uses: actions/checkout@v3
+        with:
+          submodules: recursive
       - name: Run Build Script
-        run: docker-compose run build
+        run: "./build_native.sh"
-        working-directory: ${{ gitea.workspace }}
+      - name: Publish Package
-      - name: Upload NuGet Package
+        run: "./publish.sh"
-        run: "bash ${{ gitea.workspace }}/publish.sh"

.gitignore

@@ -2,3 +2,5 @@
 **/obj
 **/out
 **/runtimes
+**/.vs*
+**/.atom

.gitmodules

@@ -1,6 +1,6 @@
 [submodule "stb"]
 	path = stb
 	url = https://github.com/nothings/stb.git
-[submodule "Quik.Common"]
+[submodule "docker-cross-compiler"]
-	path = Quik.Common
+	path = docker-cross-compiler
-	url = https://git.mixedup.dev/QUIK/Quik.Common.git
+	url = https://git.mixedup.dev/ReFuel/docker-cross-compiler

3RDPARTY.md

@@ -0,0 +1,47 @@
+This package uses 3rd-party software from the following vendors:
+
+-----
+* nothings/stb_image.h
+* nothigns/stb_image_writer.h
+
+https://raw.githubusercontent.com/nothings/stb/master/LICENSE
+
+This software is available under 2 licenses -- choose whichever you prefer.
+
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+-----

CMakeLists.txt

@@ -1,10 +1,12 @@
 cmake_minimum_required(VERSION 3.0)
 
-project(quik_stbi LANGUAGES C VERSION 1.0)
+project(rf_stbi LANGUAGES C VERSION 1.0)
 
-add_compile_options(-static-libgcc)
+if (NOT ("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin"))
+    add_compile_options(-static-libgcc -static-libstdc++ -fno-exceptions)
+endif()
 
-add_library(stbi SHARED "quik_stbi.c")
+add_library(stbi SHARED "rf_stbi.c")
 install(
     TARGETS stbi
     RUNTIME DESTINATION .

LICENSE.md

@@ -0,0 +1,19 @@
+Copyright (c) 2024 ReFuel.StbImage - H. Utku Maden
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+Also see 3RDPARTY.md

NativeTypeNameAttribute.cs

@@ -1,6 +1,6 @@
 using System;
 
-namespace Quik.Stb.Image
+namespace Quik.Stb
 {
     [AttributeUsage(System.AttributeTargets.All, Inherited = false, AllowMultiple = true)]
     internal sealed class NativeTypeNameAttribute : System.Attribute

README.md

@@ -0,0 +1,9 @@
+ReFuel.StbImage
+=============
+ReFuel.StbImage is a binary distribution of the popular stb_image.h single header
+library. Existing packages were either bad source ports, had odd wrappers or
+weren't up to date.
+
+Originally intended for my own purposes, however feel free to view the code at
+https://git.mixedup.dev/ReFuel/ReFuel.StbImage, and shoot me patch files through
+email.

ReFuel.StbImage.csproj

@@ -5,18 +5,22 @@
     <Nullable>disable</Nullable>
     <LangVersion>7.3</LangVersion>
     <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
-    <RuntimeIdentifiers>linux-arm;linux-arm64;linux-x64;win-x86;win-x64</RuntimeIdentifiers>
+    <RuntimeIdentifiers>linux-arm;linux-arm64;linux-x64;win-x86;win-x64;osx-arm64;osx-x64</RuntimeIdentifiers>
+    <RootNamespace>ReFuel.Stb</RootNamespace>
   </PropertyGroup>
 
   <PropertyGroup>
     <!-- Nuget Properties. -->
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
-    <PackageId>Quik.StbImage</PackageId>
+    <PackageId>ReFuel.StbImage</PackageId>
     <Version>1.0.0</Version>
     <Authors>STBI Authors, H. Utku Maden</Authors>
     <Description>
-      A C# wrapper for the ubiquitous Stb Image library.
+      A C# wrapper for the ubiquitous stb_image.h and stb_image_write.h library.
     </Description>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
+    <PackageLicenseFile>LICENSE.md</PackageLicenseFile>
+    <PackageIcon>images\icon.png</PackageIcon>
   </PropertyGroup>
 
   <!--
@@ -26,6 +30,8 @@
     that determines a lot of load paths for projects.
   -->
   <ItemGroup>
+    <Content Include="*.md" Pack="true" PackagePath="/"/>
+    <None Include="rf_stbimage.png" Pack="true" PackagePath="images\icon.png"/>
     <Content Include="runtimes/linux-arm/native/*.so">
       <PackagePath>runtimes/linux-arm/native/</PackagePath>
       <Pack>true</Pack>
@@ -56,6 +62,16 @@
       <Pack>true</Pack>
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <Content Include="runtimes/osx-x64/native/*.dylib">
+      <PackagePath>runtimes/osx-x64/native/</PackagePath>
+      <Pack>true</Pack>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="runtimes/osx-arm64/native/*.dylib">
+      <PackagePath>runtimes/osx-arm64/native/</PackagePath>
+      <Pack>true</Pack>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
   </ItemGroup>
 
 </Project>

ReFuel.StbImage.sln

@@ -1,25 +1,22 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 17
-VisualStudioVersion = 17.5.002.0
+VisualStudioVersion = 17.0.31903.59
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Quik.StbImage", "Quik.StbImage.csproj", "{C808B4BC-C3AF-4682-8EDA-EAAC780800C3}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ReFuel.StbImage", "ReFuel.StbImage.csproj", "{413ACBF4-3851-416F-B2A2-F7157EC306B2}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
 		Release|Any CPU = Release|Any CPU
 	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{C808B4BC-C3AF-4682-8EDA-EAAC780800C3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{C808B4BC-C3AF-4682-8EDA-EAAC780800C3}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{C808B4BC-C3AF-4682-8EDA-EAAC780800C3}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{C808B4BC-C3AF-4682-8EDA-EAAC780800C3}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		SolutionGuid = {B04E5FBA-41E6-4B0B-BC31-F996BE353F5A}
+		{413ACBF4-3851-416F-B2A2-F7157EC306B2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{413ACBF4-3851-416F-B2A2-F7157EC306B2}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{413ACBF4-3851-416F-B2A2-F7157EC306B2}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{413ACBF4-3851-416F-B2A2-F7157EC306B2}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 EndGlobal

StbImage.cs

@@ -2,7 +2,7 @@ using System;
 using System.IO;
 using System.Runtime.InteropServices;
 
-namespace Quik.Stb
+namespace ReFuel.Stb
 {
     /// <summary>
     /// A class that encompasses all features of stb_image.h in a safe way.
@@ -31,6 +31,9 @@ namespace Quik.Stb
         /// Internal image format.
         /// </summary>
         public StbiImageFormat Format { get; }
+        /// <summary>
+        /// True if the image is a floating point image.
+        /// </summary>
         public bool IsFloat { get; }
 
         private StbImage(IntPtr image, int x, int y, StbiImageFormat format, bool isFloat)
@@ -112,6 +115,42 @@ namespace Quik.Stb
             }
         }
 
+        /// <summary>
+        /// Try loading an image, without raising exceptions.
+        /// </summary>
+        /// <param name="image">The resulting image.</param>
+        /// <param name="span">Source memory span.</param>
+        /// <param name="format">The desired image format.</param>
+        /// <returns>True on success.</returns>
+        public static bool TryLoad<T>(out StbImage image, ReadOnlySpan<T> span, StbiImageFormat format = StbiImageFormat.Default, bool isFloat = false)
+            where T : unmanaged
+        {
+            IntPtr imagePtr = IntPtr.Zero;
+            int x, y, iFormat;
+            fixed (byte *ptr = MemoryMarshal.AsBytes(span))
+            {
+                if (isFloat)
+                {
+                    imagePtr = (IntPtr)Stbi.loadf_from_memory(ptr, span.Length * sizeof(T), &x, &y, &iFormat, (int)format);
+                }
+                else
+                {
+                    imagePtr = (IntPtr)Stbi.load_from_memory(ptr, span.Length * sizeof(T), &x, &y, &iFormat, (int)format);
+                }
+
+                if (imagePtr != IntPtr.Zero)
+                {
+                    image = new StbImage(imagePtr, x, y, (StbiImageFormat)iFormat, isFloat);
+                    return true;
+                }
+                else
+                {
+                    image = null;
+                    return false;
+                }
+            }
+        }
+
         /// <summary>
         /// Load an image.
         /// </summary>
@@ -129,7 +168,33 @@ namespace Quik.Stb
             throw new Exception($"Failed to load image: {reason}");
         }
 
-        public bool IsLoadable(Stream stream)
+        /// <summary>
+        /// Load an image.
+        /// </summary>
+        /// <param name="span">The span of memory to load from.</param>
+        /// <param name="format">The desired image format.</param>
+        /// <returns>The image object.</returns>
+        public static StbImage Load<T>(ReadOnlySpan<T> span, StbiImageFormat format = StbiImageFormat.Default, bool isFloat = false)
+            where T : unmanaged
+        {
+            if (TryLoad(out StbImage image, span, format, isFloat))
+            {
+                return image;
+            }
+
+            string reason = Marshal.PtrToStringUTF8((IntPtr)Stbi.failure_reason());
+            throw new Exception($"Failed to load image: {reason}");
+        }
+
+        /// <summary>
+        /// Peek image info from a stream.
+        /// </summary>
+        /// <param name="stream">The stream to peek into.</param>
+        /// <param name="width">Width of the image.</param>
+        /// <param name="height">Height of the image.</param>
+        /// <param name="format">The image format.</param>
+        /// <returns>True if the stream contained an image.</returns>
+        public static bool PeekInfo(Stream stream, out int width, out int height, out StbiImageFormat format)
         {
             int x, y, iFormat;
             StbiStreamWrapper wrapper = new StbiStreamWrapper(stream, true);
@@ -138,7 +203,32 @@ namespace Quik.Stb
             stream.Position = 0;
             int result = Stbi.info_from_callbacks(&cb, null, &x, &y, &iFormat);
 
+            width = x;
+            height = y;
+            format = (StbiImageFormat)iFormat;
+
             return result != 0;
         }
+
+        /// <summary>
+        /// Peek image info from a span.
+        /// </summary>
+        /// <param name="span">The span to peek into.</param>
+        /// <param name="width">Width of the image.</param>
+        /// <param name="height">Height of the image.</param>
+        /// <param name="format">The image format.</param>
+        /// <returns>True if the stream contained an image.</returns>
+        public static bool PeekInfo<T>(ReadOnlySpan<T> span, out int width, out int height, out StbiImageFormat format) where T : unmanaged
+        {
+            fixed (byte* ptr = MemoryMarshal.AsBytes(span))
+            {
+                int x, y, iFormat;
+                int result = Stbi.info_from_memory(ptr, span.Length * sizeof(T), &x, &y, &iFormat);
+                width = x;
+                height = y;
+                format = (StbiImageFormat)iFormat;
+                return result != 0;
+            }
+        }
     }
 }

Stbi.Manual.cs

@@ -4,7 +4,7 @@ using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Reflection;
 
-namespace Quik.Stb
+namespace ReFuel.Stb
 {
     public unsafe static partial class Stbi
     {
@@ -19,7 +19,8 @@ namespace Quik.Stb
             "runtimes/linux-arm/native/libstbi.so",
             "runtimes/linux-arm64/native/libstbi.so",
             "runtimes/linux-x64/native/libstbi.so",
-            "runtimes/native/libstbi.dylib",
+            "runtimes/osx-arm64/libstbi.dylib",
+            "runtimes/osx-x64/libstbi.dylib",
             "libstbi.dll",
             "libstbi.so",
             "libstbi.dylib",
@@ -28,8 +29,6 @@ namespace Quik.Stb
         static Stbi()
         {
             NativeLibrary.SetDllImportResolver(Assembly.GetExecutingAssembly(), Resolver);
-
-            // quik_stbi_failed_assert_store(Marshal.GetFunctionPointerForDelegate<FailedAssertProc>(FailedAssert));
         }
 
         private static IntPtr Resolver(string libraryName, Assembly assembly, DllImportSearchPath? searchPath)
@@ -47,19 +46,5 @@ namespace Quik.Stb
 
             return NativeLibrary.Load(libraryName);
         }
-
-        private static void FailedAssert(byte *expression, byte *file, int line, byte *function)
-        {
-            string expr = expression == null ? string.Empty : Marshal.PtrToStringUTF8((IntPtr)expression);
-            string f    = file       == null ? string.Empty : Marshal.PtrToStringUTF8((IntPtr)file);
-            string func = function   == null ? string.Empty : Marshal.PtrToStringUTF8((IntPtr)function);
-
-            Exception ex = new Exception("Assert failed in native stbi code.");
-                ex.Data.Add("Expression", expr);
-                ex.Data.Add("File", f);
-                ex.Data.Add("Line", line);
-                ex.Data.Add("Function", func);
-            throw ex;
-        }
     }
 }

Stbi.cs

@@ -1,10 +1,8 @@
 using System;
 using System.Runtime.InteropServices;
-using Quik.Stb.Image;
 
-namespace Quik.Stb
+namespace ReFuel.Stb
 {
-    [NativeTypeName("unsigned int")]
     public enum StbiEnum : uint
     {
         STBI_default = 0,
@@ -16,65 +14,62 @@ namespace Quik.Stb
 
     public partial struct stbi_io_callbacks
     {
-        [NativeTypeName("int (*)(void *, char *, int)")]
         public IntPtr read;
 
-        [NativeTypeName("void (*)(void *, int)")]
         public IntPtr skip;
 
-        [NativeTypeName("int (*)(void *)")]
         public IntPtr eof;
     }
 
     public static unsafe partial class Stbi
     {
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_load_from_memory", ExactSpelling = true)]
-        [return: NativeTypeName("stbi_uc *")]
+
-        public static extern byte* load_from_memory([NativeTypeName("const stbi_uc *")] byte* buffer, int len, int* x, int* y, int* channels_in_file, int desired_channels);
+        public static extern byte* load_from_memory(byte* buffer, int len, int* x, int* y, int* channels_in_file, int desired_channels);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_load_from_callbacks", ExactSpelling = true)]
-        [return: NativeTypeName("stbi_uc *")]
+
-        public static extern byte* load_from_callbacks([NativeTypeName("const stbi_io_callbacks *")] stbi_io_callbacks* clbk, void* user, int* x, int* y, int* channels_in_file, int desired_channels);
+        public static extern byte* load_from_callbacks(stbi_io_callbacks* clbk, void* user, int* x, int* y, int* channels_in_file, int desired_channels);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_load", ExactSpelling = true)]
-        [return: NativeTypeName("stbi_uc *")]
+
-        public static extern byte* load([NativeTypeName("const char *")] sbyte* filename, int* x, int* y, int* channels_in_file, int desired_channels);
+        public static extern byte* load(sbyte* filename, int* x, int* y, int* channels_in_file, int desired_channels);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_load_from_file", ExactSpelling = true)]
-        [return: NativeTypeName("stbi_uc *")]
+
-        public static extern byte* load_from_file([NativeTypeName("FILE *")] void* f, int* x, int* y, int* channels_in_file, int desired_channels);
+        public static extern byte* load_from_file(void* f, int* x, int* y, int* channels_in_file, int desired_channels);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_load_gif_from_memory", ExactSpelling = true)]
-        [return: NativeTypeName("stbi_uc *")]
+
-        public static extern byte* load_gif_from_memory([NativeTypeName("const stbi_uc *")] byte* buffer, int len, int** delays, int* x, int* y, int* z, int* comp, int req_comp);
+        public static extern byte* load_gif_from_memory(byte* buffer, int len, int** delays, int* x, int* y, int* z, int* comp, int req_comp);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_load_16_from_memory", ExactSpelling = true)]
-        [return: NativeTypeName("stbi_us *")]
+
-        public static extern ushort* load_16_from_memory([NativeTypeName("const stbi_uc *")] byte* buffer, int len, int* x, int* y, int* channels_in_file, int desired_channels);
+        public static extern ushort* load_16_from_memory(byte* buffer, int len, int* x, int* y, int* channels_in_file, int desired_channels);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_load_16_from_callbacks", ExactSpelling = true)]
-        [return: NativeTypeName("stbi_us *")]
+
-        public static extern ushort* load_16_from_callbacks([NativeTypeName("const stbi_io_callbacks *")] stbi_io_callbacks* clbk, void* user, int* x, int* y, int* channels_in_file, int desired_channels);
+        public static extern ushort* load_16_from_callbacks(stbi_io_callbacks* clbk, void* user, int* x, int* y, int* channels_in_file, int desired_channels);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_load_16", ExactSpelling = true)]
-        [return: NativeTypeName("stbi_us *")]
+
-        public static extern ushort* load_16([NativeTypeName("const char *")] sbyte* filename, int* x, int* y, int* channels_in_file, int desired_channels);
+        public static extern ushort* load_16(sbyte* filename, int* x, int* y, int* channels_in_file, int desired_channels);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_load_from_file_16", ExactSpelling = true)]
-        [return: NativeTypeName("stbi_us *")]
+
-        public static extern ushort* load_from_file_16([NativeTypeName("FILE *")] void* f, int* x, int* y, int* channels_in_file, int desired_channels);
+        public static extern ushort* load_from_file_16(void* f, int* x, int* y, int* channels_in_file, int desired_channels);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_loadf_from_memory", ExactSpelling = true)]
-        public static extern float* loadf_from_memory([NativeTypeName("const stbi_uc *")] byte* buffer, int len, int* x, int* y, int* channels_in_file, int desired_channels);
+        public static extern float* loadf_from_memory(byte* buffer, int len, int* x, int* y, int* channels_in_file, int desired_channels);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_loadf_from_callbacks", ExactSpelling = true)]
-        public static extern float* loadf_from_callbacks([NativeTypeName("const stbi_io_callbacks *")] stbi_io_callbacks* clbk, void* user, int* x, int* y, int* channels_in_file, int desired_channels);
+        public static extern float* loadf_from_callbacks(stbi_io_callbacks* clbk, void* user, int* x, int* y, int* channels_in_file, int desired_channels);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_loadf", ExactSpelling = true)]
-        public static extern float* loadf([NativeTypeName("const char *")] sbyte* filename, int* x, int* y, int* channels_in_file, int desired_channels);
+        public static extern float* loadf(sbyte* filename, int* x, int* y, int* channels_in_file, int desired_channels);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_loadf_from_file", ExactSpelling = true)]
-        public static extern float* loadf_from_file([NativeTypeName("FILE *")] void* f, int* x, int* y, int* channels_in_file, int desired_channels);
+        public static extern float* loadf_from_file(void* f, int* x, int* y, int* channels_in_file, int desired_channels);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_hdr_to_ldr_gamma", ExactSpelling = true)]
         public static extern void hdr_to_ldr_gamma(float gamma);
@@ -89,47 +84,47 @@ namespace Quik.Stb
         public static extern void ldr_to_hdr_scale(float scale);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_is_hdr_from_callbacks", ExactSpelling = true)]
-        public static extern int is_hdr_from_callbacks([NativeTypeName("const stbi_io_callbacks *")] stbi_io_callbacks* clbk, void* user);
+        public static extern int is_hdr_from_callbacks(stbi_io_callbacks* clbk, void* user);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_is_hdr_from_memory", ExactSpelling = true)]
-        public static extern int is_hdr_from_memory([NativeTypeName("const stbi_uc *")] byte* buffer, int len);
+        public static extern int is_hdr_from_memory(byte* buffer, int len);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_is_hdr", ExactSpelling = true)]
-        public static extern int is_hdr([NativeTypeName("const char *")] sbyte* filename);
+        public static extern int is_hdr(sbyte* filename);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_is_hdr_from_file", ExactSpelling = true)]
-        public static extern int is_hdr_from_file([NativeTypeName("FILE *")] void* f);
+        public static extern int is_hdr_from_file(void* f);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_failure_reason", ExactSpelling = true)]
-        [return: NativeTypeName("const char *")]
+
         public static extern sbyte* failure_reason();
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_image_free", ExactSpelling = true)]
         public static extern void image_free(void* retval_from_stbi_load);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_info_from_memory", ExactSpelling = true)]
-        public static extern int info_from_memory([NativeTypeName("const stbi_uc *")] byte* buffer, int len, int* x, int* y, int* comp);
+        public static extern int info_from_memory(byte* buffer, int len, int* x, int* y, int* comp);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_info_from_callbacks", ExactSpelling = true)]
-        public static extern int info_from_callbacks([NativeTypeName("const stbi_io_callbacks *")] stbi_io_callbacks* clbk, void* user, int* x, int* y, int* comp);
+        public static extern int info_from_callbacks(stbi_io_callbacks* clbk, void* user, int* x, int* y, int* comp);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_is_16_bit_from_memory", ExactSpelling = true)]
-        public static extern int is_16_bit_from_memory([NativeTypeName("const stbi_uc *")] byte* buffer, int len);
+        public static extern int is_16_bit_from_memory(byte* buffer, int len);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_is_16_bit_from_callbacks", ExactSpelling = true)]
-        public static extern int is_16_bit_from_callbacks([NativeTypeName("const stbi_io_callbacks *")] stbi_io_callbacks* clbk, void* user);
+        public static extern int is_16_bit_from_callbacks(stbi_io_callbacks* clbk, void* user);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_info", ExactSpelling = true)]
-        public static extern int info([NativeTypeName("const char *")] sbyte* filename, int* x, int* y, int* comp);
+        public static extern int info(sbyte* filename, int* x, int* y, int* comp);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_info_from_file", ExactSpelling = true)]
-        public static extern int info_from_file([NativeTypeName("FILE *")] void* f, int* x, int* y, int* comp);
+        public static extern int info_from_file(void* f, int* x, int* y, int* comp);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_is_16_bit", ExactSpelling = true)]
-        public static extern int is_16_bit([NativeTypeName("const char *")] sbyte* filename);
+        public static extern int is_16_bit(sbyte* filename);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_is_16_bit_from_file", ExactSpelling = true)]
-        public static extern int is_16_bit_from_file([NativeTypeName("FILE *")] void* f);
+        public static extern int is_16_bit_from_file(void* f);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_set_unpremultiply_on_load", ExactSpelling = true)]
         public static extern void set_unpremultiply_on_load(int flag_true_if_should_unpremultiply);
@@ -150,25 +145,25 @@ namespace Quik.Stb
         public static extern void set_flip_vertically_on_load_thread(int flag_true_if_should_flip);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_zlib_decode_malloc_guesssize", ExactSpelling = true)]
-        [return: NativeTypeName("char *")]
+
-        public static extern sbyte* zlib_decode_malloc_guesssize([NativeTypeName("const char *")] sbyte* buffer, int len, int initial_size, int* outlen);
+        public static extern sbyte* zlib_decode_malloc_guesssize(sbyte* buffer, int len, int initial_size, int* outlen);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_zlib_decode_malloc_guesssize_headerflag", ExactSpelling = true)]
-        [return: NativeTypeName("char *")]
+
-        public static extern sbyte* zlib_decode_malloc_guesssize_headerflag([NativeTypeName("const char *")] sbyte* buffer, int len, int initial_size, int* outlen, int parse_header);
+        public static extern sbyte* zlib_decode_malloc_guesssize_headerflag(sbyte* buffer, int len, int initial_size, int* outlen, int parse_header);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_zlib_decode_malloc", ExactSpelling = true)]
-        [return: NativeTypeName("char *")]
+
-        public static extern sbyte* zlib_decode_malloc([NativeTypeName("const char *")] sbyte* buffer, int len, int* outlen);
+        public static extern sbyte* zlib_decode_malloc(sbyte* buffer, int len, int* outlen);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_zlib_decode_buffer", ExactSpelling = true)]
-        public static extern int zlib_decode_buffer([NativeTypeName("char *")] sbyte* obuffer, int olen, [NativeTypeName("const char *")] sbyte* ibuffer, int ilen);
+        public static extern int zlib_decode_buffer(sbyte* ibuffer, int ilen);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_zlib_decode_noheader_malloc", ExactSpelling = true)]
-        [return: NativeTypeName("char *")]
+
-        public static extern sbyte* zlib_decode_noheader_malloc([NativeTypeName("const char *")] sbyte* buffer, int len, int* outlen);
+        public static extern sbyte* zlib_decode_noheader_malloc(sbyte* buffer, int len, int* outlen);
 
         [DllImport("stbi", CallingConvention = CallingConvention.Cdecl, EntryPoint = "stbi_zlib_decode_noheader_buffer", ExactSpelling = true)]
-        public static extern int zlib_decode_noheader_buffer([NativeTypeName("char *")] sbyte* obuffer, int olen, [NativeTypeName("const char *")] sbyte* ibuffer, int ilen);
+        public static extern int zlib_decode_noheader_buffer(sbyte* ibuffer, int ilen);
     }
 }

StbiImageFormat.cs

@@ -1,4 +1,4 @@
-namespace Quik.Stb
+namespace ReFuel.Stb
 {
     public enum StbiImageFormat
     {

StbiStreamWrapper.cs

@@ -2,17 +2,21 @@ using System;
 using System.IO;
 using System.Runtime.InteropServices;
 
-namespace Quik.Stb
+namespace ReFuel.Stb
 {
+    public unsafe delegate int StbiReadProc(void *userdata, byte* buffer, int count);
+    public unsafe delegate void StbiSkipProc(void *userdata, int count);
+    public unsafe delegate int StbiEofProc(void *userdata);
+
     public unsafe class StbiStreamWrapper : IDisposable
     {
         private Stream _stream;
         private bool _keepOpen;
         private bool _isDisposed;
 
-        private delegate int ReadProc(void *userdata, byte* buffer, int count);
+        private StbiReadProc _readCb;
-        private delegate void SkipProc(void *userdata, int count);
+        private StbiSkipProc _skipCb;
-        private delegate int Eof(void *userdata);
+        private StbiEofProc _eofCb;
 
         public StbiStreamWrapper(Stream stream, bool keepOpen = false)
         {
@@ -20,14 +24,18 @@ namespace Quik.Stb
 
             _stream = stream;
             _keepOpen = keepOpen;
+
+            _readCb = ReadCb;
+            _skipCb = SkipCb;
+            _eofCb = EofCb;
         }
 
         public void CreateCallbacks(out stbi_io_callbacks cb)
         {
             cb = default;
-            cb.read = Marshal.GetFunctionPointerForDelegate<ReadProc>(ReadCb);
+            cb.read = Marshal.GetFunctionPointerForDelegate<StbiReadProc>(_readCb);
-            cb.skip = Marshal.GetFunctionPointerForDelegate<SkipProc>(SkipCb);
+            cb.skip = Marshal.GetFunctionPointerForDelegate<StbiSkipProc>(_skipCb);
-            cb.eof = Marshal.GetFunctionPointerForDelegate<Eof>(EofCb);
+            cb.eof = Marshal.GetFunctionPointerForDelegate<StbiEofProc>(_eofCb);
         }
 
         private int ReadCb(void *userdata, byte* buffer, int count)

build_ci_cd.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+cd $(dirname "$0")
+if [ -z "$QUIK_API_KEY" ]
+then
+    echo "Please define QUIK_API_KEY"
+    exit 1
+fi
+
+pwd
+docker-compose run build && docker-compose run publish

build_native.sh

@@ -1,4 +1,4 @@
 #!/bin/bash
 cd $(dirname "$0")
-Quik.Common/sh/quik_build_native.sh .
+./docker-cross-compiler/sh/build_native.sh .
 dotnet build

docker-compose.yaml

@@ -2,7 +2,15 @@ version: "2"
 
 services:
   build:
-    image: git.mixedup.dev/quik/docker-cross-compiler
+    image: git.mixedup.dev/refuel/docker-cross-compiler
-    command: "/home/quik/src/build_native.sh"
+    command: "/home/refuel/src/build_native.sh"
     volumes:
-      - .:/home/quik/src
+      - .:/home/refuel/src
+  publish:
+    image: git.mixedup.dev/refuel/docker-cross-compiler
+    command: "/home/refuel/src/publish.sh"
+    environment:
+      QUIK_API_KEY: ${QUIK_API_KEY}
+    volumes:
+      - .:/home/refuel/src
+      

publish.sh

@@ -1,11 +1,27 @@
 #!/bin/bash
 
 cd $(dirname "$0")
-if [ -z "$QUIK_API_KEY" ]
+
+if [ -z "$REFUEL_API_KEY" ]
 then
-    echo "Please define QUIK_API_KEY"
+    echo "Please define REFUEL_API_KEY"
     exit 1
 fi
 
-dotnet nuget add source -n QUIK -u themixedupstuff -p "$QUIK_API_KEY" https://git.mixedup.dev/api/packages/QUIK/nuget/index.json
+if [ -z "$NUGET_USER_NAME" ]
-dotnet nuget push -s QUIK
+then
+    echo "Please define NUGET_USER_NAME"
+    exit 1
+fi
+
+if [ -z "$NUGET_INDEX" ]
+then
+    echo "Please define NUGET_INDEX"
+    exit 1
+fi
+
+dotnet nuget add source \
+    -n ReFuel -u "$NUGET_USER_NAME" -p "$REFUEL_API_KEY" \
+    --store-password-in-clear-text \
+    "$NUGET_INDEX"
+dotnet nuget push -s ReFuel bin/*/*.nupkg

quik_stbi.c

@@ -1,4 +0,0 @@
-#include "quik_stbi.h"
-
-#define STB_IMAGE_IMPLEMENTATION 1
-#include "stb/stb_image.h"

quik_stbi.h

@@ -1,10 +0,0 @@
-#ifndef _QUIK_STBI_H_
-#define _QUIK_STBI_H_
-
-#include "Quik.Common/include/quik_common.h"
-
-#define STBIDEF QEXTERN
-
-#include "stb/stb_image.h"
-
-#endif

rf_stbi.c

@@ -0,0 +1,7 @@
+#include "rf_stbi.h"
+
+#define STB_IMAGE_IMPLEMENTATION 1
+#include "stb/stb_image.h"
+
+#define STB_IMAGE_WRITE_IMPLEMENTATION 1
+#include "stb/stb_image_write.h"

rf_stbi.h

@@ -0,0 +1,13 @@
+#ifndef _REFUEL_STBI_H_
+#define _REFUEL_STBI_H_
+
+#include "docker-cross-compiler/include/rf_common.h"
+
+#define STBIDEF RFEXTERN
+#define STBI_NO_THREAD_LOCALS 1
+#include "stb/stb_image.h"
+
+#define STBI_WRITE_NO_STDIO 1
+#include "stb/stb_image_write.h"
+
+#endif

stb_image.rsp

@@ -10,18 +10,18 @@
     generate-setslastsystemerror-attribute
     unix-types
 --include-directory
-    ../lib
+    stb
 --include-directory
-    ../Quik.StbImage
+    .
 --include-directory
     /usr/lib/llvm-14/lib/clang/14.0.6/include
 --file
-    ../Quik.StbImage.redist/quik_stbi.h
+    rf_stbi.h
-    ../lib/stb/stb_image.h
+    stb/stb_image.h
 --methodClassName
     Stbi
 --namespace
-    Quik.Stb
+    ReFuel.Stb
 --output
     Stbi.cs
 --prefixStrip

stb_image_write.rsp

@@ -0,0 +1,30 @@
+-x
+    c
+-l
+    stbi
+--config
+    compatible-codegen
+    single-file
+    exclude-fnptr-codegen
+    generate-aggressive-inlining
+    generate-setslastsystemerror-attribute
+    unix-types
+--include-directory
+    stb
+--include-directory
+    .
+--include-directory
+    /usr/lib/llvm-14/lib/clang/14.0.6/include
+--file
+    rf_stbi.h
+    stb/stb_image_write.h
+--methodClassName
+    StbiWrite
+--namespace
+    ReFuel.Stb
+--output
+    StbiWrite.cs
+--prefixStrip
+    stbi_write_
+--with-type
+    FILE=void