Merge pull request 'main' (#102) from Onek8/LNXSDK:main into main

Reviewed-on: LeenkxTeam/LNXSDK#102

.gitattributes

@@ -0,0 +1,2 @@
+*.hdr binary
+blender/lnx/props.py ident

.gitignore

@@ -0,0 +1,3 @@
+__pycache__/
+*.pyc
+*.DS_Store

Kha/Backends/Kinc-HL/hl/include/mbedtls/library/entropy_poll.c

@@ -1,268 +1,268 @@
-/*
- *  Platform-specific and custom entropy polling functions
- *
- *  Copyright (C) 2006-2016, ARM Limited, All Rights Reserved
- *  SPDX-License-Identifier: Apache-2.0
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may
- *  not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *  http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *  This file is part of mbed TLS (https://tls.mbed.org)
- */
-
-#if !defined(MBEDTLS_CONFIG_FILE)
-#include "mbedtls/config.h"
-#else
-#include MBEDTLS_CONFIG_FILE
-#endif
-
-#if defined(MBEDTLS_ENTROPY_C)
-
-#include "mbedtls/entropy.h"
-#include "mbedtls/entropy_poll.h"
-
-#if defined(MBEDTLS_TIMING_C)
-#include <string.h>
-#include "mbedtls/timing.h"
-#endif
-#if defined(MBEDTLS_HAVEGE_C)
-#include "mbedtls/havege.h"
-#endif
-#if defined(MBEDTLS_ENTROPY_NV_SEED)
-#include "mbedtls/platform.h"
-#endif
-
-#if !defined(MBEDTLS_NO_PLATFORM_ENTROPY)
-
-#if !defined(unix) && !defined(__unix__) && !defined(__unix) && \
-    !defined(__APPLE__) && !defined(_WIN32)
-#error "Platform entropy sources only work on Unix and Windows, see MBEDTLS_NO_PLATFORM_ENTROPY in config.h"
-#endif
-
-#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
-
-#if !defined(_WIN32_WINNT)
-#define _WIN32_WINNT 0x0400
-#endif
-#include <windows.h>
-#include <wincrypt.h>
-
-int mbedtls_platform_entropy_poll( void *data, unsigned char *output, size_t len,
-                           size_t *olen )
-{
-    HCRYPTPROV provider;
-    ((void) data);
-    *olen = 0;
-
-    if( CryptAcquireContext( &provider, NULL, NULL,
-                              PROV_RSA_FULL, CRYPT_VERIFYCONTEXT ) == FALSE )
-    {
-        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
-    }
-
-    if( CryptGenRandom( provider, (DWORD) len, output ) == FALSE )
-    {
-        CryptReleaseContext( provider, 0 );
-        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
-    }
-
-    CryptReleaseContext( provider, 0 );
-    *olen = len;
-
-    return( 0 );
-}
-#else /* _WIN32 && !EFIX64 && !EFI32 */
-
-/*
- * Test for Linux getrandom() support.
- * Since there is no wrapper in the libc yet, use the generic syscall wrapper
- * available in GNU libc and compatible libc's (eg uClibc).
- */
-#if defined(__linux__) && defined(__GLIBC__)
-#include <unistd.h>
-#include <sys/syscall.h>
-#if defined(SYS_getrandom)
-#define HAVE_GETRANDOM
-
-static int getrandom_wrapper( void *buf, size_t buflen, unsigned int flags )
-{
-    /* MemSan cannot understand that the syscall writes to the buffer */
-#if defined(__has_feature)
-#if __has_feature(memory_sanitizer)
-    memset( buf, 0, buflen );
-#endif
-#endif
-
-    return( syscall( SYS_getrandom, buf, buflen, flags ) );
-}
-
-#include <sys/utsname.h>
-/* Check if version is at least 3.17.0 */
-static int check_version_3_17_plus( void )
-{
-    int minor;
-    struct utsname un;
-    const char *ver;
-
-    /* Get version information */
-    uname(&un);
-    ver = un.release;
-
-    /* Check major version; assume a single digit */
-    if( ver[0] < '3' || ver[0] > '9' || ver [1] != '.' )
-        return( -1 );
-
-    if( ver[0] - '0' > 3 )
-        return( 0 );
-
-    /* Ok, so now we know major == 3, check minor.
-     * Assume 1 or 2 digits. */
-    if( ver[2] < '0' || ver[2] > '9' )
-        return( -1 );
-
-    minor = ver[2] - '0';
-
-    if( ver[3] >= '0' && ver[3] <= '9' )
-        minor = 10 * minor + ver[3] - '0';
-    else if( ver [3] != '.' )
-        return( -1 );
-
-    if( minor < 17 )
-        return( -1 );
-
-    return( 0 );
-}
-static int has_getrandom = -1;
-#endif /* SYS_getrandom */
-#endif /* __linux__ */
-
-#include <stdio.h>
-
-int mbedtls_platform_entropy_poll( void *data,
-                           unsigned char *output, size_t len, size_t *olen )
-{
-    FILE *file;
-    size_t read_len;
-    ((void) data);
-
-#if defined(HAVE_GETRANDOM)
-    if( has_getrandom == -1 )
-        has_getrandom = ( check_version_3_17_plus() == 0 );
-
-    if( has_getrandom )
-    {
-        int ret;
-
-        if( ( ret = getrandom_wrapper( output, len, 0 ) ) < 0 )
-            return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
-
-        *olen = ret;
-        return( 0 );
-    }
-#endif /* HAVE_GETRANDOM */
-
-    *olen = 0;
-
-    file = fopen( "/dev/urandom", "rb" );
-    if( file == NULL )
-        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
-
-    read_len = fread( output, 1, len, file );
-    if( read_len != len )
-    {
-        fclose( file );
-        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
-    }
-
-    fclose( file );
-    *olen = len;
-
-    return( 0 );
-}
-#endif /* _WIN32 && !EFIX64 && !EFI32 */
-#endif /* !MBEDTLS_NO_PLATFORM_ENTROPY */
-
-#if defined(MBEDTLS_TEST_NULL_ENTROPY)
-int mbedtls_null_entropy_poll( void *data,
-                    unsigned char *output, size_t len, size_t *olen )
-{
-    ((void) data);
-    ((void) output);
-    *olen = 0;
-
-    if( len < sizeof(unsigned char) )
-        return( 0 );
-
-    *olen = sizeof(unsigned char);
-
-    return( 0 );
-}
-#endif
-
-#if defined(MBEDTLS_TIMING_C)
-int mbedtls_hardclock_poll( void *data,
-                    unsigned char *output, size_t len, size_t *olen )
-{
-    unsigned long timer = mbedtls_timing_hardclock();
-    ((void) data);
-    *olen = 0;
-
-    if( len < sizeof(unsigned long) )
-        return( 0 );
-
-    memcpy( output, &timer, sizeof(unsigned long) );
-    *olen = sizeof(unsigned long);
-
-    return( 0 );
-}
-#endif /* MBEDTLS_TIMING_C */
-
-#if defined(MBEDTLS_HAVEGE_C)
-int mbedtls_havege_poll( void *data,
-                 unsigned char *output, size_t len, size_t *olen )
-{
-    mbedtls_havege_state *hs = (mbedtls_havege_state *) data;
-    *olen = 0;
-
-    if( mbedtls_havege_random( hs, output, len ) != 0 )
-        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
-
-    *olen = len;
-
-    return( 0 );
-}
-#endif /* MBEDTLS_HAVEGE_C */
-
-#if defined(MBEDTLS_ENTROPY_NV_SEED)
-int mbedtls_nv_seed_poll( void *data,
-                          unsigned char *output, size_t len, size_t *olen )
-{
-    unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
-    size_t use_len = MBEDTLS_ENTROPY_BLOCK_SIZE;
-    ((void) data);
-
-    memset( buf, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
-
-    if( mbedtls_nv_seed_read( buf, MBEDTLS_ENTROPY_BLOCK_SIZE ) < 0 )
-      return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
-
-    if( len < use_len )
-      use_len = len;
-
-    memcpy( output, buf, use_len );
-    *olen = use_len;
-
-    return( 0 );
-}
-#endif /* MBEDTLS_ENTROPY_NV_SEED */
-
-#endif /* MBEDTLS_ENTROPY_C */
+/*
+ *  Platform-specific and custom entropy polling functions
+ *
+ *  Copyright (C) 2006-2016, ARM Limited, All Rights Reserved
+ *  SPDX-License-Identifier: Apache-2.0
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may
+ *  not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *  This file is part of mbed TLS (https://tls.mbed.org)
+ */
+#define _GNU_SOURCE
+#if !defined(MBEDTLS_CONFIG_FILE)
+#include "mbedtls/config.h"
+#else
+#include MBEDTLS_CONFIG_FILE
+#endif
+
+#if defined(MBEDTLS_ENTROPY_C)
+
+#include "mbedtls/entropy.h"
+#include "mbedtls/entropy_poll.h"
+
+#if defined(MBEDTLS_TIMING_C)
+#include <string.h>
+#include "mbedtls/timing.h"
+#endif
+#if defined(MBEDTLS_HAVEGE_C)
+#include "mbedtls/havege.h"
+#endif
+#if defined(MBEDTLS_ENTROPY_NV_SEED)
+#include "mbedtls/platform.h"
+#endif
+
+#if !defined(MBEDTLS_NO_PLATFORM_ENTROPY)
+
+#if !defined(unix) && !defined(__unix__) && !defined(__unix) && \
+    !defined(__APPLE__) && !defined(_WIN32)
+#error "Platform entropy sources only work on Unix and Windows, see MBEDTLS_NO_PLATFORM_ENTROPY in config.h"
+#endif
+
+#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
+
+#if !defined(_WIN32_WINNT)
+#define _WIN32_WINNT 0x0400
+#endif
+#include <windows.h>
+#include <wincrypt.h>
+
+int mbedtls_platform_entropy_poll( void *data, unsigned char *output, size_t len,
+                           size_t *olen )
+{
+    HCRYPTPROV provider;
+    ((void) data);
+    *olen = 0;
+
+    if( CryptAcquireContext( &provider, NULL, NULL,
+                              PROV_RSA_FULL, CRYPT_VERIFYCONTEXT ) == FALSE )
+    {
+        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
+    }
+
+    if( CryptGenRandom( provider, (DWORD) len, output ) == FALSE )
+    {
+        CryptReleaseContext( provider, 0 );
+        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
+    }
+
+    CryptReleaseContext( provider, 0 );
+    *olen = len;
+
+    return( 0 );
+}
+#else /* _WIN32 && !EFIX64 && !EFI32 */
+
+/*
+ * Test for Linux getrandom() support.
+ * Since there is no wrapper in the libc yet, use the generic syscall wrapper
+ * available in GNU libc and compatible libc's (eg uClibc).
+ */
+#if defined(__linux__) && defined(__GLIBC__)
+#include <unistd.h>
+#include <sys/syscall.h>
+#if defined(SYS_getrandom)
+#define HAVE_GETRANDOM
+
+static int getrandom_wrapper( void *buf, size_t buflen, unsigned int flags )
+{
+    /* MemSan cannot understand that the syscall writes to the buffer */
+#if defined(__has_feature)
+#if __has_feature(memory_sanitizer)
+    memset( buf, 0, buflen );
+#endif
+#endif
+
+    return( syscall( SYS_getrandom, buf, buflen, flags ) );
+}
+
+#include <sys/utsname.h>
+/* Check if version is at least 3.17.0 */
+static int check_version_3_17_plus( void )
+{
+    int minor;
+    struct utsname un;
+    const char *ver;
+
+    /* Get version information */
+    uname(&un);
+    ver = un.release;
+
+    /* Check major version; assume a single digit */
+    if( ver[0] < '3' || ver[0] > '9' || ver [1] != '.' )
+        return( -1 );
+
+    if( ver[0] - '0' > 3 )
+        return( 0 );
+
+    /* Ok, so now we know major == 3, check minor.
+     * Assume 1 or 2 digits. */
+    if( ver[2] < '0' || ver[2] > '9' )
+        return( -1 );
+
+    minor = ver[2] - '0';
+
+    if( ver[3] >= '0' && ver[3] <= '9' )
+        minor = 10 * minor + ver[3] - '0';
+    else if( ver [3] != '.' )
+        return( -1 );
+
+    if( minor < 17 )
+        return( -1 );
+
+    return( 0 );
+}
+static int has_getrandom = -1;
+#endif /* SYS_getrandom */
+#endif /* __linux__ */
+
+#include <stdio.h>
+
+int mbedtls_platform_entropy_poll( void *data,
+                           unsigned char *output, size_t len, size_t *olen )
+{
+    FILE *file;
+    size_t read_len;
+    ((void) data);
+
+#if defined(HAVE_GETRANDOM)
+    if( has_getrandom == -1 )
+        has_getrandom = ( check_version_3_17_plus() == 0 );
+
+    if( has_getrandom )
+    {
+        int ret;
+
+        if( ( ret = getrandom_wrapper( output, len, 0 ) ) < 0 )
+            return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
+
+        *olen = ret;
+        return( 0 );
+    }
+#endif /* HAVE_GETRANDOM */
+
+    *olen = 0;
+
+    file = fopen( "/dev/urandom", "rb" );
+    if( file == NULL )
+        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
+
+    read_len = fread( output, 1, len, file );
+    if( read_len != len )
+    {
+        fclose( file );
+        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
+    }
+
+    fclose( file );
+    *olen = len;
+
+    return( 0 );
+}
+#endif /* _WIN32 && !EFIX64 && !EFI32 */
+#endif /* !MBEDTLS_NO_PLATFORM_ENTROPY */
+
+#if defined(MBEDTLS_TEST_NULL_ENTROPY)
+int mbedtls_null_entropy_poll( void *data,
+                    unsigned char *output, size_t len, size_t *olen )
+{
+    ((void) data);
+    ((void) output);
+    *olen = 0;
+
+    if( len < sizeof(unsigned char) )
+        return( 0 );
+
+    *olen = sizeof(unsigned char);
+
+    return( 0 );
+}
+#endif
+
+#if defined(MBEDTLS_TIMING_C)
+int mbedtls_hardclock_poll( void *data,
+                    unsigned char *output, size_t len, size_t *olen )
+{
+    unsigned long timer = mbedtls_timing_hardclock();
+    ((void) data);
+    *olen = 0;
+
+    if( len < sizeof(unsigned long) )
+        return( 0 );
+
+    memcpy( output, &timer, sizeof(unsigned long) );
+    *olen = sizeof(unsigned long);
+
+    return( 0 );
+}
+#endif /* MBEDTLS_TIMING_C */
+
+#if defined(MBEDTLS_HAVEGE_C)
+int mbedtls_havege_poll( void *data,
+                 unsigned char *output, size_t len, size_t *olen )
+{
+    mbedtls_havege_state *hs = (mbedtls_havege_state *) data;
+    *olen = 0;
+
+    if( mbedtls_havege_random( hs, output, len ) != 0 )
+        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
+
+    *olen = len;
+
+    return( 0 );
+}
+#endif /* MBEDTLS_HAVEGE_C */
+
+#if defined(MBEDTLS_ENTROPY_NV_SEED)
+int mbedtls_nv_seed_poll( void *data,
+                          unsigned char *output, size_t len, size_t *olen )
+{
+    unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
+    size_t use_len = MBEDTLS_ENTROPY_BLOCK_SIZE;
+    ((void) data);
+
+    memset( buf, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
+
+    if( mbedtls_nv_seed_read( buf, MBEDTLS_ENTROPY_BLOCK_SIZE ) < 0 )
+      return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
+
+    if( len < use_len )
+      use_len = len;
+
+    memcpy( output, buf, use_len );
+    *olen = use_len;
+
+    return( 0 );
+}
+#endif /* MBEDTLS_ENTROPY_NV_SEED */
+
+#endif /* MBEDTLS_ENTROPY_C */

Kha/Backends/Kinc-HL/kfile.js

@@ -9,6 +9,7 @@ if (platform == Platform.OSX) project.addDefine('KORE_DEBUGDIR="osx-hl"');
 if (platform == Platform.iOS) project.addDefine('KORE_DEBUGDIR="ios-hl"');
 if (platform !== Platform.Windows || audio !== AudioApi.DirectSound) {
 	project.addDefine('KORE_MULTITHREADED_AUDIO');
+	project.addDefine('KINC_MULTITHREADED_AUDIO');
 }
 
 project.addDefine('KORE');

Kha/Backends/Kinc-HL/kha/graphics4/FragmentShader.hx

@@ -1,31 +1,70 @@
-package kha.graphics4;
-
-import kha.Blob;
-
-class FragmentShader {
-	public var _shader: Pointer;
-
-	public function new(sources: Array<Blob>, files: Array<String>) {
-		initShader(sources[0]);
-	}
-
-	function initShader(source: Blob): Void {
-		_shader = kinc_create_fragmentshader(source.bytes.getData(), source.bytes.getData().length);
-	}
-
-	public static function fromSource(source: String): FragmentShader {
-		var sh = new FragmentShader(null, null);
-		sh._shader = kinc_fragmentshader_from_source(StringHelper.convert(source));
-		return sh;
-	}
-
-	public function delete(): Void {}
-
-	@:hlNative("std", "kinc_create_fragmentshader") static function kinc_create_fragmentshader(data: hl.Bytes, length: Int): Pointer {
-		return null;
-	}
-
-	@:hlNative("std", "kinc_fragmentshader_from_source") static function kinc_fragmentshader_from_source(source: hl.Bytes): Pointer {
-		return null;
-	}
-}
+package kha.graphics4;
+using StringTools;
+import kha.Blob;
+
+class FragmentShader {
+	public var _shader: Pointer;
+
+	public function new(sources: Array<Blob>, files: Array<String>) {
+		//initShader(sources[0]);
+		var shaderBlob: Blob = null;
+		var shaderFile: String = null;
+
+		#if kha_opengl
+		final expectedExtension = ".glsl";
+		#elseif kha_direct3d11
+		final expectedExtension = ".d3d11";
+		#elseif kha_direct3d12
+		final expectedExtension = ".d3d12";
+		#elseif kha_metal
+		final expectedExtension = ".metal";
+		#elseif kha_vulkan
+		final expectedExtension = ".spirv";
+		#else
+		final expectedExtension = ".glsl";
+		#end
+
+		if (sources != null && files != null) {
+			for (i in 0...files.length) {
+				if (files[i].endsWith(expectedExtension)) {
+					shaderBlob = sources[i];
+					shaderFile = files[i];
+					break;
+				}
+			}
+		}
+
+		if (shaderBlob == null && sources != null && sources.length > 0) {
+			trace('Warning: Could not find shader with extension ${expectedExtension}. Falling back to sources[0]: ${files != null && files.length > 0 ? files[0] : "Unknown"}');
+			shaderBlob = sources[0];
+		}
+
+		if (shaderBlob != null) {
+			initShader(shaderBlob);
+		} else {
+			trace('Error: No suitable fragment shader source found!');
+		}
+
+	}
+
+	function initShader(source: Blob): Void {
+		//_shader = kinc_create_fragmentshader(source.bytes.getData(), source.bytes.getData().length);
+		_shader = kinc_create_fragmentshader(source.bytes.getData(), source.length); // Use source.length here
+	}
+
+	public static function fromSource(source: String): FragmentShader {
+		var sh = new FragmentShader(null, null);
+		sh._shader = kinc_fragmentshader_from_source(StringHelper.convert(source));
+		return sh;
+	}
+
+	public function delete(): Void {}
+
+	@:hlNative("std", "kinc_create_fragmentshader") static function kinc_create_fragmentshader(data: hl.Bytes, length: Int): Pointer {
+		return null;
+	}
+
+	@:hlNative("std", "kinc_fragmentshader_from_source") static function kinc_fragmentshader_from_source(source: hl.Bytes): Pointer {
+		return null;
+	}
+}

Kha/Backends/Kinc-HL/kinc-bridge/compute.c.h

@@ -1,179 +1,38 @@
-#include <kinc/compute/compute.h>
+#include <kinc/graphics4/compute.h>
 #include <kinc/graphics4/texture.h>
 
 #include <hl.h>
 
 vbyte *hl_kinc_compute_create_shader(vbyte *data, int length) {
-	kinc_compute_shader_t *shader = (kinc_compute_shader_t *)malloc(sizeof(kinc_compute_shader_t));
-	kinc_compute_shader_init(shader, data, length);
+	kinc_g4_compute_shader *shader = (kinc_g4_compute_shader *)malloc(sizeof(kinc_g4_compute_shader));
+	kinc_g4_compute_shader_init(shader, data, length);
 	return (vbyte *)shader;
 }
 
 void hl_kinc_compute_delete_shader(vbyte *shader) {
-	kinc_compute_shader_t *sh = (kinc_compute_shader_t *)shader;
-	kinc_compute_shader_destroy(sh);
+	kinc_g4_compute_shader *sh = (kinc_g4_compute_shader *)shader;
+	kinc_g4_compute_shader_destroy(sh);
 	free(sh);
 }
 
 vbyte *hl_kinc_compute_get_constantlocation(vbyte *shader, vbyte *name) {
-	kinc_compute_shader_t *sh = (kinc_compute_shader_t *)shader;
-	kinc_compute_constant_location_t *location = (kinc_compute_constant_location_t *)malloc(sizeof(kinc_compute_constant_location_t));
-	*location = kinc_compute_shader_get_constant_location(sh, (char *)name), sizeof(kinc_compute_constant_location_t);
+	kinc_g4_compute_shader *sh = (kinc_g4_compute_shader *)shader;
+	kinc_g4_constant_location_t *location = (kinc_g4_constant_location_t *)malloc(sizeof(kinc_g4_constant_location_t));
+	*location = kinc_g4_compute_shader_get_constant_location(sh, (char *)name);
 	return (vbyte *)location;
 }
 
 vbyte *hl_kinc_compute_get_textureunit(vbyte *shader, vbyte *name) {
-	kinc_compute_shader_t *sh = (kinc_compute_shader_t *)shader;
-	kinc_compute_texture_unit_t *unit = (kinc_compute_texture_unit_t *)malloc(sizeof(kinc_compute_texture_unit_t));
-	*unit = kinc_compute_shader_get_texture_unit(sh, (char *)name), sizeof(kinc_compute_texture_unit_t);
+	kinc_g4_compute_shader *sh = (kinc_g4_compute_shader *)shader;
+	kinc_g4_texture_unit_t *unit = (kinc_g4_texture_unit_t *)malloc(sizeof(kinc_g4_texture_unit_t));
+	*unit = kinc_g4_compute_shader_get_texture_unit(sh, (char *)name);
 	return (vbyte *)unit;
 }
 
-void hl_kinc_compute_set_bool(vbyte *location, bool value) {
-	kinc_compute_constant_location_t *loc = (kinc_compute_constant_location_t *)location;
-	kinc_compute_set_bool(*loc, value);
+void hl_kinc_set_compute_shader(vbyte *shader) {
+	kinc_g4_set_compute_shader((kinc_g4_compute_shader *)shader);
 }
 
-void hl_kinc_compute_set_int(vbyte *location, int value) {
-	kinc_compute_constant_location_t *loc = (kinc_compute_constant_location_t *)location;
-	kinc_compute_set_int(*loc, value);
-}
-
-void hl_kinc_compute_set_float(vbyte *location, float value) {
-	kinc_compute_constant_location_t *loc = (kinc_compute_constant_location_t *)location;
-	kinc_compute_set_float(*loc, value);
-}
-
-void hl_kinc_compute_set_float2(vbyte *location, float value1, float value2) {
-	kinc_compute_constant_location_t *loc = (kinc_compute_constant_location_t *)location;
-	kinc_compute_set_float2(*loc, value1, value2);
-}
-
-void hl_kinc_compute_set_float3(vbyte *location, float value1, float value2, float value3) {
-	kinc_compute_constant_location_t *loc = (kinc_compute_constant_location_t *)location;
-	kinc_compute_set_float3(*loc, value1, value2, value3);
-}
-
-void hl_kinc_compute_set_float4(vbyte *location, float value1, float value2, float value3, float value4) {
-	kinc_compute_constant_location_t *loc = (kinc_compute_constant_location_t *)location;
-	kinc_compute_set_float4(*loc, value1, value2, value3, value4);
-}
-
-void hl_kinc_compute_set_floats(vbyte *location, vbyte *values, int count) {
-	kinc_compute_constant_location_t *loc = (kinc_compute_constant_location_t *)location;
-	kinc_compute_set_floats(*loc, (float *)values, count);
-}
-
-void hl_kinc_compute_set_matrix(vbyte *location, float _00, float _10, float _20, float _30, float _01, float _11, float _21, float _31, float _02, float _12,
-                                float _22, float _32, float _03, float _13, float _23, float _33) {
-	kinc_compute_constant_location_t *loc = (kinc_compute_constant_location_t *)location;
-	kinc_matrix4x4_t value;
-	kinc_matrix4x4_set(&value, 0, 0, _00);
-	kinc_matrix4x4_set(&value, 0, 1, _01);
-	kinc_matrix4x4_set(&value, 0, 2, _02);
-	kinc_matrix4x4_set(&value, 0, 3, _03);
-	kinc_matrix4x4_set(&value, 1, 0, _10);
-	kinc_matrix4x4_set(&value, 1, 1, _11);
-	kinc_matrix4x4_set(&value, 1, 2, _12);
-	kinc_matrix4x4_set(&value, 1, 3, _13);
-	kinc_matrix4x4_set(&value, 2, 0, _20);
-	kinc_matrix4x4_set(&value, 2, 1, _21);
-	kinc_matrix4x4_set(&value, 2, 2, _22);
-	kinc_matrix4x4_set(&value, 2, 3, _23);
-	kinc_matrix4x4_set(&value, 3, 0, _30);
-	kinc_matrix4x4_set(&value, 3, 1, _31);
-	kinc_matrix4x4_set(&value, 3, 2, _32);
-	kinc_matrix4x4_set(&value, 3, 3, _33);
-	kinc_compute_set_matrix4(*loc, &value);
-}
-
-void hl_kinc_compute_set_matrix3(vbyte *location, float _00, float _10, float _20, float _01, float _11, float _21, float _02, float _12, float _22) {
-	kinc_compute_constant_location_t *loc = (kinc_compute_constant_location_t *)location;
-	kinc_matrix3x3_t value;
-	kinc_matrix3x3_set(&value, 0, 0, _00);
-	kinc_matrix3x3_set(&value, 0, 1, _01);
-	kinc_matrix3x3_set(&value, 0, 2, _02);
-	kinc_matrix3x3_set(&value, 1, 0, _10);
-	kinc_matrix3x3_set(&value, 1, 1, _11);
-	kinc_matrix3x3_set(&value, 1, 2, _12);
-	kinc_matrix3x3_set(&value, 2, 0, _20);
-	kinc_matrix3x3_set(&value, 2, 1, _21);
-	kinc_matrix3x3_set(&value, 2, 2, _22);
-	kinc_compute_set_matrix3(*loc, &value);
-}
-
-void hl_kinc_compute_set_texture(vbyte *unit, vbyte *texture, int access) {
-	kinc_compute_texture_unit_t *u = (kinc_compute_texture_unit_t *)unit;
-	kinc_g4_texture_t *tex = (kinc_g4_texture_t *)texture;
-	kinc_compute_set_texture(*u, tex, (kinc_compute_access_t)access);
-}
-
-void hl_kinc_compute_set_target(vbyte *unit, vbyte *renderTarget, int access) {
-	kinc_compute_texture_unit_t *u = (kinc_compute_texture_unit_t *)unit;
-	kinc_g4_render_target_t *rt = (kinc_g4_render_target_t *)renderTarget;
-	kinc_compute_set_render_target(*u, rt, (kinc_compute_access_t)access);
-}
-
-void hl_kinc_compute_set_sampled_texture(vbyte *unit, vbyte *texture) {
-	kinc_compute_texture_unit_t *u = (kinc_compute_texture_unit_t *)unit;
-	kinc_g4_texture_t *tex = (kinc_g4_texture_t *)texture;
-	kinc_compute_set_sampled_texture(*u, tex);
-}
-
-void hl_kinc_compute_set_sampled_target(vbyte *unit, vbyte *renderTarget) {
-	kinc_compute_texture_unit_t *u = (kinc_compute_texture_unit_t *)unit;
-	kinc_g4_render_target_t *rt = (kinc_g4_render_target_t *)renderTarget;
-	kinc_compute_set_sampled_render_target(*u, rt);
-}
-
-void hl_kinc_compute_set_sampled_depth_target(vbyte *unit, vbyte *renderTarget) {
-	kinc_compute_texture_unit_t *u = (kinc_compute_texture_unit_t *)unit;
-	kinc_g4_render_target_t *rt = (kinc_g4_render_target_t *)renderTarget;
-	kinc_compute_set_sampled_depth_from_render_target(*u, rt);
-}
-
-void hl_kinc_compute_set_sampled_cubemap_texture(vbyte *unit, vbyte *texture) {
-	kinc_compute_texture_unit_t *u = (kinc_compute_texture_unit_t *)unit;
-	kinc_g4_texture_t *tex = (kinc_g4_texture_t *)texture;
-	kinc_compute_set_sampled_texture(*u, tex);
-}
-
-void hl_kinc_compute_set_sampled_cubemap_target(vbyte *unit, vbyte *renderTarget) {
-	kinc_compute_texture_unit_t *u = (kinc_compute_texture_unit_t *)unit;
-	kinc_g4_render_target_t *rt = (kinc_g4_render_target_t *)renderTarget;
-	kinc_compute_set_sampled_render_target(*u, rt);
-}
-
-void hl_kinc_compute_set_sampled_cubemap_depth_target(vbyte *unit, vbyte *renderTarget) {
-	kinc_compute_texture_unit_t *u = (kinc_compute_texture_unit_t *)unit;
-	kinc_g4_render_target_t *rt = (kinc_g4_render_target_t *)renderTarget;
-	kinc_compute_set_sampled_depth_from_render_target(*u, rt);
-}
-
-void hl_kinc_compute_set_texture_parameters(vbyte *unit, int uAddressing, int vAddressing, int minificationFilter, int magnificationFilter, int mipmapFilter) {
-	kinc_compute_texture_unit_t *u = (kinc_compute_texture_unit_t *)unit;
-	kinc_compute_set_texture_addressing(*u, KINC_G4_TEXTURE_DIRECTION_U, (kinc_g4_texture_addressing_t)uAddressing);
-	kinc_compute_set_texture_addressing(*u, KINC_G4_TEXTURE_DIRECTION_V, (kinc_g4_texture_addressing_t)vAddressing);
-	kinc_compute_set_texture_minification_filter(*u, (kinc_g4_texture_filter_t)minificationFilter);
-	kinc_compute_set_texture_magnification_filter(*u, (kinc_g4_texture_filter_t)magnificationFilter);
-	kinc_compute_set_texture_mipmap_filter(*u, (kinc_g4_mipmap_filter_t)mipmapFilter);
-}
-
-void hl_kinc_compute_set_texture3d_parameters(vbyte *unit, int uAddressing, int vAddressing, int wAddressing, int minificationFilter, int magnificationFilter,
-                                              int mipmapFilter) {
-	kinc_compute_texture_unit_t *u = (kinc_compute_texture_unit_t *)unit;
-	kinc_compute_set_texture3d_addressing(*u, KINC_G4_TEXTURE_DIRECTION_U, (kinc_g4_texture_addressing_t)uAddressing);
-	kinc_compute_set_texture3d_addressing(*u, KINC_G4_TEXTURE_DIRECTION_V, (kinc_g4_texture_addressing_t)vAddressing);
-	kinc_compute_set_texture3d_addressing(*u, KINC_G4_TEXTURE_DIRECTION_W, (kinc_g4_texture_addressing_t)wAddressing);
-	kinc_compute_set_texture3d_minification_filter(*u, (kinc_g4_texture_filter_t)minificationFilter);
-	kinc_compute_set_texture3d_magnification_filter(*u, (kinc_g4_texture_filter_t)magnificationFilter);
-	kinc_compute_set_texture3d_mipmap_filter(*u, (kinc_g4_mipmap_filter_t)mipmapFilter);
-}
-
-void hl_kinc_compute_set_shader(vbyte *shader) {
-	kinc_compute_set_shader((kinc_compute_shader_t *)shader);
-}
-
-void hl_kinc_compute_compute(int x, int y, int z) {
-	kinc_compute(x, y, z);
+void hl_kinc_compute(int x, int y, int z) {
+	kinc_g4_compute(x, y, z);
 }

Kha/Backends/Kinc-HL/kinc-bridge/kinc.c.h

@@ -1,127 +1,129 @@
-#include <kinc/audio2/audio.h>
-#include <kinc/graphics4/graphics.h>
-#include <kinc/io/filereader.h>
-#include <kinc/log.h>
-#include <kinc/system.h>
-#include <kinc/window.h>
-
-#include <hl.h>
-
-void frame();
-
-static bool visible = true;
-static bool paused = false;
-
-typedef void (*FN_AUDIO_CALL_CALLBACK)(int);
-typedef float (*FN_AUDIO_READ_SAMPLE)(void);
-
-void (*audioCallCallback)(int);
-float (*audioReadSample)(void);
-
-static void update(void *data) {
-	if (paused) {
-		return;
-	}
-
-	kinc_a2_update();
-
-	int windowCount = kinc_count_windows();
-
-	for (int windowIndex = 0; windowIndex < windowCount; ++windowIndex) {
-		if (visible) {
-			kinc_g4_begin(windowIndex);
-			frame();
-			kinc_g4_end(windowIndex);
-		}
-	}
-
-	if (!kinc_g4_swap_buffers()) {
-		kinc_log(KINC_LOG_LEVEL_ERROR, "Graphics context lost.");
-	}
-}
-
-static bool mixThreadregistered = false;
-
-static void mix(kinc_a2_buffer_t *buffer, int samples) {
-#ifdef KORE_MULTITHREADED_AUDIO
-	if (!mixThreadregistered) {
-		vdynamic *ret;
-		hl_register_thread(&ret);
-		mixThreadregistered = true;
-	}
-	hl_blocking(true);
-#endif
-
-	audioCallCallback(samples);
-
-	for (int i = 0; i < samples; ++i) {
-		float value = audioReadSample();
-		*(float *)&buffer->data[buffer->write_location] = value;
-		buffer->write_location += 4;
-		if (buffer->write_location >= buffer->data_size) {
-			buffer->write_location = 0;
-		}
-	}
-
-#ifdef KORE_MULTITHREADED_AUDIO
-	hl_blocking(false);
-#endif
-}
-
-void hl_init_kore(vbyte *title, int width, int height, int samplesPerPixel, bool vSync, int windowMode, int windowFeatures) {
-	kinc_log(KINC_LOG_LEVEL_INFO, "Starting KincHL");
-
-	kinc_window_options_t win;
-	kinc_window_options_set_defaults(&win);
-	win.title = (char *)title;
-	win.width = width;
-	win.height = height;
-	win.x = -1;
-	win.y = -1;
-	win.mode = (kinc_window_mode_t)windowMode;
-	win.window_features = windowFeatures;
-	kinc_framebuffer_options_t frame;
-	kinc_framebuffer_options_set_defaults(&frame);
-	frame.vertical_sync = vSync;
-	frame.samples_per_pixel = samplesPerPixel;
-	kinc_init((char *)title, width, height, &win, &frame);
-
-	kinc_set_update_callback(update, NULL);
-}
-
-void hl_kinc_init_audio(vclosure *callCallback, vclosure *readSample, int *outSamplesPerSecond) {
-	audioCallCallback = *((FN_AUDIO_CALL_CALLBACK *)(&callCallback->fun));
-	audioReadSample = *((FN_AUDIO_READ_SAMPLE *)(&readSample->fun));
-	kinc_a2_set_callback(mix);
-	kinc_a2_init();
-	*outSamplesPerSecond = kinc_a2_samples_per_second;
-}
-
-void hl_run_kore(void) {
-	kinc_start();
-}
-
-vbyte *hl_kinc_file_contents(vbyte *name, int *size) {
-	int len;
-	int p = 0;
-	vbyte *content;
-	kinc_file_reader_t file;
-	if (!kinc_file_reader_open(&file, (char *)name, KINC_FILE_TYPE_ASSET)) {
-		return NULL;
-	}
-	hl_blocking(true);
-	len = (int)kinc_file_reader_size(&file);
-	if (size) {
-		*size = len;
-	}
-	hl_blocking(false);
-	content = (vbyte *)hl_gc_alloc_noptr(size ? len : len + 1);
-	hl_blocking(true);
-	if (!size) {
-		content[len] = 0; // final 0 for UTF8
-	}
-	kinc_file_reader_read(&file, content, len);
-	kinc_file_reader_close(&file);
-	hl_blocking(false);
-	return content;
-}
+#include <kinc/audio2/audio.h>
+#include <kinc/graphics4/graphics.h>
+#include <kinc/io/filereader.h>
+#include <kinc/log.h>
+#include <kinc/system.h>
+#include <kinc/window.h>
+
+#include <hl.h>
+
+void frame();
+
+static bool visible = true;
+static bool paused = false;
+
+typedef void (*FN_AUDIO_CALL_CALLBACK)(int);
+typedef float (*FN_AUDIO_READ_SAMPLE)(void);
+
+void (*audioCallCallback)(int);
+float (*audioReadSample)(void);
+
+static void update(void *data) {
+	if (paused) {
+		return;
+	}
+
+	kinc_a2_update();
+
+	int windowCount = kinc_count_windows();
+
+	for (int windowIndex = 0; windowIndex < windowCount; ++windowIndex) {
+		if (visible) {
+			kinc_g4_begin(windowIndex);
+			frame();
+			kinc_g4_end(windowIndex);
+		}
+	}
+
+	if (!kinc_g4_swap_buffers()) {
+		kinc_log(KINC_LOG_LEVEL_ERROR, "Graphics context lost.");
+	}
+}
+
+static bool mixThreadregistered = false;
+
+static void mix(kinc_a2_buffer_t *buffer, uint32_t samples, void *userdata) {
+#ifdef KINC_MULTITHREADED_AUDIO
+	if (!mixThreadregistered) {
+		vdynamic *ret;
+		hl_register_thread(&ret);
+		mixThreadregistered = true;
+	}
+	hl_blocking(true);
+#endif
+
+	audioCallCallback(samples);
+
+	for (uint32_t i = 0; i < samples; i += 2) {
+		float left_value = audioReadSample();
+		float right_value = audioReadSample();
+		*(float *)&buffer->channels[0][buffer->write_location] = left_value;
+		*(float *)&buffer->channels[1][buffer->write_location] = right_value;
+		buffer->write_location += 1;
+		if (buffer->write_location >= buffer->data_size) {
+			buffer->write_location = 0;
+		}
+	}
+
+#ifdef KINC_MULTITHREADED_AUDIO
+	hl_blocking(false);
+#endif
+}
+
+void hl_init_kore(vbyte *title, int width, int height, int samplesPerPixel, bool vSync, int windowMode, int windowFeatures) {
+	kinc_log(KINC_LOG_LEVEL_INFO, "Starting KincHL");
+
+	kinc_window_options_t win;
+	kinc_window_options_set_defaults(&win);
+	win.title = (char *)title;
+	win.width = width;
+	win.height = height;
+	win.x = -1;
+	win.y = -1;
+	win.mode = (kinc_window_mode_t)windowMode;
+	win.window_features = windowFeatures;
+	kinc_framebuffer_options_t frame;
+	kinc_framebuffer_options_set_defaults(&frame);
+	frame.vertical_sync = vSync;
+	frame.samples_per_pixel = samplesPerPixel;
+	kinc_init((char *)title, width, height, &win, &frame);
+
+	kinc_set_update_callback(update, NULL);
+}
+
+void hl_kinc_init_audio(vclosure *callCallback, vclosure *readSample, int *outSamplesPerSecond) {
+	audioCallCallback = *((FN_AUDIO_CALL_CALLBACK *)(&callCallback->fun));
+	audioReadSample = *((FN_AUDIO_READ_SAMPLE *)(&readSample->fun));
+	kinc_a2_init();
+	kinc_a2_set_callback(mix, NULL);
+	*outSamplesPerSecond = kinc_a2_samples_per_second();
+}
+
+void hl_run_kore(void) {
+	kinc_start();
+}
+
+vbyte *hl_kinc_file_contents(vbyte *name, int *size) {
+	int len;
+	int p = 0;
+	vbyte *content;
+	kinc_file_reader_t file;
+	if (!kinc_file_reader_open(&file, (char *)name, KINC_FILE_TYPE_ASSET)) {
+		return NULL;
+	}
+	hl_blocking(true);
+	len = (int)kinc_file_reader_size(&file);
+	if (size) {
+		*size = len;
+	}
+	hl_blocking(false);
+	content = (vbyte *)hl_gc_alloc_noptr(size ? len : len + 1);
+	hl_blocking(true);
+	if (!size) {
+		content[len] = 0; // final 0 for UTF8
+	}
+	kinc_file_reader_read(&file, content, len);
+	kinc_file_reader_close(&file);
+	hl_blocking(false);
+	return content;
+}

Kha/Backends/Kinc-HL/kinc-bridge/shader.c.h

@@ -1,265 +1,265 @@
-#include <kinc/graphics4/graphics.h>
-#include <kinc/graphics4/pipeline.h>
-#include <kinc/graphics4/shader.h>
-#include <kinc/graphics4/vertexstructure.h>
-
-#include <hl.h>
-
-static kinc_g4_compare_mode_t convertCompareMode(int mode) {
-	switch (mode) {
-	case 0:
-		return KINC_G4_COMPARE_ALWAYS;
-	case 1:
-		return KINC_G4_COMPARE_NEVER;
-	case 2:
-		return KINC_G4_COMPARE_EQUAL;
-	case 3:
-		return KINC_G4_COMPARE_NOT_EQUAL;
-	case 4:
-		return KINC_G4_COMPARE_LESS;
-	case 5:
-		return KINC_G4_COMPARE_LESS_EQUAL;
-	case 6:
-		return KINC_G4_COMPARE_GREATER;
-	case 7:
-	default:
-		return KINC_G4_COMPARE_GREATER_EQUAL;
-	}
-}
-
-static kinc_g4_stencil_action_t convertStencilAction(int action) {
-	switch (action) {
-	case 0:
-		return KINC_G4_STENCIL_KEEP;
-	case 1:
-		return KINC_G4_STENCIL_ZERO;
-	case 2:
-		return KINC_G4_STENCIL_REPLACE;
-	case 3:
-		return KINC_G4_STENCIL_INCREMENT;
-	case 4:
-		return KINC_G4_STENCIL_INCREMENT_WRAP;
-	case 5:
-		return KINC_G4_STENCIL_DECREMENT;
-	case 6:
-		return KINC_G4_STENCIL_DECREMENT_WRAP;
-	case 7:
-	default:
-		return KINC_G4_STENCIL_INVERT;
-	}
-}
-
-static kinc_g4_render_target_format_t convertColorAttachment(int format) {
-	switch (format) {
-	case 0:
-		return KINC_G4_RENDER_TARGET_FORMAT_32BIT;
-	case 1:
-		return KINC_G4_RENDER_TARGET_FORMAT_8BIT_RED;
-	case 2:
-		return KINC_G4_RENDER_TARGET_FORMAT_128BIT_FLOAT;
-	case 3:
-		return KINC_G4_RENDER_TARGET_FORMAT_16BIT_DEPTH;
-	case 4:
-		return KINC_G4_RENDER_TARGET_FORMAT_64BIT_FLOAT;
-	case 5:
-		return KINC_G4_RENDER_TARGET_FORMAT_32BIT_RED_FLOAT;
-	case 6:
-	default:
-		return KINC_G4_RENDER_TARGET_FORMAT_16BIT_RED_FLOAT;
-	}
-}
-
-vbyte *hl_kinc_create_vertexshader(vbyte *data, int length) {
-	kinc_g4_shader_t *shader = (kinc_g4_shader_t *)malloc(sizeof(kinc_g4_shader_t));
-	kinc_g4_shader_init(shader, data, length, KINC_G4_SHADER_TYPE_VERTEX);
-	return (vbyte *)shader;
-}
-
-vbyte *hl_kinc_create_fragmentshader(vbyte *data, int length) {
-	kinc_g4_shader_t *shader = (kinc_g4_shader_t *)malloc(sizeof(kinc_g4_shader_t));
-	kinc_g4_shader_init(shader, data, length, KINC_G4_SHADER_TYPE_FRAGMENT);
-	return (vbyte *)shader;
-}
-
-vbyte *hl_kinc_create_geometryshader(vbyte *data, int length) {
-	kinc_g4_shader_t *shader = (kinc_g4_shader_t *)malloc(sizeof(kinc_g4_shader_t));
-	kinc_g4_shader_init(shader, data, length, KINC_G4_SHADER_TYPE_GEOMETRY);
-	return (vbyte *)shader;
-}
-
-vbyte *hl_kinc_create_tesscontrolshader(vbyte *data, int length) {
-	kinc_g4_shader_t *shader = (kinc_g4_shader_t *)malloc(sizeof(kinc_g4_shader_t));
-	kinc_g4_shader_init(shader, data, length, KINC_G4_SHADER_TYPE_TESSELLATION_CONTROL);
-	return (vbyte *)shader;
-}
-
-vbyte *hl_kinc_create_tessevalshader(vbyte *data, int length) {
-	kinc_g4_shader_t *shader = (kinc_g4_shader_t *)malloc(sizeof(kinc_g4_shader_t));
-	kinc_g4_shader_init(shader, data, length, KINC_G4_SHADER_TYPE_TESSELLATION_EVALUATION);
-	return (vbyte *)shader;
-}
-
-vbyte *hl_kinc_vertexshader_from_source(vbyte *source) {
-	kinc_g4_shader_t *shader = (kinc_g4_shader_t *)malloc(sizeof(kinc_g4_shader_t));
-	kinc_g4_shader_init_from_source(shader, (char *)source, KINC_G4_SHADER_TYPE_VERTEX);
-	return (vbyte *)shader;
-}
-
-vbyte *hl_kinc_fragmentshader_from_source(vbyte *source) {
-	kinc_g4_shader_t *shader = (kinc_g4_shader_t *)malloc(sizeof(kinc_g4_shader_t));
-	kinc_g4_shader_init_from_source(shader, (char *)source, KINC_G4_SHADER_TYPE_FRAGMENT);
-	return (vbyte *)shader;
-}
-
-vbyte *hl_kinc_geometryshader_from_source(vbyte *source) {
-	kinc_g4_shader_t *shader = (kinc_g4_shader_t *)malloc(sizeof(kinc_g4_shader_t));
-	kinc_g4_shader_init_from_source(shader, (char *)source, KINC_G4_SHADER_TYPE_GEOMETRY);
-	return (vbyte *)shader;
-}
-
-vbyte *hl_kinc_tesscontrolshader_from_source(vbyte *source) {
-	kinc_g4_shader_t *shader = (kinc_g4_shader_t *)malloc(sizeof(kinc_g4_shader_t));
-	kinc_g4_shader_init_from_source(shader, (char *)source, KINC_G4_SHADER_TYPE_TESSELLATION_CONTROL);
-	return (vbyte *)shader;
-}
-
-vbyte *hl_kinc_tessevalshader_from_source(vbyte *source) {
-	kinc_g4_shader_t *shader = (kinc_g4_shader_t *)malloc(sizeof(kinc_g4_shader_t));
-	kinc_g4_shader_init_from_source(shader, (char *)source, KINC_G4_SHADER_TYPE_TESSELLATION_EVALUATION);
-	return (vbyte *)shader;
-}
-
-vbyte *hl_kinc_create_pipeline() {
-	kinc_g4_pipeline_t *pipeline = (kinc_g4_pipeline_t *)malloc(sizeof(kinc_g4_pipeline_t));
-	kinc_g4_pipeline_init(pipeline);
-	return (vbyte *)pipeline;
-}
-
-void hl_kinc_delete_pipeline(vbyte *pipeline) {
-	kinc_g4_pipeline_t *pipe = (kinc_g4_pipeline_t *)pipeline;
-	kinc_g4_pipeline_destroy(pipe);
-	free(pipe);
-}
-
-void hl_kinc_pipeline_set_vertex_shader(vbyte *pipeline, vbyte *shader) {
-	kinc_g4_pipeline_t *pipe = (kinc_g4_pipeline_t *)pipeline;
-	kinc_g4_shader_t *sh = (kinc_g4_shader_t *)shader;
-	pipe->vertex_shader = sh;
-}
-
-void hl_kinc_pipeline_set_fragment_shader(vbyte *pipeline, vbyte *shader) {
-	kinc_g4_pipeline_t *pipe = (kinc_g4_pipeline_t *)pipeline;
-	kinc_g4_shader_t *sh = (kinc_g4_shader_t *)shader;
-	pipe->fragment_shader = sh;
-}
-
-void hl_kinc_pipeline_set_geometry_shader(vbyte *pipeline, vbyte *shader) {
-	kinc_g4_pipeline_t *pipe = (kinc_g4_pipeline_t *)pipeline;
-	kinc_g4_shader_t *sh = (kinc_g4_shader_t *)shader;
-	pipe->geometry_shader = sh;
-}
-
-void hl_kinc_pipeline_set_tesscontrol_shader(vbyte *pipeline, vbyte *shader) {
-	kinc_g4_pipeline_t *pipe = (kinc_g4_pipeline_t *)pipeline;
-	kinc_g4_shader_t *sh = (kinc_g4_shader_t *)shader;
-	pipe->tessellation_control_shader = sh;
-}
-
-void hl_kinc_pipeline_set_tesseval_shader(vbyte *pipeline, vbyte *shader) {
-	kinc_g4_pipeline_t *pipe = (kinc_g4_pipeline_t *)pipeline;
-	kinc_g4_shader_t *sh = (kinc_g4_shader_t *)shader;
-	pipe->tessellation_evaluation_shader = sh;
-}
-
-void hl_kinc_pipeline_compile(vbyte *pipeline, vbyte *structure0, vbyte *structure1, vbyte *structure2, vbyte *structure3) {
-	kinc_g4_pipeline_t *pipe = (kinc_g4_pipeline_t *)pipeline;
-	pipe->input_layout[0] = (kinc_g4_vertex_structure_t *)structure0;
-	pipe->input_layout[1] = (kinc_g4_vertex_structure_t *)structure1;
-	pipe->input_layout[2] = (kinc_g4_vertex_structure_t *)structure2;
-	pipe->input_layout[3] = (kinc_g4_vertex_structure_t *)structure3;
-	pipe->input_layout[4] = NULL;
-	kinc_g4_pipeline_compile(pipe);
-}
-
-void hl_kinc_pipeline_set_states(vbyte *pipeline, int cullMode, int depthMode, int stencilFrontMode, int stencilFrontBothPass, int stencilFrontDepthFail,
-                                 int stencilFrontFail, int stencilBackMode, int stencilBackBothPass, int stencilBackDepthFail, int stencilBackFail,
-                                 int blendSource, int blendDestination, int alphaBlendSource, int alphaBlendDestination, bool depthWrite,
-                                 int stencilReferenceValue, int stencilReadMask, int stencilWriteMask, bool colorWriteMaskRed, bool colorWriteMaskGreen,
-                                 bool colorWriteMaskBlue, bool colorWriteMaskAlpha, int colorAttachmentCount, int colorAttachment0, int colorAttachment1,
-                                 int colorAttachment2, int colorAttachment3, int colorAttachment4, int colorAttachment5, int colorAttachment6,
-                                 int colorAttachment7, int depthAttachmentBits, int stencilAttachmentBits, bool conservativeRasterization) {
-	kinc_g4_pipeline_t *pipe = (kinc_g4_pipeline_t *)pipeline;
-
-	switch (cullMode) {
-	case 0:
-		pipe->cull_mode = KINC_G4_CULL_CLOCKWISE;
-		break;
-	case 1:
-		pipe->cull_mode = KINC_G4_CULL_COUNTER_CLOCKWISE;
-		break;
-	case 2:
-		pipe->cull_mode = KINC_G4_CULL_NOTHING;
-		break;
-	}
-
-	pipe->depth_mode = convertCompareMode(depthMode);
-	pipe->depth_write = depthWrite;
-
-	pipe->stencil_front_mode = convertCompareMode(stencilFrontMode);
-	pipe->stencil_front_both_pass = convertStencilAction(stencilFrontBothPass);
-	pipe->stencil_front_depth_fail = convertStencilAction(stencilFrontDepthFail);
-	pipe->stencil_front_fail = convertStencilAction(stencilFrontFail);
-
-	pipe->stencil_back_mode = convertCompareMode(stencilBackMode);
-	pipe->stencil_back_both_pass = convertStencilAction(stencilBackBothPass);
-	pipe->stencil_back_depth_fail = convertStencilAction(stencilBackDepthFail);
-	pipe->stencil_back_fail = convertStencilAction(stencilBackFail);
-
-	pipe->stencil_reference_value = stencilReferenceValue;
-	pipe->stencil_read_mask = stencilReadMask;
-	pipe->stencil_write_mask = stencilWriteMask;
-
-	pipe->blend_source = (kinc_g4_blending_factor_t)blendSource;
-	pipe->blend_destination = (kinc_g4_blending_factor_t)blendDestination;
-	pipe->alpha_blend_source = (kinc_g4_blending_factor_t)alphaBlendSource;
-	pipe->alpha_blend_destination = (kinc_g4_blending_factor_t)alphaBlendDestination;
-
-	pipe->color_write_mask_red[0] = colorWriteMaskRed;
-	pipe->color_write_mask_green[0] = colorWriteMaskGreen;
-	pipe->color_write_mask_blue[0] = colorWriteMaskBlue;
-	pipe->color_write_mask_alpha[0] = colorWriteMaskAlpha;
-
-	pipe->color_attachment_count = colorAttachmentCount;
-	pipe->color_attachment[0] = convertColorAttachment(colorAttachment0);
-	pipe->color_attachment[1] = convertColorAttachment(colorAttachment1);
-	pipe->color_attachment[2] = convertColorAttachment(colorAttachment2);
-	pipe->color_attachment[3] = convertColorAttachment(colorAttachment3);
-	pipe->color_attachment[4] = convertColorAttachment(colorAttachment4);
-	pipe->color_attachment[5] = convertColorAttachment(colorAttachment5);
-	pipe->color_attachment[6] = convertColorAttachment(colorAttachment6);
-	pipe->color_attachment[7] = convertColorAttachment(colorAttachment7);
-
-	pipe->depth_attachment_bits = depthAttachmentBits;
-	pipe->stencil_attachment_bits = stencilAttachmentBits;
-
-	pipe->conservative_rasterization = conservativeRasterization;
-}
-
-void hl_kinc_pipeline_set(vbyte *pipeline) {
-	kinc_g4_pipeline_t *pipe = (kinc_g4_pipeline_t *)pipeline;
-	kinc_g4_set_pipeline(pipe);
-}
-
-vbyte *hl_kinc_pipeline_get_constantlocation(vbyte *pipeline, vbyte *name) {
-	kinc_g4_pipeline_t *pipe = (kinc_g4_pipeline_t *)pipeline;
-	kinc_g4_constant_location_t *location = (kinc_g4_constant_location_t *)malloc(sizeof(kinc_g4_constant_location_t));
-	*location = kinc_g4_pipeline_get_constant_location(pipe, (char *)name);
-	return (vbyte *)location;
-}
-
-vbyte *hl_kinc_pipeline_get_textureunit(vbyte *pipeline, vbyte *name) {
-	kinc_g4_pipeline_t *pipe = (kinc_g4_pipeline_t *)pipeline;
-	kinc_g4_texture_unit_t *unit = (kinc_g4_texture_unit_t *)malloc(sizeof(kinc_g4_texture_unit_t));
-	*unit = kinc_g4_pipeline_get_texture_unit(pipe, (char *)name);
-	return (vbyte *)unit;
-}
+#include <kinc/graphics4/graphics.h>
+#include <kinc/graphics4/pipeline.h>
+#include <kinc/graphics4/shader.h>
+#include <kinc/graphics4/vertexstructure.h>
+
+#include <hl.h>
+
+static kinc_g4_compare_mode_t convertCompareMode(int mode) {
+	switch (mode) {
+	case 0:
+		return KINC_G4_COMPARE_ALWAYS;
+	case 1:
+		return KINC_G4_COMPARE_NEVER;
+	case 2:
+		return KINC_G4_COMPARE_EQUAL;
+	case 3:
+		return KINC_G4_COMPARE_NOT_EQUAL;
+	case 4:
+		return KINC_G4_COMPARE_LESS;
+	case 5:
+		return KINC_G4_COMPARE_LESS_EQUAL;
+	case 6:
+		return KINC_G4_COMPARE_GREATER;
+	case 7:
+	default:
+		return KINC_G4_COMPARE_GREATER_EQUAL;
+	}
+}
+
+static kinc_g4_stencil_action_t convertStencilAction(int action) {
+	switch (action) {
+	case 0:
+		return KINC_G4_STENCIL_KEEP;
+	case 1:
+		return KINC_G4_STENCIL_ZERO;
+	case 2:
+		return KINC_G4_STENCIL_REPLACE;
+	case 3:
+		return KINC_G4_STENCIL_INCREMENT;
+	case 4:
+		return KINC_G4_STENCIL_INCREMENT_WRAP;
+	case 5:
+		return KINC_G4_STENCIL_DECREMENT;
+	case 6:
+		return KINC_G4_STENCIL_DECREMENT_WRAP;
+	case 7:
+	default:
+		return KINC_G4_STENCIL_INVERT;
+	}
+}
+
+static kinc_g4_render_target_format_t convertColorAttachment(int format) {
+	switch (format) {
+	case 0:
+		return KINC_G4_RENDER_TARGET_FORMAT_32BIT;
+	case 1:
+		return KINC_G4_RENDER_TARGET_FORMAT_8BIT_RED;
+	case 2:
+		return KINC_G4_RENDER_TARGET_FORMAT_128BIT_FLOAT;
+	case 3:
+		return KINC_G4_RENDER_TARGET_FORMAT_16BIT_DEPTH;
+	case 4:
+		return KINC_G4_RENDER_TARGET_FORMAT_64BIT_FLOAT;
+	case 5:
+		return KINC_G4_RENDER_TARGET_FORMAT_32BIT_RED_FLOAT;
+	case 6:
+	default:
+		return KINC_G4_RENDER_TARGET_FORMAT_16BIT_RED_FLOAT;
+	}
+}
+
+vbyte *hl_kinc_create_vertexshader(vbyte *data, int length) {
+	kinc_g4_shader_t *shader = (kinc_g4_shader_t *)malloc(sizeof(kinc_g4_shader_t));
+	kinc_g4_shader_init(shader, data, length, KINC_G4_SHADER_TYPE_VERTEX);
+	return (vbyte *)shader;
+}
+
+vbyte *hl_kinc_create_fragmentshader(vbyte *data, int length) {
+	kinc_g4_shader_t *shader = (kinc_g4_shader_t *)malloc(sizeof(kinc_g4_shader_t));
+	kinc_g4_shader_init(shader, data, length, KINC_G4_SHADER_TYPE_FRAGMENT);
+	return (vbyte *)shader;
+}
+
+vbyte *hl_kinc_create_geometryshader(vbyte *data, int length) {
+	kinc_g4_shader_t *shader = (kinc_g4_shader_t *)malloc(sizeof(kinc_g4_shader_t));
+	kinc_g4_shader_init(shader, data, length, KINC_G4_SHADER_TYPE_GEOMETRY);
+	return (vbyte *)shader;
+}
+
+vbyte *hl_kinc_create_tesscontrolshader(vbyte *data, int length) {
+	kinc_g4_shader_t *shader = (kinc_g4_shader_t *)malloc(sizeof(kinc_g4_shader_t));
+	kinc_g4_shader_init(shader, data, length, KINC_G4_SHADER_TYPE_TESSELLATION_CONTROL);
+	return (vbyte *)shader;
+}
+
+vbyte *hl_kinc_create_tessevalshader(vbyte *data, int length) {
+	kinc_g4_shader_t *shader = (kinc_g4_shader_t *)malloc(sizeof(kinc_g4_shader_t));
+	kinc_g4_shader_init(shader, data, length, KINC_G4_SHADER_TYPE_TESSELLATION_EVALUATION);
+	return (vbyte *)shader;
+}
+
+vbyte *hl_kinc_vertexshader_from_source(vbyte *source) {
+	kinc_g4_shader_t *shader = (kinc_g4_shader_t *)malloc(sizeof(kinc_g4_shader_t));
+	kinc_g4_shader_init_from_source(shader, (char *)source, KINC_G4_SHADER_TYPE_VERTEX);
+	return (vbyte *)shader;
+}
+
+vbyte *hl_kinc_fragmentshader_from_source(vbyte *source) {
+	kinc_g4_shader_t *shader = (kinc_g4_shader_t *)malloc(sizeof(kinc_g4_shader_t));
+	kinc_g4_shader_init_from_source(shader, (char *)source, KINC_G4_SHADER_TYPE_FRAGMENT);
+	return (vbyte *)shader;
+}
+
+vbyte *hl_kinc_geometryshader_from_source(vbyte *source) {
+	kinc_g4_shader_t *shader = (kinc_g4_shader_t *)malloc(sizeof(kinc_g4_shader_t));
+	kinc_g4_shader_init_from_source(shader, (char *)source, KINC_G4_SHADER_TYPE_GEOMETRY);
+	return (vbyte *)shader;
+}
+
+vbyte *hl_kinc_tesscontrolshader_from_source(vbyte *source) {
+	kinc_g4_shader_t *shader = (kinc_g4_shader_t *)malloc(sizeof(kinc_g4_shader_t));
+	kinc_g4_shader_init_from_source(shader, (char *)source, KINC_G4_SHADER_TYPE_TESSELLATION_CONTROL);
+	return (vbyte *)shader;
+}
+
+vbyte *hl_kinc_tessevalshader_from_source(vbyte *source) {
+	kinc_g4_shader_t *shader = (kinc_g4_shader_t *)malloc(sizeof(kinc_g4_shader_t));
+	kinc_g4_shader_init_from_source(shader, (char *)source, KINC_G4_SHADER_TYPE_TESSELLATION_EVALUATION);
+	return (vbyte *)shader;
+}
+
+vbyte *hl_kinc_create_pipeline() {
+	kinc_g4_pipeline_t *pipeline = (kinc_g4_pipeline_t *)malloc(sizeof(kinc_g4_pipeline_t));
+	kinc_g4_pipeline_init(pipeline);
+	return (vbyte *)pipeline;
+}
+
+void hl_kinc_delete_pipeline(vbyte *pipeline) {
+	kinc_g4_pipeline_t *pipe = (kinc_g4_pipeline_t *)pipeline;
+	kinc_g4_pipeline_destroy(pipe);
+	free(pipe);
+}
+
+void hl_kinc_pipeline_set_vertex_shader(vbyte *pipeline, vbyte *shader) {
+	kinc_g4_pipeline_t *pipe = (kinc_g4_pipeline_t *)pipeline;
+	kinc_g4_shader_t *sh = (kinc_g4_shader_t *)shader;
+	pipe->vertex_shader = sh;
+}
+
+void hl_kinc_pipeline_set_fragment_shader(vbyte *pipeline, vbyte *shader) {
+	kinc_g4_pipeline_t *pipe = (kinc_g4_pipeline_t *)pipeline;
+	kinc_g4_shader_t *sh = (kinc_g4_shader_t *)shader;
+	pipe->fragment_shader = sh;
+}
+
+void hl_kinc_pipeline_set_geometry_shader(vbyte *pipeline, vbyte *shader) {
+	kinc_g4_pipeline_t *pipe = (kinc_g4_pipeline_t *)pipeline;
+	kinc_g4_shader_t *sh = (kinc_g4_shader_t *)shader;
+	pipe->geometry_shader = sh;
+}
+
+void hl_kinc_pipeline_set_tesscontrol_shader(vbyte *pipeline, vbyte *shader) {
+	kinc_g4_pipeline_t *pipe = (kinc_g4_pipeline_t *)pipeline;
+	kinc_g4_shader_t *sh = (kinc_g4_shader_t *)shader;
+	pipe->tessellation_control_shader = sh;
+}
+
+void hl_kinc_pipeline_set_tesseval_shader(vbyte *pipeline, vbyte *shader) {
+	kinc_g4_pipeline_t *pipe = (kinc_g4_pipeline_t *)pipeline;
+	kinc_g4_shader_t *sh = (kinc_g4_shader_t *)shader;
+	pipe->tessellation_evaluation_shader = sh;
+}
+
+void hl_kinc_pipeline_compile(vbyte *pipeline, vbyte *structure0, vbyte *structure1, vbyte *structure2, vbyte *structure3) {
+	kinc_g4_pipeline_t *pipe = (kinc_g4_pipeline_t *)pipeline;
+	pipe->input_layout[0] = (kinc_g4_vertex_structure_t *)structure0;
+	pipe->input_layout[1] = (kinc_g4_vertex_structure_t *)structure1;
+	pipe->input_layout[2] = (kinc_g4_vertex_structure_t *)structure2;
+	pipe->input_layout[3] = (kinc_g4_vertex_structure_t *)structure3;
+	pipe->input_layout[4] = NULL;
+	kinc_g4_pipeline_compile(pipe);
+}
+
+void hl_kinc_pipeline_set_states(vbyte *pipeline, int cullMode, int depthMode, int stencilFrontMode, int stencilFrontBothPass, int stencilFrontDepthFail,
+                                 int stencilFrontFail, int stencilBackMode, int stencilBackBothPass, int stencilBackDepthFail, int stencilBackFail,
+                                 int blendSource, int blendDestination, int alphaBlendSource, int alphaBlendDestination, bool depthWrite,
+                                 int stencilReferenceValue, int stencilReadMask, int stencilWriteMask, bool colorWriteMaskRed, bool colorWriteMaskGreen,
+                                 bool colorWriteMaskBlue, bool colorWriteMaskAlpha, int colorAttachmentCount, int colorAttachment0, int colorAttachment1,
+                                 int colorAttachment2, int colorAttachment3, int colorAttachment4, int colorAttachment5, int colorAttachment6,
+                                 int colorAttachment7, int depthAttachmentBits, int stencilAttachmentBits, bool conservativeRasterization) {
+	kinc_g4_pipeline_t *pipe = (kinc_g4_pipeline_t *)pipeline;
+
+	switch (cullMode) {
+	case 0:
+		pipe->cull_mode = KINC_G4_CULL_CLOCKWISE;
+		break;
+	case 1:
+		pipe->cull_mode = KINC_G4_CULL_COUNTER_CLOCKWISE;
+		break;
+	case 2:
+		pipe->cull_mode = KINC_G4_CULL_NOTHING;
+		break;
+	}
+
+	pipe->depth_mode = convertCompareMode(depthMode);
+	pipe->depth_write = depthWrite;
+
+	pipe->stencil_front_mode = convertCompareMode(stencilFrontMode);
+	pipe->stencil_front_both_pass = convertStencilAction(stencilFrontBothPass);
+	pipe->stencil_front_depth_fail = convertStencilAction(stencilFrontDepthFail);
+	pipe->stencil_front_fail = convertStencilAction(stencilFrontFail);
+
+	pipe->stencil_back_mode = convertCompareMode(stencilBackMode);
+	pipe->stencil_back_both_pass = convertStencilAction(stencilBackBothPass);
+	pipe->stencil_back_depth_fail = convertStencilAction(stencilBackDepthFail);
+	pipe->stencil_back_fail = convertStencilAction(stencilBackFail);
+
+	pipe->stencil_reference_value = stencilReferenceValue;
+	pipe->stencil_read_mask = stencilReadMask;
+	pipe->stencil_write_mask = stencilWriteMask;
+
+	pipe->blend_source = (kinc_g4_blending_factor_t)blendSource;
+	pipe->blend_destination = (kinc_g4_blending_factor_t)blendDestination;
+	pipe->alpha_blend_source = (kinc_g4_blending_factor_t)alphaBlendSource;
+	pipe->alpha_blend_destination = (kinc_g4_blending_factor_t)alphaBlendDestination;
+
+	pipe->color_write_mask_red[0] = colorWriteMaskRed;
+	pipe->color_write_mask_green[0] = colorWriteMaskGreen;
+	pipe->color_write_mask_blue[0] = colorWriteMaskBlue;
+	pipe->color_write_mask_alpha[0] = colorWriteMaskAlpha;
+
+	pipe->color_attachment_count = colorAttachmentCount;
+	pipe->color_attachment[0] = convertColorAttachment(colorAttachment0);
+	pipe->color_attachment[1] = convertColorAttachment(colorAttachment1);
+	pipe->color_attachment[2] = convertColorAttachment(colorAttachment2);
+	pipe->color_attachment[3] = convertColorAttachment(colorAttachment3);
+	pipe->color_attachment[4] = convertColorAttachment(colorAttachment4);
+	pipe->color_attachment[5] = convertColorAttachment(colorAttachment5);
+	pipe->color_attachment[6] = convertColorAttachment(colorAttachment6);
+	pipe->color_attachment[7] = convertColorAttachment(colorAttachment7);
+
+	pipe->depth_attachment_bits = depthAttachmentBits;
+	pipe->stencil_attachment_bits = stencilAttachmentBits;
+
+	pipe->conservative_rasterization = conservativeRasterization;
+}
+
+void hl_kinc_pipeline_set(vbyte *pipeline) {
+	kinc_g4_pipeline_t *pipe = (kinc_g4_pipeline_t *)pipeline;
+	kinc_g4_set_pipeline(pipe);
+}
+
+vbyte *hl_kinc_pipeline_get_constantlocation(vbyte *pipeline, vbyte *name) {
+	kinc_g4_pipeline_t *pipe = (kinc_g4_pipeline_t *)pipeline;
+	kinc_g4_constant_location_t *location = (kinc_g4_constant_location_t *)malloc(sizeof(kinc_g4_constant_location_t));
+	*location = kinc_g4_pipeline_get_constant_location(pipe, (char *)name);
+	return (vbyte *)location;
+}
+
+vbyte *hl_kinc_pipeline_get_textureunit(vbyte *pipeline, vbyte *name) {
+	kinc_g4_pipeline_t *pipe = (kinc_g4_pipeline_t *)pipeline;
+	kinc_g4_texture_unit_t *unit = (kinc_g4_texture_unit_t *)malloc(sizeof(kinc_g4_texture_unit_t));
+	*unit = kinc_g4_pipeline_get_texture_unit(pipe, (char *)name);
+	return (vbyte *)unit;
+} 

Kha/Backends/Kinc-HL/kinc-bridge/system.c.h

@@ -1,201 +1,201 @@
-#include <kinc/input/acceleration.h>
-#include <kinc/input/gamepad.h>
-#include <kinc/input/keyboard.h>
-#include <kinc/input/mouse.h>
-#include <kinc/input/pen.h>
-#include <kinc/input/rotation.h>
-#include <kinc/input/surface.h>
-#include <kinc/log.h>
-#include <kinc/system.h>
-#include <kinc/video.h>
-#include <kinc/window.h>
-
-#include <hl.h>
-
-void hl_kinc_log(vbyte *v) {
-	kinc_log(KINC_LOG_LEVEL_INFO, (char *)v);
-}
-
-double hl_kinc_get_time(void) {
-	return kinc_time();
-}
-
-int hl_kinc_get_window_width(int window) {
-	return kinc_window_width(window);
-}
-
-int hl_kinc_get_window_height(int window) {
-	return kinc_window_height(window);
-}
-
-vbyte *hl_kinc_get_system_id(void) {
-	return (vbyte *)kinc_system_id();
-}
-
-void hl_kinc_vibrate(int ms) {
-	kinc_vibrate(ms);
-}
-
-vbyte *hl_kinc_get_language(void) {
-	return (vbyte *)kinc_language();
-}
-
-void hl_kinc_request_shutdown(void) {
-	kinc_stop();
-}
-
-void hl_kinc_mouse_lock(int windowId) {
-	kinc_mouse_lock(windowId);
-}
-
-void hl_kinc_mouse_unlock(void) {
-	kinc_mouse_unlock();
-}
-
-bool hl_kinc_can_lock_mouse(void) {
-	return kinc_mouse_can_lock();
-}
-
-bool hl_kinc_is_mouse_locked(void) {
-	return kinc_mouse_is_locked();
-}
-
-void hl_kinc_show_mouse(bool show) {
-	if (show) {
-		kinc_mouse_show();
-	}
-	else {
-		kinc_mouse_hide();
-	}
-}
-
-bool hl_kinc_system_is_fullscreen(void) {
-	return false; // kinc_is_fullscreen();
-}
-
-void hl_kinc_system_request_fullscreen(void) {
-	// kinc_change_resolution(display_width(), display_height(), true);
-}
-
-void hl_kinc_system_exit_fullscreen(int previousWidth, int previousHeight) {
-	// kinc_change_resolution(previousWidth, previousHeight, false);
-}
-
-void hl_kinc_system_change_resolution(int width, int height) {
-	// kinc_change_resolution(width, height, false);
-}
-
-void hl_kinc_system_set_keepscreenon(bool on) {
-	kinc_set_keep_screen_on(on);
-}
-
-void hl_kinc_system_load_url(vbyte *url) {
-	kinc_load_url((char *)url);
-}
-
-vbyte *hl_kinc_get_gamepad_id(int index) {
-	return (vbyte*)kinc_gamepad_product_name(index);
-}
-
-vbyte *hl_kinc_get_gamepad_vendor(int index) {
-	return (vbyte*)kinc_gamepad_vendor(index);
-}
-
-bool hl_kinc_gamepad_connected(int index) {
-	return kinc_gamepad_connected(index);
-}
-
-typedef void (*FN_KEY_DOWN)(int, void *);
-typedef void (*FN_KEY_UP)(int, void *);
-typedef void (*FN_KEY_PRESS)(unsigned int, void *);
-
-void hl_kinc_register_keyboard(vclosure *keyDown, vclosure *keyUp, vclosure *keyPress) {
-	kinc_keyboard_set_key_down_callback(*((FN_KEY_DOWN *)(&keyDown->fun)), NULL);
-	kinc_keyboard_set_key_up_callback(*((FN_KEY_UP *)(&keyUp->fun)), NULL);
-	kinc_keyboard_set_key_press_callback(*((FN_KEY_PRESS *)(&keyPress->fun)), NULL);
-}
-
-typedef void (*FN_MOUSE_DOWN)(int, int, int, int, void *);
-typedef void (*FN_MOUSE_UP)(int, int, int, int, void *);
-typedef void (*FN_MOUSE_MOVE)(int, int, int, int, int, void *);
-typedef void (*FN_MOUSE_WHEEL)(int, int, void *);
-
-void hl_kinc_register_mouse(vclosure *mouseDown, vclosure *mouseUp, vclosure *mouseMove, vclosure *mouseWheel) {
-	kinc_mouse_set_press_callback(*((FN_MOUSE_DOWN *)(&mouseDown->fun)), NULL);
-	kinc_mouse_set_release_callback(*((FN_MOUSE_UP *)(&mouseUp->fun)), NULL);
-	kinc_mouse_set_move_callback(*((FN_MOUSE_MOVE *)(&mouseMove->fun)), NULL);
-	kinc_mouse_set_scroll_callback(*((FN_MOUSE_WHEEL *)(&mouseWheel->fun)), NULL);
-}
-
-typedef void (*FN_PEN_DOWN)(int, int, int, float);
-typedef void (*FN_PEN_UP)(int, int, int, float);
-typedef void (*FN_PEN_MOVE)(int, int, int, float);
-
-void hl_kinc_register_pen(vclosure *penDown, vclosure *penUp, vclosure *penMove) {
-	kinc_pen_set_press_callback(*((FN_PEN_DOWN *)(&penDown->fun)));
-	kinc_pen_set_release_callback(*((FN_PEN_UP *)(&penUp->fun)));
-	kinc_pen_set_move_callback(*((FN_PEN_MOVE *)(&penMove->fun)));
-}
-
-typedef void (*FN_GAMEPAD_AXIS)(int, int, float);
-typedef void (*FN_GAMEPAD_BUTTON)(int, int, float);
-
-void hl_kinc_register_gamepad(vclosure *gamepadAxis, vclosure *gamepadButton) {
-	kinc_gamepad_set_axis_callback(*((FN_GAMEPAD_AXIS *)(&gamepadAxis->fun)));
-	kinc_gamepad_set_button_callback(*((FN_GAMEPAD_BUTTON *)(&gamepadButton->fun)));
-}
-
-typedef void (*FN_TOUCH_START)(int, int, int);
-typedef void (*FN_TOUCH_END)(int, int, int);
-typedef void (*FN_TOUCH_MOVE)(int, int, int);
-
-void hl_kinc_register_surface(vclosure *touchStart, vclosure *touchEnd, vclosure *touchMove) {
-	kinc_surface_set_touch_start_callback(*((FN_TOUCH_START *)(&touchStart->fun)));
-	kinc_surface_set_touch_end_callback(*((FN_TOUCH_END *)(&touchEnd->fun)));
-	kinc_surface_set_move_callback(*((FN_TOUCH_MOVE *)(&touchMove->fun)));
-}
-
-typedef void (*FN_SENSOR_ACCELEROMETER)(float, float, float);
-typedef void (*FN_SENSOR_GYROSCOPE)(float, float, float);
-
-void hl_kinc_register_sensor(vclosure *accelerometerChanged, vclosure *gyroscopeChanged) {
-	kinc_acceleration_set_callback(*((FN_SENSOR_ACCELEROMETER *)(&accelerometerChanged->fun)));
-	kinc_rotation_set_callback(*((FN_SENSOR_GYROSCOPE *)(&gyroscopeChanged->fun)));
-}
-
-// typedef void(*FN_CB_ORIENTATION)(int);
-typedef void (*FN_CB_FOREGROUND)(void *);
-typedef void (*FN_CB_RESUME)(void *);
-typedef void (*FN_CB_PAUSE)(void *);
-typedef void (*FN_CB_BACKGROUND)(void *);
-typedef void (*FN_CB_SHUTDOWN)(void *);
-
-void hl_kinc_register_callbacks(vclosure *foreground, vclosure *resume, vclosure *pause, vclosure *background, vclosure *shutdown) {
-	// kinc_set_orientation_callback(orientation);
-	kinc_set_foreground_callback(*((FN_CB_FOREGROUND *)(&foreground->fun)), NULL);
-	kinc_set_resume_callback(*((FN_CB_RESUME *)(&resume->fun)), NULL);
-	kinc_set_pause_callback(*((FN_CB_PAUSE *)(&pause->fun)), NULL);
-	kinc_set_background_callback(*((FN_CB_BACKGROUND *)(&background->fun)), NULL);
-	kinc_set_shutdown_callback(*((FN_CB_SHUTDOWN *)(&shutdown->fun)), NULL);
-}
-
-typedef void (*FN_CB_DROPFILES)(wchar_t *);
-
-void hl_kinc_register_dropfiles(vclosure *dropFiles) {
-	// todo: string convert
-	// kinc_set_drop_files_callback(*((FN_CB_DROPFILES*)(&dropFiles->fun)));
-}
-
-typedef char *(*FN_CB_COPY)(void *);
-typedef char *(*FN_CB_CUT)(void *);
-typedef void (*FN_CB_PASTE)(char *, void *);
-
-void hl_kinc_register_copycutpaste(vclosure *copy, vclosure *cut, vclosure *paste) {
-	kinc_set_copy_callback(*((FN_CB_COPY *)(&copy->fun)), NULL);
-	kinc_set_cut_callback(*((FN_CB_CUT *)(&cut->fun)), NULL);
-	kinc_set_paste_callback(*((FN_CB_PASTE *)(&paste->fun)), NULL);
-}
-
-const char *hl_kinc_video_format(void) {
-	return kinc_video_formats()[0];
-}
+#include <kinc/input/acceleration.h>
+#include <kinc/input/gamepad.h>
+#include <kinc/input/keyboard.h>
+#include <kinc/input/mouse.h>
+#include <kinc/input/pen.h>
+#include <kinc/input/rotation.h>
+#include <kinc/input/surface.h>
+#include <kinc/log.h>
+#include <kinc/system.h>
+#include <kinc/video.h>
+#include <kinc/window.h>
+
+#include <hl.h>
+
+void hl_kinc_log(vbyte *v) {
+	kinc_log(KINC_LOG_LEVEL_INFO, (char *)v);
+}
+
+double hl_kinc_get_time(void) {
+	return kinc_time();
+}
+
+int hl_kinc_get_window_width(int window) {
+	return kinc_window_width(window);
+}
+
+int hl_kinc_get_window_height(int window) {
+	return kinc_window_height(window);
+}
+
+vbyte *hl_kinc_get_system_id(void) {
+	return (vbyte *)kinc_system_id();
+}
+
+void hl_kinc_vibrate(int ms) {
+	kinc_vibrate(ms);
+}
+
+vbyte *hl_kinc_get_language(void) {
+	return (vbyte *)kinc_language();
+}
+
+void hl_kinc_request_shutdown(void) {
+	kinc_stop();
+}
+
+void hl_kinc_mouse_lock(int windowId) {
+	kinc_mouse_lock(windowId);
+}
+
+void hl_kinc_mouse_unlock(void) {
+	kinc_mouse_unlock();
+}
+
+bool hl_kinc_can_lock_mouse(void) {
+	return kinc_mouse_can_lock();
+}
+
+bool hl_kinc_is_mouse_locked(void) {
+	return kinc_mouse_is_locked();
+}
+
+void hl_kinc_show_mouse(bool show) {
+	if (show) {
+		kinc_mouse_show();
+	}
+	else {
+		kinc_mouse_hide();
+	}
+}
+
+bool hl_kinc_system_is_fullscreen(void) {
+	return false; // kinc_is_fullscreen();
+}
+
+void hl_kinc_system_request_fullscreen(void) {
+	// kinc_change_resolution(display_width(), display_height(), true);
+}
+
+void hl_kinc_system_exit_fullscreen(int previousWidth, int previousHeight) {
+	// kinc_change_resolution(previousWidth, previousHeight, false);
+}
+
+void hl_kinc_system_change_resolution(int width, int height) {
+	// kinc_change_resolution(width, height, false);
+}
+
+void hl_kinc_system_set_keepscreenon(bool on) {
+	kinc_set_keep_screen_on(on);
+}
+
+void hl_kinc_system_load_url(vbyte *url) {
+	kinc_load_url((char *)url);
+}
+
+vbyte *hl_kinc_get_gamepad_id(int index) {
+	return (vbyte *)kinc_gamepad_product_name(index);
+}
+
+vbyte *hl_kinc_get_gamepad_vendor(int index) {
+	return (vbyte *)kinc_gamepad_vendor(index);
+}
+
+bool hl_kinc_gamepad_connected(int index) {
+	return kinc_gamepad_connected(index);
+}
+
+typedef void (*FN_KEY_DOWN)(int, void *);
+typedef void (*FN_KEY_UP)(int, void *);
+typedef void (*FN_KEY_PRESS)(unsigned int, void *);
+
+void hl_kinc_register_keyboard(vclosure *keyDown, vclosure *keyUp, vclosure *keyPress) {
+	kinc_keyboard_set_key_down_callback(*((FN_KEY_DOWN *)(&keyDown->fun)), NULL);
+	kinc_keyboard_set_key_up_callback(*((FN_KEY_UP *)(&keyUp->fun)), NULL);
+	kinc_keyboard_set_key_press_callback(*((FN_KEY_PRESS *)(&keyPress->fun)), NULL);
+}
+
+typedef void (*FN_MOUSE_DOWN)(int, int, int, int, void *);
+typedef void (*FN_MOUSE_UP)(int, int, int, int, void *);
+typedef void (*FN_MOUSE_MOVE)(int, int, int, int, int, void *);
+typedef void (*FN_MOUSE_WHEEL)(int, int, void *);
+
+void hl_kinc_register_mouse(vclosure *mouseDown, vclosure *mouseUp, vclosure *mouseMove, vclosure *mouseWheel) {
+	kinc_mouse_set_press_callback(*((FN_MOUSE_DOWN *)(&mouseDown->fun)), NULL);
+	kinc_mouse_set_release_callback(*((FN_MOUSE_UP *)(&mouseUp->fun)), NULL);
+	kinc_mouse_set_move_callback(*((FN_MOUSE_MOVE *)(&mouseMove->fun)), NULL);
+	kinc_mouse_set_scroll_callback(*((FN_MOUSE_WHEEL *)(&mouseWheel->fun)), NULL);
+}
+
+typedef void (*FN_PEN_DOWN)(int, int, int, float);
+typedef void (*FN_PEN_UP)(int, int, int, float);
+typedef void (*FN_PEN_MOVE)(int, int, int, float);
+
+void hl_kinc_register_pen(vclosure *penDown, vclosure *penUp, vclosure *penMove) {
+	kinc_pen_set_press_callback(*((FN_PEN_DOWN *)(&penDown->fun)));
+	kinc_pen_set_release_callback(*((FN_PEN_UP *)(&penUp->fun)));
+	kinc_pen_set_move_callback(*((FN_PEN_MOVE *)(&penMove->fun)));
+}
+
+typedef void (*FN_GAMEPAD_AXIS)(int, int, float, void *);
+typedef void (*FN_GAMEPAD_BUTTON)(int, int, float, void *);
+
+void hl_kinc_register_gamepad(vclosure *gamepadAxis, vclosure *gamepadButton) {
+	kinc_gamepad_set_axis_callback(*((FN_GAMEPAD_AXIS *)(&gamepadAxis->fun)), NULL);
+	kinc_gamepad_set_button_callback(*((FN_GAMEPAD_BUTTON *)(&gamepadButton->fun)), NULL);
+}
+
+typedef void (*FN_TOUCH_START)(int, int, int);
+typedef void (*FN_TOUCH_END)(int, int, int);
+typedef void (*FN_TOUCH_MOVE)(int, int, int);
+
+void hl_kinc_register_surface(vclosure *touchStart, vclosure *touchEnd, vclosure *touchMove) {
+	kinc_surface_set_touch_start_callback(*((FN_TOUCH_START *)(&touchStart->fun)));
+	kinc_surface_set_touch_end_callback(*((FN_TOUCH_END *)(&touchEnd->fun)));
+	kinc_surface_set_move_callback(*((FN_TOUCH_MOVE *)(&touchMove->fun)));
+}
+
+typedef void (*FN_SENSOR_ACCELEROMETER)(float, float, float);
+typedef void (*FN_SENSOR_GYROSCOPE)(float, float, float);
+
+void hl_kinc_register_sensor(vclosure *accelerometerChanged, vclosure *gyroscopeChanged) {
+	kinc_acceleration_set_callback(*((FN_SENSOR_ACCELEROMETER *)(&accelerometerChanged->fun)));
+	kinc_rotation_set_callback(*((FN_SENSOR_GYROSCOPE *)(&gyroscopeChanged->fun)));
+}
+
+// typedef void(*FN_CB_ORIENTATION)(int);
+typedef void (*FN_CB_FOREGROUND)(void *);
+typedef void (*FN_CB_RESUME)(void *);
+typedef void (*FN_CB_PAUSE)(void *);
+typedef void (*FN_CB_BACKGROUND)(void *);
+typedef void (*FN_CB_SHUTDOWN)(void *);
+
+void hl_kinc_register_callbacks(vclosure *foreground, vclosure *resume, vclosure *pause, vclosure *background, vclosure *shutdown) {
+	// kinc_set_orientation_callback(orientation);
+	kinc_set_foreground_callback(*((FN_CB_FOREGROUND *)(&foreground->fun)), NULL);
+	kinc_set_resume_callback(*((FN_CB_RESUME *)(&resume->fun)), NULL);
+	kinc_set_pause_callback(*((FN_CB_PAUSE *)(&pause->fun)), NULL);
+	kinc_set_background_callback(*((FN_CB_BACKGROUND *)(&background->fun)), NULL);
+	kinc_set_shutdown_callback(*((FN_CB_SHUTDOWN *)(&shutdown->fun)), NULL);
+}
+
+typedef void (*FN_CB_DROPFILES)(wchar_t *);
+
+void hl_kinc_register_dropfiles(vclosure *dropFiles) {
+	// todo: string convert
+	// kinc_set_drop_files_callback(*((FN_CB_DROPFILES*)(&dropFiles->fun)));
+}
+
+typedef char *(*FN_CB_COPY)(void *);
+typedef char *(*FN_CB_CUT)(void *);
+typedef void (*FN_CB_PASTE)(char *, void *);
+
+void hl_kinc_register_copycutpaste(vclosure *copy, vclosure *cut, vclosure *paste) {
+	kinc_set_copy_callback(*((FN_CB_COPY *)(&copy->fun)), NULL);
+	kinc_set_cut_callback(*((FN_CB_CUT *)(&cut->fun)), NULL);
+	kinc_set_paste_callback(*((FN_CB_PASTE *)(&paste->fun)), NULL);
+}
+
+const char *hl_kinc_video_format(void) {
+	return kinc_video_formats()[0];
+}

Kha/Backends/Krom/Krom.hx

@@ -80,6 +80,7 @@ extern class Krom {
 	static function unloadImage(image: kha.Image): Void;
 	static function loadSound(file: String): Dynamic;
 	static function writeAudioBuffer(buffer: js.lib.ArrayBuffer, samples: Int): Void;
+	static function getSamplesPerSecond(): Int;
 	static function loadBlob(file: String): js.lib.ArrayBuffer;
 
 	static function init(title: String, width: Int, height: Int, samplesPerPixel: Int, vSync: Bool, windowMode: Int, windowFeatures: Int, kromApi: Int): Void;
@@ -115,6 +116,7 @@ extern class Krom {
 	static function screenDpi(): Int;
 	static function systemId(): String;
 	static function requestShutdown(): Void;
+	static function displayFrequency(): Int;
 	static function displayCount(): Int;
 	static function displayWidth(index: Int): Int;
 	static function displayHeight(index: Int): Int;

Kha/Backends/Krom/kha/Display.hx

@@ -79,7 +79,7 @@ class Display {
 	public var frequency(get, never): Int;
 
 	function get_frequency(): Int {
-		return 60;
+		return Krom.displayFrequency();
 	}
 
 	public var pixelsPerInch(get, never): Int;

Kha/Backends/Krom/kha/SystemImpl.hx

@@ -1,343 +1,344 @@
-package kha;
-
-import kha.graphics4.TextureFormat;
-import kha.input.Gamepad;
-import kha.input.Keyboard;
-import kha.input.Mouse;
-import kha.input.MouseImpl;
-import kha.input.Pen;
-import kha.input.Surface;
-import kha.System;
-import haxe.ds.Vector;
-
-class SystemImpl {
-	static var start: Float;
-	static var framebuffer: Framebuffer;
-	static var keyboard: Keyboard;
-	static var mouse: Mouse;
-	static var pen: Pen;
-	static var maxGamepads: Int = 4;
-	static var gamepads: Array<Gamepad>;
-	static var mouseLockListeners: Array<Void->Void> = [];
-
-	static function renderCallback(): Void {
-		Scheduler.executeFrame();
-		System.render([framebuffer]);
-	}
-
-	static function dropFilesCallback(filePath: String): Void {
-		System.dropFiles(filePath);
-	}
-
-	static function copyCallback(): String {
-		if (System.copyListener != null) {
-			return System.copyListener();
-		}
-		else {
-			return null;
-		}
-	}
-
-	static function cutCallback(): String {
-		if (System.cutListener != null) {
-			return System.cutListener();
-		}
-		else {
-			return null;
-		}
-	}
-
-	static function pasteCallback(data: String): Void {
-		if (System.pasteListener != null) {
-			System.pasteListener(data);
-		}
-	}
-
-	static function foregroundCallback(): Void {
-		System.foreground();
-	}
-
-	static function resumeCallback(): Void {
-		System.resume();
-	}
-
-	static function pauseCallback(): Void {
-		System.pause();
-	}
-
-	static function backgroundCallback(): Void {
-		System.background();
-	}
-
-	static function shutdownCallback(): Void {
-		System.shutdown();
-	}
-
-	static function keyboardDownCallback(code: Int): Void {
-		keyboard.sendDownEvent(cast code);
-	}
-
-	static function keyboardUpCallback(code: Int): Void {
-		keyboard.sendUpEvent(cast code);
-	}
-
-	static function keyboardPressCallback(charCode: Int): Void {
-		keyboard.sendPressEvent(String.fromCharCode(charCode));
-	}
-
-	static function mouseDownCallback(button: Int, x: Int, y: Int): Void {
-		mouse.sendDownEvent(0, button, x, y);
-	}
-
-	static function mouseUpCallback(button: Int, x: Int, y: Int): Void {
-		mouse.sendUpEvent(0, button, x, y);
-	}
-
-	static function mouseMoveCallback(x: Int, y: Int, mx: Int, my: Int): Void {
-		mouse.sendMoveEvent(0, x, y, mx, my);
-	}
-
-	static function mouseWheelCallback(delta: Int): Void {
-		mouse.sendWheelEvent(0, delta);
-	}
-
-	static function penDownCallback(x: Int, y: Int, pressure: Float): Void {
-		pen.sendDownEvent(0, x, y, pressure);
-	}
-
-	static function penUpCallback(x: Int, y: Int, pressure: Float): Void {
-		pen.sendUpEvent(0, x, y, pressure);
-	}
-
-	static function penMoveCallback(x: Int, y: Int, pressure: Float): Void {
-		pen.sendMoveEvent(0, x, y, pressure);
-	}
-
-	static function gamepadAxisCallback(gamepad: Int, axis: Int, value: Float): Void {
-		gamepads[gamepad].sendAxisEvent(axis, value);
-	}
-
-	static function gamepadButtonCallback(gamepad: Int, button: Int, value: Float): Void {
-		gamepads[gamepad].sendButtonEvent(button, value);
-	}
-
-	static function audioCallback(samples: Int): Void {
-		kha.audio2.Audio._callCallback(samples);
-		var buffer = @:privateAccess kha.audio2.Audio.buffer;
-		Krom.writeAudioBuffer(buffer.data.buffer, samples);
-	}
-
-	public static function init(options: SystemOptions, callback: Window->Void): Void {
-		Krom.init(options.title, options.width, options.height, options.framebuffer.samplesPerPixel, options.framebuffer.verticalSync,
-			cast options.window.mode, options.window.windowFeatures, Krom.KROM_API);
-
-		start = Krom.getTime();
-
-		haxe.Log.trace = function(v: Dynamic, ?infos: haxe.PosInfos) {
-			var message = haxe.Log.formatOutput(v, infos);
-			Krom.log(message);
-		};
-
-		new Window(0);
-		Scheduler.init();
-		Shaders.init();
-
-		var g4 = new kha.krom.Graphics();
-		framebuffer = new Framebuffer(0, null, null, g4);
-		framebuffer.init(new kha.graphics2.Graphics1(framebuffer), new kha.graphics4.Graphics2(framebuffer), g4);
-		Krom.setCallback(renderCallback);
-		Krom.setDropFilesCallback(dropFilesCallback);
-		Krom.setCutCopyPasteCallback(cutCallback, copyCallback, pasteCallback);
-		Krom.setApplicationStateCallback(foregroundCallback, resumeCallback, pauseCallback, backgroundCallback, shutdownCallback);
-
-		keyboard = new Keyboard();
-		mouse = new MouseImpl();
-		pen = new Pen();
-		gamepads = new Array<Gamepad>();
-		for (i in 0...maxGamepads) {
-			gamepads[i] = new Gamepad(i);
-		}
-
-		Krom.setKeyboardDownCallback(keyboardDownCallback);
-		Krom.setKeyboardUpCallback(keyboardUpCallback);
-		Krom.setKeyboardPressCallback(keyboardPressCallback);
-		Krom.setMouseDownCallback(mouseDownCallback);
-		Krom.setMouseUpCallback(mouseUpCallback);
-		Krom.setMouseMoveCallback(mouseMoveCallback);
-		Krom.setMouseWheelCallback(mouseWheelCallback);
-		Krom.setPenDownCallback(penDownCallback);
-		Krom.setPenUpCallback(penUpCallback);
-		Krom.setPenMoveCallback(penMoveCallback);
-		Krom.setGamepadAxisCallback(gamepadAxisCallback);
-		Krom.setGamepadButtonCallback(gamepadButtonCallback);
-
-		kha.audio2.Audio._init();
-		kha.audio1.Audio._init();
-		Krom.setAudioCallback(audioCallback);
-
-		Scheduler.start();
-
-		callback(Window.get(0));
-	}
-
-	public static function initEx(title: String, options: Array<WindowOptions>, windowCallback: Int->Void, callback: Void->Void): Void {}
-
-	static function translateWindowMode(value: Null<WindowMode>): Int {
-		if (value == null) {
-			return 0;
-		}
-
-		return switch (value) {
-			case Windowed: 0;
-			case Fullscreen: 1;
-			case ExclusiveFullscreen: 2;
-		}
-	}
-
-	public static function getScreenRotation(): ScreenRotation {
-		return ScreenRotation.RotationNone;
-	}
-
-	public static function getTime(): Float {
-		return Krom.getTime() - start;
-	}
-
-	public static function getVsync(): Bool {
-		return true;
-	}
-
-	public static function getRefreshRate(): Int {
-		return 60;
-	}
-
-	public static function getSystemId(): String {
-		return Krom.systemId();
-	}
-
-	public static function vibrate(ms: Int): Void {
-		// TODO: Implement
-	}
-
-	public static function getLanguage(): String {
-		return "en"; // TODO: Implement
-	}
-
-	public static function requestShutdown(): Bool {
-		Krom.requestShutdown();
-		return true;
-	}
-
-	public static function getMouse(num: Int): Mouse {
-		return mouse;
-	}
-
-	public static function getPen(num: Int): Pen {
-		return pen;
-	}
-
-	public static function getKeyboard(num: Int): Keyboard {
-		return keyboard;
-	}
-
-	public static function lockMouse(): Void {
-		if (!isMouseLocked()) {
-			Krom.lockMouse();
-			for (listener in mouseLockListeners) {
-				listener();
-			}
-		}
-	}
-
-	public static function unlockMouse(): Void {
-		if (isMouseLocked()) {
-			Krom.unlockMouse();
-			for (listener in mouseLockListeners) {
-				listener();
-			}
-		}
-	}
-
-	public static function canLockMouse(): Bool {
-		return Krom.canLockMouse();
-	}
-
-	public static function isMouseLocked(): Bool {
-		return Krom.isMouseLocked();
-	}
-
-	public static function notifyOfMouseLockChange(func: Void->Void, error: Void->Void): Void {
-		if (canLockMouse() && func != null) {
-			mouseLockListeners.push(func);
-		}
-	}
-
-	public static function removeFromMouseLockChange(func: Void->Void, error: Void->Void): Void {
-		if (canLockMouse() && func != null) {
-			mouseLockListeners.remove(func);
-		}
-	}
-
-	public static function hideSystemCursor(): Void {
-		Krom.showMouse(false);
-	}
-
-	public static function showSystemCursor(): Void {
-		Krom.showMouse(true);
-	}
-
-	static function unload(): Void {}
-
-	public static function canSwitchFullscreen(): Bool {
-		return false;
-	}
-
-	public static function isFullscreen(): Bool {
-		return false;
-	}
-
-	public static function requestFullscreen(): Void {}
-
-	public static function exitFullscreen(): Void {}
-
-	public static function notifyOfFullscreenChange(func: Void->Void, error: Void->Void): Void {}
-
-	public static function removeFromFullscreenChange(func: Void->Void, error: Void->Void): Void {}
-
-	public static function changeResolution(width: Int, height: Int): Void {}
-
-	public static function setKeepScreenOn(on: Bool): Void {}
-
-	public static function loadUrl(url: String): Void {}
-
-	public static function getGamepadId(index: Int): String {
-		return "unknown";
-	}
-
-	public static function getGamepadVendor(index: Int): String {
-		return "unknown";
-	}
-
-	public static function setGamepadRumble(index: Int, leftAmount: Float, rightAmount: Float): Void {}
-
-	public static function safeZone(): Float {
-		return 1.0;
-	}
-
-	public static function login(): Void {}
-
-	public static function automaticSafeZone(): Bool {
-		return true;
-	}
-
-	public static function setSafeZone(value: Float): Void {}
-
-	public static function unlockAchievement(id: Int): Void {}
-
-	public static function waitingForLogin(): Bool {
-		return false;
-	}
-
-	public static function disallowUserChange(): Void {}
-
-	public static function allowUserChange(): Void {}
-}
+package kha;
+
+import kha.graphics4.TextureFormat;
+import kha.input.Gamepad;
+import kha.input.Keyboard;
+import kha.input.Mouse;
+import kha.input.MouseImpl;
+import kha.input.Pen;
+import kha.input.Surface;
+import kha.System;
+import haxe.ds.Vector;
+
+class SystemImpl {
+	static var start: Float;
+	static var framebuffer: Framebuffer;
+	static var keyboard: Keyboard;
+	static var mouse: Mouse;
+	static var pen: Pen;
+	static var maxGamepads: Int = 4;
+	static var gamepads: Array<Gamepad>;
+	static var mouseLockListeners: Array<Void->Void> = [];
+
+	static function renderCallback(): Void {
+		Scheduler.executeFrame();
+		System.render([framebuffer]);
+	}
+
+	static function dropFilesCallback(filePath: String): Void {
+		System.dropFiles(filePath);
+	}
+
+	static function copyCallback(): String {
+		if (System.copyListener != null) {
+			return System.copyListener();
+		}
+		else {
+			return null;
+		}
+	}
+
+	static function cutCallback(): String {
+		if (System.cutListener != null) {
+			return System.cutListener();
+		}
+		else {
+			return null;
+		}
+	}
+
+	static function pasteCallback(data: String): Void {
+		if (System.pasteListener != null) {
+			System.pasteListener(data);
+		}
+	}
+
+	static function foregroundCallback(): Void {
+		System.foreground();
+	}
+
+	static function resumeCallback(): Void {
+		System.resume();
+	}
+
+	static function pauseCallback(): Void {
+		System.pause();
+	}
+
+	static function backgroundCallback(): Void {
+		System.background();
+	}
+
+	static function shutdownCallback(): Void {
+		System.shutdown();
+	}
+
+	static function keyboardDownCallback(code: Int): Void {
+		keyboard.sendDownEvent(cast code);
+	}
+
+	static function keyboardUpCallback(code: Int): Void {
+		keyboard.sendUpEvent(cast code);
+	}
+
+	static function keyboardPressCallback(charCode: Int): Void {
+		keyboard.sendPressEvent(String.fromCharCode(charCode));
+	}
+
+	static function mouseDownCallback(button: Int, x: Int, y: Int): Void {
+		mouse.sendDownEvent(0, button, x, y);
+	}
+
+	static function mouseUpCallback(button: Int, x: Int, y: Int): Void {
+		mouse.sendUpEvent(0, button, x, y);
+	}
+
+	static function mouseMoveCallback(x: Int, y: Int, mx: Int, my: Int): Void {
+		mouse.sendMoveEvent(0, x, y, mx, my);
+	}
+
+	static function mouseWheelCallback(delta: Int): Void {
+		mouse.sendWheelEvent(0, delta);
+	}
+
+	static function penDownCallback(x: Int, y: Int, pressure: Float): Void {
+		pen.sendDownEvent(0, x, y, pressure);
+	}
+
+	static function penUpCallback(x: Int, y: Int, pressure: Float): Void {
+		pen.sendUpEvent(0, x, y, pressure);
+	}
+
+	static function penMoveCallback(x: Int, y: Int, pressure: Float): Void {
+		pen.sendMoveEvent(0, x, y, pressure);
+	}
+
+	static function gamepadAxisCallback(gamepad: Int, axis: Int, value: Float): Void {
+		gamepads[gamepad].sendAxisEvent(axis, value);
+	}
+
+	static function gamepadButtonCallback(gamepad: Int, button: Int, value: Float): Void {
+		gamepads[gamepad].sendButtonEvent(button, value);
+	}
+
+	static function audioCallback(samples: Int): Void {
+		kha.audio2.Audio._callCallback(samples);
+		var buffer = @:privateAccess kha.audio2.Audio.buffer;
+		Krom.writeAudioBuffer(buffer.data.buffer, samples);
+	}
+
+	public static function init(options: SystemOptions, callback: Window->Void): Void {
+		Krom.init(options.title, options.width, options.height, options.framebuffer.samplesPerPixel, options.framebuffer.verticalSync,
+			cast options.window.mode, options.window.windowFeatures, Krom.KROM_API);
+
+		start = Krom.getTime();
+
+		haxe.Log.trace = function(v: Dynamic, ?infos: haxe.PosInfos) {
+			var message = haxe.Log.formatOutput(v, infos);
+			Krom.log(message);
+		};
+
+		new Window(0);
+		Scheduler.init();
+		Shaders.init();
+
+		var g4 = new kha.krom.Graphics();
+		framebuffer = new Framebuffer(0, null, null, g4);
+		framebuffer.init(new kha.graphics2.Graphics1(framebuffer), new kha.graphics4.Graphics2(framebuffer), g4);
+		Krom.setCallback(renderCallback);
+		Krom.setDropFilesCallback(dropFilesCallback);
+		Krom.setCutCopyPasteCallback(cutCallback, copyCallback, pasteCallback);
+		Krom.setApplicationStateCallback(foregroundCallback, resumeCallback, pauseCallback, backgroundCallback, shutdownCallback);
+
+		keyboard = new Keyboard();
+		mouse = new MouseImpl();
+		pen = new Pen();
+		gamepads = new Array<Gamepad>();
+		for (i in 0...maxGamepads) {
+			gamepads[i] = new Gamepad(i);
+		}
+
+		Krom.setKeyboardDownCallback(keyboardDownCallback);
+		Krom.setKeyboardUpCallback(keyboardUpCallback);
+		Krom.setKeyboardPressCallback(keyboardPressCallback);
+		Krom.setMouseDownCallback(mouseDownCallback);
+		Krom.setMouseUpCallback(mouseUpCallback);
+		Krom.setMouseMoveCallback(mouseMoveCallback);
+		Krom.setMouseWheelCallback(mouseWheelCallback);
+		Krom.setPenDownCallback(penDownCallback);
+		Krom.setPenUpCallback(penUpCallback);
+		Krom.setPenMoveCallback(penMoveCallback);
+		Krom.setGamepadAxisCallback(gamepadAxisCallback);
+		Krom.setGamepadButtonCallback(gamepadButtonCallback);
+
+		kha.audio2.Audio.samplesPerSecond = Krom.getSamplesPerSecond();
+		kha.audio1.Audio._init();
+		kha.audio2.Audio._init();
+		Krom.setAudioCallback(audioCallback);
+
+		Scheduler.start();
+
+		callback(Window.get(0));
+	}
+
+	public static function initEx(title: String, options: Array<WindowOptions>, windowCallback: Int->Void, callback: Void->Void): Void {}
+
+	static function translateWindowMode(value: Null<WindowMode>): Int {
+		if (value == null) {
+			return 0;
+		}
+
+		return switch (value) {
+			case Windowed: 0;
+			case Fullscreen: 1;
+			case ExclusiveFullscreen: 2;
+		}
+	}
+
+	public static function getScreenRotation(): ScreenRotation {
+		return ScreenRotation.RotationNone;
+	}
+
+	public static function getTime(): Float {
+		return Krom.getTime() - start;
+	}
+
+	public static function getVsync(): Bool {
+		return true;
+	}
+
+	public static function getRefreshRate(): Int {
+		return Krom.displayFrequency();
+	}
+
+	public static function getSystemId(): String {
+		return Krom.systemId();
+	}
+
+	public static function vibrate(ms: Int): Void {
+		// TODO: Implement
+	}
+
+	public static function getLanguage(): String {
+		return "en"; // TODO: Implement
+	}
+
+	public static function requestShutdown(): Bool {
+		Krom.requestShutdown();
+		return true;
+	}
+
+	public static function getMouse(num: Int): Mouse {
+		return mouse;
+	}
+
+	public static function getPen(num: Int): Pen {
+		return pen;
+	}
+
+	public static function getKeyboard(num: Int): Keyboard {
+		return keyboard;
+	}
+
+	public static function lockMouse(): Void {
+		if (!isMouseLocked()) {
+			Krom.lockMouse();
+			for (listener in mouseLockListeners) {
+				listener();
+			}
+		}
+	}
+
+	public static function unlockMouse(): Void {
+		if (isMouseLocked()) {
+			Krom.unlockMouse();
+			for (listener in mouseLockListeners) {
+				listener();
+			}
+		}
+	}
+
+	public static function canLockMouse(): Bool {
+		return Krom.canLockMouse();
+	}
+
+	public static function isMouseLocked(): Bool {
+		return Krom.isMouseLocked();
+	}
+
+	public static function notifyOfMouseLockChange(func: Void->Void, error: Void->Void): Void {
+		if (canLockMouse() && func != null) {
+			mouseLockListeners.push(func);
+		}
+	}
+
+	public static function removeFromMouseLockChange(func: Void->Void, error: Void->Void): Void {
+		if (canLockMouse() && func != null) {
+			mouseLockListeners.remove(func);
+		}
+	}
+
+	public static function hideSystemCursor(): Void {
+		Krom.showMouse(false);
+	}
+
+	public static function showSystemCursor(): Void {
+		Krom.showMouse(true);
+	}
+
+	static function unload(): Void {}
+
+	public static function canSwitchFullscreen(): Bool {
+		return false;
+	}
+
+	public static function isFullscreen(): Bool {
+		return false;
+	}
+
+	public static function requestFullscreen(): Void {}
+
+	public static function exitFullscreen(): Void {}
+
+	public static function notifyOfFullscreenChange(func: Void->Void, error: Void->Void): Void {}
+
+	public static function removeFromFullscreenChange(func: Void->Void, error: Void->Void): Void {}
+
+	public static function changeResolution(width: Int, height: Int): Void {}
+
+	public static function setKeepScreenOn(on: Bool): Void {}
+
+	public static function loadUrl(url: String): Void {}
+
+	public static function getGamepadId(index: Int): String {
+		return "unknown";
+	}
+
+	public static function getGamepadVendor(index: Int): String {
+		return "unknown";
+	}
+
+	public static function setGamepadRumble(index: Int, leftAmount: Float, rightAmount: Float): Void {}
+
+	public static function safeZone(): Float {
+		return 1.0;
+	}
+
+	public static function login(): Void {}
+
+	public static function automaticSafeZone(): Bool {
+		return true;
+	}
+
+	public static function setSafeZone(value: Float): Void {}
+
+	public static function unlockAchievement(id: Int): Void {}
+
+	public static function waitingForLogin(): Bool {
+		return false;
+	}
+
+	public static function disallowUserChange(): Void {}
+
+	public static function allowUserChange(): Void {}
+}

Kha/Backends/Krom/kha/audio2/Audio.hx

@@ -1,57 +1,56 @@
-package kha.audio2;
-
-import kha.Sound;
-import kha.internal.IntBox;
-
-class Audio {
-	public static var disableGcInteractions = false;
-	static var intBox: IntBox = new IntBox(0);
-	static var buffer: Buffer;
-
-	public static function _init() {
-		var bufferSize = 1024 * 2;
-		buffer = new Buffer(bufferSize * 4, 2, 44100);
-		Audio.samplesPerSecond = 44100;
-	}
-
-	public static function _callCallback(samples: Int): Void {
-		if (buffer == null)
-			return;
-		if (audioCallback != null) {
-			intBox.value = samples;
-			audioCallback(intBox, buffer);
-		}
-		else {
-			for (i in 0...samples) {
-				buffer.data.set(buffer.writeLocation, 0);
-				buffer.writeLocation += 1;
-				if (buffer.writeLocation >= buffer.size) {
-					buffer.writeLocation = 0;
-				}
-			}
-		}
-	}
-
-	public static function _readSample(): Float {
-		if (buffer == null)
-			return 0;
-		var value = buffer.data.get(buffer.readLocation);
-		buffer.readLocation += 1;
-		if (buffer.readLocation >= buffer.size) {
-			buffer.readLocation = 0;
-		}
-		return value;
-	}
-
-	public static var samplesPerSecond: Int;
-
-	public static var audioCallback: IntBox->Buffer->Void;
-
-	public static function play(sound: Sound, loop: Bool = false): kha.audio1.AudioChannel {
-		return null;
-	}
-
-	public static function stream(sound: Sound, loop: Bool = false): kha.audio1.AudioChannel {
-		return null;
-	}
-}
+package kha.audio2;
+
+import kha.Sound;
+import kha.internal.IntBox;
+
+class Audio {
+	public static var disableGcInteractions = false;
+	static var intBox: IntBox = new IntBox(0);
+	static var buffer: Buffer;
+
+	public static function _init() {
+		var bufferSize = 1024 * 2;
+		buffer = new Buffer(bufferSize * 4, 2, samplesPerSecond);
+	}
+
+	public static function _callCallback(samples: Int): Void {
+		if (buffer == null)
+			return;
+		if (audioCallback != null) {
+			intBox.value = samples;
+			audioCallback(intBox, buffer);
+		}
+		else {
+			for (i in 0...samples) {
+				buffer.data.set(buffer.writeLocation, 0);
+				buffer.writeLocation += 1;
+				if (buffer.writeLocation >= buffer.size) {
+					buffer.writeLocation = 0;
+				}
+			}
+		}
+	}
+
+	public static function _readSample(): FastFloat {
+		if (buffer == null)
+			return 0;
+		var value = buffer.data.get(buffer.readLocation);
+		++buffer.readLocation;
+		if (buffer.readLocation >= buffer.size) {
+			buffer.readLocation = 0;
+		}
+		return value;
+	}
+
+	public static var samplesPerSecond: Int;
+
+	public static var audioCallback: IntBox->Buffer->Void;
+
+	public static function play(sound: Sound, loop: Bool = false): kha.audio1.AudioChannel {
+		return null;
+	}
+
+	public static function stream(sound: Sound, loop: Bool = false): kha.audio1.AudioChannel {
+		return null;
+	}
+}

Kha/Backends/Krom/kha/krom/Graphics.hx

@@ -59,7 +59,7 @@ class Graphics implements kha.graphics4.Graphics {
 	}
 
 	public function refreshRate(): Int {
-		return 60;
+		return Krom.displayFrequency();
 	}
 
 	public function clear(?color: Color, ?depth: Float, ?stencil: Int): Void {

Kha/Kinc/Backends/System/Linux/Sources/kinc/backend/sound.c.h

@@ -34,22 +34,46 @@ void copySample(void *buffer) {
 }
 
 int playback_callback(snd_pcm_sframes_t nframes) {
-	int err = 0;
-	if (kinc_a2_internal_callback(&a2_buffer, nframes)) {
-		int ni = 0;
-		while (ni < nframes) {
-			int i = 0;
-			for (; ni < nframes && i < 4096 * 2; ++i, ++ni) {
-				copySample(&buf[i * 2]);
-			}
-			int err2;
-			if ((err2 = snd_pcm_writei(playback_handle, buf, i)) < 0) {
-				fprintf(stderr, "write failed (%s)\n", snd_strerror(err2));
-			}
-			err += err2;
-		}
-	}
-	return err;
+    int err = 0; 
+    if (kinc_a2_internal_callback(&a2_buffer, nframes)) {
+        int ni = 0;
+        while (ni < nframes) {
+            int i = 0;
+            for (; ni < nframes && i < 4096; ++i, ++ni) {
+                copySample(&buf[i * 2]);
+            }
+            int err2 = snd_pcm_writei(playback_handle, buf, i);
+            if (err2 < 0) {
+                fprintf(stderr, "ALSA write failed in playback_callback: %s\n", snd_strerror(err2));
+                return err2;
+            }
+            if (err2 < i) {
+                fprintf(stderr, "ALSA short write in playback_callback: wrote %d of %d frames\n", err2, i);
+            }
+        }
+        err = nframes;
+    }
+    else {
+        // Write silence data to prevent recovery
+        if (nframes > 4096) {
+             fprintf(stderr, "Warning: ALSA requested %ld frames for silence, exceeding local buffer size %d. Clamping.\n", nframes, 4096);
+             nframes = 4096; 
+        }
+        memset(buf, 0, nframes * 4);
+
+        int err2 = snd_pcm_writei(playback_handle, buf, nframes);
+
+        if (err2 < 0) {
+            fprintf(stderr, "ALSA silence write failed in playback_callback: %s\n", snd_strerror(err2));
+            err = err2;
+        } else {
+            if (err2 < nframes) {
+                fprintf(stderr, "ALSA short silence write in playback_callback: wrote %d of %d frames\n", err2, (int)nframes);
+            }
+            err = err2;
+        }
+    }
+    return err;
 }
 
 bool tryToRecover(snd_pcm_t *handle, int errorCode) {

Kha/Kinc/Sources/kinc/input/gamepad.h

@@ -140,4 +140,4 @@ void kinc_internal_gamepad_trigger_button(int gamepad, int button, float value)
 
 #ifdef __cplusplus
 }
-#endif
+#endif

README.md

@@ -6,22 +6,12 @@ Welcome to Leenkx!
 
 
 <br>
-- <a style="color:#2AE0E0;" class="text primary primary-text" href="https://leenkx.com/files/LeenkxSDK3_RC.zip">LeenkxSDKV3.6 lts</a>
-<br>
-- <a style="color:#2AE0E0;" class="text primary primary-text" href="https://leenkx.com/files/lx/Leenkx.js">Leenkx.js</a>
-<br>
-- Run your own private p2p torrent socket changing Leenkx javascript file directly in /lnxsdk/lib/leenkx_tools/lxjs/Leenkx.js or by configuring the OPTS map in the create Leenkx node.
+- Run your own private p2p torrent socket changing Leenkx javascript file directly in /lnxsdk/lib/leenkx_tools/lnxjs/Leenkx.js or by configuring the OPTS map in the create Leenkx node.
 <br> 
-- All works are open source ZLIB / MIT and any compatible licence that  guarantee the softwares freedom from my additions to the previous maintainers 
-<br>
-- LxJS Works as a standalone library
+- LNXJS Works as a standalone library
 <br>
 - The SDK is not ready for production, use for educational purposes. Help the team by reaching out at Leenkx.com!
 <br>
-- This build is based on QuantumCoder's whole new core animation system packed with new features! Timmodrians Aura library is also built into this build when audio is enabled! 
-<br>
-- The SDK is still undergoing many changes so working on large projects is not recommended. 
-<br>
 - Special thanks to all contributors from the following projects!
 <br>
 * https://github.com/armory3d/armory/graphs/contributors<br>

api/api.hxml

@@ -2,10 +2,12 @@
 -cp ../Kha/Backends/Krom
 -cp ../leenkx/Sources
 -cp ../iron/Sources
+-cp ../lib/aura/Sources
 -cp ../lib/haxebullet/Sources
 -cp ../lib/haxerecast/Sources
 -cp ../lib/zui/Sources
 --macro include('iron', true, null, ['../iron/Sources'])
+--macro include('aura', true, null, ['../lib/aura/Sources'])
 --macro include('haxebullet', true, null, ['../lib/haxebullet/Sources'])
 --macro include('haxerecast', true, null, ['../lib/haxerecast/Sources'])
 --macro include('leenkx', true, ['leenkx.network'], ['../leenkx/Sources','../iron/Sources'])

leenkx.py

@@ -310,9 +310,9 @@ class LeenkxAddonPreferences(AddonPreferences):
         layout.label(text="Welcome to Leenkx!")
 
         # Compare version Blender and Leenkx (major, minor)
-        if bpy.app.version[0] != 3 or bpy.app.version[1] != 6:
+        if bpy.app.version[:2] not in [(4, 4), (4, 2), (3, 6), (3, 3)]:
             box = layout.box().column()
-            box.label(text="Warning: For Leenkx to work correctly, you need Blender 3.6 LTS.")
+            box.label(text="Warning: For Leenkx to work correctly, use a Blender LTS version")
 
         layout.prop(self, "sdk_path")
         sdk_path = get_sdk_path(context)
@@ -914,7 +914,10 @@ def restart_leenkx(context):
 
 @persistent
 def on_load_post(context):
-    restart_leenkx(bpy.context)  # context is None, use bpy.context instead
+    if bpy.context is not None:
+        restart_leenkx(bpy.context)  # context is None, use bpy.context instead
+    else:
+        bpy.app.timers.register(lambda: restart_leenkx(bpy.context), first_interval=0.1)
 
 
 def on_register_post():

leenkx/Shaders/blur_bilat_blend_pass/blur_bilat_blend_pass.frag.glsl

@@ -3,6 +3,10 @@
 
 #include "compiled.inc"
 
+#ifdef _CPostprocess
+uniform vec4 PPComp17;
+#endif
+
 uniform sampler2D tex;
 uniform vec2 dir;
 uniform vec2 screenSize;
@@ -45,6 +49,12 @@ void main() {
 		res += factor * col;
 	}
 
+	#ifdef _CPostprocess
+		vec3 AirColor = vec3(PPComp17.x, PPComp17.y, PPComp17.z);
+	#else
+		vec3 AirColor = volumAirColor;
+	#endif
+	
 	res /= sumfactor;
-	fragColor = vec4(volumAirColor * res, 1.0);
+	fragColor = vec4(AirColor * res, 1.0);
 }

leenkx/Shaders/blur_bilat_blend_pass/blur_bilat_blend_pass.json

@@ -19,6 +19,11 @@
 				{
 					"name": "screenSize",
 					"link": "_screenSize"
+				},
+				{
+					"name": "PPComp17",
+					"link": "_PPComp17",
+					"ifdef": ["_CPostprocess"]
 				}
 			],
 			"texture_params": [],

leenkx/Shaders/chromatic_aberration_pass/chromatic_aberration_pass.frag.glsl

@@ -5,7 +5,7 @@
 uniform sampler2D tex;
 
 #ifdef _CPostprocess
-uniform vec3 PPComp13;
+uniform vec4 PPComp13;
 #endif
 
 in vec2 texCoord;
@@ -43,13 +43,17 @@ void main() {
 	#ifdef _CPostprocess
 		float max_distort = PPComp13.x;
 		int num_iter = int(PPComp13.y);
+		int CAType = int(PPComp13.z);
+		int on = int(PPComp13.w);
 	#else
 		float max_distort = compoChromaticStrength;
 		int num_iter = compoChromaticSamples;
+		int CAType = compoChromaticType;
+		int on = 1;
 	#endif
 
 	// Spectral
-	if (compoChromaticType == 1) {
+	if (CAType == 1) {
 		float reci_num_iter_f = 1.0 / float(num_iter);
 
 		vec2 resolution = vec2(1,1);
@@ -64,7 +68,7 @@ void main() {
 			sumcol += w * texture(tex, barrelDistortion(uv, 0.6 * max_distort * t));
 		}
 
-		fragColor = sumcol / sumw;
+		if (on == 1) fragColor = sumcol / sumw; else fragColor = texture(tex, texCoord);
 	}
 
 	// Simple
@@ -73,6 +77,7 @@ void main() {
 		col.x = texture(tex, texCoord + ((vec2(0.0, 1.0) * max_distort) / vec2(1000.0))).x;
 		col.y = texture(tex, texCoord + ((vec2(-0.85, -0.5) * max_distort) / vec2(1000.0))).y;
 		col.z = texture(tex, texCoord + ((vec2(0.85, -0.5) * max_distort) / vec2(1000.0))).z;
-		fragColor = vec4(col.x, col.y, col.z, fragColor.w);
+		if (on == 1) fragColor = vec4(col.x, col.y, col.z, fragColor.w); 
+		else fragColor = texture(tex, texCoord);
 	}
 }

leenkx/Shaders/compositor_pass/compositor_pass.frag.glsl

@@ -62,8 +62,11 @@ uniform vec3 PPComp5;
 uniform vec3 PPComp6;
 uniform vec3 PPComp7;
 uniform vec3 PPComp8;
+uniform vec3 PPComp11;
 uniform vec3 PPComp14;
 uniform vec4 PPComp15;
+uniform vec4 PPComp16;
+uniform vec4 PPComp18;
 #endif
 
 // #ifdef _CPos
@@ -106,6 +109,16 @@ in vec2 texCoord;
 out vec4 fragColor;
 
 #ifdef _CFog
+	#ifdef _CPostprocess
+		vec3 FogColor = vec3(PPComp18.x, PPComp18.y, PPComp18.z);
+		float FogAmountA = PPComp18.w;
+		float FogAmountB = PPComp11.z;
+	#else
+		vec3 FogColor = compoFogColor;
+		float FogAmountA = compoFogAmountA;
+		float FogAmountB = compoFogAmountB;
+	#endif
+	
 // const vec3 compoFogColor = vec3(0.5, 0.6, 0.7);
 // const float compoFogAmountA = 1.0; // b = 0.01
 // const float compoFogAmountB = 1.0; // c = 0.1
@@ -118,8 +131,8 @@ out vec4 fragColor;
 // }
 vec3 applyFog(vec3 rgb, float distance) {
 	// float fogAmount = 1.0 - exp(-distance * compoFogAmountA);
-	float fogAmount = 1.0 - exp(-distance * (compoFogAmountA / 100));
-	return mix(rgb, compoFogColor, fogAmount);
+	float fogAmount = 1.0 - exp(-distance * (FogAmountA / 100));
+	return mix(rgb, FogColor, fogAmount);
 }
 #endif
 
@@ -131,7 +144,7 @@ float ConvertEV100ToExposure(float EV100) {
     return 1/0.8 * exp2(-EV100);
 }
 float ComputeEV(float avgLuminance) {
-    const float sqAperture = PPComp1[0].x * PPComp1.x;
+    const float sqAperture = PPComp1.x * PPComp1.x;
     const float shutterTime = 1.0 / PPComp1.y;
     const float ISO = PPComp1.z;
     const float EC = PPComp2.x;
@@ -349,16 +362,22 @@ void main() {
 
 #ifdef _CSharpen
 	#ifdef _CPostprocess
-		float strengthSharpen = PPComp14.y;
+		float strengthSharpen = PPComp14.y;	
+		vec3 SharpenColor = vec3(PPComp16.x, PPComp16.y, PPComp16.z); 
+		float SharpenSize = PPComp16.w;
 	#else
 		float strengthSharpen = compoSharpenStrength;
+		vec3 SharpenColor = compoSharpenColor;
+		float SharpenSize = compoSharpenSize;
 	#endif
-	vec3 col1 = textureLod(tex, texCo + vec2(-texStep.x, -texStep.y) * 1.5, 0.0).rgb;
-	vec3 col2 = textureLod(tex, texCo + vec2(texStep.x, -texStep.y) * 1.5, 0.0).rgb;
-	vec3 col3 = textureLod(tex, texCo + vec2(-texStep.x, texStep.y) * 1.5, 0.0).rgb;
-	vec3 col4 = textureLod(tex, texCo + vec2(texStep.x, texStep.y) * 1.5, 0.0).rgb;
+	vec3 col1 = textureLod(tex, texCo + vec2(-texStep.x, -texStep.y) * SharpenSize, 0.0).rgb;
+	vec3 col2 = textureLod(tex, texCo + vec2(texStep.x, -texStep.y) * SharpenSize, 0.0).rgb;
+	vec3 col3 = textureLod(tex, texCo + vec2(-texStep.x, texStep.y) * SharpenSize, 0.0).rgb;
+	vec3 col4 = textureLod(tex, texCo + vec2(texStep.x, texStep.y) * SharpenSize, 0.0).rgb;
 	vec3 colavg = (col1 + col2 + col3 + col4) * 0.25;
-	fragColor.rgb += (fragColor.rgb - colavg) * strengthSharpen;
+	
+	float edgeMagnitude = length(fragColor.rgb - colavg); 
+	fragColor.rgb = mix(fragColor.rgb, SharpenColor, min(edgeMagnitude * strengthSharpen * 2.0, 1.0));
 #endif
 
 #ifdef _CFog
@@ -407,7 +426,11 @@ void main() {
 #endif
 
 #ifdef _CExposure
-	fragColor.rgb += fragColor.rgb * compoExposureStrength;
+	#ifdef _CPostprocess
+		fragColor.rgb+=fragColor.rgb*PPComp8.x;
+	#else
+		fragColor.rgb+= fragColor.rgb*compoExposureStrength;
+	#endif
 #endif
 
 #ifdef _CPostprocess
@@ -415,8 +438,13 @@ void main() {
 #endif
 
 #ifdef _AutoExposure
+	#ifdef _CPostprocess
+		float AEStrength = PPComp8.y;
+	#else
+		float AEStrength = autoExposureStrength;
+	#endif
 	float expo = 2.0 - clamp(length(textureLod(histogram, vec2(0.5, 0.5), 0).rgb), 0.0, 1.0);
-	fragColor.rgb *= pow(expo, autoExposureStrength * 2.0);
+	fragColor.rgb *= pow(expo, AEStrength * 2.0);
 #endif
 
 // Clamp color to get rid of INF values that don't work for the tone mapping below
@@ -475,10 +503,12 @@ fragColor.rgb = min(fragColor.rgb, 65504 * 0.5);
 			} else {
 				fragColor.rgb = mix(midLumColor, maxLumColor, luminance);
 			}
-
-		} else {
-			fragColor.rgb = vec3(0,1,0); //ERROR
-		}
+		} else if (PPComp4.x == 9){
+			fragColor.rgb = tonemapAgXSimple(fragColor.rgb);
+			fragColor.rgb = pow(fragColor.rgb, vec3(1.0 / 2.2)); // To gamma
+		} else if (PPComp4.x == 10){
+			fragColor.rgb = tonemapAgXFull(fragColor.rgb);
+		} //else { fragColor.rgb = vec3(0,1,0); //ERROR}
 	#endif
 
 #else
@@ -498,6 +528,13 @@ fragColor.rgb = min(fragColor.rgb, 65504 * 0.5);
 		fragColor.rgb = pow(fragColor.rgb, vec3(1.0 / 2.2)); // To gamma
 		fragColor.rgb = clamp(fragColor.rgb, 0.0, 2.2);
 	#endif
+	#ifdef _CToneAgXSimple
+		fragColor.rgb = tonemapAgXSimple(fragColor.rgb);
+		fragColor.rgb = pow(fragColor.rgb, vec3(1.0 / 2.2)); // To gamma
+	#endif
+	#ifdef _CToneAgXFull
+		fragColor.rgb = tonemapAgXFull(fragColor.rgb);
+	#endif
 	#ifdef _CToneNone
 		fragColor.rgb = pow(fragColor.rgb, vec3(1.0 / 2.2)); // To gamma
 	#endif
@@ -614,4 +651,37 @@ fragColor.rgb = min(fragColor.rgb, 65504 * 0.5);
 #ifdef _CLUT
 	fragColor = LUTlookup(fragColor, lutTexture);
 #endif
+
+
+#ifdef _CDitheringBlueNoise
+	const float ditherStrength = ditherStrengthValue / 255.0;
+	float noise = ditherBlueNoiseStyle(gl_FragCoord.xy);
+	float noiseOffset = (noise - 0.5) * ditherStrength;
+	fragColor.rgb += noiseOffset;
+#endif
+
+#ifdef _CDitheringWhiteNoise
+	const float ditherStrength = ditherStrengthValue / 255.0;
+	float noise = ditherWhiteNoise(gl_FragCoord.xy);
+	float noiseOffset = (noise - 0.5) * ditherStrength;
+	fragColor.rgb += noiseOffset;
+#endif
+
+#ifdef _CDitheringOrderedBayer4x4
+	const float ditherStrength = ditherStrengthValue / 255.0;
+	float noise = ditherOrderedBayer4x4(ivec2(gl_FragCoord.xy));
+	float noiseOffset = (noise - 0.5) * ditherStrength;
+	fragColor.rgb += noiseOffset;
+#endif
+
+#ifdef _CDitheringOrderedBayer8x8
+	const float ditherStrength = ditherStrengthValue / 255.0;
+	float noise = ditherOrderedBayer8x8(ivec2(gl_FragCoord.xy));
+	float noiseOffset = (noise - 0.5) * ditherStrength;
+	fragColor.rgb += noiseOffset;
+#endif
+
+	//fragColor.rgb = clamp(fragColor.rgb, 0.0, 1.0);
+
+
 }

leenkx/Shaders/compositor_pass/compositor_pass.json

@@ -235,6 +235,16 @@
 					"name": "PPComp15",
 					"link": "_PPComp15",
 					"ifdef": ["_CPostprocess"]
+				},
+				{
+					"name": "PPComp16",
+					"link": "_PPComp16",
+					"ifdef": ["_CPostprocess"]
+				},
+				{
+					"name": "PPComp18",
+					"link": "_PPComp18",
+					"ifdef": ["_CPostprocess"]
 				}
 			],
 			"texture_params": [],

leenkx/Shaders/histogram_pass/histogram_pass.frag.glsl

@@ -2,13 +2,22 @@
 
 #include "compiled.inc"
 
+#ifdef _CPostprocess
+uniform vec3 PPComp8;
+#endif
+
 uniform sampler2D tex;
 
 in vec2 texCoord;
 out vec4 fragColor;
 
 void main() {
-	fragColor.a = 0.01 * autoExposureSpeed;
+	#ifdef _CPostprocess
+		fragColor.a = 0.01 * PPComp8.z;
+	#else
+		fragColor.a = 0.01 * autoExposureSpeed;
+	#endif
+
 	fragColor.rgb = textureLod(tex, vec2(0.5, 0.5), 0.0).rgb +
 					textureLod(tex, vec2(0.2, 0.2), 0.0).rgb +
 					textureLod(tex, vec2(0.8, 0.2), 0.0).rgb +

leenkx/Shaders/histogram_pass/histogram_pass.json

@@ -8,7 +8,13 @@
 			"blend_source": "source_alpha",
 			"blend_destination": "inverse_source_alpha",
 			"blend_operation": "add",
-			"links": [],
+			"links": [
+				{
+					"name": "PPComp8",
+					"link": "_PPComp8",
+					"ifdef": ["_CPostprocess"]
+				}
+			],
 			"texture_params": [],
 			"vertex_shader": "../include/pass.vert.glsl",
 			"fragment_shader": "histogram_pass.frag.glsl"

leenkx/Shaders/ssrefr_pass/ssrefr_pass.frag.glsl

@@ -86,7 +86,7 @@ void main() {
 
     vec3 viewNormal = V3 * n;
     vec3 viewPos = getPosView(viewRay, d, cameraProj);
-    vec3 refracted = refract(viewPos, viewNormal, 1.0 / ior);
+    vec3 refracted = refract(normalize(viewPos), viewNormal, 1.0 / ior);
     hitCoord = viewPos;
 
     vec3 dir = refracted * (1.0 - rand(texCoord) * ss_refractionJitter * roughness) * 2.0;

leenkx/Shaders/std/shadows.glsl

@@ -87,6 +87,40 @@ float lpToDepth(vec3 lp, const vec2 lightProj) {
 	return zcomp * 0.5 + 0.5;
 }
 
+#ifndef _ShadowMapAtlas
+vec3 PCFCube(samplerCubeShadow shadowMapCube, samplerCube shadowMapCubeTransparent, vec3 lp, vec3 ml, float bias, vec2 lightProj, vec3 n, const bool transparent) {
+    const float s = shadowmapCubePcfSize;
+    float compare = lpToDepth(lp, lightProj) - bias * 1.5;
+    ml = ml + n * bias * 20;
+    #ifdef _InvY
+    ml.y = -ml.y;
+    #endif
+    
+    float shadowFactor = 0.0;
+    shadowFactor = texture(shadowMapCube, vec4(ml, compare));
+    shadowFactor += texture(shadowMapCube, vec4(ml + vec3(s, s, s), compare));
+    shadowFactor += texture(shadowMapCube, vec4(ml + vec3(-s, s, s), compare));
+    shadowFactor += texture(shadowMapCube, vec4(ml + vec3(s, -s, s), compare));
+    shadowFactor += texture(shadowMapCube, vec4(ml + vec3(s, s, -s), compare));
+    shadowFactor += texture(shadowMapCube, vec4(ml + vec3(-s, -s, s), compare));
+    shadowFactor += texture(shadowMapCube, vec4(ml + vec3(s, -s, -s), compare));
+    shadowFactor += texture(shadowMapCube, vec4(ml + vec3(-s, s, -s), compare));
+    shadowFactor += texture(shadowMapCube, vec4(ml + vec3(-s, -s, -s), compare));
+    shadowFactor /= 9.0;
+    
+    vec3 result = vec3(shadowFactor);
+    
+    if (transparent == false) {
+        vec4 shadowmap_transparent = texture(shadowMapCubeTransparent, ml);
+        if (shadowmap_transparent.a < compare)
+            result *= shadowmap_transparent.rgb;
+    }
+
+    return result;
+}
+#endif
+
+#ifdef _ShadowMapAtlas
 vec3 PCFCube(samplerCubeShadow shadowMapCube, samplerCube shadowMapCubeTransparent, const vec3 lp, vec3 ml, const float bias, const vec2 lightProj, const vec3 n, const bool transparent) {
 	const float s = shadowmapCubePcfSize; // TODO: incorrect...
 	float compare = lpToDepth(lp, lightProj) - bias * 1.5;
@@ -115,7 +149,7 @@ vec3 PCFCube(samplerCubeShadow shadowMapCube, samplerCube shadowMapCubeTranspare
 	return result;
 }
 
-#ifdef _ShadowMapAtlas
+
 // transform "out-of-bounds" coordinates to the correct face/coordinate system
 // https://www.khronos.org/opengl/wiki/File:CubeMapAxes.png
 vec2 transformOffsetedUV(const int faceIndex, out int newFaceIndex, vec2 uv) {

leenkx/Shaders/std/tonemap.glsl

@@ -1,4 +1,3 @@
-
 vec3 uncharted2Tonemap(const vec3 x) {
 	const float A = 0.15;
 	const float B = 0.50;
@@ -12,6 +11,8 @@ vec3 uncharted2Tonemap(const vec3 x) {
 vec3 tonemapUncharted2(const vec3 color) {
 	const float W = 11.2;
 	const float exposureBias = 2.0;
+    // TODO - Find out why black world value of 0.0,0.0,0.0 turns to white pixels
+	if (dot(color, color) < 0.001) return vec3(0.001);
 	vec3 curr = uncharted2Tonemap(exposureBias * color);
 	vec3 whiteScale = 1.0 / uncharted2Tonemap(vec3(W));
 	return curr * whiteScale;
@@ -36,3 +37,106 @@ vec3 acesFilm(const vec3 x) {
 vec3 tonemapReinhard(const vec3 color) {
 	return color / (color + vec3(1.0));
 }
+
+// Blender AgX Implementation 
+// Troy Sobotka https://github.com/sobotka/AgX
+
+// AGX Simple
+vec3 tonemapAgXSimple(vec3 x) {
+	// TODO CORRECT AND OPTIMIZE
+    x = max(x, vec3(0.0));
+    float exposure = 0.6;
+    x *= exposure;
+    const vec3 AgX_A = vec3(0.92, 0.92, 0.72);
+    const vec3 AgX_B = vec3(0.24, 0.24, 0.36);
+    const vec3 AgX_C = vec3(0.92, 0.92, 0.72);
+    const vec3 AgX_D = vec3(0.24, 0.24, 0.36);
+    const vec3 AgX_E = vec3(0.08, 0.08, 0.12);
+    const vec3 AgX_F = vec3(0.0);
+    vec3 result = (x * (AgX_A * x + AgX_B)) / (x * (AgX_C * x + AgX_D) + AgX_E) + AgX_F;
+    float luma = dot(result, vec3(0.2126, 0.7152, 0.0722));
+    result = mix(vec3(luma), result, 0.6);
+    return clamp(result, vec3(0.0), vec3(1.0));
+}
+
+// AGX Full Contrast Approx
+vec3 agxDefaultContrastApprox(vec3 x) {
+    vec3 x2 = x * x;
+    vec3 x4 = x2 * x2;
+    return + 15.5     * x4 * x2
+           - 40.14    * x4 * x
+           + 31.96    * x4
+           - 6.868    * x2 * x
+           + 0.4298   * x2
+           + 0.1191   * x
+           - 0.00232;
+}
+// AGX Full Look
+vec3 agxLook(vec3 x, float strength) {
+    const vec3 slope = vec3(1.0);
+    const vec3 power = vec3(1.35);
+    const vec3 sat = vec3(1.4);
+    vec3 lw = vec3(0.2126, 0.7152, 0.0722);
+    float luma = dot(x, lw);
+    return pow(x * slope, power) * sat - (pow(luma * slope, power) * (sat - 1.0));
+}
+
+// AGX Full
+vec3 tonemapAgXFull(vec3 x) {
+    // x *= 2.0 * (1.0/0.8); // Brightness scale to match Blender's default
+    x = clamp(x, 0.0, 65504.0);
+    x = log2(x + 1.0);
+    x = agxDefaultContrastApprox(clamp(x * 0.5 - 10.5, -12.0, 12.0));    
+    x = mix(x, agxLook(x, 0.5), 0.5);
+    x = clamp(x, 0.0, 1.0);
+    return pow(x, vec3(1.0/2.2)); 
+}
+
+
+// Interleaved Gradient Noise (Pseudo-random, AKA Blue Noise style)
+// Based on http://momentsingraphics.de/BlueNoise.html
+float ditherBlueNoiseStyle(vec2 p) {
+    return fract(sin(dot(p.xy, vec2(12.9898, 78.233))) * 43758.5453123);
+}
+
+// White Noise Dithering
+float ditherWhiteNoise(vec2 p) {
+    return fract(sin(dot(p, vec2(12.9898, 4.1414))) * 43758.5453);
+}
+
+// Ordered Dithering (4x4 Bayer Matrix)
+float ditherOrderedBayer4x4(ivec2 p) {
+    const float bayer[16] = float[16](
+         0.0,  8.0,  2.0, 10.0,
+        12.0,  4.0, 14.0,  6.0,
+         3.0, 11.0,  1.0,  9.0,
+        15.0,  7.0, 13.0,  5.0
+    );
+    int index = (p.x % 4) * 4 + (p.y % 4);
+    return bayer[index] / 16.0;
+}
+
+// Ordered Dithering (8x8 Bayer Matrix)
+float ditherOrderedBayer8x8(ivec2 p) {
+    const float bayer8x8[64] = float[64](
+         0.0, 32.0,  8.0, 40.0,  2.0, 34.0, 10.0, 42.0,
+        48.0, 16.0, 56.0, 24.0, 50.0, 18.0, 58.0, 26.0,
+        12.0, 44.0,  4.0, 36.0, 14.0, 46.0,  6.0, 38.0,
+        60.0, 28.0, 52.0, 20.0, 62.0, 30.0, 54.0, 22.0,
+         3.0, 35.0, 11.0, 43.0,  1.0, 33.0,  9.0, 41.0,
+        51.0, 19.0, 59.0, 27.0, 49.0, 17.0, 57.0, 25.0,
+        15.0, 47.0,  7.0, 39.0, 13.0, 45.0,  5.0, 37.0,
+        63.0, 31.0, 55.0, 23.0, 61.0, 29.0, 53.0, 21.0
+    );
+    int index = (p.x % 8) * 8 + (p.y % 8);
+    return bayer8x8[index] / 64.0;
+}
+
+
+//vec3 applyDither(vec3 color, vec2 screenCoord) {
+//    float quantizationLevels = 255.0;
+//    float noise = randomDither(screenCoord);
+//    float noiseOffset = (noise - 0.5) / quantizationLevels;
+//    vec3 ditheredColor = color + noiseOffset;
+//    return clamp(ditheredColor, 0.0, 1.0);
+//}

leenkx/Shaders/volumetric_light/volumetric_light.frag.glsl

@@ -11,6 +11,11 @@
 #include "std/light_common.glsl"
 #endif
 
+#ifdef _CPostprocess
+uniform vec3 PPComp11;
+uniform vec4 PPComp17;
+#endif
+
 uniform sampler2D gbufferD;
 uniform sampler2D snoise;
 
@@ -87,7 +92,13 @@ out float fragColor;
 const float tScat = 0.08;
 const float tAbs = 0.0;
 const float tExt = tScat + tAbs;
-const float stepLen = 1.0 / volumSteps;
+#ifdef _CPostprocess
+	float stepLen = 1.0 / int(PPComp11.y);
+	float AirTurbidity = PPComp17.w;
+#else
+	const float stepLen = 1.0 / volumSteps;
+	float AirTurbidity = volumAirTurbidity;
+#endif
 const float lighting = 0.4;
 
 void rayStep(inout vec3 curPos, inout float curOpticalDepth, inout float scatteredLightAmount, float stepLenWorld, vec3 viewVecNorm) {
@@ -162,5 +173,5 @@ void main() {
 		rayStep(curPos, curOpticalDepth, scatteredLightAmount, stepLenWorld, viewVecNorm);
 	}
 
-	fragColor = scatteredLightAmount * volumAirTurbidity;
+	fragColor = scatteredLightAmount * AirTurbidity;
 }

leenkx/Shaders/volumetric_light/volumetric_light.json

@@ -140,6 +140,16 @@
 					"link": "_biasLightWorldViewProjectionMatrixSpot3",
 					"ifndef": ["_ShadowMapAtlas"],
 					"ifdef": ["_Spot", "_ShadowMap"]
+				},
+				{
+					"name": "PPComp11",
+					"link": "_PPComp11",
+					"ifdef": ["_CPostprocess"]
+				},
+				{
+					"name": "PPComp17",
+					"link": "_PPComp17",
+					"ifdef": ["_CPostprocess"]
 				}
 			],
 			"texture_params": [],

leenkx/Shaders/voxel_resolve_specular/voxel_resolve_specular.comp.glsl

@@ -48,7 +48,7 @@ void main() {
 	const vec2 pixel = gl_GlobalInvocationID.xy;
 	vec2 uv = (pixel + 0.5) / postprocess_resolution;
 	#ifdef _InvY
-	uv.y = 1.0 - uv.y
+	uv.y = 1.0 - uv.y;
 	#endif
 
 	float depth = textureLod(gbufferD, uv, 0.0).r * 2.0 - 1.0;

leenkx/Sources/iron/App.hx

@@ -12,6 +12,7 @@ class App {
 	static var traitInits: Array<Void->Void> = [];
 	static var traitUpdates: Array<Void->Void> = [];
 	static var traitLateUpdates: Array<Void->Void> = [];
+	static var traitFixedUpdates: Array<Void->Void> = [];
 	static var traitRenders: Array<kha.graphics4.Graphics->Void> = [];
 	static var traitRenders2D: Array<kha.graphics2.Graphics->Void> = [];
 	public static var framebuffer: kha.Framebuffer;
@@ -23,6 +24,8 @@ class App {
 	public static var renderPathTime: Float;
 	public static var endFrameCallbacks: Array<Void->Void> = [];
 	#end
+	static var last = 0.0;
+	static var time = 0.0;
 	static var lastw = -1;
 	static var lasth = -1;
 	public static var onResize: Void->Void = null;
@@ -34,13 +37,14 @@ class App {
 	function new(done: Void->Void) {
 		done();
 		kha.System.notifyOnFrames(render);
-		kha.Scheduler.addTimeTask(update, 0, iron.system.Time.delta);
+		kha.Scheduler.addTimeTask(update, 0, iron.system.Time.step);
 	}
 
 	public static function reset() {
 		traitInits = [];
 		traitUpdates = [];
 		traitLateUpdates = [];
+		traitFixedUpdates = [];
 		traitRenders = [];
 		traitRenders2D = [];
 		if (onResets != null) for (f in onResets) f();
@@ -48,6 +52,8 @@ class App {
 
 	static function update() {
 		if (Scene.active == null || !Scene.active.ready) return;
+		
+		iron.system.Time.update();
 		if (pauseUpdates) return;
 
 		#if lnx_debug
@@ -56,6 +62,14 @@ class App {
 
 		Scene.active.updateFrame();
 
+
+		time += iron.system.Time.delta;
+
+		while (time >= iron.system.Time.fixedStep) {
+			for (f in traitFixedUpdates) f();
+			time -= iron.system.Time.fixedStep;
+		}
+
 		var i = 0;
 		var l = traitUpdates.length;
 		while (i < l) {
@@ -106,7 +120,7 @@ class App {
 		var frame = frames[0];
 		framebuffer = frame;
 
-		iron.system.Time.update();
+		iron.system.Time.render();
 
 		if (Scene.active == null || !Scene.active.ready) {
 			render2D(frame);
@@ -172,6 +186,14 @@ class App {
 		traitLateUpdates.remove(f);
 	}
 
+	public static function notifyOnFixedUpdate(f: Void->Void) {
+		traitFixedUpdates.push(f);
+	}
+
+	public static function removeFixedUpdate(f: Void->Void) {
+		traitFixedUpdates.remove(f);
+	}
+
 	public static function notifyOnRender(f: kha.graphics4.Graphics->Void) {
 		traitRenders.push(f);
 	}

leenkx/Sources/iron/RenderPath.hx

@@ -518,12 +518,44 @@ class RenderPath {
 		return Reflect.field(kha.Shaders, handle + "_comp");
 	}
 
-	#if (kha_krom && lnx_vr)
-	public function drawStereo(drawMeshes: Int->Void) {
-		for (eye in 0...2) {
-			Krom.vrBeginRender(eye);
-			drawMeshes(eye);
-			Krom.vrEndRender(eye);
+	#if lnx_vr
+	public function drawStereo(drawMeshes: Void->Void) {
+		var vr = kha.vr.VrInterface.instance;
+		var appw = iron.App.w();
+		var apph = iron.App.h();
+		var halfw = Std.int(appw / 2);
+		var g = currentG;
+
+		if (vr != null && vr.IsPresenting()) {
+			// Left eye
+			Scene.active.camera.V.setFrom(Scene.active.camera.leftV);
+			Scene.active.camera.P.self = vr.GetProjectionMatrix(0);
+			g.viewport(0, 0, halfw, apph);
+			drawMeshes();
+
+			// Right eye
+			begin(g, additionalTargets);
+			Scene.active.camera.V.setFrom(Scene.active.camera.rightV);
+			Scene.active.camera.P.self = vr.GetProjectionMatrix(1);
+			g.viewport(halfw, 0, halfw, apph);
+			drawMeshes();
+		}
+		else { // Simulate
+			Scene.active.camera.buildProjection(halfw / apph);
+
+			// Left eye
+			g.viewport(0, 0, halfw, apph);
+			drawMeshes();
+
+			// Right eye
+			begin(g, additionalTargets);
+			Scene.active.camera.transform.move(Scene.active.camera.right(), 0.032);
+			Scene.active.camera.buildMatrix();
+			g.viewport(halfw, 0, halfw, apph);
+			drawMeshes();
+
+			Scene.active.camera.transform.move(Scene.active.camera.right(), -0.032);
+			Scene.active.camera.buildMatrix();
 		}
 	}
 	#end

leenkx/Sources/iron/Scene.hx

@@ -775,6 +775,7 @@ class Scene {
 			// Attach particle systems
 			#if lnx_particles
 			if (o.particle_refs != null) {
+				cast(object, MeshObject).render_emitter = o.render_emitter;
 				for (ref in o.particle_refs) cast(object, MeshObject).setupParticleSystem(sceneName, ref);
 			}
 			#end
@@ -782,6 +783,11 @@ class Scene {
 			if (o.tilesheet_ref != null) {
 				cast(object, MeshObject).setupTilesheet(sceneName, o.tilesheet_ref, o.tilesheet_action_ref);
 			}
+			
+			if (o.camera_list != null){
+				cast(object, MeshObject).cameraList = o.camera_list;
+			}
+
 			returnObject(object, o, done);
 		});
 	}
@@ -883,6 +889,10 @@ class Scene {
 
 						if (StringTools.endsWith(ptype, "Object") && pval != "") {
 							Reflect.setProperty(traitInst, pname, Scene.active.getChild(pval));
+						} else if (ptype == "TSceneFormat" && pval != "") {
+							Data.getSceneRaw(pval, function (r: TSceneFormat) {
+								Reflect.setProperty(traitInst, pname, r);
+							});
 						}
 						else {
 							switch (ptype) {

leenkx/Sources/iron/Trait.hx

@@ -16,6 +16,7 @@ class Trait {
 	var _remove: Array<Void->Void> = null;
 	var _update: Array<Void->Void> = null;
 	var _lateUpdate: Array<Void->Void> = null;
+	var _fixedUpdate: Array<Void->Void> = null;
 	var _render: Array<kha.graphics4.Graphics->Void> = null;
 	var _render2D: Array<kha.graphics2.Graphics->Void> = null;
 
@@ -87,6 +88,23 @@ class Trait {
 		App.removeLateUpdate(f);
 	}
 
+    /**
+      Add fixed game logic handler.
+    **/
+	public function notifyOnFixedUpdate(f: Void->Void) {
+		if (_fixedUpdate == null) _fixedUpdate = [];
+		_fixedUpdate.push(f);
+		App.notifyOnFixedUpdate(f);
+	}
+
+    /**
+      Remove fixed game logic handler.
+    **/
+	public function removeFixedUpdate(f: Void->Void) {
+		_fixedUpdate.remove(f);
+		App.removeFixedUpdate(f);
+	}
+
     /**
       Add render handler.
     **/

leenkx/Sources/iron/data/SceneFormat.hx

@@ -392,6 +392,8 @@ typedef TParticleData = {
 #end
 	public var name: String;
 	public var type: Int; // 0 - Emitter, Hair
+	public var auto_start: Bool;
+	public var is_unique: Bool;
 	public var loop: Bool;
 	public var count: Int;
 	public var frame_start: FastFloat;
@@ -439,6 +441,7 @@ typedef TObj = {
 	@:optional public var traits: Array<TTrait>;
 	@:optional public var properties: Array<TProperty>;
 	@:optional public var vertex_groups: Array<TVertex_groups>;
+	@:optional public var camera_list: Array<String>;
 	@:optional public var constraints: Array<TConstraint>;
 	@:optional public var dimensions: Float32Array; // Geometry objects
 	@:optional public var object_actions: Array<String>;

leenkx/Sources/iron/format/bmp/Data.hx

@@ -0,0 +1,50 @@
+/*
+ * format - Haxe File Formats
+ *
+ *  BMP File Format
+ *  Copyright (C) 2007-2009 Trevor McCauley, Baluta Cristian (hx port) & Robert Sköld (format conversion)
+ *
+ * Copyright (c) 2009, The Haxe Project Contributors
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   - Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE HAXE PROJECT CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE HAXE PROJECT CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package iron.format.bmp;
+
+typedef Data = {
+    var header : iron.format.bmp.Header;
+    var pixels : haxe.io.Bytes;
+#if (haxe_ver < 4)
+    var colorTable : Null<haxe.io.Bytes>;
+#else
+    var ?colorTable : haxe.io.Bytes;
+#end
+}
+
+typedef Header = {
+    var width : Int;          // real width (in pixels)
+    var height : Int;         // real height (in pixels)
+    var paddedStride : Int;   // number of bytes in a stride (including padding)
+    var topToBottom : Bool;   // whether the bitmap is stored top to bottom
+    var bpp : Int;            // bits per pixel
+    var dataLength : Int;     // equal to `paddedStride` * `height`
+    var compression : Int;    // which compression is being used, 0 for no compression
+}

leenkx/Sources/iron/format/bmp/Reader.hx

@@ -0,0 +1,122 @@
+/*
+ * format - Haxe File Formats
+ *
+ *  BMP File Format
+ *  Copyright (C) 2007-2009 Robert Sköld
+ *
+ * Copyright (c) 2009, The Haxe Project Contributors
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   - Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE HAXE PROJECT CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE HAXE PROJECT CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+package iron.format.bmp;
+
+import iron.format.bmp.Data;
+
+
+class Reader {
+
+	var input : haxe.io.Input;
+
+	public function new( i ) {
+		input = i;
+	}
+
+	/** 
+	 * Only supports uncompressed 24bpp bitmaps (the most common format).
+	 * 
+	 * The returned bytes in `Data.pixels` will be in BGR order, and with padding (if present).
+	 * 
+	 * @see https://msdn.microsoft.com/en-us/library/windows/desktop/dd318229(v=vs.85).aspx
+	 * @see https://en.wikipedia.org/wiki/BMP_file_format#Bitmap_file_header
+	 */
+	public function read() : format.bmp.Data {
+		// Read Header
+		for (b in ["B".code, "M".code]) {
+			if (input.readByte() != b) throw "Invalid header";
+		}
+	
+		var fileSize = input.readInt32();
+		input.readInt32();							// Reserved
+		var offset = input.readInt32();
+
+		// Read InfoHeader
+		var infoHeaderSize = input.readInt32();		// InfoHeader size
+		if (infoHeaderSize != 40) {
+			throw 'Info headers with size $infoHeaderSize not supported.';
+		}
+		var width = input.readInt32();				// Image width (actual, not padded)
+		var height = input.readInt32();				// Image height
+		var numPlanes = input.readInt16();			// Number of planes
+		var bits = input.readInt16();				// Bits per pixel
+		var compression = input.readInt32();		// Compression type
+		var dataLength = input.readInt32();			// Image data size (includes padding!)
+		input.readInt32();							// Horizontal resolution
+		input.readInt32();							// Vertical resolution
+		var colorsUsed = input.readInt32();			// Colors used (0 when uncompressed)
+		input.readInt32();							// Important colors (0 when uncompressed)
+
+		// If there's no compression, the dataLength may be 0
+		if ( compression == 0 && dataLength == 0 ) dataLength = fileSize - offset;
+
+		var bytesRead = 54; // total read above
+		
+		var colorTable : haxe.io.Bytes = null;
+		if ( bits <= 8 ) {
+			if ( colorsUsed == 0 ) {
+				colorsUsed = Tools.getNumColorsForBitDepth(bits);
+			}
+			var colorTableLength = 4 * colorsUsed;
+			colorTable = haxe.io.Bytes.alloc( colorTableLength );
+			input.readFullBytes( colorTable, 0, colorTableLength );
+			bytesRead += colorTableLength;
+		}
+
+		input.read( offset - bytesRead );
+		
+		var p = haxe.io.Bytes.alloc( dataLength );	
+		
+		// Read Raster Data
+		var paddedStride = Tools.computePaddedStride(width, bits);
+		var topToBottom = false;
+		if ( height < 0 ) { // if bitmap is stored top to bottom
+			topToBottom = true;
+			height = -height;
+		}
+    
+		input.readFullBytes(p, 0, dataLength);
+			
+		return {
+			header: {
+				width: width,
+				height: height,
+				paddedStride: paddedStride,
+				topToBottom: topToBottom,
+				bpp: bits,
+				dataLength: dataLength,
+				compression: compression
+			},
+			pixels: p,
+			colorTable: colorTable
+		}
+	}
+}

leenkx/Sources/iron/format/bmp/Tools.hx

@@ -0,0 +1,256 @@
+/*
+ * format - Haxe File Formats
+ *
+ *  BMP File Format
+ *  Copyright (C) 2007-2009 Trevor McCauley, Baluta Cristian (hx port) & Robert Sköld (format conversion)
+ *
+ * Copyright (c) 2009, The Haxe Project Contributors
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   - Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE HAXE PROJECT CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE HAXE PROJECT CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package iron.format.bmp;
+
+
+class Tools {
+
+	//												  a  r  g  b
+	static var ARGB_MAP(default, never):Array<Int> = [0, 1, 2, 3];
+	static var BGRA_MAP(default, never):Array<Int> = [3, 2, 1, 0];
+
+	static var COLOR_SIZE(default, never):Int = 4;
+	
+	/**
+		Extract BMP pixel data (24bpp in BGR format) and expands it to BGRA, removing any padding in the process.
+	**/
+	inline static public function extractBGRA( bmp : iron.format.bmp.Data ) : haxe.io.Bytes {
+		return _extract32(bmp, BGRA_MAP, 0xFF);
+	}
+
+	/**
+		Extract BMP pixel data (24bpp in BGR format) and converts it to ARGB.
+	**/
+	inline static public function extractARGB( bmp : iron.format.bmp.Data ) : haxe.io.Bytes {
+		return _extract32(bmp, ARGB_MAP, 0xFF);
+	}
+  
+	/**
+		Creates BMP data from bytes in BGRA format for each pixel.
+	**/
+	inline static public function buildFromBGRA( width : Int, height : Int, srcBytes : haxe.io.Bytes, topToBottom : Bool = false ) : Data {
+		return _buildFrom32(width, height, srcBytes, BGRA_MAP, topToBottom);
+	}
+  
+	/**
+		Creates BMP data from bytes in ARGB format for each pixel.
+	**/
+	inline static public function buildFromARGB( width : Int, height : Int, srcBytes : haxe.io.Bytes, topToBottom : Bool = false ) : Data {
+		return _buildFrom32(width, height, srcBytes, ARGB_MAP, topToBottom);
+	}
+
+	inline static public function computePaddedStride(width:Int, bpp:Int):Int {
+		return ((((width * bpp) + 31) & ~31) >> 3);
+	}
+
+	/**
+	 * Gets number of colors for indexed palettes
+	 */
+	inline static public function getNumColorsForBitDepth(bpp:Int):Int {
+		return switch (bpp) {
+			case 1: 2;
+			case 4: 16;
+			case 8: 256;
+			case 16: 65536;
+			default: throw 'Unsupported bpp $bpp';
+		}
+	}
+	
+	
+	// `channelMap` contains indices to map into ARGB (f.e. the mapping for ARGB is [0,1,2,3], while for BGRA is [3,2,1,0])
+	static function _extract32( bmp : iron.format.bmp.Data, channelMap : Array<Int>, alpha : Int = 0xFF) : haxe.io.Bytes {
+		var srcBytes = bmp.pixels;
+		var dstLen = bmp.header.width * bmp.header.height * 4;
+		var dstBytes = haxe.io.Bytes.alloc( dstLen );
+		var srcPaddedStride = bmp.header.paddedStride;
+		
+		var yDir = -1;
+		var dstPos = 0;
+		var srcPos = srcPaddedStride * (bmp.header.height - 1);
+    
+		if ( bmp.header.topToBottom ) {
+			yDir = 1;
+			srcPos = 0;
+		}
+
+		if ( bmp.header.bpp < 8 || bmp.header.bpp == 16 ) {
+			throw 'bpp ${bmp.header.bpp} not supported';
+		}
+
+		var colorTable:haxe.io.Bytes = null;
+		if ( bmp.header.bpp <= 8 ) {
+			var colorTableLength = getNumColorsForBitDepth(bmp.header.bpp);
+			colorTable = haxe.io.Bytes.alloc(colorTableLength * COLOR_SIZE);
+			var definedColorTableLength = Std.int( bmp.colorTable.length / COLOR_SIZE );
+			for( i in 0...definedColorTableLength ) {
+				var b = bmp.colorTable.get( i * COLOR_SIZE);
+				var g = bmp.colorTable.get( i * COLOR_SIZE + 1);
+				var r = bmp.colorTable.get( i * COLOR_SIZE + 2);
+
+				colorTable.set(i * COLOR_SIZE + channelMap[0], alpha);
+				colorTable.set(i * COLOR_SIZE + channelMap[1], r);
+				colorTable.set(i * COLOR_SIZE + channelMap[2], g);
+				colorTable.set(i * COLOR_SIZE + channelMap[3], b);
+			}
+			// We want to have the table the full length in case indices outside the range are present
+			colorTable.fill(definedColorTableLength, colorTableLength - definedColorTableLength, 0);
+			for( i in definedColorTableLength...colorTableLength ) {
+				colorTable.set(i * COLOR_SIZE + channelMap[0], alpha);
+			}
+		}
+
+		switch bmp.header.compression {
+			case 0:
+				while( dstPos < dstLen ) {
+					for( i in 0...bmp.header.width ) {
+						if (bmp.header.bpp == 8) {
+
+							var currentSrcPos = srcPos + i;
+							var index = srcBytes.get(currentSrcPos);
+							dstBytes.blit( dstPos, colorTable, index * COLOR_SIZE, COLOR_SIZE );
+
+						} else if (bmp.header.bpp == 24) {
+
+							var currentSrcPos = srcPos + i * 3;
+							var b = srcBytes.get(currentSrcPos);
+							var g = srcBytes.get(currentSrcPos + 1);
+							var r = srcBytes.get(currentSrcPos + 2);
+							
+							dstBytes.set(dstPos + channelMap[0], alpha);
+							dstBytes.set(dstPos + channelMap[1], r);
+							dstBytes.set(dstPos + channelMap[2], g);
+							dstBytes.set(dstPos + channelMap[3], b);
+
+						} else if (bmp.header.bpp == 32) {
+
+							var currentSrcPos = srcPos + i * 4;
+							var b = srcBytes.get(currentSrcPos);
+							var g = srcBytes.get(currentSrcPos + 1);
+							var r = srcBytes.get(currentSrcPos + 2);
+							
+							dstBytes.set(dstPos + channelMap[0], alpha);
+							dstBytes.set(dstPos + channelMap[1], r);
+							dstBytes.set(dstPos + channelMap[2], g);
+							dstBytes.set(dstPos + channelMap[3], b);
+
+						}
+						dstPos += 4;
+					}
+					srcPos += yDir * srcPaddedStride;
+				}
+			case 1:
+				srcPos = 0;
+				var x = 0;
+				var y = bmp.header.topToBottom ? 0 : bmp.header.height - 1;
+				while( srcPos < bmp.header.dataLength ) {
+					var count = srcBytes.get(srcPos++);
+					var index = srcBytes.get(srcPos++);
+					if ( count == 0 ) {
+						if ( index == 0 ) {
+							x = 0;
+							y += yDir;
+						} else if ( index == 1 ) {
+							break;
+						} else if ( index == 2 ) {
+							x += srcBytes.get(srcPos++);
+							y += srcBytes.get(srcPos++);
+						} else {
+							count = index;
+							for( i in 0...count ) {
+								index = srcBytes.get(srcPos++);
+								dstBytes.blit( COLOR_SIZE * ((x+i) + y * bmp.header.width), colorTable, index * COLOR_SIZE, COLOR_SIZE );
+							}
+							if (srcPos % 2 != 0) srcPos++;
+							x += count;
+						}
+					} else {
+						for( i in 0...count ) {
+							dstBytes.blit( COLOR_SIZE * ((x+i) + y * bmp.header.width), colorTable, index * COLOR_SIZE, COLOR_SIZE );
+						}
+						x += count;
+					}
+				}
+			default:
+				throw 'compression ${bmp.header.compression} not supported';
+		}
+
+		return dstBytes;
+	}
+	
+	// `channelMap` contains indices to map into ARGB (f.e. the mapping for ARGB is [0,1,2,3], while for BGRA is [3,2,1,0])
+	static function _buildFrom32( width : Int, height : Int, srcBytes : haxe.io.Bytes, channelMap : Array<Int>, topToBottom : Bool = false ) : Data {
+		var bpp = 24;
+		var paddedStride = computePaddedStride(width, bpp);
+		var bytesBGR = haxe.io.Bytes.alloc(paddedStride * height);
+		var topToBottom = topToBottom;
+		var dataLength = bytesBGR.length;
+		
+		var dstStride = width * 3;
+		var srcLen = width * height * 4;
+		var yDir = -1;
+		var dstPos = dataLength - paddedStride;
+		var srcPos = 0;
+		
+		if ( topToBottom ) {
+			yDir = 1;
+			dstPos = 0;
+		}
+		
+		while( srcPos < srcLen ) {
+			var i = dstPos;
+			while( i < dstPos + dstStride ) {
+				var r = srcBytes.get(srcPos + channelMap[1]);
+				var g = srcBytes.get(srcPos + channelMap[2]);
+				var b = srcBytes.get(srcPos + channelMap[3]);
+				
+				bytesBGR.set(i++, b);
+				bytesBGR.set(i++, g);
+				bytesBGR.set(i++, r);
+				
+				srcPos += 4;
+			}
+			dstPos += yDir * paddedStride;
+		}
+		
+		return {
+			header: {
+				width: width,
+				height: height,
+				paddedStride: paddedStride,
+				topToBottom: topToBottom,
+				bpp: bpp,
+				dataLength: dataLength,
+				compression: 0
+			},
+			pixels: bytesBGR,
+			colorTable: null
+		}
+	}
+}

leenkx/Sources/iron/format/bmp/Writer.hx

@@ -0,0 +1,74 @@
+/*
+ * format - Haxe File Formats
+ *
+ *  BMP File Format
+ *  Copyright (C) 2007-2009 Robert Sköld
+ *
+ * Copyright (c) 2009, The Haxe Project Contributors
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   - Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE HAXE PROJECT CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE HAXE PROJECT CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+package iron.format.bmp;
+
+import iron.format.bmp.Data;
+
+
+class Writer {
+
+	static var DATA_OFFSET : Int = 0x36;
+
+	var output : haxe.io.Output;
+
+	public function new(o) {
+		output = o;
+	}
+	
+	/**
+	 * Specs: http://s223767089.online.de/en/file-format-bmp
+	 */
+	public function write( bmp : Data ) {
+		// Write Header (14 bytes)
+		output.writeString( "BM" );								// Signature
+		output.writeInt32(bmp.pixels.length + DATA_OFFSET );	// FileSize
+		output.writeInt32( 0 );									// Reserved
+		output.writeInt32( DATA_OFFSET );						// Offset
+
+		// Write InfoHeader (40 bytes)
+		output.writeInt32( 40 );								// InfoHeader size
+		output.writeInt32( bmp.header.width );					// Image width
+		var height = bmp.header.height;
+		if (bmp.header.topToBottom) height = -height; 
+		output.writeInt32( height );							// Image height
+		output.writeInt16( 1 );									// Number of planes
+		output.writeInt16( 24 );								// Bits per pixel (24bit RGB)
+		output.writeInt32( 0 );									// Compression type (no compression)
+		output.writeInt32( bmp.header.dataLength );				// Image data size (0 when uncompressed)
+		output.writeInt32( 0x2e30 );							// Horizontal resolution
+		output.writeInt32( 0x2e30 );							// Vertical resolution
+		output.writeInt32( 0 );									// Colors used (0 when uncompressed)
+		output.writeInt32( 0 );									// Important colors (0 when uncompressed)
+
+		// Write Raster Data
+		output.write(bmp.pixels);
+  }
+}

leenkx/Sources/iron/math/Quat.hx

@@ -66,12 +66,32 @@ class Quat {
 	}
 
 	public inline function fromAxisAngle(axis: Vec4, angle: FastFloat): Quat {
-		var s: FastFloat = Math.sin(angle * 0.5);
-		x = axis.x * s;
-		y = axis.y * s;
-		z = axis.z * s;
-		w = Math.cos(angle * 0.5);
-		return normalize();
+		//var s: FastFloat = Math.sin(angle * 0.5);
+		//x = axis.x * s;
+		//y = axis.y * s;
+		//z = axis.z * s;
+		//w = Math.cos(angle * 0.5);
+		//return normalize();
+		// Normalize the axis vector first
+		var axisLen = Math.sqrt(axis.x * axis.x + axis.y * axis.y + axis.z * axis.z);
+		if (axisLen > 0.00001) {
+			var aL = 1.0 / axisLen;
+			var nX = axis.x * aL;
+			var nY = axis.y * aL;
+			var nZ = axis.z * aL;
+			var halfAngle = angle * 0.5;
+			var s: FastFloat = Math.sin(halfAngle);
+			x = nX * s;
+			y = nY * s;
+			z = nZ * s;
+			w = Math.cos(halfAngle);
+		} else {
+			x = 0.0;
+			y = 0.0;
+			z = 0.0;
+			w = 1.0;
+		}
+		return this;
 	}
 
 	public inline function toAxisAngle(axis: Vec4): FastFloat {
@@ -379,17 +399,33 @@ class Quat {
 		@return	This quaternion.
 	**/
 	public inline function fromEulerOrdered(e: Vec4, order: String): Quat {
-		var c1 = Math.cos(e.x / 2);
-		var c2 = Math.cos(e.y / 2);
-		var c3 = Math.cos(e.z / 2);
-		var s1 = Math.sin(e.x / 2);
-		var s2 = Math.sin(e.y / 2);
-		var s3 = Math.sin(e.z / 2);
-
+		
+		var mappedAngles = new Vec4();
+		switch (order) {
+			case "XYZ":
+				mappedAngles.set(e.x, e.y, e.z);
+			case "XZY":
+				mappedAngles.set(e.x, e.z, e.y);
+			case "YXZ": 
+				mappedAngles.set(e.y, e.x, e.z);
+			case "YZX": 
+				mappedAngles.set(e.y, e.z, e.x);
+			case "ZXY": 
+				mappedAngles.set(e.z, e.x, e.y);
+			case "ZYX": 
+				mappedAngles.set(e.z, e.y, e.x);
+		}
+		var c1 = Math.cos(mappedAngles.x / 2);
+		var c2 = Math.cos(mappedAngles.y / 2);
+		var c3 = Math.cos(mappedAngles.z / 2);
+		var s1 = Math.sin(mappedAngles.x / 2);
+		var s2 = Math.sin(mappedAngles.y / 2);
+		var s3 = Math.sin(mappedAngles.z / 2);
 		var qx = new Quat(s1, 0, 0, c1);
 		var qy = new Quat(0, s2, 0, c2);
 		var qz = new Quat(0, 0, s3, c3);
 
+		// Original multiplication sequence (implements reverse of 'order')
 		if (order.charAt(2) == 'X')
 			this.setFrom(qx);
 		else if (order.charAt(2) == 'Y')
@@ -409,6 +445,12 @@ class Quat {
 		else
 			this.mult(qz);
 
+		// TO DO quick fix somethings wrong..
+		this.x = -this.x;
+		this.y = -this.y;
+		this.z = -this.z;
+		this.w = -this.w;
+		
 		return this;
 	}
 

leenkx/Sources/iron/object/Animation.hx

@@ -159,9 +159,17 @@ class Animation {
 			if(markerEvents.get(sampler) != null){
 				for (i in 0...anim.marker_frames.length) {
 					if (frameIndex == anim.marker_frames[i]) {
-						var marketAct = markerEvents.get(sampler);
-						var ar = marketAct.get(anim.marker_names[i]);
+						var markerAct = markerEvents.get(sampler);
+						var ar = markerAct.get(anim.marker_names[i]);
 						if (ar != null) for (f in ar) f();
+					} else {
+						for (j in 0...(frameIndex - lastFrameIndex)) {
+							if (lastFrameIndex + j + 1 == anim.marker_frames[i]) {
+								var markerAct = markerEvents.get(sampler);
+								var ar = markerAct.get(anim.marker_names[i]);
+								if (ar != null) for (f in ar) f();
+							}
+						}
 					}
 				}
 				lastFrameIndex = frameIndex;
@@ -411,12 +419,23 @@ class ActionSampler {
 	 */
 	public inline function setBoneAction(actionData: Array<TObj>) {
 		this.actionData = actionData;
-		this.totalFrames = actionData[0].anim.tracks[0].frames.length;
-		if(actionData[0].anim.root_motion_pos) this.rootMotionPos = true;
-		if(actionData[0].anim.root_motion_rot) this.rootMotionRot = true;
+		if (actionData != null && actionData.length > 0 && actionData[0] != null && actionData[0].anim != null) {
+			if (actionData[0].anim.tracks != null && actionData[0].anim.tracks.length > 0) {
+				this.totalFrames = actionData[0].anim.tracks[0].frames.length;
+			}
+			else {
+				this.totalFrames = 0;
+			}
+			if(actionData[0].anim.root_motion_pos) this.rootMotionPos = true;
+			if(actionData[0].anim.root_motion_rot) this.rootMotionRot = true;
+		}
+		else {
+			this.totalFrames = 0;
+		}
 		actionDataInit = true;
 	}
 
+
 	/**
 	 * Cache raw object data for object animation.
 	 * @param actionData Raw object data.

leenkx/Sources/iron/object/CameraObject.hx

@@ -30,12 +30,22 @@ class CameraObject extends Object {
 	static var sphereCenter = new Vec4();
 	static var vcenter = new Vec4();
 	static var vup = new Vec4();
-
+	
+	#if lnx_vr
+	var helpMat = Mat4.identity();
+	public var leftV = Mat4.identity();
+	public var rightV = Mat4.identity();
+	#end
+	
 	public function new(data: CameraData) {
 		super();
 
 		this.data = data;
 
+		#if lnx_vr
+		iron.system.VR.initButton();
+		#end
+		
 		buildProjection();
 
 		V = Mat4.identity();
@@ -117,6 +127,26 @@ class CameraObject extends Object {
 		V.getInverse(transform.world);
 		VP.multmats(P, V);
 
+
+		#if lnx_vr
+		var vr = kha.vr.VrInterface.instance;
+		if (vr != null && vr.IsPresenting()) {
+			leftV.setFrom(V);
+			helpMat.self = vr.GetViewMatrix(0);
+			leftV.multmat(helpMat);
+
+			rightV.setFrom(V);
+			helpMat.self = vr.GetViewMatrix(1);
+			rightV.multmat(helpMat);
+		}
+		else {
+			leftV.setFrom(V);
+		}
+		VP.multmats(P, leftV);
+		#else
+		VP.multmats(P, V);
+		#end
+
 		if (data.raw.frustum_culling) {
 			buildViewFrustum(VP, frustumPlanes);
 		}

leenkx/Sources/iron/object/LightObject.hx

@@ -155,8 +155,13 @@ class LightObject extends Object {
 	}
 
 	public function setCascade(camera: CameraObject, cascade: Int) {
-		m.setFrom(camera.V);
 
+		#if lnx_vr
+		m.setFrom(camera.leftV);
+		#else
+		m.setFrom(camera.V);
+		#end
+		
 		#if lnx_csm
 		if (camSlicedP == null) {
 			camSlicedP = [];

leenkx/Sources/iron/object/MeshObject.hx

@@ -21,8 +21,10 @@ class MeshObject extends Object {
 	public var particleChildren: Array<MeshObject> = null;
 	public var particleOwner: MeshObject = null; // Particle object
 	public var particleIndex = -1;
+	public var render_emitter = true;
 	#end
 	public var cameraDistance: Float;
+	public var cameraList: Array<String> = null;
 	public var screenSize = 0.0;
 	public var frustumCulling = true;
 	public var activeTilesheet: Tilesheet = null;
@@ -234,6 +236,8 @@ class MeshObject extends Object {
 		if (cullMesh(context, Scene.active.camera, RenderPath.active.light)) return;
 		var meshContext = raw != null ? context == "mesh" : false;
 
+		if (cameraList != null && cameraList.indexOf(Scene.active.camera.name) < 0) return;
+
 		#if lnx_particles
 		if (raw != null && raw.is_particle && particleOwner == null) return; // Instancing not yet set-up by particle system owner
 		if (particleSystems != null && meshContext) {
@@ -244,6 +248,7 @@ class MeshObject extends Object {
 					Scene.active.spawnObject(psys.data.raw.instance_object, null, function(o: Object) {
 						if (o != null) {
 							var c: MeshObject = cast o;
+    						c.cameraList = this.cameraList;
 							particleChildren.push(c);
 							c.particleOwner = this;
 							c.particleIndex = particleChildren.length - 1;
@@ -255,11 +260,11 @@ class MeshObject extends Object {
 				particleSystems[i].update(particleChildren[i], this);
 			}
 		}
-		if (particleSystems != null && particleSystems.length > 0 && !raw.render_emitter) return;
+		if (particleSystems != null && particleSystems.length > 0 && !render_emitter) return;
+        if (particleSystems == null && cullMaterial(context)) return;
+        #else
+        if (cullMaterial(context)) return;
 		#end
-
-		if (cullMaterial(context)) return;
-
 		// Get lod
 		var mats = materials;
 		var lod = this;

leenkx/Sources/iron/object/Object.hx

@@ -172,6 +172,10 @@ class Object {
 			for (f in t._init) App.removeInit(f);
 			t._init = null;
 		}
+		if (t._fixedUpdate != null) {
+			for (f in t._fixedUpdate) App.removeFixedUpdate(f);
+			t._fixedUpdate = null;
+		}
 		if (t._update != null) {
 			for (f in t._update) App.removeUpdate(f);
 			t._update = null;

leenkx/Sources/iron/object/ParticleSystem.hx

@@ -2,6 +2,7 @@ package iron.object;
 
 #if lnx_particles
 
+import kha.FastFloat;
 import kha.graphics4.Usage;
 import kha.arrays.Float32Array;
 import iron.data.Data;
@@ -16,10 +17,12 @@ import iron.math.Vec4;
 class ParticleSystem {
 	public var data: ParticleData;
 	public var speed = 1.0;
+	var currentSpeed = 0.0;
 	var particles: Array<Particle>;
 	var ready: Bool;
 	var frameRate = 24;
 	var lifetime = 0.0;
+	var looptime = 0.0;
 	var animtime = 0.0;
 	var time = 0.0;
 	var spawnRate = 0.0;
@@ -46,11 +49,16 @@ class ParticleSystem {
 	var ownerLoc = new Vec4();
 	var ownerRot = new Quat();
 	var ownerScl = new Vec4();
+	
+	var random = 0.0;
 
 	public function new(sceneName: String, pref: TParticleReference) {
 		seed = pref.seed;
+		currentSpeed = speed;
+		speed = 0;
 		particles = [];
 		ready = false;
+		
 		Data.getParticle(sceneName, pref.particle, function(b: ParticleData) {
 			data = b;
 			r = data.raw;
@@ -64,27 +72,61 @@ class ParticleSystem {
 				gy = 0;
 				gz = -9.81 * r.weight_gravity;
 			}
-			alignx = r.object_align_factor[0] / 2;
-			aligny = r.object_align_factor[1] / 2;
-			alignz = r.object_align_factor[2] / 2;
+			alignx = r.object_align_factor[0];
+			aligny = r.object_align_factor[1];
+			alignz = r.object_align_factor[2];
+			looptime = (r.frame_end - r.frame_start) / frameRate;
 			lifetime = r.lifetime / frameRate;
-			animtime = (r.frame_end - r.frame_start) / frameRate;
+			animtime = r.loop ? looptime : looptime + lifetime;
 			spawnRate = ((r.frame_end - r.frame_start) / r.count) / frameRate;
-			for (i in 0...r.count) particles.push(new Particle(i));
+
+			for (i in 0...r.count) {
+				particles.push(new Particle(i));
+			}
+
 			ready = true;
+			if (r.auto_start){
+				start();
+			}
 		});
 	}
 
+	public function start() {
+		if (r.is_unique) random = Math.random();
+		lifetime = r.lifetime / frameRate;
+		time = 0;
+		lap = 0;
+		lapTime = 0;
+		speed = currentSpeed;
+	}
+
 	public function pause() {
-		lifetime = 0;
+		speed = 0;
 	}
 
 	public function resume() {
 		lifetime = r.lifetime / frameRate;
+		speed = currentSpeed;
 	}
 
+
+
+	// TODO: interrupt smoothly
+	public function stop() {
+		end();
+	}
+
+	function end() {
+		lifetime = 0;
+		speed = 0;
+		lap = 0;
+	}
+	
 	public function update(object: MeshObject, owner: MeshObject) {
 		if (!ready || object == null || speed == 0.0) return;
+		if (iron.App.pauseUpdates) return;
+		
+		var prevLap = lap;
 
 		// Copy owner world transform but discard scale
 		owner.transform.world.decompose(ownerLoc, ownerRot, ownerScl);
@@ -108,17 +150,21 @@ class ParticleSystem {
 		}
 
 		// Animate
-		time += Time.realDelta * speed;
+		time += Time.renderDelta * speed; // realDelta to renderDelta
 		lap = Std.int(time / animtime);
 		lapTime = time - lap * animtime;
 		count = Std.int(lapTime / spawnRate);
 
+		if (lap > prevLap && !r.loop) {
+			end();
+		}
+		
 		updateGpu(object, owner);
 	}
 
 	public function getData(): Mat4 {
 		var hair = r.type == 1;
-		m._00 = r.loop ? animtime : -animtime;
+		m._00 = animtime;
 		m._01 = hair ? 1 / particles.length : spawnRate;
 		m._02 = hair ? 1 : lifetime;
 		m._03 = particles.length;
@@ -126,9 +172,9 @@ class ParticleSystem {
 		m._11 = hair ? 0 : aligny;
 		m._12 = hair ? 0 : alignz;
 		m._13 = hair ? 0 : r.factor_random;
-		m._20 = hair ? 0 : gx * r.mass;
-		m._21 = hair ? 0 : gy * r.mass;
-		m._22 = hair ? 0 : gz * r.mass;
+		m._20 = hair ? 0 : gx;
+		m._21 = hair ? 0 : gy;
+		m._22 = hair ? 0 : gz;
 		m._23 = hair ? 0 : r.lifetime_random;
 		m._30 = tilesx;
 		m._31 = tilesy;
@@ -137,6 +183,18 @@ class ParticleSystem {
 		return m;
 	}
 
+	public function getSizeRandom(): FastFloat {
+		return r.size_random;
+	}
+
+	public function getRandom(): FastFloat {
+		return random;
+	}
+
+	public function getSize(): FastFloat {
+		return r.particle_size;
+	}
+
 	function updateGpu(object: MeshObject, owner: MeshObject) {
 		if (!object.data.geom.instanced) setupGeomGpu(object, owner);
 		// GPU particles transform is attached to owner object
@@ -236,9 +294,11 @@ class ParticleSystem {
 
 class Particle {
 	public var i: Int;
+	
 	public var x = 0.0;
 	public var y = 0.0;
 	public var z = 0.0;
+
 	public var cameraDistance: Float;
 
 	public function new(i: Int) {

leenkx/Sources/iron/object/Tilesheet.hx

@@ -80,7 +80,7 @@ class Tilesheet {
 	function update() {
 		if (!ready || paused || action.start >= action.end) return;
 
-		time += Time.realDelta;
+		time += Time.renderDelta;
 
 		var frameTime = 1 / raw.framerate;
 		var framesToAdvance = 0;

leenkx/Sources/iron/object/Uniforms.hx

@@ -1109,6 +1109,26 @@ class Uniforms {
 				case "_texUnpack": {
 					f = texUnpack != null ? texUnpack : 1.0;
 				}
+				#if lnx_particles
+				case "_particleSizeRandom": {
+					var mo = cast(object, MeshObject);
+					if (mo.particleOwner != null && mo.particleOwner.particleSystems != null) {
+						f = mo.particleOwner.particleSystems[mo.particleIndex].getSizeRandom();
+					}
+				}
+				case "_particleRandom": {
+					var mo = cast(object, MeshObject);
+					if (mo.particleOwner != null && mo.particleOwner.particleSystems != null) {
+						f = mo.particleOwner.particleSystems[mo.particleIndex].getRandom();
+					}
+				}
+				case "_particleSize": {
+					var mo = cast(object, MeshObject);
+					if (mo.particleOwner != null && mo.particleOwner.particleSystems != null) {
+						f = mo.particleOwner.particleSystems[mo.particleIndex].getSize();
+					}
+				}
+				#end
 			}
 
 			if (f == null && externalFloatLinks != null) {

leenkx/Sources/iron/system/LnxPack.hx

@@ -160,6 +160,7 @@ class LnxPack {
 			case "anim": TAnimation;
 			case "tracks": TTrack;
 			case "morph_target": TMorphTarget;
+			case "vertex_groups": TVertex_groups;
 			case _: TSceneFormat;
 		}
 	}

leenkx/Sources/iron/system/Time.hx

@@ -1,37 +1,58 @@
 package iron.system;
 
 class Time {
-
+	public static var scale = 1.0;
+	
+	static var frequency: Null<Int> = null;
+	static function initFrequency() {
+		frequency = kha.Display.primary != null ? kha.Display.primary.frequency : 60;
+	}
+	
 	public static var step(get, never): Float;
 	static function get_step(): Float {
 		if (frequency == null) initFrequency();
 		return 1 / frequency;
 	}
-
-	public static var scale = 1.0;
-	public static var delta(get, never): Float;
-	static function get_delta(): Float {
-		if (frequency == null) initFrequency();
-		return (1 / frequency) * scale;
+	
+	static var _fixedStep: Null<Float> = 1/60;
+	public static var fixedStep(get, never): Float;
+	static function get_fixedStep(): Float {
+		return _fixedStep;
+	}
+	
+	public static function initFixedStep(value: Float = 1 / 60) {
+		_fixedStep = value;
 	}
 
-	static var last = 0.0;
-	public static var realDelta = 0.0;
+	static var lastTime = 0.0;
+	static var _delta = 0.0;
+	public static var delta(get, never): Float;
+	static function get_delta(): Float {
+		return _delta;
+	}
+	
+	static var lastRenderTime = 0.0;
+	static var _renderDelta = 0.0;
+	public static var renderDelta(get, never): Float;
+	static function get_renderDelta(): Float {
+		return _renderDelta;
+	}
+		
 	public static inline function time(): Float {
 		return kha.Scheduler.time();
 	}
+	
 	public static inline function realTime(): Float {
 		return kha.Scheduler.realTime();
 	}
 
-	static var frequency: Null<Int> = null;
-
-	static function initFrequency() {
-		frequency = kha.Display.primary != null ? kha.Display.primary.frequency : 60;
+	public static function update() {
+		_delta = realTime() - lastTime;
+		lastTime = realTime();
 	}
 
-	public static function update() {
-		realDelta = realTime() - last;
-		last = realTime();
+	public static function render() {
+		_renderDelta = realTime() - lastRenderTime;
+		lastRenderTime = realTime();
 	}
 }

leenkx/Sources/iron/system/VR.hx

@@ -0,0 +1,52 @@
+package iron.system;
+
+import iron.math.Mat4;
+
+#if lnx_vr
+class VR {
+
+	static var undistortionMatrix: Mat4 = null;
+
+	public function new() {}
+
+	public static function getUndistortionMatrix(): Mat4 {
+		if (undistortionMatrix == null) {
+			undistortionMatrix = Mat4.identity();
+		}
+
+		return undistortionMatrix;
+	}
+
+	public static function getMaxRadiusSq(): Float {
+		return 0.0;
+	}
+
+	public static function initButton() {
+		function vrDownListener(index: Int, x: Float, y: Float) {
+			var vr = kha.vr.VrInterface.instance;
+			if (vr == null || !vr.IsVrEnabled() || vr.IsPresenting()) return;
+			var w: Float = iron.App.w();
+			var h: Float = iron.App.h();
+			if (x < w - 150 || y < h - 150) return;
+			vr.onVRRequestPresent();
+		}
+
+		function vrRender2D(g: kha.graphics2.Graphics) {
+			var vr = kha.vr.VrInterface.instance;
+			if (vr == null || !vr.IsVrEnabled() || vr.IsPresenting()) return;
+			var w: Float = iron.App.w();
+			var h: Float = iron.App.h();
+			g.color = 0xffff0000;
+			g.fillRect(w - 150, h - 150, 140, 140);
+		}
+
+		kha.input.Mouse.get().notify(vrDownListener, null, null, null);
+		iron.App.notifyOnRender2D(vrRender2D);
+
+		var vr = kha.vr.VrInterface.instance; // Straight to VR (Oculus Carmel)
+		if (vr != null && vr.IsVrEnabled()) {
+			vr.onVRRequestPresent();
+		}
+	}
+}
+#end

leenkx/Sources/leenkx/data/Config.hx

@@ -20,6 +20,7 @@ class Config {
 		var path = iron.data.Data.dataPath + "config.lnx";
 		var bytes = haxe.io.Bytes.ofString(haxe.Json.stringify(raw));
 		#if kha_krom
+		if (iron.data.Data.dataPath == '') path = Krom.getFilesLocation() + "/config.lnx";
 		Krom.fileSaveBytes(path, bytes.getData());
 		#elseif kha_kore
 		sys.io.File.saveBytes(path, bytes);
@@ -47,6 +48,7 @@ typedef TConfig = {
 	@:optional var rp_ssr: Null<Bool>;
 	@:optional var rp_ssrefr: Null<Bool>;
 	@:optional var rp_bloom: Null<Bool>;
+	@:optional var rp_chromatic_aberration: Null<Bool>;
 	@:optional var rp_motionblur: Null<Bool>;
 	@:optional var rp_gi: Null<Bool>; // voxelao
 	@:optional var rp_dynres: Null<Bool>; // dynamic resolution scaling

leenkx/Sources/leenkx/logicnode/AddParticleToObjectNode.hx

@@ -0,0 +1,99 @@
+package leenkx.logicnode;
+
+import iron.data.SceneFormat.TSceneFormat;
+import iron.data.Data;
+import iron.object.Object;
+
+class AddParticleToObjectNode extends LogicNode {
+
+	public var property0: String;
+
+	public function new(tree: LogicTree) {
+		super(tree);
+	}
+
+	override function run(from: Int) {
+		#if lnx_particles
+
+		if (property0 == 'Scene Active'){		
+			var objFrom: Object = inputs[1].get();
+			var slot: Int = inputs[2].get();
+			var objTo: Object = inputs[3].get();
+	
+			if (objFrom == null || objTo == null) return;
+	
+			var mobjFrom = cast(objFrom, iron.object.MeshObject);
+	
+			var psys = mobjFrom.particleSystems != null ? mobjFrom.particleSystems[slot] : 
+				mobjFrom.particleOwner != null && mobjFrom.particleOwner.particleSystems != null ? mobjFrom.particleOwner.particleSystems[slot] : null;
+
+			if (psys == null) return;
+	
+			var mobjTo = cast(objTo, iron.object.MeshObject);
+	
+			mobjTo.setupParticleSystem(iron.Scene.active.raw.name, {name: 'LnxPS', seed: 0, particle: @:privateAccess psys.r.name});
+			
+			mobjTo.render_emitter = inputs[4].get();
+
+			iron.Scene.active.spawnObject(psys.data.raw.instance_object, null, function(o: Object) {
+				if (o != null) {
+					var c: iron.object.MeshObject = cast o;
+					if (mobjTo.particleChildren == null) mobjTo.particleChildren = [];
+					mobjTo.particleChildren.push(c);
+					c.particleOwner = mobjTo;
+					c.particleIndex = mobjTo.particleChildren.length - 1;
+				}
+			});
+	
+			var oslot: Int = mobjTo.particleSystems.length-1;
+			var opsys = mobjTo.particleSystems[oslot];
+			@:privateAccess opsys.setupGeomGpu(mobjTo.particleChildren[oslot], mobjTo);
+		
+		} else {
+			var sceneName: String = inputs[1].get();
+			var objectName: String = inputs[2].get();
+			var slot: Int = inputs[3].get();
+
+			var mobjTo: Object = inputs[4].get();
+			var mobjTo = cast(mobjTo, iron.object.MeshObject);
+
+			#if lnx_json
+				sceneName += ".json";
+			#elseif lnx_compress
+				sceneName += ".lz4";
+			#end
+
+			Data.getSceneRaw(sceneName, (rawScene: TSceneFormat) -> {
+
+			for (obj in rawScene.objects) {
+				if (obj.name == objectName) {
+					mobjTo.setupParticleSystem(sceneName, obj.particle_refs[slot]);
+					mobjTo.render_emitter = inputs[5].get();					
+
+					iron.Scene.active.spawnObject(rawScene.particle_datas[slot].instance_object, null, function(o: Object) {
+						if (o != null) {
+							var c: iron.object.MeshObject = cast o;
+							if (mobjTo.particleChildren == null) mobjTo.particleChildren = [];
+							mobjTo.particleChildren.push(c);
+							c.particleOwner = mobjTo;
+							c.particleIndex = mobjTo.particleChildren.length - 1;
+						}
+					}, true, rawScene);
+
+					var oslot: Int = mobjTo.particleSystems.length-1;
+					var opsys = mobjTo.particleSystems[oslot];
+					@:privateAccess opsys.setupGeomGpu(mobjTo.particleChildren[oslot], mobjTo);
+
+					break;
+				}
+			}
+
+			});
+
+		}
+
+		#end
+
+		runOutput(0);
+	}
+}

leenkx/Sources/leenkx/logicnode/AddPhysicsConstraintNode.hx

@@ -2,9 +2,11 @@ package leenkx.logicnode;
 
 import iron.object.Object;
 
-#if lnx_physics
+#if lnx_bullet
 import leenkx.trait.physics.PhysicsConstraint;
 import leenkx.trait.physics.bullet.PhysicsConstraint.ConstraintType;
+#elseif lnx_oimo
+// TODO
 #end
 
 class AddPhysicsConstraintNode extends LogicNode {
@@ -25,7 +27,7 @@ class AddPhysicsConstraintNode extends LogicNode {
 
 		if (pivotObject == null || rb1 == null || rb2 == null) return;
 
-#if lnx_physics
+#if lnx_bullet
 
 		var disableCollisions: Bool = inputs[4].get();
 		var breakable: Bool = inputs[5].get();
@@ -108,6 +110,8 @@ class AddPhysicsConstraintNode extends LogicNode {
 			}
 			pivotObject.addTrait(con);
 		}
+#elseif lnx_oimo
+// TODO
 #end
 		runOutput(0);
 	}

leenkx/Sources/leenkx/logicnode/AddRigidBodyNode.hx

@@ -4,7 +4,7 @@ import iron.object.Object;
 
 #if lnx_physics
 import leenkx.trait.physics.RigidBody;
-import leenkx.trait.physics.bullet.RigidBody.Shape;
+import leenkx.trait.physics.RigidBody.Shape;
 #end
 
 

leenkx/Sources/leenkx/logicnode/ApplyForceNode.hx

@@ -21,7 +21,7 @@ class ApplyForceNode extends LogicNode {
 
 #if lnx_physics
 		var rb: RigidBody = object.getTrait(RigidBody);
-
+		if (rb == null) return;
 		!local ? rb.applyForce(force) : rb.applyForce(object.transform.worldVecToOrientation(force));
 #end
 

leenkx/Sources/leenkx/logicnode/ArrayIndexListNode.hx

@@ -0,0 +1,26 @@
+package leenkx.logicnode;
+
+class ArrayIndexListNode extends LogicNode {
+
+	public function new(tree: LogicTree) {
+		super(tree);
+	}
+
+	override function get(from: Int): Dynamic {
+		var array: Array<Dynamic> = inputs[0].get();
+		array = array.map(item -> Std.string(item));
+		var value: Dynamic = inputs[1].get();
+		var from: Int = 0;
+
+		var arrayList: Array<Int> = [];
+
+		var index: Int = array.indexOf(Std.string(value), from);
+
+		while(index != -1){
+			arrayList.push(index);
+			index = array.indexOf(Std.string(value), index+1);
+		}
+
+		return arrayList;
+	}
+}

leenkx/Sources/leenkx/logicnode/AudioHRTFPannerNode.hx

@@ -1,7 +1,7 @@
 package leenkx.logicnode;
 import aura.Aura;
 import aura.Types;
-import aura.types.HRTFData;
+import aura.types.HRTF;
 import aura.dsp.panner.HRTFPanner;
 
 class AudioHRTFPannerNode extends LogicNode {

leenkx/Sources/leenkx/logicnode/AutoExposureGetNode.hx

@@ -0,0 +1,16 @@
+package leenkx.logicnode;
+
+class AutoExposureGetNode extends LogicNode {
+
+	public function new(tree:LogicTree) {
+		super(tree);
+	}
+
+	override function get(from:Int):Dynamic {
+		return switch (from) {
+			case 0: leenkx.renderpath.Postprocess.auto_exposure_uniforms[0];
+			case 1: leenkx.renderpath.Postprocess.auto_exposure_uniforms[1];
+			default: 0.0;
+		}
+	}
+}

leenkx/Sources/leenkx/logicnode/AutoExposureSetNode.hx

@@ -0,0 +1,15 @@
+package leenkx.logicnode;
+
+class AutoExposureSetNode extends LogicNode {
+
+	public function new(tree:LogicTree) {
+		super(tree);
+	}
+
+	override function run(from:Int) {
+        leenkx.renderpath.Postprocess.auto_exposure_uniforms[0] = inputs[1].get();
+        leenkx.renderpath.Postprocess.auto_exposure_uniforms[1] = inputs[2].get();
+
+		runOutput(0);
+	}
+}

leenkx/Sources/leenkx/logicnode/CameraSetNode.hx

@@ -1,26 +1,49 @@
 package leenkx.logicnode;
 
 class CameraSetNode extends LogicNode {
-
+	
+	public var property0: String;
+	
 	public function new(tree:LogicTree) {
 		super(tree);
 	}
 
 	override function run(from:Int) {
-		leenkx.renderpath.Postprocess.camera_uniforms[0] = inputs[1].get();//Camera: F-Number
-		leenkx.renderpath.Postprocess.camera_uniforms[1] = inputs[2].get();//Camera: Shutter time
-		leenkx.renderpath.Postprocess.camera_uniforms[2] = inputs[3].get();//Camera: ISO
-		leenkx.renderpath.Postprocess.camera_uniforms[3] = inputs[4].get();//Camera: Exposure Compensation
-		leenkx.renderpath.Postprocess.camera_uniforms[4] = inputs[5].get();//Fisheye Distortion
-		leenkx.renderpath.Postprocess.camera_uniforms[5] = inputs[6].get();//DoF AutoFocus §§ If true, it ignores the DoF Distance setting
-		leenkx.renderpath.Postprocess.camera_uniforms[6] = inputs[7].get();//DoF Distance
-		leenkx.renderpath.Postprocess.camera_uniforms[7] = inputs[8].get();//DoF Focal Length mm
-		leenkx.renderpath.Postprocess.camera_uniforms[8] = inputs[9].get();//DoF F-Stop
-		leenkx.renderpath.Postprocess.camera_uniforms[9] = inputs[10].get();//Tonemapping Method
-		leenkx.renderpath.Postprocess.camera_uniforms[10] = inputs[11].get();//Distort
-		leenkx.renderpath.Postprocess.camera_uniforms[11] = inputs[12].get();//Film Grain
-		leenkx.renderpath.Postprocess.camera_uniforms[12] = inputs[13].get();//Sharpen
-		leenkx.renderpath.Postprocess.camera_uniforms[13] = inputs[14].get();//Vignette
+
+		switch (property0) {
+			case 'F-stop':
+				leenkx.renderpath.Postprocess.camera_uniforms[0] = inputs[1].get();//Camera: F-Number
+			case 'Shutter Time':	
+				leenkx.renderpath.Postprocess.camera_uniforms[1] = inputs[1].get();//Camera: Shutter time
+			case 'ISO':
+				leenkx.renderpath.Postprocess.camera_uniforms[2] = inputs[1].get();//Camera: ISO
+			case 'Exposure Compensation':
+				leenkx.renderpath.Postprocess.camera_uniforms[3] = inputs[1].get();//Camera: Exposure Compensation
+			case 'Fisheye Distortion':
+				leenkx.renderpath.Postprocess.camera_uniforms[4] = inputs[1].get();//Fisheye Distortion
+			case 'Auto Focus':
+				leenkx.renderpath.Postprocess.camera_uniforms[5] = inputs[1].get();//DoF AutoFocus §§ If true, it ignores the DoF Distance setting
+			case 'DoF Distance':
+				leenkx.renderpath.Postprocess.camera_uniforms[6] = inputs[1].get();//DoF Distance
+			case 'DoF Length':
+				leenkx.renderpath.Postprocess.camera_uniforms[7] = inputs[1].get();//DoF Focal Length mm
+			case 'DoF F-Stop':
+				leenkx.renderpath.Postprocess.camera_uniforms[8] = inputs[1].get();//DoF F-Stop
+			case 'Tonemapping':
+				leenkx.renderpath.Postprocess.camera_uniforms[9] = inputs[1].get();//Tonemapping Method
+			case 'Distort':
+				leenkx.renderpath.Postprocess.camera_uniforms[10] = inputs[1].get();//Distort
+			case 'Film Grain':
+				leenkx.renderpath.Postprocess.camera_uniforms[11] = inputs[1].get();//Film Grain
+			case 'Sharpen':
+				leenkx.renderpath.Postprocess.camera_uniforms[12] = inputs[1].get();//Sharpen
+			case 'Vignette':
+				leenkx.renderpath.Postprocess.camera_uniforms[13] = inputs[1].get();//Vignette
+			case 'Exposure':
+				leenkx.renderpath.Postprocess.exposure_uniforms[0] = inputs[1].get();//Exposure
+			default: 
+				null;
+			}
 
 		runOutput(0);
 	}

leenkx/Sources/leenkx/logicnode/ChromaticAberrationGetNode.hx

@@ -10,6 +10,7 @@ class ChromaticAberrationGetNode extends LogicNode {
 		return switch (from) {
 			case 0: leenkx.renderpath.Postprocess.chromatic_aberration_uniforms[0];
 			case 1: leenkx.renderpath.Postprocess.chromatic_aberration_uniforms[1];
+			case 2: leenkx.renderpath.Postprocess.chromatic_aberration_uniforms[2];
 			default: 0.0;
 		}
 	}

leenkx/Sources/leenkx/logicnode/ChromaticAberrationSetNode.hx

@@ -10,6 +10,7 @@ class ChromaticAberrationSetNode extends LogicNode {
 
         leenkx.renderpath.Postprocess.chromatic_aberration_uniforms[0] = inputs[1].get();
         leenkx.renderpath.Postprocess.chromatic_aberration_uniforms[1] = inputs[2].get();
+		leenkx.renderpath.Postprocess.chromatic_aberration_uniforms[2] = inputs[3].get();
 
 		runOutput(0);
 	}

leenkx/Sources/leenkx/logicnode/DrawCameraTextureNode.hx

@@ -2,6 +2,9 @@ package leenkx.logicnode;
 
 import iron.Scene;
 import iron.object.CameraObject;
+import iron.math.Vec4;
+import iron.math.Quat;
+import leenkx.math.Helper;
 
 import leenkx.renderpath.RenderPathCreator;
 
@@ -27,11 +30,19 @@ class DrawCameraTextureNode extends LogicNode {
 				final c = inputs[2].get();
 				assert(Error, Std.isOfType(c, CameraObject), "Camera must be a camera object!");
 				cam = cast(c, CameraObject);
-				rt = kha.Image.createRenderTarget(iron.App.w(), iron.App.h());
+				rt = kha.Image.createRenderTarget(iron.App.w(), iron.App.h(),
+					kha.graphics4.TextureFormat.RGBA32,
+					kha.graphics4.DepthStencilFormat.NoDepthAndStencil);
 
 				assert(Error, mo.materials[matSlot].contexts[0].textures != null, 'Object "${mo.name}" has no diffuse texture to render to');
-				mo.materials[matSlot].contexts[0].textures[0] = rt; // Override diffuse texture
 
+                final n = inputs[5].get();
+				for (i => node in mo.materials[matSlot].contexts[0].raw.bind_textures){
+					if (node.name == n){
+						mo.materials[matSlot].contexts[0].textures[i] = rt; // Override diffuse texture
+						break;
+					}
+				}
 				tree.notifyOnRender(render);
 				runOutput(0);
 
@@ -48,8 +59,20 @@ class DrawCameraTextureNode extends LogicNode {
 		iron.Scene.active.camera = cam;
 		cam.renderTarget = rt;
 
+		#if kha_html5
+		var q: Quat = new Quat();
+		q.fromAxisAngle(new Vec4(0, 0, 1, 1), Helper.degToRad(180));
+		cam.transform.rot.mult(q);
+		cam.transform.buildMatrix();
+		#end
+
 		cam.renderFrame(g);
 
+		#if kha_html5
+		cam.transform.rot.mult(q);
+		cam.transform.buildMatrix();
+		#end
+
 		cam.renderTarget = oldRT;
 		iron.Scene.active.camera = sceneCam;
 	}

leenkx/Sources/leenkx/logicnode/DrawImageSequenceNode.hx

@@ -99,8 +99,6 @@ class DrawImageSequenceNode extends LogicNode {
 		final colorVec = inputs[4].get();
 		g.color = Color.fromFloats(colorVec.x, colorVec.y, colorVec.z, colorVec.w);
 
-		trace(currentImgIdx);
-
 		g.drawScaledImage(images[currentImgIdx], inputs[5].get(), inputs[6].get(), inputs[7].get(), inputs[8].get());
 	}
 }

leenkx/Sources/leenkx/logicnode/DrawSubImageNode.hx

@@ -0,0 +1,59 @@
+package leenkx.logicnode;
+
+import iron.math.Vec4;
+import kha.Image;
+import kha.Color;
+import leenkx.renderpath.RenderToTexture;
+
+class DrawSubImageNode extends LogicNode {
+    var img: Image;
+    var lastImgName = "";
+
+    public function new(tree: LogicTree) {
+        super(tree);
+    }
+
+    override function run(from: Int) {
+        RenderToTexture.ensure2DContext("DrawImageNode");
+
+        final imgName: String = inputs[1].get();
+        final colorVec: Vec4 = inputs[2].get();
+        final anchorH: Int = inputs[3].get();
+        final anchorV: Int = inputs[4].get();
+        final x: Float = inputs[5].get();
+        final y: Float = inputs[6].get();
+        final width: Float = inputs[7].get();
+        final height: Float = inputs[8].get();
+        final sx: Float = inputs[9].get();
+        final sy: Float = inputs[10].get();
+        final swidth: Float = inputs[11].get();
+        final sheight: Float = inputs[12].get();
+        final angle: Float = inputs[13].get();
+
+        final drawx = x - 0.5 * width * anchorH;
+        final drawy = y - 0.5 * height * anchorV;
+        final sdrawx = sx - 0.5 * swidth * anchorH;
+        final sdrawy = sy - 0.5 * sheight * anchorV;
+
+        RenderToTexture.g.rotate(angle, x, y);
+
+        if (imgName != lastImgName) {
+            // Load new image
+            lastImgName = imgName;
+            iron.data.Data.getImage(imgName, (image: Image) -> {
+                img = image;
+            });
+        }
+
+        if (img == null) {
+            runOutput(0);
+            return;
+        }
+
+        RenderToTexture.g.color = Color.fromFloats(colorVec.x, colorVec.y, colorVec.z, colorVec.w);
+        RenderToTexture.g.drawScaledSubImage(img, sdrawx, sdrawy, swidth, sheight, drawx, drawy, width, height);
+        RenderToTexture.g.rotate(-angle, x, y);
+
+        runOutput(0);
+    }
+}

leenkx/Sources/leenkx/logicnode/GetAudioPositionNode.hx

@@ -0,0 +1,17 @@
+package leenkx.logicnode;
+
+import aura.Aura;
+import aura.Types;
+
+class GetAudioPositionNode extends LogicNode {
+
+	public function new(tree: LogicTree) {
+		super(tree);
+	}
+
+	override function get(from: Int): Dynamic {
+		var audio = inputs[0].get();
+		if (audio == null || audio.channel == null) return 0.0;
+		return audio.channel.floatPosition / audio.channel.sampleRate;
+	}
+}

leenkx/Sources/leenkx/logicnode/GetBoneTransformNode.hx

@@ -26,10 +26,9 @@ class GetBoneTransformNode extends LogicNode {
 		// Get bone in armature
 		var bone = anim.getBone(boneName);
 
-        //return anim.getAbsWorldMat(bone);
-		return anim.getAbsMat(bone).clone().multmat(object.transform.world);
-		//return anim.getAbsWorldMat(bone);
-
+		return anim.getAbsWorldMat(anim.skeletonMats, bone);
+        //return anim.getAbsMat(bone).clone().multmat(object.transform.world);
+		
         #else
         return null;
 

leenkx/Sources/leenkx/logicnode/GetCameraRenderFilterNode.hx

@@ -0,0 +1,19 @@
+package leenkx.logicnode;
+
+import iron.object.MeshObject;
+import iron.object.CameraObject;
+
+class GetCameraRenderFilterNode extends LogicNode {
+
+	public function new(tree: LogicTree) {
+		super(tree);
+	}
+
+	override function get(from: Int): Dynamic {
+		var mo: MeshObject = cast inputs[0].get();
+
+		if (mo == null) return null;
+
+		return mo.cameraList;
+	}
+}

leenkx/Sources/leenkx/logicnode/GetFPSNode.hx

@@ -8,7 +8,7 @@ class GetFPSNode extends LogicNode {
 
     override function get(from: Int): Dynamic {
         if (from == 0) {
-            var fps = Math.round(1 / iron.system.Time.realDelta);
+            var fps = Math.round(1 / iron.system.Time.renderDelta);
             if ((fps == Math.POSITIVE_INFINITY) || (fps == Math.NEGATIVE_INFINITY) || (Math.isNaN(fps))) {
                 return 0;
             }

leenkx/Sources/leenkx/logicnode/GetParticleDataNode.hx

@@ -0,0 +1,72 @@
+package leenkx.logicnode;
+
+import iron.object.Object;
+
+class GetParticleDataNode extends LogicNode {
+
+	public function new(tree: LogicTree) {
+		super(tree);
+	}
+
+	override function get(from: Int): Dynamic {
+		var object: Object = inputs[0].get();
+		var slot: Int = inputs[1].get();
+
+		if (object == null) return null;
+
+	#if lnx_particles
+
+		var mo = cast(object, iron.object.MeshObject);
+
+		var psys = mo.particleSystems != null ? mo.particleSystems[slot] : 
+			mo.particleOwner != null && mo.particleOwner.particleSystems != null ? mo.particleOwner.particleSystems[slot] : null;
+
+		if (psys == null) return null;
+
+		return switch (from) {
+			case 0:
+				@:privateAccess psys.r.name;
+			case 1:
+				@:privateAccess psys.r.particle_size;
+			case 2:
+				@:privateAccess psys.r.frame_start;
+			case 3:
+				@:privateAccess psys.r.frame_end;
+			case 4:
+				@:privateAccess psys.lifetime;
+			case 5:
+				@:privateAccess psys.r.lifetime;
+			case 6:
+				@:privateAccess psys.r.emit_from;
+			case 7:
+				@:privateAccess psys.r.auto_start;
+			case 8:
+				@:privateAccess psys.r.is_unique;
+			case 9:
+				@:privateAccess psys.r.loop;
+			case 10:
+				new iron.math.Vec3(@:privateAccess psys.alignx, @:privateAccess psys.aligny, @:privateAccess psys.alignz);
+			case 11:
+				@:privateAccess psys.r.factor_random;
+			case 12:
+				new iron.math.Vec3(@:privateAccess psys.gx, @:privateAccess psys.gy, @:privateAccess psys.gz);
+			case 13:
+				@:privateAccess psys.r.weight_gravity;
+			case 14:
+				psys.speed;
+			case 15:
+				@:privateAccess psys.time;
+			case 16:
+				@:privateAccess psys.lap;
+			case 17:
+				@:privateAccess psys.lapTime;
+			case 18:
+				@:privateAccess psys.count;
+			default: 
+				null;
+		}
+	#end
+
+		return null;
+	}
+}

leenkx/Sources/leenkx/logicnode/GetParticleNode.hx

@@ -0,0 +1,38 @@
+package leenkx.logicnode;
+
+import iron.object.Object;
+
+class GetParticleNode extends LogicNode {
+
+	public function new(tree: LogicTree) {
+		super(tree);
+	}
+
+	override function get(from: Int): Dynamic {
+		var object: Object = inputs[0].get();
+
+		if (object == null) return null;
+
+	#if lnx_particles
+
+		var mo = cast(object, iron.object.MeshObject);
+	
+		switch (from) {
+			case 0:
+				var names: Array<String> = [];
+				if (mo.particleSystems != null)
+					for (psys in mo.particleSystems)
+						names.push(@:privateAccess psys.r.name);
+				return names;
+			case 1:
+				return mo.particleSystems != null ? mo.particleSystems.length : 0;
+			case 2:
+				return mo.render_emitter;
+			default: 
+				null;
+		}
+	#end
+
+		return null;
+	}
+}

leenkx/Sources/leenkx/logicnode/GetPositionSpeakerNode.hx

@@ -0,0 +1,33 @@
+package leenkx.logicnode;
+
+#if lnx_audio
+import iron.object.SpeakerObject;
+import kha.audio1.AudioChannel;
+#end
+
+class GetPositionSpeakerNode extends LogicNode {
+
+	public function new(tree: LogicTree) {
+		super(tree);
+	}
+
+	override function get(from: Int): Dynamic {
+		#if lnx_audio
+		var object: SpeakerObject = cast(inputs[0].get(), SpeakerObject);
+		if (object == null || object.sound == null) return 0.0;
+		
+		if (object.channels.length == 0) return 0.0;
+		
+		var channel = object.channels[0];
+		
+		var position = 0.0;
+		if (channel != null) {
+			position = @:privateAccess channel.get_position();
+		}
+		
+		return position;
+		#else
+		return 0.0;
+		#end
+	}
+}

leenkx/Sources/leenkx/logicnode/GetWorldNode.hx

@@ -1,26 +1,12 @@
 package leenkx.logicnode;
 
-import iron.object.Object;
-import iron.math.Vec4;
-
 class GetWorldNode extends LogicNode {
 
-	public var property0: String;
-
 	public function new(tree: LogicTree) {
 		super(tree);
 	}
 
 	override function get(from: Int): Dynamic {
-		var object: Object = inputs[0].get();
-
-		if (object == null) return null;
-
-		return switch (property0) {
-			case "Right": object.transform.world.right();
-			case "Look": object.transform.world.look();
-			case "Up": object.transform.world.up();
-			default: null;
-		}
+		return iron.Scene.active.raw.world_ref;
 	}
-}
+}

leenkx/Sources/leenkx/logicnode/GetWorldOrientationNode.hx

@@ -0,0 +1,26 @@
+package leenkx.logicnode;
+
+import iron.object.Object;
+import iron.math.Vec4;
+
+class GetWorldOrientationNode extends LogicNode {
+
+	public var property0: String;
+
+	public function new(tree: LogicTree) {
+		super(tree);
+	}
+
+	override function get(from: Int): Dynamic {
+		var object: Object = inputs[0].get();
+
+		if (object == null) return null;
+
+		return switch (property0) {
+			case "Right": object.transform.world.right();
+			case "Look": object.transform.world.look();
+			case "Up": object.transform.world.up();
+			default: null;
+		}
+	}
+}

leenkx/Sources/leenkx/logicnode/GoToLocationNode.hx

@@ -1,7 +1,7 @@
 package leenkx.logicnode;
 
 #if lnx_physics
-import leenkx.trait.physics.bullet.PhysicsWorld;
+import leenkx.trait.physics.PhysicsWorld;
 #end
 import leenkx.trait.navigation.Navigation;
 import iron.object.Object;

leenkx/Sources/leenkx/logicnode/MouseLookNode.hx

@@ -0,0 +1,233 @@
+package leenkx.logicnode;
+
+import iron.math.Vec4;
+import iron.system.Input;
+import iron.object.Object;
+import kha.System;
+import kha.FastFloat;
+
+/**
+ * MouseLookNode - FPS-style mouse look camera controller
+ * 
+ * This node provides smooth, resolution-independent mouse look functionality for 
+ * first-person perspective controls. It supports separate body and head objects,
+ * allowing for realistic FPS camera movement where the body rotates horizontally
+ * and the head/camera rotates vertically.
+ * 
+ * Key Features:
+ * - Resolution-adaptive scaling for consistent feel across different screen sizes
+ * - Configurable axis orientations (X, Y, Z as front)
+ * - Optional mouse cursor locking and hiding
+ * - Invertible X/Y axes
+ * - Rotation capping/limiting for both horizontal and vertical movement
+ * - Smoothing support for smoother camera movement
+ * - Physics integration with automatic rigid body synchronization
+ * - Support for both local and world space head rotation
+ */
+class MouseLookNode extends LogicNode {
+	// Configuration properties (set from Blender node interface)
+	public var property0: String;  // Front axis: "X", "Y", or "Z"
+	public var property1: Bool;    // Hide Locked: auto-lock mouse cursor
+	public var property2: Bool;    // Invert X: invert horizontal mouse movement
+	public var property3: Bool;    // Invert Y: invert vertical mouse movement
+	public var property4: Bool;    // Cap Left/Right: limit horizontal rotation
+	public var property5: Bool;    // Cap Up/Down: limit vertical rotation
+	public var property6: Bool;    // Head Local Space: use local space for head rotation
+
+	// Smoothing state variables - maintain previous frame values for interpolation
+	var smoothX: Float = 0.0;      // Smoothed horizontal mouse delta
+	var smoothY: Float = 0.0;      // Smoothed vertical mouse delta
+	
+	// Rotation limits (in radians)
+	var maxHorizontal: Float = Math.PI;      // Maximum horizontal rotation (180 degrees)
+	var maxVertical: Float = Math.PI / 2;    // Maximum vertical rotation (90 degrees)
+	
+	// Current rotation tracking for capping calculations
+	var currentHorizontal: Float = 0.0;      // Accumulated horizontal rotation
+	var currentVertical: Float = 0.0;        // Accumulated vertical rotation
+	
+	// Resolution scaling reference - base resolution for consistent sensitivity
+	var baseResolutionWidth: Float = 1920.0;
+	
+	// Sensitivity scaling constants
+	static inline var BASE_SCALE: Float = 1500.0;              // Base sensitivity scale factor
+	static var RADIAN_SCALING_FACTOR: Float = Math.PI * 50.0 / 180.0;  // Degrees to radians conversion with sensitivity scaling
+
+	public function new(tree: LogicTree) {
+		super(tree);
+	}
+
+	/**
+	 * Main execution function called every frame when the node is active
+	 * 
+	 * Input connections:
+	 * [0] - Action trigger (not used in current implementation)
+	 * [1] - Body Object: the main object that rotates horizontally
+	 * [2] - Head Object: optional object that rotates vertically (typically camera)
+	 * [3] - Sensitivity: mouse sensitivity multiplier
+	 * [4] - Smoothing: movement smoothing factor (0.0 = no smoothing, 0.99 = maximum smoothing)
+	 */
+	override function run(from: Int) {
+		// Get input values from connected nodes
+		var bodyObject: Object = inputs[1].get();
+		var headObject: Object = inputs[2].get();
+		var sensitivity: FastFloat = inputs[3].get();
+		var smoothing: FastFloat = inputs[4].get();
+
+		// Early exit if no body object is provided
+		if (bodyObject == null) {
+			runOutput(0);
+			return;
+		}
+
+		// Get mouse input state
+		var mouse = Input.getMouse();
+		
+		// Handle automatic mouse cursor locking for FPS controls
+		if (property1) {
+			if (mouse.started() && !mouse.locked) {
+				mouse.lock();  // Center and hide cursor, enable unlimited movement
+			}
+		}
+
+		// Only process mouse look when cursor is locked or mouse button is held
+		// This prevents unwanted camera movement when UI elements are being used
+		if (!mouse.locked && !mouse.down()) {
+			runOutput(0);
+			return;
+		}
+
+		// Get raw mouse movement delta (pixels moved since last frame)
+		var deltaX: Float = mouse.movementX;
+		var deltaY: Float = mouse.movementY;
+
+		// Apply axis inversion if configured
+		if (property2) deltaX = -deltaX;  // Invert horizontal movement
+		if (property3) deltaY = -deltaY;  // Invert vertical movement
+
+		// Calculate resolution-adaptive scaling to maintain consistent sensitivity
+		// across different screen resolutions. Higher resolutions will have proportionally
+		// higher scaling to compensate for increased pixel density.
+		var resolutionMultiplier: Float = System.windowWidth() / baseResolutionWidth;
+
+		// Apply movement smoothing if enabled
+		// This creates a weighted average between current and previous movement values
+		// to reduce jittery camera movement, especially useful for low framerates
+		if (smoothing > 0.0) {
+			var smoothingFactor: Float = Math.min(smoothing, 0.99);  // Cap smoothing to prevent complete freeze
+			smoothX = smoothX * smoothingFactor + deltaX * (1.0 - smoothingFactor);
+			smoothY = smoothY * smoothingFactor + deltaY * (1.0 - smoothingFactor);
+			deltaX = smoothX;
+			deltaY = smoothY;
+		}
+
+		// Define rotation axes based on the configured front axis
+		// These determine which 3D axes are used for horizontal and vertical rotation
+		var horizontalAxis = new Vec4();  // Axis for left/right body rotation
+		var verticalAxis = new Vec4();    // Axis for up/down head rotation
+		
+		switch (property0) {
+			case "X":  // X-axis forward (e.g., for side-scrolling or specific orientations)
+				horizontalAxis.set(0, 0, 1);  // Z-axis for horizontal rotation
+				verticalAxis.set(0, 1, 0);    // Y-axis for vertical rotation
+			case "Y":  // Y-axis forward (most common for 3D games)
+				#if lnx_yaxisup
+				// Y-up coordinate system (Blender default)
+				horizontalAxis.set(0, 0, 1);  // Z-axis for horizontal rotation
+				verticalAxis.set(1, 0, 0);    // X-axis for vertical rotation
+				#else
+				// Z-up coordinate system
+				horizontalAxis.set(0, 0, 1);  // Z-axis for horizontal rotation
+				verticalAxis.set(1, 0, 0);    // X-axis for vertical rotation
+				#end
+			case "Z":  // Z-axis forward (top-down or specific orientations)
+				horizontalAxis.set(0, 1, 0);  // Y-axis for horizontal rotation
+				verticalAxis.set(1, 0, 0);    // X-axis for vertical rotation
+		}
+
+		// Calculate final sensitivity scaling combining base scale and resolution adaptation
+		var finalScale: Float = BASE_SCALE * resolutionMultiplier;
+
+		// Apply user-defined sensitivity multiplier
+		deltaX *= sensitivity;
+		deltaY *= sensitivity;
+
+		// Convert pixel movement to rotation angles (radians)
+		// Negative values ensure natural movement direction (moving mouse right rotates right)
+		var horizontalRotation: Float = (-deltaX / finalScale) * RADIAN_SCALING_FACTOR;
+		var verticalRotation: Float = (-deltaY / finalScale) * RADIAN_SCALING_FACTOR;
+
+		// Apply horizontal rotation capping if enabled
+		// This prevents the character from rotating beyond specified limits
+		if (property4) {
+			currentHorizontal += horizontalRotation;
+			// Clamp rotation to maximum horizontal range and adjust current frame rotation
+			if (currentHorizontal > maxHorizontal) {
+				horizontalRotation -= (currentHorizontal - maxHorizontal);
+				currentHorizontal = maxHorizontal;
+			} else if (currentHorizontal < -maxHorizontal) {
+				horizontalRotation -= (currentHorizontal + maxHorizontal);
+				currentHorizontal = -maxHorizontal;
+			}
+		}
+
+		// Apply vertical rotation capping if enabled
+		// This prevents looking too far up or down (like human neck limitations)
+		if (property5) {
+			currentVertical += verticalRotation;
+			// Clamp rotation to maximum vertical range and adjust current frame rotation
+			if (currentVertical > maxVertical) {
+				verticalRotation -= (currentVertical - maxVertical);
+				currentVertical = maxVertical;
+			} else if (currentVertical < -maxVertical) {
+				verticalRotation -= (currentVertical + maxVertical);
+				currentVertical = -maxVertical;
+			}
+		}
+
+		// Apply horizontal rotation to body object (character turning left/right)
+		if (horizontalRotation != 0.0) {
+			bodyObject.transform.rotate(horizontalAxis, horizontalRotation);
+			
+			// Synchronize physics rigid body if present
+			// This ensures physics simulation stays in sync with visual transform
+			#if lnx_physics
+			var rigidBody = bodyObject.getTrait(leenkx.trait.physics.RigidBody);
+			if (rigidBody != null) rigidBody.syncTransform();
+			#end
+		}
+
+		// Apply vertical rotation to head object (camera looking up/down)
+		if (headObject != null && verticalRotation != 0.0) {
+			if (property6) {
+				// Local space rotation - recommended when head is a child of body
+				// This prevents gimbal lock and rotation inheritance issues
+				headObject.transform.rotate(verticalAxis, verticalRotation);
+			} else {
+				// World space rotation - uses head object's current right vector
+				// More accurate for independent head objects but can cause issues with parenting
+				var headVerticalAxis = headObject.transform.world.right();
+				headObject.transform.rotate(headVerticalAxis, verticalRotation);
+			}
+			
+			// Synchronize head physics rigid body if present
+			#if lnx_physics
+			var headRigidBody = headObject.getTrait(leenkx.trait.physics.RigidBody);
+			if (headRigidBody != null) headRigidBody.syncTransform();
+			#end
+		} else if (headObject == null && verticalRotation != 0.0) {
+			// Fallback: if no separate head object, apply vertical rotation to body
+			// This creates a simpler single-object camera control
+			bodyObject.transform.rotate(verticalAxis, verticalRotation);
+			
+			// Synchronize body physics rigid body
+			#if lnx_physics
+			var rigidBody = bodyObject.getTrait(leenkx.trait.physics.RigidBody);
+			if (rigidBody != null) rigidBody.syncTransform();
+			#end
+		}
+
+		// Continue to next connected node in the logic tree
+		runOutput(0);
+	}
+} 

leenkx/Sources/leenkx/logicnode/OnceNode.hx

@@ -0,0 +1,23 @@
+package leenkx.logicnode;
+
+class OnceNode extends LogicNode {
+
+    var triggered:Bool = false;
+
+    public function new(tree: LogicTree) {
+        super(tree);
+    }
+
+    override function run(from: Int) {
+		if(from == 1){
+			triggered = false;
+			return;
+		}
+
+        if (!triggered) {
+			triggered = true;
+            runOutput(0);
+        }
+    }
+
+}

leenkx/Sources/leenkx/logicnode/PauseSoundNode.hx

@@ -1,7 +1,7 @@
 package leenkx.logicnode;
-
+#if lnx_audio
 import iron.object.SpeakerObject;
-
+#end
 class PauseSoundNode extends LogicNode {
 
 	public function new(tree: LogicTree) {
@@ -9,9 +9,11 @@ class PauseSoundNode extends LogicNode {
 	}
 
 	override function run(from: Int) {
+		#if lnx_audio
 		var object: SpeakerObject = cast(inputs[1].get(), SpeakerObject);
 		if (object == null) return;
 		object.pause();
+		#end
 		runOutput(0);
 	}
 }

leenkx/Sources/leenkx/logicnode/PhysicsConstraintNode.hx

@@ -1,7 +1,7 @@
 package leenkx.logicnode;
 
 #if lnx_physics
-import leenkx.trait.physics.bullet.PhysicsConstraint.ConstraintAxis;
+import leenkx.trait.physics.PhysicsConstraint.ConstraintAxis;
 #end
 
 class PhysicsConstraintNode extends LogicNode {

leenkx/Sources/leenkx/logicnode/PlayAnimationTreeNode.hx

@@ -9,19 +9,38 @@ import iron.Scene;
 
 class PlayAnimationTreeNode extends LogicNode {
 
+	var object: Object;
+	var action: Dynamic;
+	var init: Bool = false;
+
 	public function new(tree: LogicTree) {
 		super(tree);
 	}
 
 	override function run(from: Int) {
-		var object: Object = inputs[1].get();
-		var action: Dynamic = inputs[2].get();
-
+		object = inputs[1].get();
+		action = inputs[2].get();
 		assert(Error, object != null, "The object input not be null");
+		init = true;
+		tree.notifyOnUpdate(playAnim);
+		// TO DO: Investigate AnimAction get and PlayAnimationTree notifiers
+	}
+	
+	function playAnim() {
+		if (init = false) return;
+		
+		init = false;
+		tree.removeUpdate(playAnim);
+		
 		var animation = object.animation;
 		if(animation == null) {
 			#if lnx_skin
 			animation = object.getBoneAnimation(object.uid);
+			if (animation == null) {
+				tree.notifyOnUpdate(playAnim);
+				init = true;
+				return;
+			}
 			cast(animation, BoneAnimation).setAnimationLoop(function f(mats) {
 				action(mats);
 			});
@@ -32,7 +51,6 @@ class PlayAnimationTreeNode extends LogicNode {
 				action(mats);
 			});
 		}
-		
 		runOutput(0);
 	}
 }

leenkx/Sources/leenkx/logicnode/PlaySoundNode.hx

@@ -1,7 +1,7 @@
 package leenkx.logicnode;
-
+#if lnx_audio
 import iron.object.SpeakerObject;
-
+#end
 class PlaySoundNode extends LogicNode {
 
 	public function new(tree: LogicTree) {
@@ -9,9 +9,11 @@ class PlaySoundNode extends LogicNode {
 	}
 
 	override function run(from: Int) {
+		#if lnx_audio
 		var object: SpeakerObject = cast(inputs[1].get(), SpeakerObject);
 		if (object == null) return;
 		object.play();
+		#end
 		runOutput(0);
 	}
 }

leenkx/Sources/leenkx/logicnode/PlaySoundRawNode.hx

@@ -16,15 +16,16 @@ class PlaySoundRawNode extends LogicNode {
 	public var property5: Bool;
 
 	public var property6: String;
-
+	#if lnx_audio
 	var sound: kha.Sound = null;
 	var channel: kha.audio1.AudioChannel = null;
-
+	#end
 	public function new(tree: LogicTree) {
 		super(tree);
 	}
 
 	override function run(from: Int) {
+		#if lnx_audio
 		switch (from) {
 			case Play:
 				if (property6 == 'Sound' ? sound == null : true) {
@@ -63,6 +64,10 @@ class PlaySoundRawNode extends LogicNode {
 			case UpdateVolume:
 				if (channel != null) channel.volume = inputs[4].get();
 		}
+		#end
+		#if !lnx_audio
+			runOutput(0);
+		#end
 	}
 
 	function onUpdate() {

leenkx/Sources/leenkx/logicnode/ProbabilisticOutputNode.hx

@@ -18,7 +18,6 @@ class ProbabilisticOutputNode extends LogicNode {
 		}
 
 		if (sum > 1){
-			trace(sum);
 			for (p in 0...probs.length)
 				probs[p] /= sum;
 		}

leenkx/Sources/leenkx/logicnode/RemoveParticleFromObjectNode.hx

@@ -0,0 +1,64 @@
+package leenkx.logicnode;
+
+import iron.object.Object;
+
+class RemoveParticleFromObjectNode extends LogicNode {
+
+	public var property0: String;
+
+	public function new(tree: LogicTree) {
+		super(tree);
+	}
+
+	override function run(from: Int) {
+		#if lnx_particles
+		var object: Object = inputs[1].get();
+
+		if (object == null) return;
+
+		var mo = cast(object, iron.object.MeshObject);
+
+		if (mo.particleSystems == null) return;
+
+		if (property0 == 'All'){
+			mo.particleSystems = null;
+			for (c in mo.particleChildren) c.remove();
+			mo.particleChildren = null;
+			mo.particleOwner = null;
+			mo.render_emitter = true;
+		} 
+		else {
+			
+			var slot: Int = -1;
+			if (property0 == 'Name'){
+				var name: String = inputs[2].get();
+				for (i => psys in mo.particleSystems){
+					if (@:privateAccess psys.r.name == name){ slot = i; break; }
+				}
+			} 
+			else slot = inputs[2].get();
+				
+			if (mo.particleSystems.length > slot){
+				for (i in slot+1...mo.particleSystems.length){
+					var mi = cast(mo.particleChildren[i], iron.object.MeshObject);
+					mi.particleIndex = mi.particleIndex - 1;
+				}
+				mo.particleSystems.splice(slot, 1);
+				mo.particleChildren[slot].remove();
+				mo.particleChildren.splice(slot, 1);
+			}
+
+			if (slot == 0){
+				mo.particleSystems = null;
+				mo.particleChildren = null;
+				mo.particleOwner = null;
+				mo.render_emitter = true;
+			}
+
+		}
+
+		#end
+
+		runOutput(0);
+	}
+}

leenkx/Sources/leenkx/logicnode/ResolutionGetNode.hx

@@ -0,0 +1,16 @@
+package leenkx.logicnode;
+
+class ResolutionGetNode extends LogicNode {
+
+	public function new(tree:LogicTree) {
+		super(tree);
+	}
+
+	override function get(from:Int):Dynamic {
+		return switch (from) {
+			case 0: leenkx.renderpath.Postprocess.resolution_uniforms[0];
+			case 1: leenkx.renderpath.Postprocess.resolution_uniforms[1];
+			default: 0;
+		}
+	}
+}

leenkx/Sources/leenkx/logicnode/ResolutionSetNode.hx

@@ -0,0 +1,33 @@
+package leenkx.logicnode;
+
+import kha.graphics4.TextureFilter;
+
+class ResolutionSetNode extends LogicNode {
+
+	public function new(tree:LogicTree) {
+		super(tree);
+	}
+
+	override function run(from:Int) {
+
+		var size: Int = inputs[1].get();
+		var filter: Int = inputs[2].get();
+
+	#if rp_resolution_filter 
+		if (filter == 0)
+			iron.object.Uniforms.defaultFilter = TextureFilter.LinearFilter;
+		else
+			iron.object.Uniforms.defaultFilter = TextureFilter.PointFilter;
+
+		leenkx.renderpath.Postprocess.resolution_uniforms[0] = size;
+		leenkx.renderpath.Postprocess.resolution_uniforms[1] = filter;
+
+		var npath = leenkx.renderpath.RenderPathCreator.get();
+		var world = iron.Scene.active.raw.world_ref;
+		npath.loadShader("shader_datas/World_" + world + "/World_" + world);
+		iron.RenderPath.setActive(npath);
+    #end
+
+		runOutput(0);
+	}
+}