https://linen.dev logo
Join Discord
Powered by
# openfl
  • b
  • b
    I was so close to this lol
  • a
    haha
  • a
    no problem
  • a
    you could probably edit the source so that all images are set to 
    smooth = false
    by default
  • a
    hacky but ...
  • a
    maybe make an issue on haxepunk repo, not sure how active it is though
  • a
    it's crazy how hard it is to get pixelated images sometimes lol
  • a
    not used it myself but in unity I think you need a specific camera or something
  • b
    i know, you'd think something like that would be very simple to do
  • a
    totally
  • b
    also, it looks like using
    Copy code
    img.smooth = false
    might actually be the intended way to do pixelated scaling in HaxePunk
  • b
    I found this in the screenscale example in the HaxePunk git repo:
  • b
    Copy code
    override public function begin()
    {
        var tilemap = new Tilemap("graphics/tiles.png", 840, 512, 60, 60, 4, 4);
        for (x in 0 ... Std.int(840/60))
        {
            for (y in 0 ... Std.int(480/60))
            {
                tilemap.setTile(x, y, Std.random(4));
            }
        }
        tilemap.smooth = false;
        // make any seams caused by scaling obvious
        tilemap.scale = 1.1;
        addGraphic(tilemap);

        label = new Text("Default\nClick to change scale mode.");
        label.smooth = false;
        addGraphic(label);
        label.y = HXP.height/2;

        setScaleMode();
    }
  • b
    taken from MainScene.hx
  • b
    when this application runs the background isn't pixelated, regardless of window size
  • b
    so I guess this is just how we're supposed to it if this is how the official example does it 🤷‍♂️
  • a
    yeah guess so
  • b
    well, I guess that's case closed
  • b
  • b
    thanks again :)
  • p
    @able-action-74275 @bright-restaurant-79188 Just FYI: the 
    smooth
    property doesn't seem to have anything to do with anti-aliasing, what it actually controls is linear vs point sampling. (minification filtering seems to be always linear, but smooth = true will make it use linear filtering for magnification too.) (But in the screenshots half shared it seems to be doing the opposite... maybe the smooth property is inverted somewhere?)
  • e
    does anyone know why 
    Assets.loadBitmapData
    doesn't work on the first try when using 
    Future<T>.result()
    , but succeeds any try after that?
  • a
    can you post an example of how you use it?
  • e
    this
    Copy code
    var loadingBitmap:Future<BitmapData> = OpenFlAssets.loadBitmapData(path).onError(loadingError);
var newBitmap:BitmapData = loadingBitmap.result();

var newGraphic:FlxGraphic;

if (newBitmap == null)
    return FlxG.bitmap.add("flixel/images/logo/default.png"); //get the flixel default image to prevent crashes
               
newGraphic = FlxGraphic.fromBitmapData(newBitmap, false, path);
newGraphic.persist = true;
  • a
    you need to use it like this
    Copy code
    hx
var future = Assets.loadBitmapData(path);

uture.onError(error -> {
    // handle error if there was one
});

future.onComplete(asset ->
{
    // handle asset now it is loaded
    newGraphic = FlxGraphic.fromBitmapData(asset)
});
  • a
    or similar
  • a
    in your code 
    loadingBitmap.result();
    is probably null the first time because it didn't finish loading by using the onComplete event it will have finished loading
  • a
    though I wonder if you need to use this at all
  • e
    if they are loading an arbitrary resource in the browser, it must be async
1...373839...57Latest