Permalink
Cannot retrieve contributors at this time
Join GitHub today
GitHub is home to over 28 million developers working together to host and review code, manage projects, and build software together.
Sign up
Fetching contributors…
Cannot retrieve contributors at this time
| import haxegon.*; | |
| import haxe.ds.ArraySort; | |
| import starling.core.Starling; | |
| import starling.textures.RenderTexture; | |
| import starling.display.Image; | |
| @:allow(Layer) | |
| private class HaxegonLayer{ | |
| private function new(w:Int, h:Int){ | |
| if (w > -1){ | |
| rendertex = new RenderTexture(w, h, true); | |
| img = new Image(rendertex); | |
| img.touchable = false; | |
| img.scale = 1; | |
| img.textureSmoothing = "none"; | |
| width = w; | |
| height = h; | |
| } | |
| x = 0; y = 0; | |
| alpha = 0; | |
| } | |
| private var rendertex:RenderTexture; | |
| private var img:Image; | |
| private var x:Float; | |
| private var y:Float; | |
| private var width:Float; | |
| private var height:Float; | |
| private var alpha:Float; | |
| } | |
| @:access(haxegon.Core) | |
| @:access(haxegon.Gfx) | |
| class Layer{ | |
| /** Enable the plugin. */ | |
| public static function enable(){ | |
| if(!enabled){ | |
| Core.registerplugin("layers", "0.1.0"); | |
| Core.checkrequirement("layers", "haxegon", "0.12.0"); | |
| layerindex = new Map<String, HaxegonLayer>(); | |
| screenready = false; | |
| var screenlayer:HaxegonLayer = new HaxegonLayer(-1, -1); | |
| screenlayer.rendertex = Gfx.backbuffer; | |
| screenlayer.img = Gfx.screen; | |
| screenlayer.width = Gfx.screenwidth; | |
| screenlayer.height = Gfx.screenheight; | |
| screenlayer.alpha = 1.0; | |
| if (screenlayer.img != null){ | |
| screenready = true; | |
| } | |
| layerindex.set("screen", screenlayer); | |
| } | |
| enabled = true; | |
| } | |
| private static function preparescreenlayer(){ | |
| if (!screenready){ | |
| var screenlayer:HaxegonLayer = layerindex.get("screen"); | |
| screenlayer.rendertex = Gfx.backbuffer; | |
| screenlayer.img = Gfx.screen; | |
| screenlayer.width = Gfx.screenwidth; | |
| screenlayer.height = Gfx.screenheight; | |
| screenlayer.alpha = 1.0; | |
| if (screenlayer.img != null){ | |
| screenready = true; | |
| } | |
| layerlistdirty = true; | |
| } | |
| } | |
| private static var screenready:Bool = false; | |
| /** Create a new layer. | |
| * layername: The name of the layer, as a string. | |
| * width/height: Optional width and height - leave blank to make a screen-sized layer. */ | |
| public static function create(layername:String, ?width:Int = 0, ?height:Int = 0){ | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layerindex.exists(layername)){ | |
| trace("Error in Layer.create(\"" + layername + "\"): Layer \"" + layername + "\" already exists."); | |
| }else{ | |
| if (width == 0) width = Gfx.screenwidth; | |
| if (height == 0) height = Gfx.screenheight; | |
| var newlayer:HaxegonLayer = new HaxegonLayer(width, height); | |
| layerindex.set(layername, newlayer); | |
| } | |
| } | |
| /** Check if a layer is currently attached to the canvas. | |
| * layername: The name of the layer to check. */ | |
| public static function attached(layername:String){ | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layername == "screen") preparescreenlayer(); | |
| if (layerindex.exists(layername)){ | |
| return (Starling.current.stage.getChildIndex(layerindex.get(layername).img) > -1); | |
| }else{ | |
| trace("Error in Layer.attach(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| return false; | |
| } | |
| /** Attach a layer to the canvas, at the front. | |
| * layername: The name of the layer to attach. | |
| * x/y: Optional x, y position for the layer - default is 0, 0. */ | |
| public static function attach(layername:String, ?x:Float = 0, ?y:Float = 0){ | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layername == "screen") preparescreenlayer(); | |
| if (layerindex.exists(layername)){ | |
| if (!attached(layername)){ | |
| Starling.current.stage.addChild(layerindex.get(layername).img); | |
| if(x != 0 || y != 0){ | |
| layerindex.get(layername).img.x = x; | |
| layerindex.get(layername).img.y = y; | |
| } | |
| layerlistdirty = true; | |
| }else{ | |
| trace("Error in Layer.attach(\"" + layername + "\"): Layer \"" + layername + "\" is already attached to the canvas."); | |
| } | |
| }else{ | |
| trace("Error in Layer.attach(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| } | |
| /** Detach a layer from the canvas. The layer still exists, and can be reattached again later. | |
| * layername: Optional, the name of the layer to detach. Leave blank to detach all layers. */ | |
| public static function detach(?layername:String){ | |
| if (!enabled) enable(); | |
| if (layername == null){ | |
| var layerlist:Array<String> = getlayers(); | |
| for (i in 0 ... layerlist.length){ | |
| detach(layerlist[i]); | |
| } | |
| }else{ | |
| layername = layername.toLowerCase(); | |
| if (layername == "screen") preparescreenlayer(); | |
| if (layerindex.exists(layername)){ | |
| if(attached(layername)){ | |
| Starling.current.stage.removeChild(layerindex.get(layername).img); | |
| layerlistdirty = true; | |
| }else{ | |
| trace("Error in Layer.detach(\"" + layername + "\"): Layer \"" + layername + "\" is already detached."); | |
| } | |
| }else{ | |
| trace("Error in Layer.detach(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| } | |
| } | |
| /** Get a list of all layers on the canvas, in order from back to front. */ | |
| public static function getlayers():Array<String> { | |
| preparescreenlayer(); | |
| if (layerlistdirty){ | |
| var newlayerlist:Array<Dynamic> = []; | |
| for (l in layerindex.keys()){ | |
| var pos:Int = Starling.current.stage.getChildIndex(layerindex.get(l).img); | |
| if(pos > -1){ | |
| newlayerlist.push({ layername: l, layerpos: pos }); | |
| } | |
| } | |
| ArraySort.sort(newlayerlist, function(a, b) { | |
| if(a.layerpos < b.layerpos) return -1; | |
| else if(a.layerpos > b.layerpos) return 1; | |
| else return 0; | |
| }); | |
| layerlist = []; | |
| for (i in 0 ... newlayerlist.length){ | |
| layerlist.push(newlayerlist[i].layername); | |
| } | |
| layerlistdirty = false; | |
| } | |
| return layerlist; | |
| } | |
| /** Specify a layer to draw to. Use Gfx.drawtoscreen(); when finished to draw to the screen again. | |
| * layername: The name of the layer to draw to. */ | |
| public static function drawto(layername:String){ | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layerindex.exists(layername)){ | |
| Gfx.screenshotdirty = true; | |
| Gfx.endmeshbatch(); | |
| if (Gfx.drawto != null){ | |
| if(Gfx.drawtolocked) Gfx.drawto.bundleunlock(); | |
| Gfx.drawtolocked = false; | |
| } | |
| Gfx.drawto = layerindex.get(layername).rendertex; | |
| if (Gfx.drawto != null){ | |
| if(!Gfx.drawtolocked) Gfx.drawto.bundlelock(); | |
| Gfx.drawtolocked = true; | |
| } | |
| }else{ | |
| trace("Error in Layer.drawto(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| } | |
| /** Copy a layer to an image. The image must have already been created already. | |
| * layername: The name of the layer to copy. | |
| * imagename: The name of the image to paste to. | |
| * xoffset/yoffset: Optional image x/y offset. */ | |
| public static function grabimagefromlayer(layername:String, imagename:String, ?xoffset:Float = 0, ?yoffset:Float = 0) { | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layerindex.exists(layername)){ | |
| if (!Gfx.imageindex.exists(imagename)) { | |
| Debug.log("ERROR: In Layer.grabimage, \"" + imagename + "\" does not exist. You need to create an image label first before using this function."); | |
| return; | |
| } | |
| //Make sure everything's on the screen before we grab it | |
| Gfx.endmeshbatch(); | |
| Gfx.haxegonimage = Gfx.images[Gfx.imageindex.get(imagename)]; | |
| // Acquire SubTexture and build an Image from it. | |
| Gfx.promotetorendertarget(Gfx.haxegonimage.contents); | |
| // Copy the old texture to the new RenderTexture | |
| Gfx.shapematrix.identity(); | |
| Gfx.shapematrix.translate(-xoffset, -yoffset); | |
| cast(Gfx.haxegonimage.contents.texture, RenderTexture).draw(layerindex.get(layername).img, Gfx.shapematrix); | |
| }else{ | |
| trace("Error in Layer.grabimagefromlayer(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| } | |
| /** Rotate a layer. | |
| * layername: The name of the layer to rotate. | |
| * rotation: Number of degrees to rotate the layer. | |
| * pivotx/pivoty: Optional. Specify the pivot point to rotate around. Default is top left. Can use Gfx.CENTER, Gfx.TOP, Gfx.BOTTOM, Gfx.LEFT and Gfx.RIGHT as shortcuts.*/ | |
| public static function rotate(layername:String, rotation:Float, pivotx:Float = 0, pivoty:Float = 0){ | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layerindex.exists(layername)){ | |
| var layerobj:HaxegonLayer = layerindex.get(layername); | |
| layerobj.img.x -= layerobj.img.pivotX; | |
| layerobj.img.y -= layerobj.img.pivotY; | |
| if (pivotx == Gfx.LEFT){ | |
| pivotx = 0; | |
| }else if (pivotx == Gfx.CENTER){ | |
| pivotx = layerobj.width / 2; | |
| }else if (pivotx == Gfx.RIGHT){ | |
| pivotx = layerobj.width; | |
| } | |
| if (pivoty == Gfx.TOP){ | |
| pivoty = 0; | |
| }else if (pivoty == Gfx.CENTER){ | |
| pivoty = layerobj.height / 2; | |
| }else if (pivoty == Gfx.BOTTOM){ | |
| pivoty = layerobj.height; | |
| } | |
| layerobj.img.pivotX = pivotx; | |
| layerobj.img.pivotY = pivoty; | |
| layerobj.img.x += pivotx; | |
| layerobj.img.y += pivoty; | |
| layerobj.img.rotation = Geom.toradians(rotation); | |
| }else{ | |
| trace("Error in Layer.rotate(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| } | |
| /** Get the current rotation of a layer. | |
| * layername: The name of the rotated layer to check. */ | |
| public static function getrotation(layername:String):Float{ | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layerindex.exists(layername)){ | |
| return Geom.todegrees(layerindex.get(layername).img.rotation); | |
| }else{ | |
| trace("Error in Layer.getrotation(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| return 0; | |
| } | |
| /** Scale a layer uniformly. To scale X and Y independently, use "scalex" and "scaley" instead. | |
| * layername: The name of the layer to scale. | |
| * scale: Amount to scale the layer. 1.0 is normal size. | |
| * pivotx/pivoty: Optional. Specify the pivot point to scale around. Default is top left. Can use Gfx.CENTER, Gfx.TOP, Gfx.BOTTOM, Gfx.LEFT and Gfx.RIGHT as shortcuts.*/ | |
| public static function scale(layername:String, scale:Float, pivotx:Float = 0, pivoty:Float = 0){ | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layerindex.exists(layername)){ | |
| var layerobj:HaxegonLayer = layerindex.get(layername); | |
| layerobj.img.x -= layerobj.img.pivotX; | |
| layerobj.img.y -= layerobj.img.pivotY; | |
| if (pivotx == Gfx.LEFT){ | |
| pivotx = 0; | |
| }else if (pivotx == Gfx.CENTER){ | |
| pivotx = layerobj.width / 2; | |
| }else if (pivotx == Gfx.RIGHT){ | |
| pivotx = layerobj.width; | |
| } | |
| if (pivoty == Gfx.TOP){ | |
| pivoty = 0; | |
| }else if (pivoty == Gfx.CENTER){ | |
| pivoty = layerobj.height / 2; | |
| }else if (pivoty == Gfx.BOTTOM){ | |
| pivoty = layerobj.height; | |
| } | |
| layerobj.img.pivotX = pivotx; | |
| layerobj.img.pivotY = pivoty; | |
| layerobj.img.x += pivotx; | |
| layerobj.img.y += pivoty; | |
| layerobj.img.scale = scale; | |
| }else{ | |
| trace("Error in Layer.scale(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| } | |
| /** Get the current scale of a layer. If X and Y scales are different, this returns the X scale only. | |
| * layername: The name of the scaled layer to check. */ | |
| public static function getscale(layername:String):Float{ | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layerindex.exists(layername)){ | |
| return layerindex.get(layername).img.scale; | |
| }else{ | |
| trace("Error in Layer.getscale(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| return 1; | |
| } | |
| /** Scale a layer horizontally. To scale uniformly, use "scale" instead. | |
| * layername: The name of the layer to scale. | |
| * scalex: Amount to scale the layer horizontally. 1.0 is normal size. | |
| * pivotx/pivoty: Optional. Specify the pivot point to scale around. Default is top left. Can use Gfx.CENTER, Gfx.TOP, Gfx.BOTTOM, Gfx.LEFT and Gfx.RIGHT as shortcuts.*/ | |
| public static function scalex(layername:String, scalex:Float, pivotx:Float = 0, pivoty:Float = 0){ | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layerindex.exists(layername)){ | |
| var layerobj:HaxegonLayer = layerindex.get(layername); | |
| layerobj.img.x -= layerobj.img.pivotX; | |
| layerobj.img.y -= layerobj.img.pivotY; | |
| if (pivotx == Gfx.LEFT){ | |
| pivotx = 0; | |
| }else if (pivotx == Gfx.CENTER){ | |
| pivotx = layerobj.width / 2; | |
| }else if (pivotx == Gfx.RIGHT){ | |
| pivotx = layerobj.width; | |
| } | |
| if (pivoty == Gfx.TOP){ | |
| pivoty = 0; | |
| }else if (pivoty == Gfx.CENTER){ | |
| pivoty = layerobj.height / 2; | |
| }else if (pivoty == Gfx.BOTTOM){ | |
| pivoty = layerobj.height; | |
| } | |
| layerobj.img.pivotX = pivotx; | |
| layerobj.img.pivotY = pivoty; | |
| layerobj.img.x += pivotx; | |
| layerobj.img.y += pivoty; | |
| layerobj.img.scaleX = scalex; | |
| }else{ | |
| trace("Error in Layer.scalex(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| } | |
| /** Get the current horizontal scale of a layer. | |
| * layername: The name of the scaled layer to check. */ | |
| public static function getscalex(layername:String):Float{ | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layerindex.exists(layername)){ | |
| return layerindex.get(layername).img.scaleX; | |
| }else{ | |
| trace("Error in Layer.getscalex(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| return 1; | |
| } | |
| /** Scale a layer vertically. To scale uniformly, use "scale" instead. | |
| * layername: The name of the layer to scale. | |
| * scaley: Amount to scale the layer vertically. 1.0 is normal size. | |
| * pivotx/pivoty: Optional. Specify the pivot point to scale around. Default is top left. Can use Gfx.CENTER, Gfx.TOP, Gfx.BOTTOM, Gfx.LEFT and Gfx.RIGHT as shortcuts.*/ | |
| public static function scaley(layername:String, scaley:Float, pivotx:Float = 0, pivoty:Float = 0){ | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layerindex.exists(layername)){ | |
| var layerobj:HaxegonLayer = layerindex.get(layername); | |
| layerobj.img.x -= layerobj.img.pivotX; | |
| layerobj.img.y -= layerobj.img.pivotY; | |
| if (pivotx == Gfx.LEFT){ | |
| pivotx = 0; | |
| }else if (pivotx == Gfx.CENTER){ | |
| pivotx = layerobj.width / 2; | |
| }else if (pivotx == Gfx.RIGHT){ | |
| pivotx = layerobj.width; | |
| } | |
| if (pivoty == Gfx.TOP){ | |
| pivoty = 0; | |
| }else if (pivoty == Gfx.CENTER){ | |
| pivoty = layerobj.height / 2; | |
| }else if (pivoty == Gfx.BOTTOM){ | |
| pivoty = layerobj.height; | |
| } | |
| layerobj.img.pivotX = pivotx; | |
| layerobj.img.pivotY = pivoty; | |
| layerobj.img.x += pivotx; | |
| layerobj.img.y += pivoty; | |
| layerobj.img.scaleY = scaley; | |
| }else{ | |
| trace("Error in Layer.scaley(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| } | |
| /** Get the current vertical scale of a layer. | |
| * layername: The name of the scaled layer to check. */ | |
| public static function getscaley(layername:String):Float{ | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layerindex.exists(layername)){ | |
| return layerindex.get(layername).img.scaleY; | |
| }else{ | |
| trace("Error in Layer.getscaley(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| return 1; | |
| } | |
| /** Scale a layer both horizontally and vertically. To scale uniformly, use "scale" instead. | |
| * layername: The name of the layer to scale. | |
| * scalex: Amount to scale the layer horizontally. 1.0 is normal size. | |
| * scaley: Amount to scale the layer vertically. 1.0 is normal size. | |
| * pivotx/pivoty: Optional. Specify the pivot point to scale around. Default is top left. Can use Gfx.CENTER, Gfx.TOP, Gfx.BOTTOM, Gfx.LEFT and Gfx.RIGHT as shortcuts.*/ | |
| public static function scalexy(layername:String, scalex:Float, scaley:Float, pivotx:Float = 0, pivoty:Float = 0){ | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layerindex.exists(layername)){ | |
| var layerobj:HaxegonLayer = layerindex.get(layername); | |
| layerobj.img.x -= layerobj.img.pivotX; | |
| layerobj.img.y -= layerobj.img.pivotY; | |
| if (pivotx == Gfx.LEFT){ | |
| pivotx = 0; | |
| }else if (pivotx == Gfx.CENTER){ | |
| pivotx = layerobj.width / 2; | |
| }else if (pivotx == Gfx.RIGHT){ | |
| pivotx = layerobj.width; | |
| } | |
| if (pivoty == Gfx.TOP){ | |
| pivoty = 0; | |
| }else if (pivoty == Gfx.CENTER){ | |
| pivoty = layerobj.height / 2; | |
| }else if (pivoty == Gfx.BOTTOM){ | |
| pivoty = layerobj.height; | |
| } | |
| layerobj.img.pivotX = pivotx; | |
| layerobj.img.pivotY = pivoty; | |
| layerobj.img.x += pivotx; | |
| layerobj.img.y += pivoty; | |
| layerobj.img.scaleX = scalex; | |
| layerobj.img.scaleY = scaley; | |
| }else{ | |
| trace("Error in Layer.scalex(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| } | |
| /** Move a layer to a screen x, y position. | |
| * layername: The name of the layer to move. | |
| * x/y: New position for the layer.*/ | |
| public static function move(layername:String, x:Float, y:Float){ | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layerindex.exists(layername)){ | |
| var img:Image = layerindex.get(layername).img; | |
| img.x = x - img.pivotX; | |
| img.y = y - img.pivotY; | |
| }else{ | |
| trace("Error in Layer.move(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| } | |
| /** Get the current x position of a layer. | |
| * layername: The name of the layer to check.*/ | |
| public static function getx(layername:String):Float{ | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layerindex.exists(layername)){ | |
| var img:Image = layerindex.get(layername).img; | |
| return img.x + img.pivotX; | |
| }else{ | |
| trace("Error in Layer.getx(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| return 0; | |
| } | |
| /** Get the current y position of a layer. | |
| * layername: The name of the layer to check. */ | |
| public static function gety(layername:String):Float{ | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layerindex.exists(layername)){ | |
| var img:Image = layerindex.get(layername).img; | |
| return img.y + img.pivotY; | |
| }else{ | |
| trace("Error in Layer.gety(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| return 0; | |
| } | |
| /** Get the width of a layer. | |
| * layername: The name of the layer to check. */ | |
| public static function width(layername:String):Float{ | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layerindex.exists(layername)){ | |
| var layerobj:HaxegonLayer = layerindex.get(layername); | |
| return layerobj.width; | |
| }else{ | |
| trace("Error in Layer.width(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| return 0; | |
| } | |
| /** Get half the width of a layer. Same as width(layername) / 2. | |
| * layername: The name of the layer to check. */ | |
| public static function widthmid(layername:String):Float{ | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layerindex.exists(layername)){ | |
| var layerobj:HaxegonLayer = layerindex.get(layername); | |
| return layerobj.width / 2; | |
| }else{ | |
| trace("Error in Layer.widthmid(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| return 0; | |
| } | |
| /** Get the height of a layer. | |
| * layername: The name of the layer to check. */ | |
| public static function height(layername:String):Float{ | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layerindex.exists(layername)){ | |
| var layerobj:HaxegonLayer = layerindex.get(layername); | |
| return layerobj.height; | |
| }else{ | |
| trace("Error in Layer.height(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| return 0; | |
| } | |
| /** Get half the height of a layer. Same as height(layername) / 2. | |
| * layername: The name of the layer to check. */ | |
| public static function heightmid(layername:String):Float{ | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layerindex.exists(layername)){ | |
| var layerobj:HaxegonLayer = layerindex.get(layername); | |
| return layerobj.height / 2; | |
| }else{ | |
| trace("Error in Layer.heightmid(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| return 0; | |
| } | |
| /** Set the alpha of a layer. | |
| * layername: The name of the layer to check. | |
| * alpha: Alpha value of the layer. Leave blank to restore to 1.0. */ | |
| public static function alpha(layername:String, alpha:Float = 1.0){ | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layerindex.exists(layername)){ | |
| var layerobj:HaxegonLayer = layerindex.get(layername); | |
| layerobj.img.alpha = alpha; | |
| }else{ | |
| trace("Error in Layer.alpha(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| } | |
| /** Get the alpha value of a layer. | |
| * layername: The name of the layer to check. */ | |
| public static function getalpha(layername:String):Float{ | |
| if (!enabled) enable(); | |
| layername = layername.toLowerCase(); | |
| if (layerindex.exists(layername)){ | |
| var layerobj:HaxegonLayer = layerindex.get(layername); | |
| return layerobj.img.alpha; | |
| }else{ | |
| trace("Error in Layer.getalpha(\"" + layername + "\"): Layer \"" + layername + "\" does not exist."); | |
| } | |
| return 1; | |
| } | |
| private static var layerindex:Map<String, HaxegonLayer>; | |
| private static var layerlistdirty:Bool = true; | |
| private static var layerlist:Array<String>; | |
| private static var enabled:Bool = false; | |
| } |