Update Files

Kha/Backends/HTML5-Worker/kha/graphics4/CubeMap.hx

@@ -0,0 +1,44 @@
+package kha.graphics4;
+
+import haxe.io.Bytes;
+
+class CubeMap implements Canvas implements Resource {
+	public static function createRenderTarget(size: Int, format: TextureFormat, depthStencil: DepthStencilFormat = NoDepthAndStencil): CubeMap {
+		return null;
+	}
+
+	public function unload(): Void {}
+
+	public function lock(level: Int = 0): Bytes {
+		return null;
+	}
+
+	public function unlock(): Void {}
+
+	public var width(get, never): Int;
+	public var height(get, never): Int;
+
+	function get_width(): Int {
+		return 512;
+	}
+
+	function get_height(): Int {
+		return 512;
+	}
+
+	public var g1(get, never): kha.graphics1.Graphics;
+	public var g2(get, never): kha.graphics2.Graphics;
+	public var g4(get, never): kha.graphics4.Graphics;
+
+	function get_g1(): kha.graphics1.Graphics {
+		return null;
+	}
+
+	function get_g2(): kha.graphics2.Graphics {
+		return null;
+	}
+
+	function get_g4(): kha.graphics4.Graphics {
+		return null;
+	}
+}

Kha/Backends/HTML5-Worker/kha/graphics4/FragmentShader.hx

@@ -0,0 +1,27 @@
+package kha.graphics4;
+
+class FragmentShader {
+	public var sources: Array<String>;
+	public var shader: Dynamic;
+	public var files: Array<String>;
+
+	public function new(sources: Array<Blob>, files: Array<String>) {
+		this.sources = [];
+		for (source in sources) {
+			this.sources.push(source.toString());
+		}
+		this.shader = null;
+		this.files = files;
+	}
+
+	public static function fromSource(source: String): FragmentShader {
+		var shader = new FragmentShader([], ["runtime-string"]);
+		shader.sources.push(source);
+		return shader;
+	}
+
+	public function delete(): Void {
+		shader = null;
+		sources = null;
+	}
+}

Kha/Backends/HTML5-Worker/kha/graphics4/IndexBuffer.hx

@@ -0,0 +1,51 @@
+package kha.graphics4;
+
+import kha.arrays.Uint32Array;
+import kha.graphics4.Usage;
+
+class IndexBuffer {
+	static var lastId: Int = -1;
+
+	public var _id: Int;
+	public var _data: Uint32Array;
+
+	var mySize: Int;
+	var usage: Usage;
+	var lockStart: Int = 0;
+	var lockEnd: Int = 0;
+
+	public function new(indexCount: Int, usage: Usage, canRead: Bool = false) {
+		this.usage = usage;
+		mySize = indexCount;
+		_data = new Uint32Array(indexCount);
+		_id = ++lastId;
+		Worker.postMessage({
+			command: 'createIndexBuffer',
+			id: _id,
+			size: indexCount,
+			usage: usage
+		});
+	}
+
+	public function delete(): Void {
+		_data = null;
+	}
+
+	public function lock(?start: Int, ?count: Int): Uint32Array {
+		lockStart = start != null ? start : 0;
+		lockEnd = count != null ? start + count : mySize;
+		return _data.subarray(lockStart, lockEnd);
+	}
+
+	public function unlock(?count: Int): Void {
+		if (count != null)
+			lockEnd = lockStart + count;
+		Worker.postMessage({command: 'updateIndexBuffer', id: _id, data: _data.subarray(lockStart, lockEnd).buffer});
+	}
+
+	public function set(): Void {}
+
+	public function count(): Int {
+		return mySize;
+	}
+}

Kha/Backends/HTML5-Worker/kha/graphics4/PipelineState.hx

@@ -0,0 +1,117 @@
+package kha.graphics4;
+
+import kha.graphics4.FragmentShader;
+import kha.graphics4.VertexData;
+import kha.graphics4.VertexShader;
+import kha.graphics4.VertexStructure;
+
+class PipelineState extends PipelineStateBase {
+	static var lastId: Int = -1;
+
+	public var _id: Int;
+
+	var textures: Array<String>;
+	var textureValues: Array<Dynamic>;
+
+	public function new() {
+		super();
+		_id = ++lastId;
+		textures = new Array<String>();
+		textureValues = new Array<Dynamic>();
+	}
+
+	public function delete(): Void {}
+
+	public function compile(): Void {
+		var index = 0;
+		for (structure in inputLayout) {
+			for (element in structure.elements) {
+				if (element.data == VertexData.Float4x4) {
+					index += 4;
+				}
+				else {
+					++index;
+				}
+			}
+		}
+
+		var layout = new Array<Dynamic>();
+		for (input in inputLayout) {
+			var elements = new Array<Dynamic>();
+			for (element in input.elements) {
+				elements.push({
+					name: element.name,
+					data: element.data
+				});
+			}
+			layout.push({
+				elements: elements
+			});
+		}
+
+		var stencilValue = -1;
+		switch (stencilReferenceValue) {
+			case Static(value):
+				stencilValue = value;
+			case Dynamic:
+				stencilValue = -1;
+		}
+
+		var state = {
+			cullMode: cullMode,
+			depthWrite: depthWrite,
+			depthMode: depthMode,
+			stencilFrontMode: stencilFrontMode,
+			stencilFrontBothPass: stencilFrontBothPass,
+			stencilFrontDepthFail: stencilFrontDepthFail,
+			stencilFrontFail: stencilFrontFail,
+			stencilBackMode: stencilBackMode,
+			stencilBackBothPass: stencilBackBothPass,
+			stencilBackDepthFail: stencilBackDepthFail,
+			stencilBackFail: stencilBackFail,
+			stencilReferenceValue: stencilValue,
+			stencilReadMask: stencilReadMask,
+			stencilWriteMask: stencilWriteMask,
+			blendSource: blendSource,
+			blendDestination: blendDestination,
+			alphaBlendSource: alphaBlendSource,
+			alphaBlendDestination: alphaBlendDestination,
+			colorWriteMaskRed: colorWriteMaskRed,
+			colorWriteMaskGreen: colorWriteMaskGreen,
+			colorWriteMaskBlue: colorWriteMaskBlue,
+			colorWriteMaskAlpha: colorWriteMaskAlpha,
+			conservativeRasterization: conservativeRasterization
+		};
+
+		Worker.postMessage({
+			command: 'compilePipeline',
+			id: _id,
+			frag: fragmentShader.files[0],
+			vert: vertexShader.files[0],
+			layout: layout,
+			state: state
+		});
+	}
+
+	public function getConstantLocation(name: String): kha.graphics4.ConstantLocation {
+		var loc = new kha.html5worker.ConstantLocation();
+		Worker.postMessage({
+			command: 'createConstantLocation',
+			id: loc._id,
+			name: name,
+			pipeline: _id
+		});
+		return loc;
+	}
+
+	public function getTextureUnit(name: String): kha.graphics4.TextureUnit {
+		var unit = new kha.html5worker.TextureUnit();
+		Worker.postMessage({
+			command: 'createTextureUnit',
+			id: unit._id,
+			name: name,
+			pipeline: _id
+		});
+		return unit;
+	}
+}

Kha/Backends/HTML5-Worker/kha/graphics4/VertexBuffer.hx

@@ -0,0 +1,115 @@
+package kha.graphics4;
+
+import kha.arrays.Float32Array;
+import kha.graphics4.Usage;
+import kha.graphics4.VertexStructure;
+import kha.graphics4.VertexData;
+
+class VertexBuffer {
+	static var lastId: Int = -1;
+
+	public var _id: Int;
+	public var _data: Float32Array;
+
+	var mySize: Int;
+	var myStride: Int;
+	var sizes: Array<Int>;
+	var offsets: Array<Int>;
+	var usage: Usage;
+	var instanceDataStepRate: Int;
+	var lockStart: Int = 0;
+	var lockCount: Int = 0;
+
+	public function new(vertexCount: Int, structure: VertexStructure, usage: Usage, instanceDataStepRate: Int = 0, canRead: Bool = false) {
+		this.usage = usage;
+		this.instanceDataStepRate = instanceDataStepRate;
+		mySize = vertexCount;
+		myStride = 0;
+		for (element in structure.elements) {
+			myStride += VertexStructure.dataByteSize(element.data);
+		}
+
+		_data = new Float32Array(Std.int(vertexCount * myStride / 4));
+
+		sizes = new Array<Int>();
+		offsets = new Array<Int>();
+		sizes[structure.elements.length - 1] = 0;
+		offsets[structure.elements.length - 1] = 0;
+
+		var offset = 0;
+		var index = 0;
+		for (element in structure.elements) {
+			var size = 0;
+			size += Std.int(VertexStructure.dataByteSize(element.data) / 4);
+			sizes[index] = size;
+			offsets[index] = offset;
+			offset += VertexStructure.dataByteSize(element.data);
+			++index;
+		}
+
+		_id = ++lastId;
+		var elements = new Array<Dynamic>();
+		for (element in structure.elements) {
+			elements.push({
+				name: element.name,
+				data: element.data
+			});
+		}
+		Worker.postMessage({
+			command: 'createVertexBuffer',
+			id: _id,
+			size: vertexCount,
+			structure: {elements: elements},
+			usage: usage
+		});
+	}
+
+	public function delete(): Void {
+		_data = null;
+	}
+
+	public function lock(?start: Int, ?count: Int): Float32Array {
+		lockStart = start != null ? start : 0;
+		lockCount = count != null ? count : mySize;
+		return _data.subarray(Std.int(lockStart * stride() / 4), Std.int((lockStart + lockCount) * stride() / 4));
+	}
+
+	public function unlock(?count: Int): Void {
+		if (count != null)
+			lockCount = count;
+		Worker.postMessage({
+			command: 'updateVertexBuffer',
+			id: _id,
+			data: _data.subarray(Std.int(lockStart * stride() / 4), Std.int((lockStart + lockCount) * stride() / 4)).buffer,
+			start: lockStart,
+			count: lockCount
+		});
+	}
+
+	public function stride(): Int {
+		return myStride;
+	}
+
+	public function count(): Int {
+		return mySize;
+	}
+
+	public function set(offset: Int): Int {
+		var attributesOffset = 0;
+		for (i in 0...sizes.length) {
+			if (sizes[i] > 4) {
+				var size = sizes[i];
+				var addonOffset = 0;
+				while (size > 0) {
+					size -= 4;
+					addonOffset += 4 * 4;
+					++attributesOffset;
+				}
+			}
+			else {
+				++attributesOffset;
+			}
+		}
+		return attributesOffset;
+	}
+}

Kha/Backends/HTML5-Worker/kha/graphics4/VertexShader.hx

@@ -0,0 +1,27 @@
+package kha.graphics4;
+
+class VertexShader {
+	public var sources: Array<String>;
+	public var shader: Dynamic;
+	public var files: Array<String>;
+
+	public function new(sources: Array<Blob>, files: Array<String>) {
+		this.sources = [];
+		for (source in sources) {
+			this.sources.push(source.toString());
+		}
+		this.shader = null;
+		this.files = files;
+	}
+
+	public static function fromSource(source: String): VertexShader {
+		var shader = new VertexShader([], ["runtime-string"]);
+		shader.sources.push(source);
+		return shader;
+	}
+
+	public function delete(): Void {
+		shader = null;
+		sources = null;
+	}
+}