Update Files

Kha/Backends/Empty/kha/Image.hx

@@ -0,0 +1,173 @@
+package kha;
+
+import haxe.io.Bytes;
+import kha.graphics4.DepthStencilFormat;
+import kha.graphics4.TextureFormat;
+import kha.graphics4.Usage;
+
+class Image implements Canvas implements Resource {
+	public static function create(width: Int, height: Int, format: TextureFormat = null, usage: Usage = null): Image {
+		return null;
+	}
+
+	public static function create3D(width: Int, height: Int, depth: Int, format: TextureFormat = null, usage: Usage = null): Image {
+		return null;
+	}
+
+	public static function createRenderTarget(width: Int, height: Int, format: TextureFormat = null,
+			depthStencil: DepthStencilFormat = DepthStencilFormat.NoDepthAndStencil, antiAliasingSamples: Int = 1): Image {
+		return null;
+	}
+
+	public static function fromBytes(bytes: Bytes, width: Int, height: Int, format: TextureFormat = null, usage: Usage = null): Image {
+		return null;
+	}
+
+	public static function fromBytes3D(bytes: Bytes, width: Int, height: Int, depth: Int, format: TextureFormat = null, usage: Usage = null): Image {
+		return null;
+	}
+
+	public static var maxSize(get, never): Int;
+
+	static function get_maxSize(): Int {
+		return 0;
+	}
+
+	public static var nonPow2Supported(get, never): Bool;
+
+	static function get_nonPow2Supported(): Bool {
+		return false;
+	}
+
+	public static function renderTargetsInvertedY(): Bool {
+		return false;
+	}
+
+	public function isOpaque(x: Int, y: Int): Bool {
+		return false;
+	}
+
+	/**
+	 * Returns the color of a pixel identified by its x/y-coordinates. This only works for images for which
+	 * the readable flag is set to true because by default images only exist in video-memory. To load images
+	 * which are readable use a line ala project.addAssets('Assets/image.png', { readable: true }); in
+	 * your khafile.
+	 * For reading the content of render-targets use getPixels() instead.
+	 */
+	public function at(x: Int, y: Int): Color {
+		return Color.Black;
+	}
+
+	public function unload(): Void {}
+
+	/**
+	 * Returns a writable Bytes object. Once unlock() is called the content of the Bytes object
+	 * is written into the image.
+	 * This can not be used to read the current content of an image - for this use at() or getPixels() instead.
+	 */
+	public function lock(level: Int = 0): Bytes {
+		return null;
+	}
+
+	public function unlock(): Void {}
+
+	/**
+	 * Returns the content of an image. This only works if the image is a render-target and it is very slow
+	 * because data will be copied from video-memory to main-memory. This is useful for making screenshots
+	 * but please avoid using it for regular rendering.
+	 * For reading the content of images which are not render-targets use at() instead.
+	 */
+	public function getPixels(): Bytes {
+		return null;
+	}
+
+	public function generateMipmaps(levels: Int): Void {}
+
+	public function setMipmaps(mipmaps: Array<Image>): Void {}
+
+	public function setDepthStencilFrom(image: Image): Void {}
+
+	public function clear(x: Int, y: Int, z: Int, width: Int, height: Int, depth: Int, color: Color): Void {}
+
+	/**
+	 * Returns the original width of the image.
+	 */
+	public var width(get, never): Int;
+
+	function get_width(): Int {
+		return 0;
+	}
+
+	/**
+	 * Returns the original height of the image.
+	 */
+	public var height(get, never): Int;
+
+	function get_height(): Int {
+		return 0;
+	}
+
+	public var depth(get, never): Int;
+
+	function get_depth(): Int {
+		return 1;
+	}
+
+	public var format(get, never): TextureFormat;
+
+	function get_format(): TextureFormat {
+		return TextureFormat.RGBA32;
+	}
+
+	/**
+	 * Very old GPUs only supported power of two texture-widths.
+	 * When an Image is created on such a GPU, Kha automatically increases
+	 * its size to a power of two and realWidth returns this new, internal
+	 * size. Knowing the real size is important for calculating
+	 * texture-coordinates correctly but all of this is irrelevant unless
+	 * you really want to support very very old GPUs.
+	 */
+	public var realWidth(get, never): Int;
+
+	function get_realWidth(): Int {
+		return 0;
+	}
+
+	/**
+	 * Very old GPUs only supported power of two texture-heights.
+	 * When an Image is created on such a GPU, Kha automatically increases
+	 * its size to a power of two and realHeight returns this new, internal
+	 * size. Knowing the real size is important for calculating
+	 * texture-coordinates correctly but all of this is irrelevant unless
+	 * you really want to support very very old GPUs.
+	 */
+	public var realHeight(get, never): Int;
+
+	function get_realHeight(): Int {
+		return 0;
+	}
+
+	public var stride(get, never): Int;
+
+	function get_stride(): Int {
+		return 0;
+	}
+
+	public var g1(get, never): kha.graphics1.Graphics;
+
+	function get_g1(): kha.graphics1.Graphics {
+		return null;
+	}
+
+	public var g2(get, never): kha.graphics2.Graphics;
+
+	function get_g2(): kha.graphics2.Graphics {
+		return null;
+	}
+
+	public var g4(get, never): kha.graphics4.Graphics;
+
+	function get_g4(): kha.graphics4.Graphics {
+		return null;
+	}
+}