Progress on the engine

build.gradle

@@ -16,39 +16,33 @@ eclipse {
 }
 
 sourceSets {
-	math {
+	math
-		java {}
+	events
-	}
+	assets
-	assets {
+	graphics
-		java {}
+	gui
-	}
+	main
-	graphics {
-		compileClasspath += sourceSets.math.output
-        runtimeClasspath += sourceSets.math.output
-		java {}
-	}
-	gui {
-		compileClasspath += sourceSets.math.output + sourceSets.graphics.output
-        runtimeClasspath += sourceSets.math.output + sourceSets.graphics.output
-		java {}
-	}
-	main {
-		compileClasspath += sourceSets.math.output
-        runtimeClasspath += sourceSets.math.output
-	}
-	
 }
 
+
 configurations {
-    graphics.extendsFrom implementation
+    commonImplementation
-    graphics.extendsFrom runtime
+    assetsImplementation.extendsFrom(eventsImplementation)
-    graphics.extendsFrom mathRuntime
+    graphicsImplementation.extendsFrom(mathImplementation, assetsImplementation)
-    
+    guiImplementation.extendsFrom(graphicsImplementation)
-    gui.extendsFrom mathRuntime
+    implementation.extendsFrom(guiImplementation)
-    gui.extendsFrom graphicsRuntime
-    implementation.extendsFrom mathRuntime
 }
 
+
+sourceSets.all { sourceSet ->
+    String implementationConfigName = sourceSet.implementationConfigurationName
+    
+    configurations.named(implementationConfigName).configure {
+        extendsFrom(configurations.named("commonImplementation").get())
+    }
+}
+
+
 repositories {
 	mavenCentral()
 	maven {
@@ -60,43 +54,51 @@ repositories {
 
 
 dependencies {
-	//LWJGL 3
+    assetsImplementation sourceSets.events.output
-	implementation platform("org.lwjgl:lwjgl-bom:$lwjglVersion")
+    graphicsImplementation sourceSets.math.output
+    graphicsImplementation sourceSets.assets.output
+    guiImplementation sourceSets.graphics.output
+    implementation sourceSets.gui.output
 	
-	implementation "org.lwjgl:lwjgl"
+	//LWJGL 3
-	implementation "org.lwjgl:lwjgl-glfw"
+	commonImplementation platform("org.lwjgl:lwjgl-bom:$lwjglVersion")
-	implementation "org.lwjgl:lwjgl-jemalloc"
+	
-	implementation "org.lwjgl:lwjgl-openal"
+	commonImplementation "org.lwjgl:lwjgl"
-	implementation "org.lwjgl:lwjgl-opengl"
+	commonImplementation "org.lwjgl:lwjgl-glfw"
-	implementation "org.lwjgl:lwjgl-stb"
+	commonImplementation "org.lwjgl:lwjgl-jemalloc"
-	implementation "org.lwjgl:lwjgl-nfd"
+	commonImplementation "org.lwjgl:lwjgl-openal"
-	implementation "org.lwjgl:lwjgl-freetype"
+	commonImplementation "org.lwjgl:lwjgl-opengl"
-	implementation "org.lwjgl:lwjgl-harfbuzz"
+	commonImplementation "org.lwjgl:lwjgl-stb"
-	implementation "org.lwjgl:lwjgl-nanovg"
+	commonImplementation "org.lwjgl:lwjgl-nfd"
-	implementation "org.lwjgl:lwjgl::$lwjglNatives"
+	commonImplementation "org.lwjgl:lwjgl-freetype"
-	implementation "org.lwjgl:lwjgl-glfw::$lwjglNatives"
+	commonImplementation "org.lwjgl:lwjgl-harfbuzz"
-	implementation "org.lwjgl:lwjgl-jemalloc::$lwjglNatives"
+	commonImplementation "org.lwjgl:lwjgl-nanovg"
-	implementation "org.lwjgl:lwjgl-openal::$lwjglNatives"
+	commonImplementation "org.lwjgl:lwjgl::$lwjglNatives"
-	implementation "org.lwjgl:lwjgl-opengl::$lwjglNatives"
+	commonImplementation "org.lwjgl:lwjgl-glfw::$lwjglNatives"
-	implementation "org.lwjgl:lwjgl-stb::$lwjglNatives"
+	commonImplementation "org.lwjgl:lwjgl-jemalloc::$lwjglNatives"
-	implementation "org.lwjgl:lwjgl-nfd::$lwjglNatives"
+	commonImplementation "org.lwjgl:lwjgl-openal::$lwjglNatives"
-	implementation "org.lwjgl:lwjgl-freetype::$lwjglNatives"
+	commonImplementation "org.lwjgl:lwjgl-opengl::$lwjglNatives"
-	implementation "org.lwjgl:lwjgl-harfbuzz::$lwjglNatives"
+	commonImplementation "org.lwjgl:lwjgl-stb::$lwjglNatives"
-	implementation "org.lwjgl:lwjgl-nanovg::$lwjglNatives"
+	commonImplementation "org.lwjgl:lwjgl-nfd::$lwjglNatives"
-	implementation "org.jspecify:jspecify:1.0.0"
+	commonImplementation "org.lwjgl:lwjgl-freetype::$lwjglNatives"
+	commonImplementation "org.lwjgl:lwjgl-harfbuzz::$lwjglNatives"
+	commonImplementation "org.lwjgl:lwjgl-nanovg::$lwjglNatives"
+	commonImplementation "org.jspecify:jspecify:1.0.0"
 	
 	//Gson
-	implementation 'com.google.code.gson:gson:2.8.6'
+	commonImplementation 'com.google.code.gson:gson:2.8.6'
 	
 	//Primitive Collections
-	implementation 'de.speiger:Primitive-Collections:1.0.0'
+	commonImplementation 'de.speiger:Primitive-Collections:1.0.0'
-	mathImplementation 'de.speiger:Primitive-Collections:1.0.0'
 }
 
 jar {
 	manifest {
-		attributes "Main-Class": 'speiger.src.coreengine.NewInputTest'
+		attributes "Main-Class": 'speiger.src.coreengine.NewRenderEngineTest'
 	}
+	sourceSets.each { ss ->
+        from ss.output
+    }
 	from {
 		configurations.runtimeClasspath.collect { 
 			it.isDirectory() ? it : zipTree(it)
@@ -106,8 +108,11 @@ jar {
 }
 
 task srcJar(type: Jar) {
-	from sourceSets.main.allSource
 	archiveClassifier = 'sources'
+	
+	sourceSets.each { ss ->
+        from ss.allSource
+    }
 	from {
 		configurations.runtimeClasspath.collect { 
 			it.isDirectory() ? it : zipTree(it)

src/events/java/speiger/src/coreengine/core/events/api/Event.java

@@ -0,0 +1,5 @@
+package speiger.src.coreengine.core.events.api;
+
+public class Event {
+	
+}

src/events/java/speiger/src/coreengine/core/events/api/EventPriority.java

@@ -0,0 +1,24 @@
+package speiger.src.coreengine.core.events.api;
+
+public enum EventPriority
+{
+	HIGH(0),
+	MEDIUM(1),
+	LOW(2);
+	
+	int priority;
+	
+	static final EventPriority[] PRIORITIES = new EventPriority[] {HIGH, MEDIUM, LOW};
+	
+	private EventPriority(int id) {
+		priority = id;
+	}
+	
+	public int getPriority() {
+		return priority;
+	}
+	
+	public static EventPriority[] getPriorities() {
+		return PRIORITIES;
+	}
+}

src/events/java/speiger/src/coreengine/core/events/api/ICancelableEvent.java

@@ -0,0 +1,6 @@
+package speiger.src.coreengine.core.events.api;
+
+public interface ICancelableEvent {
+	void setCanceled(boolean value);
+	boolean isCanceled();
+}

src/events/java/speiger/src/coreengine/core/events/api/SubscribeEvent.java

@@ -0,0 +1,18 @@
+package speiger.src.coreengine.core.events.api;
+
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.TYPE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+@Retention(RUNTIME)
+@Target({TYPE, FIELD, METHOD})
+public @interface SubscribeEvent
+{
+	public EventPriority priority() default EventPriority.MEDIUM;
+	
+	public Class<? extends Event> value() default Event.class;
+}

src/events/java/speiger/src/coreengine/core/events/bus/BusBuilder.java

@@ -0,0 +1,36 @@
+package speiger.src.coreengine.core.events.bus;
+
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.Predicate;
+
+import speiger.src.coreengine.core.events.api.Event;
+import speiger.src.coreengine.core.events.utility.IEventDispatcher;
+import speiger.src.coreengine.core.events.utility.IEventExceptionHandler;
+
+public class BusBuilder {
+	IEventDispatcher dispatcher = IEventDispatcher.DIRECT;
+	Optional<IEventExceptionHandler> exceptions = Optional.empty();
+	Predicate<Class<? extends Event>> filter = _ -> true;
+	boolean checkType = false;
+	
+	public BusBuilder dispatcher(IEventDispatcher dispatcher) {
+		this.dispatcher = Objects.requireNonNull(dispatcher, "A Dispatcher is required");
+		return this;
+	}
+	
+	public BusBuilder exceptions(IEventExceptionHandler exceptions) {
+		this.exceptions = Optional.ofNullable(exceptions);
+		return this;
+	}
+	
+	public BusBuilder filter(Predicate<Class<? extends Event>> filter) {
+		this.filter = Objects.requireNonNull(filter, "A Filter is required");
+		checkType = true;
+		return this;
+	}
+	
+	public EventBus build() {
+		return new EventBus(this);
+	}
+}

src/events/java/speiger/src/coreengine/core/events/bus/EventBus.java

@@ -0,0 +1,189 @@
+package speiger.src.coreengine.core.events.bus;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandleInfo;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodHandles.Lookup;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import speiger.src.collections.objects.lists.ObjectArrayList;
+import speiger.src.collections.objects.maps.impl.concurrent.Object2ObjectConcurrentOpenHashMap;
+import speiger.src.coreengine.core.events.api.Event;
+import speiger.src.coreengine.core.events.api.EventPriority;
+import speiger.src.coreengine.core.events.api.SubscribeEvent;
+import speiger.src.coreengine.core.events.utility.IEventDispatcher;
+import speiger.src.coreengine.core.events.utility.IEventExceptionHandler;
+import speiger.src.coreengine.core.events.utility.Listeners;
+import speiger.src.coreengine.core.events.utility.Subscription;
+
+public class EventBus implements IEventExceptionHandler {
+	private static final Lookup LOOKUP = MethodHandles.lookup();
+	IEventDispatcher dispatcher;
+	IEventExceptionHandler exceptions;
+	Predicate<Class<? extends Event>> filter;
+	boolean checkType;
+	boolean shutdown = false;
+	
+	Map<Class<? extends Event>, Listeners> listeners = new Object2ObjectConcurrentOpenHashMap<>();
+	
+	EventBus(BusBuilder builder) {
+		dispatcher = builder.dispatcher;
+		exceptions = builder.exceptions.orElse(this);
+		checkType = builder.checkType;
+		filter = builder.filter;
+	}
+	
+	public static BusBuilder builder() {
+		return new BusBuilder();
+	}
+	
+	public Subscriptions create() {
+		return new Subscriptions(this);
+	}
+	
+	public <T extends Event> T post(T event) {
+		if(shutdown) throw new IllegalStateException("Bus is shutdown");
+		validateType(event.getClass());
+		Listeners listener = listeners.get(event.getClass());
+		if(listener == null) return event;
+		dispatcher.post(listener.getListeners(), event, exceptions);
+		return event;
+	}
+	
+	public <T extends Event> CompletableFuture<T> postAsync(T event) {
+		if(shutdown) throw new IllegalStateException("Bus is shutdown");
+		return CompletableFuture.supplyAsync(() -> post(event)); 
+	}
+	
+	public <T extends Event> CompletableFuture<T> postAsync(T event, Executor executor) {
+		if(shutdown) throw new IllegalStateException("Bus is shutdown");
+		return CompletableFuture.supplyAsync(() -> post(event), executor);
+	}
+	
+	@Override
+	public void handleException(Event event, Consumer<Event>[] listeners, int index, Throwable crash) {
+		StringBuilder builder = new StringBuilder();
+		builder.append("Event ["+event.getClass()+"] caused an Exception: ").append(crash.getMessage()).append('\n');
+		builder.append('\t').append("At Index=").append(index).append('\n');
+		builder.append("Listeners: ");
+		for (int x = 0; x < listeners.length; x++) {
+			builder.append("\t\t").append(x).append(": ").append(listeners[x]).append('\n');
+		}
+		StringWriter exception = new StringWriter();
+		crash.printStackTrace(new PrintWriter(exception));
+		builder.append(exception.getBuffer());
+		//TODO implement logging
+		System.err.println(builder.toString());
+	}
+	
+	<T extends Event> Subscription register(Class<T> clz, EventPriority prio, Consumer<T> listener) {
+		validateType(clz);
+		registerListener(clz).addListener(prio, cast(listener));
+		return new EventListener(castClass(clz), cast(listener));
+	}
+	
+	<T extends Event> List<Subscription> register(Object obj, boolean superClasses) {
+		final List<Subscription> list = new ObjectArrayList<>();
+		try {
+			register(obj.getClass().getDeclaredAnnotation(SubscribeEvent.class), obj, list);
+			find(obj.getClass(), superClasses, Class::getDeclaredMethods, t -> {
+				try {
+					t.setAccessible(true);
+					SubscribeEvent data = t.getAnnotation(SubscribeEvent.class);
+					if(data == null) return;
+					Consumer<Event> listener = new MethodListener(LOOKUP.unreflect(t).bindTo(obj));
+					Class<Event> clz = castClass(t.getParameterTypes()[0]); 
+					validateType(clz);
+					registerListener(clz).addListener(data.priority(), listener);
+					list.add(new EventListener(clz, listener));
+				}
+				catch(Exception e) { e.printStackTrace(); }
+			});
+			find(obj.getClass(), superClasses, Class::getDeclaredFields, t -> {
+				try {
+					t.setAccessible(true);
+					register(t.getAnnotation(SubscribeEvent.class), t.get(obj), list);						
+				}
+				catch(Exception e) { e.printStackTrace(); }
+			});
+		}
+		catch(Exception e) { e.printStackTrace(); }
+		return list;
+	}
+	
+	private synchronized Listeners registerListener(Class<? extends Event> event) {
+		Listeners result = listeners.get(event);
+		if(result == null) {
+			result = event == Event.class ? new Listeners() : new Listeners(registerListener(castClass(event.getSuperclass())));
+			listeners.put(event, result);
+		}
+		return result;
+	}
+		
+	public class EventListener implements Subscription {
+		Class<Event> event;
+		Consumer<Event> listener;
+		
+		public EventListener(Class<Event> event, Consumer<Event> listener) {
+			this.event = event;
+			this.listener = listener;
+		}
+		
+		@Override
+		public void unsubscribe() { registerListener(event).removeListeners(listener); }
+		@Override
+		public Class<Event> type() { return event; }
+	}
+	
+	public static record MethodListener(MethodHandle handle) implements Consumer<Event> {
+		@Override
+		public void accept(Event t) {
+			try { handle.invoke(t); }
+			catch(Throwable e) { e.printStackTrace(); }
+		}
+		
+		@Override
+		public final String toString() {
+			MethodHandleInfo type = LOOKUP.revealDirect(handle);
+			return String.format("%s(%s)", type.getDeclaringClass().getCanonicalName(), String.join(", ", type.getMethodType().parameterList().stream().map(Class::getSimpleName).toList()));
+		}
+	}
+	
+	private void register(SubscribeEvent data, Object obj, List<Subscription> listeners) {
+		if(data == null || !(obj instanceof Consumer)) return;
+		validateType(data.value());
+		registerListener(data.value()).addListener(data.priority(), cast(obj));
+		listeners.add(new EventListener(castClass(data.value()), cast(obj)));
+	}
+	
+	private <T> void find(Class<?> clz, boolean superClasses, Function<Class<?>, T[]> mapper, Consumer<T> result) {
+		do {
+			for(T value : mapper.apply(clz)) result.accept(value);
+			clz = clz.getSuperclass();
+		}
+		while(clz != Object.class && superClasses);
+	}
+	
+	private void validateType(Class<? extends Event> type) {
+		if(checkType && !filter.test(type)) throw new IllegalStateException("Event ["+type.getSimpleName()+"] is not allowed with this EventBus");
+	}
+	
+	@SuppressWarnings("unchecked")
+	private <T> Consumer<T> cast(Object obj) {
+		return (Consumer<T>) obj;
+	}
+	
+	@SuppressWarnings("unchecked")
+	private <T> Class<T> castClass(Class<?> clz) {
+		return (Class<T>) clz;
+	}
+
+}

src/events/java/speiger/src/coreengine/core/events/bus/Subscriptions.java

@@ -0,0 +1,53 @@
+package speiger.src.coreengine.core.events.bus;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Consumer;
+
+import speiger.src.collections.objects.lists.ObjectArrayList;
+import speiger.src.coreengine.core.events.api.Event;
+import speiger.src.coreengine.core.events.api.EventPriority;
+import speiger.src.coreengine.core.events.utility.Subscription;
+
+public class Subscriptions {
+	List<Subscription> subscriptions = new ObjectArrayList<>();
+	EventBus owner;
+	
+	Subscriptions(EventBus owner) {
+		this.owner = owner;
+	}
+	
+	public <T extends Event> Subscriptions on(Class<T> clz, Consumer<T> event) {
+		return on(clz, EventPriority.MEDIUM, event);
+	}
+	
+	public <T extends Event> Subscriptions on(Class<T> clz, EventPriority priority, Consumer<T> event) {
+		subscriptions.add(owner.register(clz, priority, event));
+		return this;
+	}
+
+	public Subscriptions register(Object obj) {
+		subscriptions.addAll(owner.register(obj, false));
+		return this;
+	}
+	
+	public Subscriptions registerRecursive(Object obj) {
+		subscriptions.addAll(owner.register(obj, true));
+		return this;
+	}
+	
+	public void unsubscripe(Class<? extends Event> subType) {
+		for(Iterator<Subscription> iter = subscriptions.iterator();iter.hasNext();) {
+			Subscription sub = iter.next();
+			if(!Objects.equals(sub.type(), subType)) continue;
+			sub.unsubscribe();
+			iter.remove();
+		}
+	}
+	
+	public void unsubscibe() {
+		subscriptions.forEach(Subscription::unsubscribe);
+		subscriptions.clear();
+	}
+}

src/events/java/speiger/src/coreengine/core/events/utility/IEventDispatcher.java

@@ -0,0 +1,84 @@
+package speiger.src.coreengine.core.events.utility;
+
+import java.util.function.Consumer;
+
+import speiger.src.collections.objects.maps.impl.hash.Object2LongLinkedOpenHashMap;
+import speiger.src.collections.objects.maps.interfaces.Object2LongMap;
+import speiger.src.coreengine.core.events.api.Event;
+import speiger.src.coreengine.core.events.api.ICancelableEvent;
+
+public interface IEventDispatcher {
+	public static final IEventDispatcher DIRECT = new Direct();
+	
+	void post(Consumer<Event>[] listeners, Event toPost, IEventExceptionHandler exceptions);
+	
+	
+	public static class Direct implements IEventDispatcher {
+		@Override
+		public void post(Consumer<Event>[] listeners, Event toPost, IEventExceptionHandler exceptions) {
+			int index = 0;
+			try {
+				if(toPost instanceof ICancelableEvent cancelable) {
+					for(;index<listeners.length;index++) {
+						listeners[index].accept(toPost);
+						if(cancelable.isCanceled()) return;
+					}
+					return;
+				}
+				for(;index<listeners.length;index++) {
+					listeners[index].accept(toPost);					
+				}
+			}
+			catch(Throwable e) {
+				exceptions.handleException(toPost, listeners, index, e);
+			}
+		}
+	}
+	
+	public static class Profiled implements IEventDispatcher {
+		Consumer<ProfileOutput> output;
+		
+		public Profiled(Consumer<ProfileOutput> output) {
+			this.output = output;
+		}
+
+		@Override
+		@SuppressWarnings("unchecked")
+		public void post(Consumer<Event>[] listeners, Event toPost, IEventExceptionHandler exceptions) {
+			long start = 0L;
+			long[] results = new long[listeners.length];
+			int index = 0;
+			try {
+				if(toPost instanceof ICancelableEvent cancelable) {
+					for(;index<listeners.length;index++) {
+						long time = handle(listeners[index], toPost);
+						start += time;
+						results[index] = time;
+						if(cancelable.isCanceled()) return;
+					}
+					return;
+				}
+				for(;index<listeners.length;index++) {
+					long time = handle(listeners[index], toPost);
+					start += time;
+					results[index] = time;				
+				}
+			}
+			catch(Throwable e) {
+				exceptions.handleException(toPost, listeners, index, e);
+			}
+			finally {
+				output.accept(new ProfileOutput(start, (Class<Event>)toPost.getClass(), new Object2LongLinkedOpenHashMap<>(listeners, results)));
+			}
+		}
+		
+		private long handle(Consumer<Event> listener, Event event) {
+			long time = System.nanoTime();
+			listener.accept(event);
+			return System.nanoTime() - time;
+		}
+		
+	}
+	
+	public record ProfileOutput(long total, Class<Event> clz, Object2LongMap<Consumer<Event>> perEvent) {}
+}

src/events/java/speiger/src/coreengine/core/events/utility/IEventExceptionHandler.java

@@ -0,0 +1,9 @@
+package speiger.src.coreengine.core.events.utility;
+
+import java.util.function.Consumer;
+
+import speiger.src.coreengine.core.events.api.Event;
+
+public interface IEventExceptionHandler {
+	void handleException(Event event, Consumer<Event>[] listeners, int index, Throwable crash);
+}

src/events/java/speiger/src/coreengine/core/events/utility/Listeners.java

@@ -0,0 +1,88 @@
+package speiger.src.coreengine.core.events.utility;
+
+import java.util.List;
+import java.util.Set;
+import java.util.function.Consumer;
+
+import speiger.src.collections.objects.lists.ObjectArrayList;
+import speiger.src.collections.objects.sets.ObjectLinkedOpenHashSet;
+import speiger.src.coreengine.core.events.api.Event;
+import speiger.src.coreengine.core.events.api.EventPriority;
+
+public class Listeners
+{
+	@SuppressWarnings("unchecked")
+	Set<Consumer<Event>>[] unsortedListeners = new Set[EventPriority.getPriorities().length];
+	@SuppressWarnings("unchecked")
+	Consumer<Event>[] listeners = new Consumer[0];
+	boolean rebuild = true;
+	Listeners parent;
+	List<Listeners> childs = null;
+	
+	public Listeners() {
+		for(int i = 0;i<unsortedListeners.length;i++) {
+			unsortedListeners[i] = new ObjectLinkedOpenHashSet<Consumer<Event>>();
+		}
+	}
+	
+	public Listeners(Listeners parent) {
+		this();
+		this.parent = parent;
+		this.parent.addChild(this);
+	}
+	
+	public void addChild(Listeners listener) {
+		if(childs == null) childs = new ObjectArrayList<>();
+		childs.add(listener);
+	}
+	
+	public void addListener(EventPriority priority, Consumer<Event> listener) {
+		synchronized(unsortedListeners) {
+			if(unsortedListeners[priority.getPriority()].add(listener)) markDirty();			
+		}
+	}
+	
+	public void removeListeners(Consumer<Event> listener) {
+		synchronized(unsortedListeners) {
+			for(int i = 0,m=unsortedListeners.length;i<m;i++) {
+				if(unsortedListeners[i].remove(listener)) markDirty();
+			}			
+		}
+	}
+	
+	public void getListeners(EventPriority entry, List<Consumer<Event>> events) {
+		synchronized(unsortedListeners) {
+			events.addAll(unsortedListeners[entry.getPriority()]);			
+		}
+		if(parent != null) parent.getListeners(entry, events);
+	}
+	
+	public Consumer<Event>[] getListeners() {
+		if(rebuild) {
+			synchronized(this) {
+				if(rebuild) rebuildListeners();
+			}
+		}
+		return listeners;
+	}
+	
+	private void markDirty() {
+		if(rebuild) return;
+		rebuild = true;
+		if(childs != null) {
+			for(int i = 0,m=childs.size();i<m;i++) {
+				childs.get(i).markDirty();
+			}
+		}
+	}
+	
+	@SuppressWarnings("unchecked")
+	public void rebuildListeners() {
+		rebuild = false;
+		List<Consumer<Event>> result = new ObjectArrayList<>();
+		for(EventPriority entry : EventPriority.getPriorities()) {
+			getListeners(entry, result);
+		}
+		listeners = result.toArray(new Consumer[result.size()]);
+	}
+}

src/events/java/speiger/src/coreengine/core/events/utility/Subscription.java

@@ -0,0 +1,8 @@
+package speiger.src.coreengine.core.events.utility;
+
+import speiger.src.coreengine.core.events.api.Event;
+
+public interface Subscription {
+	void unsubscribe();
+	Class<Event> type();
+}

src/graphics/java/speiger/src/coreengine/graphics/api/buffer/states/IndeciesType.java

@@ -1,7 +0,0 @@
-package speiger.src.coreengine.graphics.api.buffer.states;
-
-public enum IndeciesType {
-	BYTE,
-	SHORT,
-	INT;
-}

src/graphics/java/speiger/src/coreengine/graphics/api/core/CommandBuffer.java

@@ -1,5 +0,0 @@
-package speiger.src.coreengine.graphics.api.core;
-
-public interface CommandBuffer {
-	int commandCount();
-}

src/graphics/java/speiger/src/coreengine/graphics/api/core/GraphicsDevice.java

@@ -1,30 +0,0 @@
-package speiger.src.coreengine.graphics.api.core;
-
-import java.util.List;
-
-import speiger.src.coreengine.graphics.api.buffer.VertexBuffer;
-import speiger.src.coreengine.graphics.api.buffer.states.BufferState;
-import speiger.src.coreengine.graphics.api.buffer.states.BufferType;
-import speiger.src.coreengine.graphics.api.compute.ComputePipeline;
-import speiger.src.coreengine.graphics.api.mesh.Mesh;
-import speiger.src.coreengine.graphics.api.sampler.Sampler;
-import speiger.src.coreengine.graphics.api.sampler.SamplerSettings;
-import speiger.src.coreengine.graphics.api.shader.ShaderPipeline;
-import speiger.src.coreengine.graphics.api.texture.Texture;
-import speiger.src.coreengine.graphics.api.texture.TextureSettings;
-import speiger.src.coreengine.graphics.api.utils.ExecutionType;
-import speiger.src.coreengine.input.window.Window;
-
-public interface GraphicsDevice {
-	Window window();
-	GraphicsSurface createSurface();
-	GraphicsCommandBuffer createCommandBuffer(ExecutionType type);
-	GraphicsCommandQueue queue();
-	VertexBuffer createBuffer(BufferType type, BufferState state);
-	VertexBuffer createBuffer(BufferType type, BufferState state, int allocatedBytes);
-	Texture createTexture(TextureSettings data, int width, int height);
-	Sampler createSampler(SamplerSettings settings);
-	Mesh createMesh(Mesh.Builder builder);
-	TimeQueryPool createQueryPool(int size);
-	void preloadPipelines(List<ShaderPipeline> graphics, List<ComputePipeline> compute);
-}

src/graphics/java/speiger/src/coreengine/graphics/api/core/GraphicsFence.java

@@ -1,7 +0,0 @@
-package speiger.src.coreengine.graphics.api.core;
-
-import speiger.src.coreengine.graphics.api.utils.GraphicsResource;
-
-public interface GraphicsFence extends GraphicsResource {
-	boolean awaitCompletion(long timeout);
-}

src/graphics/java/speiger/src/coreengine/graphics/api/shader/states/PolygonMode.java

@@ -1,7 +0,0 @@
-package speiger.src.coreengine.graphics.api.shader.states;
-
-public enum PolygonMode {
-	POINT,
-	LINE,
-	FILL;
-}

src/graphics/java/speiger/src/coreengine/graphics/api/shader/states/PrimitiveType.java

@@ -1,10 +0,0 @@
-package speiger.src.coreengine.graphics.api.shader.states;
-
-public enum PrimitiveType {
-	BYTE,
-	SHORT,
-	INT,
-	LONG,
-	FLOAT,
-	DOUBLE;
-}

src/graphics/java/speiger/src/coreengine/graphics/api/texture/states/StencilType.java

@@ -1,6 +0,0 @@
-package speiger.src.coreengine.graphics.api.texture.states;
-
-public enum StencilType {
-	GL_COMPARE_REF_TO_TEXTURE,
-	GL_NONE
-}

src/graphics/java/speiger/src/coreengine/graphics/api/texture/states/SwizzleMask.java

@@ -1,10 +0,0 @@
-package speiger.src.coreengine.graphics.api.texture.states;
-
-public enum SwizzleMask {
-	ZERO,
-	ONE,
-	RED,
-	GREEN,
-	BLUE,
-	ALPHA;
-}

src/graphics/java/speiger/src/coreengine/graphics/api/utils/AccessType.java

@@ -1,7 +0,0 @@
-package speiger.src.coreengine.graphics.api.utils;
-
-public enum AccessType {
-	READ,
-	WRITE,
-	BOTH;
-}

src/graphics/java/speiger/src/coreengine/graphics/api/utils/BufferOwner.java

@@ -1,6 +0,0 @@
-package speiger.src.coreengine.graphics.api.utils;
-
-public enum BufferOwner {
-	KEPT,
-	GIVEN;
-}

src/graphics/java/speiger/src/coreengine/graphics/api/utils/ExecutionType.java

@@ -1,6 +0,0 @@
-package speiger.src.coreengine.graphics.api.utils;
-
-public enum ExecutionType {
-	IMMEDIATE,
-	RECORDED;
-}

src/graphics/java/speiger/src/coreengine/platform/graphics/api/buffer/VertexBuffer.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.buffer;
+package speiger.src.coreengine.platform.graphics.api.buffer;
 
 import java.nio.Buffer;
 import java.nio.ByteBuffer;
@@ -8,10 +8,10 @@ import org.jspecify.annotations.NonNull;
 import org.lwjgl.system.MemoryUtil;
 
 import speiger.src.collections.ints.misc.pairs.IntObjectPair;
-import speiger.src.coreengine.graphics.api.buffer.states.BufferState;
+import speiger.src.coreengine.platform.graphics.api.buffer.states.BufferState;
-import speiger.src.coreengine.graphics.api.buffer.states.BufferType;
+import speiger.src.coreengine.platform.graphics.api.buffer.states.BufferType;
-import speiger.src.coreengine.graphics.api.utils.BufferOwner;
+import speiger.src.coreengine.platform.graphics.api.utils.BufferOwner;
-import speiger.src.coreengine.graphics.api.utils.GraphicsResource;
+import speiger.src.coreengine.platform.graphics.api.utils.GraphicsResource;
 
 public abstract class VertexBuffer implements GraphicsResource {
 	protected final BufferType type;

src/graphics/java/speiger/src/coreengine/platform/graphics/api/buffer/states/BufferState.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.buffer.states;
+package speiger.src.coreengine.platform.graphics.api.buffer.states;
 
 public enum BufferState {
 	STATIC_DRAW,

src/graphics/java/speiger/src/coreengine/platform/graphics/api/buffer/states/BufferType.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.buffer.states;
+package speiger.src.coreengine.platform.graphics.api.buffer.states;
 
 public enum BufferType {
 	ARRAY_BUFFER,

src/graphics/java/speiger/src/coreengine/platform/graphics/api/buffer/states/IndeciesType.java

@@ -0,0 +1,7 @@
+package speiger.src.coreengine.platform.graphics.api.buffer.states;
+
+public enum IndeciesType {
+	BYTE,
+	SHORT,
+	INT;
+}

src/graphics/java/speiger/src/coreengine/platform/graphics/api/compute/BarrierType.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.compute;
+package speiger.src.coreengine.platform.graphics.api.compute;
 
 public enum BarrierType {
 	MESH_BUFFER,

src/graphics/java/speiger/src/coreengine/platform/graphics/api/compute/ComputePipeline.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.compute;
+package speiger.src.coreengine.platform.graphics.api.compute;
 
 import java.util.List;
 import java.util.Objects;
@@ -6,11 +6,11 @@ import java.util.Objects;
 import speiger.src.collections.objects.lists.ObjectArrayList;
 import speiger.src.collections.objects.lists.ObjectList;
 import speiger.src.coreengine.assets.api.ID;
-import speiger.src.coreengine.graphics.api.shader.states.Bindings.BufferBinding;
+import speiger.src.coreengine.platform.graphics.api.shader.states.Bindings.BufferBinding;
-import speiger.src.coreengine.graphics.api.shader.states.Bindings.BufferMode;
+import speiger.src.coreengine.platform.graphics.api.shader.states.Bindings.BufferMode;
-import speiger.src.coreengine.graphics.api.shader.states.Bindings.TextureBinding;
+import speiger.src.coreengine.platform.graphics.api.shader.states.Bindings.TextureBinding;
-import speiger.src.coreengine.graphics.api.shader.states.Bindings.TextureMode;
+import speiger.src.coreengine.platform.graphics.api.shader.states.Bindings.TextureMode;
-import speiger.src.coreengine.graphics.api.texture.states.TextureType;
+import speiger.src.coreengine.platform.graphics.api.texture.states.TextureType;
 
 public record ComputePipeline(ID id, ID shader, List<BufferBinding> uniforms, List<TextureBinding> textures) {
 	

src/graphics/java/speiger/src/coreengine/platform/graphics/api/core/CommandBuffer.java

@@ -0,0 +1,5 @@
+package speiger.src.coreengine.platform.graphics.api.core;
+
+public interface CommandBuffer {
+	int commandCount();
+}

src/graphics/java/speiger/src/coreengine/platform/graphics/api/core/ComputeCommandBuffer.java

@@ -1,12 +1,12 @@
-package speiger.src.coreengine.graphics.api.core;
+package speiger.src.coreengine.platform.graphics.api.core;
 
-import speiger.src.coreengine.graphics.api.buffer.VertexBuffer;
+import speiger.src.coreengine.platform.graphics.api.buffer.VertexBuffer;
-import speiger.src.coreengine.graphics.api.compute.BarrierType;
+import speiger.src.coreengine.platform.graphics.api.compute.BarrierType;
-import speiger.src.coreengine.graphics.api.compute.ComputePipeline;
+import speiger.src.coreengine.platform.graphics.api.compute.ComputePipeline;
-import speiger.src.coreengine.graphics.api.sampler.Sampler;
+import speiger.src.coreengine.platform.graphics.api.sampler.Sampler;
-import speiger.src.coreengine.graphics.api.texture.Texture;
+import speiger.src.coreengine.platform.graphics.api.texture.Texture;
-import speiger.src.coreengine.graphics.api.utils.AccessType;
+import speiger.src.coreengine.platform.graphics.api.utils.AccessType;
-import speiger.src.coreengine.graphics.api.utils.GraphicsResource;
+import speiger.src.coreengine.platform.graphics.api.utils.GraphicsResource;
 
 public interface ComputeCommandBuffer extends GraphicsResource, CommandBuffer {
 	ComputeCommandBuffer begin();

src/graphics/java/speiger/src/coreengine/platform/graphics/api/core/Graphics.java

@@ -1,6 +1,6 @@
-package speiger.src.coreengine.graphics.api.core;
+package speiger.src.coreengine.platform.graphics.api.core;
 
-import speiger.src.coreengine.input.window.Window;
+import speiger.src.coreengine.platform.input.window.Window;
 
 public interface Graphics {
 	public String getName();

src/graphics/java/speiger/src/coreengine/platform/graphics/api/core/GraphicsCommandBuffer.java

@@ -1,12 +1,12 @@
-package speiger.src.coreengine.graphics.api.core;
+package speiger.src.coreengine.platform.graphics.api.core;
 
-import speiger.src.coreengine.graphics.api.buffer.VertexBuffer;
+import speiger.src.coreengine.platform.graphics.api.buffer.VertexBuffer;
-import speiger.src.coreengine.graphics.api.mesh.Mesh;
+import speiger.src.coreengine.platform.graphics.api.mesh.Mesh;
-import speiger.src.coreengine.graphics.api.sampler.Sampler;
+import speiger.src.coreengine.platform.graphics.api.sampler.Sampler;
-import speiger.src.coreengine.graphics.api.shader.ShaderPipeline;
+import speiger.src.coreengine.platform.graphics.api.shader.ShaderPipeline;
-import speiger.src.coreengine.graphics.api.texture.Texture;
+import speiger.src.coreengine.platform.graphics.api.texture.Texture;
-import speiger.src.coreengine.graphics.api.utils.AccessType;
+import speiger.src.coreengine.platform.graphics.api.utils.AccessType;
-import speiger.src.coreengine.graphics.api.utils.GraphicsResource;
+import speiger.src.coreengine.platform.graphics.api.utils.GraphicsResource;
 
 public interface GraphicsCommandBuffer extends GraphicsResource, CommandBuffer {
 	GraphicsCommandBuffer begin();

src/graphics/java/speiger/src/coreengine/platform/graphics/api/core/GraphicsCommandQueue.java

@@ -1,11 +1,11 @@
-package speiger.src.coreengine.graphics.api.core;
+package speiger.src.coreengine.platform.graphics.api.core;
 
-import speiger.src.coreengine.graphics.api.shader.states.GraphicsDataType;
-import speiger.src.coreengine.graphics.api.target.RenderTarget;
-import speiger.src.coreengine.graphics.api.texture.Texture;
-import speiger.src.coreengine.graphics.api.texture.states.TextureFormat;
-import speiger.src.coreengine.graphics.api.utils.PushableResource;
 import speiger.src.coreengine.math.vector.floats.Vec4f;
+import speiger.src.coreengine.platform.graphics.api.shader.states.GraphicsDataType;
+import speiger.src.coreengine.platform.graphics.api.target.RenderTarget;
+import speiger.src.coreengine.platform.graphics.api.texture.Texture;
+import speiger.src.coreengine.platform.graphics.api.texture.states.TextureFormat;
+import speiger.src.coreengine.platform.graphics.api.utils.PushableResource;
 
 public interface GraphicsCommandQueue {
 	public static final int CLEAR_COLOR = 1;

src/graphics/java/speiger/src/coreengine/platform/graphics/api/core/GraphicsDevice.java

@@ -0,0 +1,31 @@
+package speiger.src.coreengine.platform.graphics.api.core;
+
+import java.util.List;
+
+import speiger.src.coreengine.platform.graphics.api.buffer.VertexBuffer;
+import speiger.src.coreengine.platform.graphics.api.buffer.states.BufferState;
+import speiger.src.coreengine.platform.graphics.api.buffer.states.BufferType;
+import speiger.src.coreengine.platform.graphics.api.compute.ComputePipeline;
+import speiger.src.coreengine.platform.graphics.api.mesh.Mesh;
+import speiger.src.coreengine.platform.graphics.api.sampler.Sampler;
+import speiger.src.coreengine.platform.graphics.api.sampler.SamplerSettings;
+import speiger.src.coreengine.platform.graphics.api.shader.ShaderPipeline;
+import speiger.src.coreengine.platform.graphics.api.texture.Texture;
+import speiger.src.coreengine.platform.graphics.api.texture.TextureSettings;
+import speiger.src.coreengine.platform.graphics.api.utils.ExecutionType;
+import speiger.src.coreengine.platform.input.window.Window;
+
+public interface GraphicsDevice {
+	public static final ScopedValue<GraphicsDevice> SCOPE = ScopedValue.newInstance();
+	Window window();
+	GraphicsSurface createSurface();
+	GraphicsCommandBuffer createCommandBuffer(ExecutionType type);
+	GraphicsCommandQueue queue();
+	VertexBuffer createBuffer(BufferType type, BufferState state);
+	VertexBuffer createBuffer(BufferType type, BufferState state, int allocatedBytes);
+	Texture createTexture(TextureSettings data, int width, int height);
+	Sampler createSampler(SamplerSettings settings);
+	Mesh createMesh(Mesh.Builder builder);
+	TimeQueryPool createQueryPool(int size);
+	void preloadPipelines(List<ShaderPipeline> graphics, List<ComputePipeline> compute);
+}

src/graphics/java/speiger/src/coreengine/platform/graphics/api/core/GraphicsFence.java

@@ -0,0 +1,7 @@
+package speiger.src.coreengine.platform.graphics.api.core;
+
+import speiger.src.coreengine.platform.graphics.api.utils.GraphicsResource;
+
+public interface GraphicsFence extends GraphicsResource {
+	boolean awaitCompletion(long timeout);
+}

src/graphics/java/speiger/src/coreengine/platform/graphics/api/core/GraphicsSurface.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.core;
+package speiger.src.coreengine.platform.graphics.api.core;
 
 public interface GraphicsSurface {
 	public void setVsync(boolean value);

src/graphics/java/speiger/src/coreengine/platform/graphics/api/core/TimeQueryPool.java

@@ -1,8 +1,8 @@
-package speiger.src.coreengine.graphics.api.core;
+package speiger.src.coreengine.platform.graphics.api.core;
 
 import java.util.OptionalLong;
 
-import speiger.src.coreengine.graphics.api.utils.GraphicsResource;
+import speiger.src.coreengine.platform.graphics.api.utils.GraphicsResource;
 
 public interface TimeQueryPool extends GraphicsResource {
 	public int size();

src/graphics/java/speiger/src/coreengine/platform/graphics/api/mesh/Mesh.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.mesh;
+package speiger.src.coreengine.platform.graphics.api.mesh;
 
 import java.util.Objects;
 import java.util.OptionalInt;
@@ -7,11 +7,11 @@ import org.jspecify.annotations.Nullable;
 
 import speiger.src.collections.ints.maps.impl.hash.Int2ObjectOpenHashMap;
 import speiger.src.collections.ints.maps.interfaces.Int2ObjectMap;
-import speiger.src.coreengine.graphics.api.buffer.VertexBuffer;
+import speiger.src.coreengine.platform.graphics.api.buffer.VertexBuffer;
-import speiger.src.coreengine.graphics.api.buffer.states.BufferState;
+import speiger.src.coreengine.platform.graphics.api.buffer.states.BufferState;
-import speiger.src.coreengine.graphics.api.buffer.states.IndeciesType;
+import speiger.src.coreengine.platform.graphics.api.buffer.states.IndeciesType;
-import speiger.src.coreengine.graphics.api.utils.GraphicsResource;
+import speiger.src.coreengine.platform.graphics.api.utils.GraphicsResource;
-import speiger.src.coreengine.graphics.api.vertex.VertexLayout;
+import speiger.src.coreengine.platform.graphics.api.vertex.VertexLayout;
 
 public abstract class Mesh implements GraphicsResource {
 	protected final Int2ObjectMap<LayoutInfo> layouts;

src/graphics/java/speiger/src/coreengine/platform/graphics/api/sampler/Sampler.java

@@ -1,6 +1,6 @@
-package speiger.src.coreengine.graphics.api.sampler;
+package speiger.src.coreengine.platform.graphics.api.sampler;
 
-import speiger.src.coreengine.graphics.api.utils.GraphicsResource;
+import speiger.src.coreengine.platform.graphics.api.utils.GraphicsResource;
 
 public abstract class Sampler implements GraphicsResource {
 	protected SamplerSettings settings;

src/graphics/java/speiger/src/coreengine/platform/graphics/api/sampler/SamplerSettings.java

@@ -1,10 +1,10 @@
-package speiger.src.coreengine.graphics.api.sampler;
+package speiger.src.coreengine.platform.graphics.api.sampler;
 
 import java.util.Objects;
 import java.util.Optional;
 
-import speiger.src.coreengine.graphics.api.sampler.states.BorderMode;
+import speiger.src.coreengine.platform.graphics.api.sampler.states.BorderMode;
-import speiger.src.coreengine.graphics.api.sampler.states.SampleMode;
+import speiger.src.coreengine.platform.graphics.api.sampler.states.SampleMode;
 
 public record SamplerSettings(BorderMode wrapS, BorderMode wrapT, Optional<BorderMode> wrapR, SampleMode minSample, SampleMode magSample) {
 	

src/graphics/java/speiger/src/coreengine/platform/graphics/api/sampler/states/BorderMode.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.sampler.states;
+package speiger.src.coreengine.platform.graphics.api.sampler.states;
 
 public enum BorderMode {
 	CLAMP_TO_EDGE, 

src/graphics/java/speiger/src/coreengine/platform/graphics/api/sampler/states/SampleMode.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.sampler.states;
+package speiger.src.coreengine.platform.graphics.api.sampler.states;
 
 public enum SampleMode {
 	NEAREST,

src/graphics/java/speiger/src/coreengine/platform/graphics/api/shader/BufferAttribute.java

@@ -1,8 +1,8 @@
-package speiger.src.coreengine.graphics.api.shader;
+package speiger.src.coreengine.platform.graphics.api.shader;
 
 import java.util.Objects;
 
-import speiger.src.coreengine.graphics.api.shader.states.GraphicsDataType;
+import speiger.src.coreengine.platform.graphics.api.shader.states.GraphicsDataType;
 
 public record BufferAttribute(String name, int index, int size, GraphicsDataType type, boolean normal) {
 	public BufferAttribute {

src/graphics/java/speiger/src/coreengine/platform/graphics/api/shader/ColorTarget.java

@@ -1,9 +1,9 @@
-package speiger.src.coreengine.graphics.api.shader;
+package speiger.src.coreengine.platform.graphics.api.shader;
 
 import java.util.Objects;
 import java.util.Optional;
 
-import speiger.src.coreengine.graphics.api.shader.states.BlendFunction;
+import speiger.src.coreengine.platform.graphics.api.shader.states.BlendFunction;
 
 public record ColorTarget(Optional<BlendFunction> blend, int writeMask) {
     public static final int RED = 1;

src/graphics/java/speiger/src/coreengine/platform/graphics/api/shader/DepthTarget.java

@@ -1,8 +1,8 @@
-package speiger.src.coreengine.graphics.api.shader;
+package speiger.src.coreengine.platform.graphics.api.shader;
 
 import java.util.Objects;
 
-import speiger.src.coreengine.graphics.api.utils.AlphaFunction;
+import speiger.src.coreengine.platform.graphics.api.utils.AlphaFunction;
 
 public record DepthTarget(boolean enabled, AlphaFunction function, boolean write) {
 	public static final DepthTarget DEFAULT = new DepthTarget(true, AlphaFunction.GEQUAL, true);

src/graphics/java/speiger/src/coreengine/platform/graphics/api/shader/RasterizerState.java

@@ -1,9 +1,9 @@
-package speiger.src.coreengine.graphics.api.shader;
+package speiger.src.coreengine.platform.graphics.api.shader;
 
 import java.util.Objects;
 
-import speiger.src.coreengine.graphics.api.shader.states.DrawMode;
+import speiger.src.coreengine.platform.graphics.api.shader.states.DrawMode;
-import speiger.src.coreengine.graphics.api.shader.states.PolygonMode;
+import speiger.src.coreengine.platform.graphics.api.shader.states.PolygonMode;
 
 public record RasterizerState(DrawMode mode, PolygonMode fillMode, boolean cullBack) {
 	public static final RasterizerState DEFAULT = new RasterizerState(DrawMode.TRIANGLES, PolygonMode.FILL, true);

src/graphics/java/speiger/src/coreengine/platform/graphics/api/shader/ShaderPipeline.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.shader;
+package speiger.src.coreengine.platform.graphics.api.shader;
 
 import java.util.Collections;
 import java.util.EnumMap;
@@ -9,15 +9,15 @@ import java.util.Objects;
 import speiger.src.collections.objects.lists.ObjectArrayList;
 import speiger.src.collections.objects.lists.ObjectList;
 import speiger.src.coreengine.assets.api.ID;
-import speiger.src.coreengine.graphics.api.shader.states.Bindings.BufferMode;
+import speiger.src.coreengine.platform.graphics.api.shader.states.DrawMode;
-import speiger.src.coreengine.graphics.api.shader.states.Bindings.TextureBinding;
+import speiger.src.coreengine.platform.graphics.api.shader.states.PolygonMode;
-import speiger.src.coreengine.graphics.api.shader.states.Bindings.TextureMode;
+import speiger.src.coreengine.platform.graphics.api.shader.states.ShaderType;
-import speiger.src.coreengine.graphics.api.shader.states.Bindings.BufferBinding;
+import speiger.src.coreengine.platform.graphics.api.shader.states.Bindings.BufferBinding;
-import speiger.src.coreengine.graphics.api.shader.states.DrawMode;
+import speiger.src.coreengine.platform.graphics.api.shader.states.Bindings.BufferMode;
-import speiger.src.coreengine.graphics.api.shader.states.PolygonMode;
+import speiger.src.coreengine.platform.graphics.api.shader.states.Bindings.TextureBinding;
-import speiger.src.coreengine.graphics.api.shader.states.ShaderType;
+import speiger.src.coreengine.platform.graphics.api.shader.states.Bindings.TextureMode;
-import speiger.src.coreengine.graphics.api.texture.states.TextureType;
+import speiger.src.coreengine.platform.graphics.api.texture.states.TextureType;
-import speiger.src.coreengine.graphics.api.vertex.VertexLayout;
+import speiger.src.coreengine.platform.graphics.api.vertex.VertexLayout;
 
 public record ShaderPipeline(ID id, Map<ShaderType, ID> shaders, List<VertexBinding> attributes, List<BufferBinding> uniforms, List<TextureBinding> textures, RasterizerState rasterizer, ColorTarget colorTarget, DepthTarget depthTarget) {
 	

src/graphics/java/speiger/src/coreengine/platform/graphics/api/shader/VertexBinding.java

@@ -1,8 +1,8 @@
-package speiger.src.coreengine.graphics.api.shader;
+package speiger.src.coreengine.platform.graphics.api.shader;
 
 import speiger.src.collections.objects.collections.ObjectIterable;
-import speiger.src.coreengine.graphics.api.vertex.VertexLayout;
+import speiger.src.coreengine.platform.graphics.api.vertex.VertexLayout;
-import speiger.src.coreengine.graphics.api.vertex.VertexLayout.Element;
+import speiger.src.coreengine.platform.graphics.api.vertex.VertexLayout.Element;
 
 public record VertexBinding(int bindingIndex, VertexLayout layout, int instanceOffset) {
 	public ObjectIterable<Element> elements() {

src/graphics/java/speiger/src/coreengine/platform/graphics/api/shader/states/Bindings.java

@@ -1,8 +1,8 @@
-package speiger.src.coreengine.graphics.api.shader.states;
+package speiger.src.coreengine.platform.graphics.api.shader.states;
 
 import java.util.Objects;
 
-import speiger.src.coreengine.graphics.api.texture.states.TextureType;
+import speiger.src.coreengine.platform.graphics.api.texture.states.TextureType;
 
 public class Bindings {
 	public record BufferBinding(String name, int binding, int slot, int bytes, BufferMode mode) {

src/graphics/java/speiger/src/coreengine/platform/graphics/api/shader/states/BlendFactor.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.shader.states;
+package speiger.src.coreengine.platform.graphics.api.shader.states;
 
 public enum BlendFactor {
 	ZERO,

src/graphics/java/speiger/src/coreengine/platform/graphics/api/shader/states/BlendFunction.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.shader.states;
+package speiger.src.coreengine.platform.graphics.api.shader.states;
 
 public record BlendFunction(BlendFactor colorSource, BlendFactor alphaSource, BlendFactor colorTarget, BlendFactor alphaTarget) {
 	public static final BlendFunction DEFAULT = new BlendFunction(BlendFactor.ONE, BlendFactor.ZERO);

src/graphics/java/speiger/src/coreengine/platform/graphics/api/shader/states/DrawMode.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.shader.states;
+package speiger.src.coreengine.platform.graphics.api.shader.states;
 
 public enum DrawMode {
 	POINT(1),

src/graphics/java/speiger/src/coreengine/platform/graphics/api/shader/states/GraphicsDataType.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.shader.states;
+package speiger.src.coreengine.platform.graphics.api.shader.states;
 
 public enum GraphicsDataType {
 	BYTE("byte", 1, PrimitiveType.BYTE),

src/graphics/java/speiger/src/coreengine/platform/graphics/api/shader/states/PolygonMode.java

@@ -0,0 +1,7 @@
+package speiger.src.coreengine.platform.graphics.api.shader.states;
+
+public enum PolygonMode {
+	POINT,
+	LINE,
+	FILL;
+}

src/graphics/java/speiger/src/coreengine/platform/graphics/api/shader/states/PrimitiveType.java

@@ -0,0 +1,10 @@
+package speiger.src.coreengine.platform.graphics.api.shader.states;
+
+public enum PrimitiveType {
+	BYTE,
+	SHORT,
+	INT,
+	LONG,
+	FLOAT,
+	DOUBLE;
+}

src/graphics/java/speiger/src/coreengine/platform/graphics/api/shader/states/ShaderType.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.shader.states;
+package speiger.src.coreengine.platform.graphics.api.shader.states;
 
 public enum ShaderType {
 	VERTEX,

src/graphics/java/speiger/src/coreengine/platform/graphics/api/target/RenderTarget.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.target;
+package speiger.src.coreengine.platform.graphics.api.target;
 
 public sealed interface RenderTarget permits ScreenTarget, TextureTarget {
 }

src/graphics/java/speiger/src/coreengine/platform/graphics/api/target/ScreenTarget.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.target;
+package speiger.src.coreengine.platform.graphics.api.target;
 
 public final class ScreenTarget implements RenderTarget {
 	public static final ScreenTarget INSTANCE = new ScreenTarget();

src/graphics/java/speiger/src/coreengine/platform/graphics/api/target/TextureTarget.java

@@ -1,8 +1,8 @@
-package speiger.src.coreengine.graphics.api.target;
+package speiger.src.coreengine.platform.graphics.api.target;
 
 import speiger.src.coreengine.assets.api.ID;
-import speiger.src.coreengine.graphics.api.texture.Texture;
+import speiger.src.coreengine.platform.graphics.api.texture.Texture;
-import speiger.src.coreengine.graphics.api.texture.states.TextureType;
+import speiger.src.coreengine.platform.graphics.api.texture.states.TextureType;
 
 public record TextureTarget(ID id, Texture color, Texture depth) implements RenderTarget {
 	public TextureTarget {

src/graphics/java/speiger/src/coreengine/platform/graphics/api/texture/Texture.java

@@ -1,6 +1,6 @@
-package speiger.src.coreengine.graphics.api.texture;
+package speiger.src.coreengine.platform.graphics.api.texture;
 
-import speiger.src.coreengine.graphics.api.utils.GraphicsResource;
+import speiger.src.coreengine.platform.graphics.api.utils.GraphicsResource;
 
 public abstract class Texture implements GraphicsResource {
 	final TextureSettings settings;

src/graphics/java/speiger/src/coreengine/platform/graphics/api/texture/TextureSettings.java

@@ -1,14 +1,14 @@
-package speiger.src.coreengine.graphics.api.texture;
+package speiger.src.coreengine.platform.graphics.api.texture;
 
 import java.util.Objects;
 import java.util.Optional;
 import java.util.OptionalInt;
 
 import speiger.src.collections.objects.lists.ImmutableObjectList;
-import speiger.src.coreengine.graphics.api.texture.states.StencilType;
+import speiger.src.coreengine.platform.graphics.api.texture.states.StencilType;
-import speiger.src.coreengine.graphics.api.texture.states.SwizzleMask;
+import speiger.src.coreengine.platform.graphics.api.texture.states.SwizzleMask;
-import speiger.src.coreengine.graphics.api.texture.states.TextureFormat;
+import speiger.src.coreengine.platform.graphics.api.texture.states.TextureFormat;
-import speiger.src.coreengine.graphics.api.texture.states.TextureType;
+import speiger.src.coreengine.platform.graphics.api.texture.states.TextureType;
 
 public record TextureSettings(TextureType type, TextureFormat internal, boolean generateMipmapping, OptionalInt baseLevel, OptionalInt maxLevel, ImmutableObjectList<Optional<SwizzleMask>> swizzle, Optional<StencilType> stencilType) {
 	

src/graphics/java/speiger/src/coreengine/platform/graphics/api/texture/drawable/Drawable.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.texture.drawable;
+package speiger.src.coreengine.platform.graphics.api.texture.drawable;
 
 import java.nio.ByteBuffer;
 import java.util.Objects;
@@ -12,11 +12,11 @@ import org.lwjgl.util.freetype.FT_Face;
 import org.lwjgl.util.freetype.FT_GlyphSlot;
 import org.lwjgl.util.freetype.FreeType;
 
-import speiger.src.coreengine.graphics.api.core.GraphicsCommandQueue;
-import speiger.src.coreengine.graphics.api.shader.states.GraphicsDataType;
-import speiger.src.coreengine.graphics.api.texture.Texture;
-import speiger.src.coreengine.graphics.api.texture.states.TextureFormat;
 import speiger.src.coreengine.math.color.ColorSpaces;
+import speiger.src.coreengine.platform.graphics.api.core.GraphicsCommandQueue;
+import speiger.src.coreengine.platform.graphics.api.shader.states.GraphicsDataType;
+import speiger.src.coreengine.platform.graphics.api.texture.Texture;
+import speiger.src.coreengine.platform.graphics.api.texture.states.TextureFormat;
 
 public class Drawable implements IDrawable, AutoCloseable {
 	TextureFormat format;

src/graphics/java/speiger/src/coreengine/platform/graphics/api/texture/drawable/IDrawable.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.texture.drawable;
+package speiger.src.coreengine.platform.graphics.api.texture.drawable;
 
 import speiger.src.coreengine.math.color.ColorSpaces;
 

src/graphics/java/speiger/src/coreengine/platform/graphics/api/texture/states/StencilType.java

@@ -0,0 +1,6 @@
+package speiger.src.coreengine.platform.graphics.api.texture.states;
+
+public enum StencilType {
+	GL_COMPARE_REF_TO_TEXTURE,
+	GL_NONE
+}

src/graphics/java/speiger/src/coreengine/platform/graphics/api/texture/states/SwizzleMask.java

@@ -0,0 +1,10 @@
+package speiger.src.coreengine.platform.graphics.api.texture.states;
+
+public enum SwizzleMask {
+	ZERO,
+	ONE,
+	RED,
+	GREEN,
+	BLUE,
+	ALPHA;
+}

src/graphics/java/speiger/src/coreengine/platform/graphics/api/texture/states/TextureFormat.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.texture.states;
+package speiger.src.coreengine.platform.graphics.api.texture.states;
 
 public enum TextureFormat {
 	R(1, 0, -1, -1, -1),

src/graphics/java/speiger/src/coreengine/platform/graphics/api/texture/states/TextureType.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.texture.states;
+package speiger.src.coreengine.platform.graphics.api.texture.states;
 
 public enum TextureType {
 	TEXTURE_1D,

src/graphics/java/speiger/src/coreengine/platform/graphics/api/utils/AccessType.java

@@ -0,0 +1,7 @@
+package speiger.src.coreengine.platform.graphics.api.utils;
+
+public enum AccessType {
+	READ,
+	WRITE,
+	BOTH;
+}

src/graphics/java/speiger/src/coreengine/platform/graphics/api/utils/AlphaFunction.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.utils;
+package speiger.src.coreengine.platform.graphics.api.utils;
 
 public enum AlphaFunction {
     NEVER,

src/graphics/java/speiger/src/coreengine/platform/graphics/api/utils/BufferOwner.java

@@ -0,0 +1,6 @@
+package speiger.src.coreengine.platform.graphics.api.utils;
+
+public enum BufferOwner {
+	KEPT,
+	GIVEN;
+}

src/graphics/java/speiger/src/coreengine/platform/graphics/api/utils/ExecutionType.java

@@ -0,0 +1,6 @@
+package speiger.src.coreengine.platform.graphics.api.utils;
+
+public enum ExecutionType {
+	IMMEDIATE,
+	RECORDED;
+}

src/graphics/java/speiger/src/coreengine/platform/graphics/api/utils/GraphicsResource.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.utils;
+package speiger.src.coreengine.platform.graphics.api.utils;
 
 public interface GraphicsResource extends AutoCloseable {
 	public boolean isRemoved();

src/graphics/java/speiger/src/coreengine/platform/graphics/api/utils/PushableResource.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.utils;
+package speiger.src.coreengine.platform.graphics.api.utils;
 
 public interface PushableResource extends AutoCloseable {
 	@Override

src/graphics/java/speiger/src/coreengine/platform/graphics/api/utils/ScissorsManager.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.utils;
+package speiger.src.coreengine.platform.graphics.api.utils;
 
 import java.util.Objects;
 

src/graphics/java/speiger/src/coreengine/platform/graphics/api/vertex/VertexLayout.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.api.vertex;
+package speiger.src.coreengine.platform.graphics.api.vertex;
 
 import java.util.Objects;
 
@@ -10,8 +10,8 @@ import speiger.src.collections.objects.lists.ObjectArrayList;
 import speiger.src.collections.objects.lists.ObjectList;
 import speiger.src.collections.objects.maps.interfaces.Object2ObjectMap;
 import speiger.src.collections.objects.utils.ObjectIterators;
-import speiger.src.coreengine.graphics.api.shader.states.GraphicsDataType;
+import speiger.src.coreengine.platform.graphics.api.shader.states.GraphicsDataType;
-import speiger.src.coreengine.graphics.api.vertex.VertexLayout.Element;
+import speiger.src.coreengine.platform.graphics.api.vertex.VertexLayout.Element;
 
 public class VertexLayout implements ObjectIterable<Element> {
 	Object2ObjectMap<String, Element> mapped = Object2ObjectMap.builder().linkedMap();

src/graphics/java/speiger/src/coreengine/platform/graphics/api/vertex/builder/IVertexBuffer.java

@@ -0,0 +1,53 @@
+package speiger.src.coreengine.platform.graphics.api.vertex.builder;
+
+import java.util.List;
+
+import speiger.src.coreengine.math.vector.matrix.Matrix4f;
+import speiger.src.coreengine.platform.graphics.api.shader.states.DrawMode;
+import speiger.src.coreengine.platform.graphics.api.shader.states.GraphicsDataType;
+import speiger.src.coreengine.platform.graphics.api.vertex.VertexLayout.Element;
+import speiger.src.coreengine.platform.graphics.api.vertex.VertexLayout.Usage;
+
+public interface IVertexBuffer extends IVertexBuilder {
+	Element current();
+	IVertexBuffer next();
+	IVertexBuffer finish();
+	List<BufferResult> results();
+	default IVertexBuffer validate(Usage usage, GraphicsDataType type, int size) { return validate(this, usage, type, size); }
+	
+	
+	IVertexBuffer put(int byteOffset, byte value);
+	IVertexBuffer putShort(int byteOffset, short value);
+	IVertexBuffer putInt(int byteOffset, int value);
+	IVertexBuffer putFloat(int byteOffset, float value);
+	
+	int vertecies();
+	
+	@Override
+	default IVertexBuffer pos(float x, float y) { return validate(Usage.POS, GraphicsDataType.FLOAT, 2).putFloat(0, x).putFloat(4, y).next(); }
+	@Override
+	default IVertexBuffer pos(float x, float y, float z) { return validate(Usage.POS, GraphicsDataType.FLOAT, 3).putFloat(0, x).putFloat(4, y).putFloat(8, z).next(); }
+	@Override
+	default IVertexBuffer rgb(int r, int g, int b) { return validate(Usage.COLOR, GraphicsDataType.UNSIGNED_BYTE, 3).put(0, (byte)r).put(1, (byte)g).put(2, (byte)b).next(); }
+	@Override
+	default IVertexBuffer rgba(int r, int g, int b, int a) { return validate(Usage.COLOR, GraphicsDataType.UNSIGNED_BYTE, 4).put(0, (byte)r).put(1, (byte)g).put(2, (byte)b).put(3, (byte)a).next(); }
+	@Override
+	default IVertexBuffer tex(float u, float v) { return validate(Usage.UV, GraphicsDataType.FLOAT, 2).putFloat(0, u).putFloat(4, v).next(); }
+	@Override
+	default IVertexBuffer normal(float x, float y, float z) { return validate(Usage.NORMAL, GraphicsDataType.FLOAT, 3).putFloat(0, x).putFloat(4, y).putFloat(8, z).next(); }
+	default IVertexBuffer matrix(Matrix4f mat) {
+		validate(Usage.MATRIX, GraphicsDataType.FLOAT, 16);
+		for(int i = 0;i<16;i++) {
+			putFloat(i*4, mat.get(i));
+		}
+		return next();
+	}
+	
+	static IVertexBuffer validate(IVertexBuffer builder, Usage usage, GraphicsDataType type, int size) {
+		Element current = builder.current();
+		if(current.size() == size && current.usage() == usage && current.type() == type) return builder;
+		throw new IllegalStateException("Expected State [Usage="+current.usage()+", Size="+current.size()+", Type="+current.type()+"], wasn't present. Actual State [Usage="+usage+", Size="+size+", Type="+type+"]");
+	}
+	
+	public record BufferResult(DrawMode mode, int startVertex, int endVertex) {}
+}

src/graphics/java/speiger/src/coreengine/platform/graphics/api/vertex/builder/IVertexBuilder.java

@@ -0,0 +1,16 @@
+package speiger.src.coreengine.platform.graphics.api.vertex.builder;
+
+import speiger.src.coreengine.math.color.ColorUtils;
+
+public interface IVertexBuilder {
+	IVertexBuffer pos(float x, float y);
+	IVertexBuffer pos(float x, float y, float z);
+	
+	default IVertexBuffer rgb(int color) { return rgb(ColorUtils.getR(color), ColorUtils.getG(color), ColorUtils.getB(color)); }
+	IVertexBuffer rgb(int r, int g, int b);
+	default IVertexBuffer rgba(int color) { return rgba(ColorUtils.getR(color), ColorUtils.getG(color), ColorUtils.getB(color), ColorUtils.getA(color)); }
+	IVertexBuffer rgba(int r, int g, int b, int a);
+	
+	IVertexBuffer tex(float u, float v);
+	IVertexBuffer normal(float x, float y, float z);
+}

src/graphics/java/speiger/src/coreengine/platform/graphics/api/vertex/builder/VertexBuilder.java

@@ -0,0 +1,177 @@
+package speiger.src.coreengine.platform.graphics.api.vertex.builder;
+
+import java.nio.ByteBuffer;
+import java.util.List;
+
+import org.lwjgl.system.MemoryUtil;
+
+import speiger.src.collections.objects.lists.ObjectArrayList;
+import speiger.src.collections.objects.lists.ObjectList;
+import speiger.src.collections.objects.utils.ObjectLists;
+import speiger.src.coreengine.platform.graphics.api.shader.states.DrawMode;
+import speiger.src.coreengine.platform.graphics.api.vertex.VertexLayout;
+import speiger.src.coreengine.platform.graphics.api.vertex.VertexLayout.Element;
+
+public class VertexBuilder implements IVertexBuffer, AutoCloseable {
+	boolean noFree = false;
+	DrawMode mode;
+	ByteBuffer buffer;
+	VertexLayout layout;
+	int vertecies;
+	int index;
+	
+	int totalStoredBytes;
+	int vertexBytes;
+	int elementBytes;
+	int lastVertecies = 0;
+	ObjectList<BufferResult> results;
+	
+	public VertexBuilder(int size) {
+		this(MemoryUtil.memAlloc(size));
+	}
+	
+	public VertexBuilder(ByteBuffer buffer) {
+		this.buffer = buffer;
+	}
+	
+	public VertexBuilder withoutFree() {
+		noFree = true;
+		return this;
+	}
+	
+	public VertexBuilder start(DrawMode mode, VertexLayout layout) {
+		this.mode = mode;
+		this.layout = layout;
+		return this;
+	}
+	
+	public VertexBuilder reset() {
+		index = 0;
+		vertecies = 0;
+		elementBytes = 0;
+		totalStoredBytes = 0;
+		vertexBytes = 0;
+		lastVertecies = 0;
+		results = null;
+		return this;
+	}
+	
+	public boolean is(DrawMode mode, VertexLayout layout) { return this.mode == mode && this.layout == layout; }
+	public DrawMode mode() { return mode; }
+	public VertexLayout getFormat() { return layout; }
+	
+	@Override
+	public void close() {
+		if(buffer == null || !buffer.isDirect()) return;
+		if(!noFree) MemoryUtil.memFree(buffer);
+		buffer = null;
+	}
+	
+	@Override
+	public Element current() {
+		return layout.get(index);
+	}
+	
+	@Override
+	public IVertexBuffer finish() {
+		if(results == null) results = new ObjectArrayList<>();
+		results.add(new BufferResult(mode, lastVertecies, vertecies));
+		lastVertecies = vertecies;
+		return this;
+	}
+	
+	@Override
+	public List<BufferResult> results() {
+		return results == null ? ObjectLists.empty() : results.unmodifiable();
+	}
+	
+	@Override
+	public VertexBuilder next() {
+		index = (index + 1) % layout.size();
+		totalStoredBytes += elementBytes;
+		vertexBytes += elementBytes;
+		elementBytes = 0;
+		if(index == 0) {
+			vertecies++;
+			if(mode == DrawMode.LINES || mode == DrawMode.LINE_STRIP) {
+				buffer.put(totalStoredBytes, buffer, totalStoredBytes - vertexBytes, vertexBytes);
+				vertecies++;
+			}
+			vertexBytes = 0;
+			ensureCapacity(totalStoredBytes + layout.bytes());
+		}
+		return this;
+	}
+	
+	@Override
+	public VertexBuilder put(int byteOffset, byte value) {
+		buffer.put(totalStoredBytes + byteOffset, value);
+		elementBytes+=1;
+		return this;
+	}
+	
+	@Override
+	public VertexBuilder putShort(int byteOffset, short value) {
+		buffer.putShort(totalStoredBytes + byteOffset, value);
+		elementBytes+=2;
+		return this;
+	}
+	
+	@Override
+	public VertexBuilder putInt(int byteOffset, int value) {
+		buffer.putInt(totalStoredBytes + byteOffset, value);
+		elementBytes+=4;
+		return this;
+	}
+	
+	@Override
+	public VertexBuilder putFloat(int byteOffset, float value) {
+		buffer.putFloat(totalStoredBytes + byteOffset, value);
+		elementBytes+=4;
+		return this;
+	}
+	
+	@Override
+	public int vertecies() {
+		return vertecies;
+	}
+	
+	
+	
+	public VertexBuilder putBulk(byte[] source) {
+		if(index != 0) throw new IllegalStateException("Can't do bulk iterations when mid Building");
+		ensureCapacity(source.length + layout.bytes());
+		buffer.position(totalStoredBytes).put(source).position(0);
+		vertecies += source.length / layout.bytes();
+		totalStoredBytes += source.length;
+		return this;
+	}
+	
+	public VertexBuilder putBulk(ByteBuffer source) {
+		if(index != 0) throw new IllegalStateException("Can't do bulk iterations when mid Building");
+		ensureCapacity(source.limit() + layout.bytes());
+		buffer.position(totalStoredBytes).put(source).position(0);
+		vertecies += source.limit() / layout.bytes();
+		totalStoredBytes += source.limit();
+		return this;
+	}
+	
+	public VertexBuilder copy(ByteBuffer buffer) {
+		buffer.put(buffer.position(), this.buffer, 0, totalStoredBytes);
+		return this;
+	}
+	
+	public byte[] bytes() {
+		byte[] data = new byte[totalStoredBytes];
+		buffer.get(0, data);
+		return data;
+	}
+	
+	private void ensureCapacity(int newValue) {
+		if(totalStoredBytes + newValue >= buffer.capacity()) {
+			int oldSize = buffer.capacity();
+			int newSize = Math.max(oldSize + (oldSize >> 1), oldSize + newValue);
+			buffer = buffer.isDirect() ? MemoryUtil.memRealloc(buffer, newSize) : ByteBuffer.allocate(newSize).put(buffer).position(0);
+		}
+	}
+}

src/graphics/java/speiger/src/coreengine/platform/graphics/opengl/buffer/GLVertexBuffer.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.opengl.buffer;
+package speiger.src.coreengine.platform.graphics.opengl.buffer;
 
 import java.nio.ByteBuffer;
 import java.util.List;
@@ -10,13 +10,11 @@ import org.lwjgl.opengl.GL45;
 import org.lwjgl.system.MemoryUtil;
 
 import speiger.src.collections.ints.misc.pairs.IntObjectPair;
-import speiger.src.coreengine.graphics.api.buffer.VertexBuffer;
+import speiger.src.coreengine.platform.graphics.api.buffer.VertexBuffer;
-import speiger.src.coreengine.graphics.api.buffer.states.BufferState;
+import speiger.src.coreengine.platform.graphics.api.buffer.states.BufferState;
-import speiger.src.coreengine.graphics.api.buffer.states.BufferType;
+import speiger.src.coreengine.platform.graphics.api.buffer.states.BufferType;
-import speiger.src.coreengine.graphics.api.utils.BufferOwner;
+import speiger.src.coreengine.platform.graphics.api.utils.BufferOwner;
-import speiger.src.coreengine.graphics.opengl.utils.GLUtils;
+import speiger.src.coreengine.platform.graphics.opengl.utils.GLUtils;
-import speiger.src.coreengine.rendering.utils.AllocationTracker;
-import speiger.src.coreengine.utils.io.GameLog;
 
 public class GLVertexBuffer extends VertexBuffer {
 	int id;
@@ -98,7 +96,7 @@ public class GLVertexBuffer extends VertexBuffer {
 				buffer.put(entry.getValue());
 			}
 			buffer.flip();
-			if(!GL45.glUnmapNamedBuffer(id)) GameLog.info("Memory Corruption?");
+			if(!GL45.glUnmapNamedBuffer(id)) System.out.println("Memory Corruption?");
 		}
 		return this;
 	}
@@ -132,7 +130,6 @@ public class GLVertexBuffer extends VertexBuffer {
 		if(source < 0 || source + length >= size) throw new ArrayIndexOutOfBoundsException();
 		if(dest < 0 || dest + length >= size) throw new ArrayIndexOutOfBoundsException();
 		GL45.glCopyNamedBufferSubData(id, id, source, dest, length);
-		AllocationTracker.INSTANCE.addGPUBytes(length*2);
 		return this;
 	}
 	

src/graphics/java/speiger/src/coreengine/platform/graphics/opengl/core/GLCommandQueue.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.opengl.core;
+package speiger.src.coreengine.platform.graphics.opengl.core;
 
 import java.util.ArrayDeque;
 import java.util.Deque;
@@ -11,24 +11,24 @@ import org.lwjgl.opengl.GL32;
 import org.lwjgl.opengl.GL45;
 
 import speiger.src.coreengine.assets.api.ID;
-import speiger.src.coreengine.graphics.api.core.CommandBuffer;
-import speiger.src.coreengine.graphics.api.core.GraphicsCommandQueue;
-import speiger.src.coreengine.graphics.api.shader.states.GraphicsDataType;
-import speiger.src.coreengine.graphics.api.target.RenderTarget;
-import speiger.src.coreengine.graphics.api.target.ScreenTarget;
-import speiger.src.coreengine.graphics.api.target.TextureTarget;
-import speiger.src.coreengine.graphics.api.texture.Texture;
-import speiger.src.coreengine.graphics.api.texture.states.TextureFormat;
-import speiger.src.coreengine.graphics.api.utils.PushableResource;
-import speiger.src.coreengine.graphics.opengl.texture.FrameBufferCache;
-import speiger.src.coreengine.graphics.opengl.texture.GLTexture;
-import speiger.src.coreengine.graphics.opengl.utils.GLStates;
-import speiger.src.coreengine.graphics.opengl.utils.GLUtils;
-import speiger.src.coreengine.graphics.opengl.utils.ViewPortStack;
-import speiger.src.coreengine.graphics.opengl.utils.states.ScissorState;
-import speiger.src.coreengine.input.window.Window;
 import speiger.src.coreengine.math.vector.floats.Vec4f;
 import speiger.src.coreengine.math.vector.ints.Vec4i;
+import speiger.src.coreengine.platform.graphics.api.core.CommandBuffer;
+import speiger.src.coreengine.platform.graphics.api.core.GraphicsCommandQueue;
+import speiger.src.coreengine.platform.graphics.api.shader.states.GraphicsDataType;
+import speiger.src.coreengine.platform.graphics.api.target.RenderTarget;
+import speiger.src.coreengine.platform.graphics.api.target.ScreenTarget;
+import speiger.src.coreengine.platform.graphics.api.target.TextureTarget;
+import speiger.src.coreengine.platform.graphics.api.texture.Texture;
+import speiger.src.coreengine.platform.graphics.api.texture.states.TextureFormat;
+import speiger.src.coreengine.platform.graphics.api.utils.PushableResource;
+import speiger.src.coreengine.platform.graphics.opengl.texture.FrameBufferCache;
+import speiger.src.coreengine.platform.graphics.opengl.texture.GLTexture;
+import speiger.src.coreengine.platform.graphics.opengl.utils.GLStates;
+import speiger.src.coreengine.platform.graphics.opengl.utils.GLUtils;
+import speiger.src.coreengine.platform.graphics.opengl.utils.ViewPortStack;
+import speiger.src.coreengine.platform.graphics.opengl.utils.states.ScissorState;
+import speiger.src.coreengine.platform.input.window.Window;
 
 public class GLCommandQueue implements GraphicsCommandQueue {
 	GLGraphicsDevice device;

src/graphics/java/speiger/src/coreengine/platform/graphics/opengl/core/GLFence.java

@@ -1,7 +1,7 @@
-package speiger.src.coreengine.graphics.opengl.core;
+package speiger.src.coreengine.platform.graphics.opengl.core;
 
-import speiger.src.coreengine.graphics.api.core.GraphicsFence;
+import speiger.src.coreengine.platform.graphics.api.core.GraphicsFence;
-import speiger.src.coreengine.graphics.opengl.core.GLCommandQueue.Frame;
+import speiger.src.coreengine.platform.graphics.opengl.core.GLCommandQueue.Frame;
 
 public class GLFence implements GraphicsFence {
 	boolean removed = false;

src/graphics/java/speiger/src/coreengine/platform/graphics/opengl/core/GLGraphics.java

@@ -1,11 +1,11 @@
-package speiger.src.coreengine.graphics.opengl.core;
+package speiger.src.coreengine.platform.graphics.opengl.core;
 
 import org.lwjgl.glfw.GLFW;
 import org.lwjgl.opengl.GL;
 
 import speiger.src.coreengine.assets.manager.AssetManager;
-import speiger.src.coreengine.graphics.api.core.Graphics;
+import speiger.src.coreengine.platform.graphics.api.core.Graphics;
-import speiger.src.coreengine.input.window.Window;
+import speiger.src.coreengine.platform.input.window.Window;
 
 public class GLGraphics implements Graphics {
 	AssetManager manager;

src/graphics/java/speiger/src/coreengine/platform/graphics/opengl/core/GLGraphicsDevice.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.opengl.core;
+package speiger.src.coreengine.platform.graphics.opengl.core;
 
 import java.nio.ByteBuffer;
 import java.util.List;
@@ -37,41 +37,41 @@ import speiger.src.coreengine.assets.api.IAssetProvider;
 import speiger.src.coreengine.assets.api.ID;
 import speiger.src.coreengine.assets.api.MultiAsset;
 import speiger.src.coreengine.assets.manager.AssetManager;
-import speiger.src.coreengine.graphics.api.buffer.VertexBuffer;
+import speiger.src.coreengine.platform.graphics.api.buffer.VertexBuffer;
-import speiger.src.coreengine.graphics.api.buffer.states.BufferState;
+import speiger.src.coreengine.platform.graphics.api.buffer.states.BufferState;
-import speiger.src.coreengine.graphics.api.buffer.states.BufferType;
+import speiger.src.coreengine.platform.graphics.api.buffer.states.BufferType;
-import speiger.src.coreengine.graphics.api.compute.ComputePipeline;
+import speiger.src.coreengine.platform.graphics.api.compute.ComputePipeline;
-import speiger.src.coreengine.graphics.api.core.GraphicsCommandBuffer;
+import speiger.src.coreengine.platform.graphics.api.core.GraphicsCommandBuffer;
-import speiger.src.coreengine.graphics.api.core.GraphicsDevice;
+import speiger.src.coreengine.platform.graphics.api.core.GraphicsDevice;
-import speiger.src.coreengine.graphics.api.core.TimeQueryPool;
+import speiger.src.coreengine.platform.graphics.api.core.TimeQueryPool;
-import speiger.src.coreengine.graphics.api.mesh.Mesh;
+import speiger.src.coreengine.platform.graphics.api.mesh.Mesh;
-import speiger.src.coreengine.graphics.api.mesh.Mesh.LayoutInfo;
+import speiger.src.coreengine.platform.graphics.api.mesh.Mesh.LayoutInfo;
-import speiger.src.coreengine.graphics.api.sampler.SamplerSettings;
+import speiger.src.coreengine.platform.graphics.api.sampler.SamplerSettings;
-import speiger.src.coreengine.graphics.api.shader.ShaderPipeline;
+import speiger.src.coreengine.platform.graphics.api.shader.ShaderPipeline;
-import speiger.src.coreengine.graphics.api.shader.VertexBinding;
+import speiger.src.coreengine.platform.graphics.api.shader.VertexBinding;
-import speiger.src.coreengine.graphics.api.shader.states.Bindings.BufferBinding;
+import speiger.src.coreengine.platform.graphics.api.shader.states.ShaderType;
-import speiger.src.coreengine.graphics.api.shader.states.Bindings.BufferMode;
+import speiger.src.coreengine.platform.graphics.api.shader.states.Bindings.BufferBinding;
-import speiger.src.coreengine.graphics.api.shader.states.Bindings.TextureBinding;
+import speiger.src.coreengine.platform.graphics.api.shader.states.Bindings.BufferMode;
-import speiger.src.coreengine.graphics.api.shader.states.Bindings.TextureMode;
+import speiger.src.coreengine.platform.graphics.api.shader.states.Bindings.TextureBinding;
-import speiger.src.coreengine.graphics.api.shader.states.ShaderType;
+import speiger.src.coreengine.platform.graphics.api.shader.states.Bindings.TextureMode;
-import speiger.src.coreengine.graphics.api.texture.TextureSettings;
+import speiger.src.coreengine.platform.graphics.api.texture.TextureSettings;
-import speiger.src.coreengine.graphics.api.texture.states.SwizzleMask;
+import speiger.src.coreengine.platform.graphics.api.texture.states.SwizzleMask;
-import speiger.src.coreengine.graphics.api.texture.states.TextureType;
+import speiger.src.coreengine.platform.graphics.api.texture.states.TextureType;
-import speiger.src.coreengine.graphics.api.utils.ExecutionType;
+import speiger.src.coreengine.platform.graphics.api.utils.ExecutionType;
-import speiger.src.coreengine.graphics.api.vertex.VertexLayout.Element;
+import speiger.src.coreengine.platform.graphics.api.vertex.VertexLayout.Element;
-import speiger.src.coreengine.graphics.opengl.buffer.GLVertexBuffer;
+import speiger.src.coreengine.platform.graphics.opengl.buffer.GLVertexBuffer;
-import speiger.src.coreengine.graphics.opengl.mesh.GLMesh;
+import speiger.src.coreengine.platform.graphics.opengl.mesh.GLMesh;
-import speiger.src.coreengine.graphics.opengl.sampler.GLSampler;
+import speiger.src.coreengine.platform.graphics.opengl.sampler.GLSampler;
-import speiger.src.coreengine.graphics.opengl.shader.ShaderCache;
+import speiger.src.coreengine.platform.graphics.opengl.shader.ShaderCache;
-import speiger.src.coreengine.graphics.opengl.shader.ShaderInstance;
+import speiger.src.coreengine.platform.graphics.opengl.shader.ShaderInstance;
-import speiger.src.coreengine.graphics.opengl.shader.ShaderInstance.BufferObject;
+import speiger.src.coreengine.platform.graphics.opengl.shader.ShaderInstance.BufferObject;
-import speiger.src.coreengine.graphics.opengl.shader.ShaderInstance.ShaderStorage;
+import speiger.src.coreengine.platform.graphics.opengl.shader.ShaderInstance.ShaderStorage;
-import speiger.src.coreengine.graphics.opengl.shader.ShaderInstance.TextureObject;
+import speiger.src.coreengine.platform.graphics.opengl.shader.ShaderInstance.TextureObject;
-import speiger.src.coreengine.graphics.opengl.texture.GLTexture;
+import speiger.src.coreengine.platform.graphics.opengl.texture.GLTexture;
-import speiger.src.coreengine.graphics.opengl.utils.GLFunctions;
+import speiger.src.coreengine.platform.graphics.opengl.utils.GLFunctions;
-import speiger.src.coreengine.graphics.opengl.utils.GLStates;
+import speiger.src.coreengine.platform.graphics.opengl.utils.GLStates;
-import speiger.src.coreengine.graphics.opengl.utils.GLUtils;
+import speiger.src.coreengine.platform.graphics.opengl.utils.GLUtils;
-import speiger.src.coreengine.input.window.Window;
+import speiger.src.coreengine.platform.input.window.Window;
 
 public class GLGraphicsDevice implements GraphicsDevice {
 	static final Map<ID, String> IMPORTS = Object2ObjectMap.builder().<ID, String>map().synchronize();

src/graphics/java/speiger/src/coreengine/platform/graphics/opengl/core/GLImmidateCommandBuffer.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.opengl.core;
+package speiger.src.coreengine.platform.graphics.opengl.core;
 
 import java.util.Objects;
 
@@ -8,26 +8,26 @@ import org.lwjgl.opengl.GL31;
 import org.lwjgl.opengl.GL43;
 import org.lwjgl.opengl.GL45;
 
-import speiger.src.coreengine.graphics.api.buffer.VertexBuffer;
+import speiger.src.coreengine.platform.graphics.api.buffer.VertexBuffer;
-import speiger.src.coreengine.graphics.api.buffer.states.BufferType;
+import speiger.src.coreengine.platform.graphics.api.buffer.states.BufferType;
-import speiger.src.coreengine.graphics.api.core.GraphicsCommandBuffer;
+import speiger.src.coreengine.platform.graphics.api.core.GraphicsCommandBuffer;
-import speiger.src.coreengine.graphics.api.mesh.Mesh;
+import speiger.src.coreengine.platform.graphics.api.mesh.Mesh;
-import speiger.src.coreengine.graphics.api.sampler.Sampler;
+import speiger.src.coreengine.platform.graphics.api.sampler.Sampler;
-import speiger.src.coreengine.graphics.api.shader.ColorTarget;
+import speiger.src.coreengine.platform.graphics.api.shader.ColorTarget;
-import speiger.src.coreengine.graphics.api.shader.DepthTarget;
+import speiger.src.coreengine.platform.graphics.api.shader.DepthTarget;
-import speiger.src.coreengine.graphics.api.shader.RasterizerState;
+import speiger.src.coreengine.platform.graphics.api.shader.RasterizerState;
-import speiger.src.coreengine.graphics.api.shader.ShaderPipeline;
+import speiger.src.coreengine.platform.graphics.api.shader.ShaderPipeline;
-import speiger.src.coreengine.graphics.api.texture.Texture;
+import speiger.src.coreengine.platform.graphics.api.texture.Texture;
-import speiger.src.coreengine.graphics.api.utils.AccessType;
+import speiger.src.coreengine.platform.graphics.api.utils.AccessType;
-import speiger.src.coreengine.graphics.api.utils.ScissorsManager;
+import speiger.src.coreengine.platform.graphics.api.utils.ScissorsManager;
-import speiger.src.coreengine.graphics.opengl.buffer.GLVertexBuffer;
+import speiger.src.coreengine.platform.graphics.opengl.buffer.GLVertexBuffer;
-import speiger.src.coreengine.graphics.opengl.mesh.GLMesh;
+import speiger.src.coreengine.platform.graphics.opengl.mesh.GLMesh;
-import speiger.src.coreengine.graphics.opengl.sampler.GLSampler;
+import speiger.src.coreengine.platform.graphics.opengl.sampler.GLSampler;
-import speiger.src.coreengine.graphics.opengl.shader.ShaderInstance;
+import speiger.src.coreengine.platform.graphics.opengl.shader.ShaderInstance;
-import speiger.src.coreengine.graphics.opengl.texture.GLTexture;
+import speiger.src.coreengine.platform.graphics.opengl.texture.GLTexture;
-import speiger.src.coreengine.graphics.opengl.utils.GLScissorsHandler;
+import speiger.src.coreengine.platform.graphics.opengl.utils.GLScissorsHandler;
-import speiger.src.coreengine.graphics.opengl.utils.GLStates;
+import speiger.src.coreengine.platform.graphics.opengl.utils.GLStates;
-import speiger.src.coreengine.graphics.opengl.utils.GLUtils;
+import speiger.src.coreengine.platform.graphics.opengl.utils.GLUtils;
 
 public class GLImmidateCommandBuffer implements GraphicsCommandBuffer {
 	GLGraphicsDevice device;

src/graphics/java/speiger/src/coreengine/platform/graphics/opengl/core/GLImmidateComputeCommandBuffer.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.opengl.core;
+package speiger.src.coreengine.platform.graphics.opengl.core;
 
 import java.util.Objects;
 
@@ -8,20 +8,20 @@ import org.lwjgl.opengl.GL42;
 import org.lwjgl.opengl.GL43;
 import org.lwjgl.opengl.GL45;
 
-import speiger.src.coreengine.graphics.api.buffer.VertexBuffer;
+import speiger.src.coreengine.platform.graphics.api.buffer.VertexBuffer;
-import speiger.src.coreengine.graphics.api.buffer.states.BufferType;
+import speiger.src.coreengine.platform.graphics.api.buffer.states.BufferType;
-import speiger.src.coreengine.graphics.api.compute.BarrierType;
+import speiger.src.coreengine.platform.graphics.api.compute.BarrierType;
-import speiger.src.coreengine.graphics.api.compute.ComputePipeline;
+import speiger.src.coreengine.platform.graphics.api.compute.ComputePipeline;
-import speiger.src.coreengine.graphics.api.core.ComputeCommandBuffer;
+import speiger.src.coreengine.platform.graphics.api.core.ComputeCommandBuffer;
-import speiger.src.coreengine.graphics.api.sampler.Sampler;
+import speiger.src.coreengine.platform.graphics.api.sampler.Sampler;
-import speiger.src.coreengine.graphics.api.texture.Texture;
+import speiger.src.coreengine.platform.graphics.api.texture.Texture;
-import speiger.src.coreengine.graphics.api.utils.AccessType;
+import speiger.src.coreengine.platform.graphics.api.utils.AccessType;
-import speiger.src.coreengine.graphics.opengl.buffer.GLVertexBuffer;
+import speiger.src.coreengine.platform.graphics.opengl.buffer.GLVertexBuffer;
-import speiger.src.coreengine.graphics.opengl.sampler.GLSampler;
+import speiger.src.coreengine.platform.graphics.opengl.sampler.GLSampler;
-import speiger.src.coreengine.graphics.opengl.shader.ShaderInstance;
+import speiger.src.coreengine.platform.graphics.opengl.shader.ShaderInstance;
-import speiger.src.coreengine.graphics.opengl.texture.GLTexture;
+import speiger.src.coreengine.platform.graphics.opengl.texture.GLTexture;
-import speiger.src.coreengine.graphics.opengl.utils.GLStates;
+import speiger.src.coreengine.platform.graphics.opengl.utils.GLStates;
-import speiger.src.coreengine.graphics.opengl.utils.GLUtils;
+import speiger.src.coreengine.platform.graphics.opengl.utils.GLUtils;
 
 public class GLImmidateComputeCommandBuffer implements ComputeCommandBuffer {
 	GLGraphicsDevice device;

src/graphics/java/speiger/src/coreengine/platform/graphics/opengl/core/GLRecordingCommandBuffer.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.opengl.core;
+package speiger.src.coreengine.platform.graphics.opengl.core;
 
 import java.util.List;
 import java.util.Objects;
@@ -10,29 +10,29 @@ import org.lwjgl.opengl.GL43;
 import org.lwjgl.opengl.GL45;
 
 import speiger.src.collections.objects.lists.ObjectArrayList;
-import speiger.src.coreengine.graphics.api.buffer.VertexBuffer;
-import speiger.src.coreengine.graphics.api.buffer.states.BufferType;
-import speiger.src.coreengine.graphics.api.buffer.states.IndeciesType;
-import speiger.src.coreengine.graphics.api.core.GraphicsCommandBuffer;
-import speiger.src.coreengine.graphics.api.mesh.Mesh;
-import speiger.src.coreengine.graphics.api.sampler.Sampler;
-import speiger.src.coreengine.graphics.api.shader.ColorTarget;
-import speiger.src.coreengine.graphics.api.shader.DepthTarget;
-import speiger.src.coreengine.graphics.api.shader.RasterizerState;
-import speiger.src.coreengine.graphics.api.shader.ShaderPipeline;
-import speiger.src.coreengine.graphics.api.shader.states.DrawMode;
-import speiger.src.coreengine.graphics.api.texture.Texture;
-import speiger.src.coreengine.graphics.api.utils.AccessType;
-import speiger.src.coreengine.graphics.api.utils.ScissorsManager;
-import speiger.src.coreengine.graphics.api.utils.ScissorsManager.NoOp;
-import speiger.src.coreengine.graphics.opengl.buffer.GLVertexBuffer;
-import speiger.src.coreengine.graphics.opengl.mesh.GLMesh;
-import speiger.src.coreengine.graphics.opengl.sampler.GLSampler;
-import speiger.src.coreengine.graphics.opengl.shader.ShaderInstance;
-import speiger.src.coreengine.graphics.opengl.texture.GLTexture;
-import speiger.src.coreengine.graphics.opengl.utils.GLStates;
-import speiger.src.coreengine.graphics.opengl.utils.GLUtils;
 import speiger.src.coreengine.math.vector.ints.Vec4i;
+import speiger.src.coreengine.platform.graphics.api.buffer.VertexBuffer;
+import speiger.src.coreengine.platform.graphics.api.buffer.states.BufferType;
+import speiger.src.coreengine.platform.graphics.api.buffer.states.IndeciesType;
+import speiger.src.coreengine.platform.graphics.api.core.GraphicsCommandBuffer;
+import speiger.src.coreengine.platform.graphics.api.mesh.Mesh;
+import speiger.src.coreengine.platform.graphics.api.sampler.Sampler;
+import speiger.src.coreengine.platform.graphics.api.shader.ColorTarget;
+import speiger.src.coreengine.platform.graphics.api.shader.DepthTarget;
+import speiger.src.coreengine.platform.graphics.api.shader.RasterizerState;
+import speiger.src.coreengine.platform.graphics.api.shader.ShaderPipeline;
+import speiger.src.coreengine.platform.graphics.api.shader.states.DrawMode;
+import speiger.src.coreengine.platform.graphics.api.texture.Texture;
+import speiger.src.coreengine.platform.graphics.api.utils.AccessType;
+import speiger.src.coreengine.platform.graphics.api.utils.ScissorsManager;
+import speiger.src.coreengine.platform.graphics.api.utils.ScissorsManager.NoOp;
+import speiger.src.coreengine.platform.graphics.opengl.buffer.GLVertexBuffer;
+import speiger.src.coreengine.platform.graphics.opengl.mesh.GLMesh;
+import speiger.src.coreengine.platform.graphics.opengl.sampler.GLSampler;
+import speiger.src.coreengine.platform.graphics.opengl.shader.ShaderInstance;
+import speiger.src.coreengine.platform.graphics.opengl.texture.GLTexture;
+import speiger.src.coreengine.platform.graphics.opengl.utils.GLStates;
+import speiger.src.coreengine.platform.graphics.opengl.utils.GLUtils;
 
 public class GLRecordingCommandBuffer implements GraphicsCommandBuffer {
 	List<Runnable> tasks = new ObjectArrayList<>();

src/graphics/java/speiger/src/coreengine/platform/graphics/opengl/core/GLRecordingComputeCommandBuffer.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.opengl.core;
+package speiger.src.coreengine.platform.graphics.opengl.core;
 
 import java.util.List;
 import java.util.Objects;
@@ -10,20 +10,20 @@ import org.lwjgl.opengl.GL43;
 import org.lwjgl.opengl.GL45;
 
 import speiger.src.collections.objects.lists.ObjectArrayList;
-import speiger.src.coreengine.graphics.api.buffer.VertexBuffer;
+import speiger.src.coreengine.platform.graphics.api.buffer.VertexBuffer;
-import speiger.src.coreengine.graphics.api.buffer.states.BufferType;
+import speiger.src.coreengine.platform.graphics.api.buffer.states.BufferType;
-import speiger.src.coreengine.graphics.api.compute.BarrierType;
+import speiger.src.coreengine.platform.graphics.api.compute.BarrierType;
-import speiger.src.coreengine.graphics.api.compute.ComputePipeline;
+import speiger.src.coreengine.platform.graphics.api.compute.ComputePipeline;
-import speiger.src.coreengine.graphics.api.core.ComputeCommandBuffer;
+import speiger.src.coreengine.platform.graphics.api.core.ComputeCommandBuffer;
-import speiger.src.coreengine.graphics.api.sampler.Sampler;
+import speiger.src.coreengine.platform.graphics.api.sampler.Sampler;
-import speiger.src.coreengine.graphics.api.texture.Texture;
+import speiger.src.coreengine.platform.graphics.api.texture.Texture;
-import speiger.src.coreengine.graphics.api.utils.AccessType;
+import speiger.src.coreengine.platform.graphics.api.utils.AccessType;
-import speiger.src.coreengine.graphics.opengl.buffer.GLVertexBuffer;
+import speiger.src.coreengine.platform.graphics.opengl.buffer.GLVertexBuffer;
-import speiger.src.coreengine.graphics.opengl.sampler.GLSampler;
+import speiger.src.coreengine.platform.graphics.opengl.sampler.GLSampler;
-import speiger.src.coreengine.graphics.opengl.shader.ShaderInstance;
+import speiger.src.coreengine.platform.graphics.opengl.shader.ShaderInstance;
-import speiger.src.coreengine.graphics.opengl.texture.GLTexture;
+import speiger.src.coreengine.platform.graphics.opengl.texture.GLTexture;
-import speiger.src.coreengine.graphics.opengl.utils.GLStates;
+import speiger.src.coreengine.platform.graphics.opengl.utils.GLStates;
-import speiger.src.coreengine.graphics.opengl.utils.GLUtils;
+import speiger.src.coreengine.platform.graphics.opengl.utils.GLUtils;
 
 public class GLRecordingComputeCommandBuffer implements ComputeCommandBuffer {
 	List<Runnable> tasks = new ObjectArrayList<>();

src/graphics/java/speiger/src/coreengine/platform/graphics/opengl/core/GLSurface.java

@@ -1,11 +1,11 @@
-package speiger.src.coreengine.graphics.opengl.core;
+package speiger.src.coreengine.platform.graphics.opengl.core;
 
 import org.lwjgl.glfw.GLFW;
 import org.lwjgl.opengl.GL;
 import org.lwjgl.opengl.GL11;
 
-import speiger.src.coreengine.graphics.api.core.GraphicsSurface;
+import speiger.src.coreengine.platform.graphics.api.core.GraphicsSurface;
-import speiger.src.coreengine.input.window.Window;
+import speiger.src.coreengine.platform.input.window.Window;
 
 public class GLSurface implements GraphicsSurface {
 	GLGraphicsDevice device;

src/graphics/java/speiger/src/coreengine/platform/graphics/opengl/core/GLTimeQueryPool.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.opengl.core;
+package speiger.src.coreengine.platform.graphics.opengl.core;
 
 import java.util.OptionalLong;
 
@@ -6,7 +6,7 @@ import org.lwjgl.opengl.GL15;
 import org.lwjgl.opengl.GL33;
 import org.lwjgl.opengl.GL45;
 
-import speiger.src.coreengine.graphics.api.core.TimeQueryPool;
+import speiger.src.coreengine.platform.graphics.api.core.TimeQueryPool;
 
 public class GLTimeQueryPool implements TimeQueryPool {
 	boolean removed = false;

src/graphics/java/speiger/src/coreengine/platform/graphics/opengl/mesh/GLMesh.java

@@ -1,17 +1,17 @@
-package speiger.src.coreengine.graphics.opengl.mesh;
+package speiger.src.coreengine.platform.graphics.opengl.mesh;
 
 import org.jspecify.annotations.Nullable;
 import org.lwjgl.opengl.GL45;
 
 import speiger.src.collections.ints.collections.IntIterator;
 import speiger.src.collections.ints.maps.interfaces.Int2ObjectMap;
-import speiger.src.coreengine.graphics.api.buffer.VertexBuffer;
+import speiger.src.coreengine.platform.graphics.api.buffer.VertexBuffer;
-import speiger.src.coreengine.graphics.api.buffer.states.IndeciesType;
+import speiger.src.coreengine.platform.graphics.api.buffer.states.IndeciesType;
-import speiger.src.coreengine.graphics.api.mesh.Mesh;
+import speiger.src.coreengine.platform.graphics.api.mesh.Mesh;
-import speiger.src.coreengine.graphics.api.vertex.VertexLayout;
+import speiger.src.coreengine.platform.graphics.api.vertex.VertexLayout;
-import speiger.src.coreengine.graphics.api.vertex.VertexLayout.Element;
+import speiger.src.coreengine.platform.graphics.api.vertex.VertexLayout.Element;
-import speiger.src.coreengine.graphics.opengl.buffer.GLVertexBuffer;
+import speiger.src.coreengine.platform.graphics.opengl.buffer.GLVertexBuffer;
-import speiger.src.coreengine.graphics.opengl.utils.GLUtils;
+import speiger.src.coreengine.platform.graphics.opengl.utils.GLUtils;
 
 public class GLMesh extends Mesh {
 	int vao;

src/graphics/java/speiger/src/coreengine/platform/graphics/opengl/sampler/GLSampler.java

@@ -1,13 +1,13 @@
-package speiger.src.coreengine.graphics.opengl.sampler;
+package speiger.src.coreengine.platform.graphics.opengl.sampler;
 
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL12;
 import org.lwjgl.opengl.GL33;
 import org.lwjgl.opengl.GL45;
 
-import speiger.src.coreengine.graphics.api.sampler.Sampler;
+import speiger.src.coreengine.platform.graphics.api.sampler.Sampler;
-import speiger.src.coreengine.graphics.api.sampler.SamplerSettings;
+import speiger.src.coreengine.platform.graphics.api.sampler.SamplerSettings;
-import speiger.src.coreengine.graphics.opengl.utils.GLUtils;
+import speiger.src.coreengine.platform.graphics.opengl.utils.GLUtils;
 
 public class GLSampler extends Sampler {
 	int id;

src/graphics/java/speiger/src/coreengine/platform/graphics/opengl/shader/ShaderCache.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.opengl.shader;
+package speiger.src.coreengine.platform.graphics.opengl.shader;
 
 import java.io.BufferedReader;
 import java.io.IOException;

src/graphics/java/speiger/src/coreengine/platform/graphics/opengl/shader/ShaderInstance.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.opengl.shader;
+package speiger.src.coreengine.platform.graphics.opengl.shader;
 
 import java.util.Map;
 

src/graphics/java/speiger/src/coreengine/platform/graphics/opengl/shader/ShaderTracker.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.opengl.shader;
+package speiger.src.coreengine.platform.graphics.opengl.shader;
 
 import org.lwjgl.opengl.GL20;
 

src/graphics/java/speiger/src/coreengine/platform/graphics/opengl/texture/FrameBufferCache.java

@@ -1,4 +1,4 @@
-package speiger.src.coreengine.graphics.opengl.texture;
+package speiger.src.coreengine.platform.graphics.opengl.texture;
 
 import org.lwjgl.opengl.GL45;
 

src/graphics/java/speiger/src/coreengine/platform/graphics/opengl/texture/GLTexture.java

@@ -1,8 +1,8 @@
-package speiger.src.coreengine.graphics.opengl.texture;
+package speiger.src.coreengine.platform.graphics.opengl.texture;
 
-import speiger.src.coreengine.graphics.api.texture.Texture;
+import speiger.src.coreengine.platform.graphics.api.texture.Texture;
-import speiger.src.coreengine.graphics.api.texture.TextureSettings;
+import speiger.src.coreengine.platform.graphics.api.texture.TextureSettings;
-import speiger.src.coreengine.graphics.opengl.utils.GLFunctions;
+import speiger.src.coreengine.platform.graphics.opengl.utils.GLFunctions;
 
 public class GLTexture extends Texture {
 	int id;

src/graphics/java/speiger/src/coreengine/platform/graphics/opengl/utils/GLFunctions.java

@@ -1,9 +1,9 @@
-package speiger.src.coreengine.graphics.opengl.utils;
+package speiger.src.coreengine.platform.graphics.opengl.utils;
 
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL45;
 
-import speiger.src.coreengine.graphics.api.texture.states.TextureType;
+import speiger.src.coreengine.platform.graphics.api.texture.states.TextureType;
 
 public class GLFunctions {
 

src/graphics/java/speiger/src/coreengine/platform/graphics/opengl/utils/GLScissorsHandler.java

@@ -1,7 +1,7 @@
-package speiger.src.coreengine.graphics.opengl.utils;
+package speiger.src.coreengine.platform.graphics.opengl.utils;
 
-import speiger.src.coreengine.graphics.api.utils.ScissorsManager.IScissorsHandler;
 import speiger.src.coreengine.math.vector.ints.Vec4i;
+import speiger.src.coreengine.platform.graphics.api.utils.ScissorsManager.IScissorsHandler;
 
 public record GLScissorsHandler(GLStates states) implements IScissorsHandler {
 	@Override

src/graphics/java/speiger/src/coreengine/platform/graphics/opengl/utils/GLStates.java

@@ -1,20 +1,20 @@
-package speiger.src.coreengine.graphics.opengl.utils;
+package speiger.src.coreengine.platform.graphics.opengl.utils;
 
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL13;
 
-import speiger.src.coreengine.graphics.api.shader.ColorTarget;
+import speiger.src.coreengine.platform.graphics.api.shader.ColorTarget;
-import speiger.src.coreengine.graphics.api.utils.AlphaFunction;
+import speiger.src.coreengine.platform.graphics.api.utils.AlphaFunction;
-import speiger.src.coreengine.graphics.opengl.shader.ShaderTracker;
+import speiger.src.coreengine.platform.graphics.opengl.shader.ShaderTracker;
-import speiger.src.coreengine.graphics.opengl.utils.states.BlendState;
+import speiger.src.coreengine.platform.graphics.opengl.utils.states.BlendState;
-import speiger.src.coreengine.graphics.opengl.utils.states.CullState;
+import speiger.src.coreengine.platform.graphics.opengl.utils.states.CullState;
-import speiger.src.coreengine.graphics.opengl.utils.states.FloatState;
+import speiger.src.coreengine.platform.graphics.opengl.utils.states.FloatState;
-import speiger.src.coreengine.graphics.opengl.utils.states.GLPolygon;
+import speiger.src.coreengine.platform.graphics.opengl.utils.states.GLPolygon;
-import speiger.src.coreengine.graphics.opengl.utils.states.GLState;
+import speiger.src.coreengine.platform.graphics.opengl.utils.states.GLState;
-import speiger.src.coreengine.graphics.opengl.utils.states.PixelState;
+import speiger.src.coreengine.platform.graphics.opengl.utils.states.PixelState;
-import speiger.src.coreengine.graphics.opengl.utils.states.SamplerState;
+import speiger.src.coreengine.platform.graphics.opengl.utils.states.SamplerState;
-import speiger.src.coreengine.graphics.opengl.utils.states.ScissorState;
+import speiger.src.coreengine.platform.graphics.opengl.utils.states.ScissorState;
-import speiger.src.coreengine.graphics.opengl.utils.states.TextureState;
+import speiger.src.coreengine.platform.graphics.opengl.utils.states.TextureState;
 
 public final class GLStates {
 	public final GLState multiSampling = new GLState(GL13.GL_MULTISAMPLE);