Work in Progress GPU Textures

Signed-off-by: TechnikTil <techniktil@tilnotdrip.org>

Author: TechnikTil

src/funkin/graphics/FunkinBitmapData.hx

@@ -0,0 +1,78 @@
+package funkin.graphics;
+
+import lime.graphics.Image;
+import openfl.Lib;
+import openfl.display.BitmapData;
+import openfl.display.DisplayObject;
+import openfl.display.DisplayObjectContainer;
+import openfl.display.IBitmapDrawable;
+import openfl.display.OpenGLRenderer;
+import openfl.display3D.Context3D;
+import openfl.display3D.textures.TextureBase;
+#if (js && html5)
+import lime._internal.graphics.ImageCanvasUtil;
+#end
+
+/**
+ * A fixed version of `BitmapData` that includes proper rendering to the GPU.
+ */
+@:access(openfl.display3D.textures.TextureBase)
+@:access(openfl.display.OpenGLRenderer)
+@:access(openfl.display3D.Context3D)
+class FunkinBitmapData extends BitmapData
+{
+  /**
+   * Creates a new `FunkinBitmapData` using an existing Lime Image instance.
+   * @param image A Lime Image object.
+   * @return A new `FunkinBitmapData` if the Image (and associated ImageBuffer) are not `null`, otherwise `null` will be returned/
+   */
+  public static function fromImage(image:Image):FunkinBitmapData
+  {
+    if (image == null || image.buffer == null)
+      return null;
+
+    var bitmapData:FunkinBitmapData = new FunkinBitmapData(0, 0, true, 0);
+    bitmapData.__fromImage(image);
+    bitmapData.image.transparent = true;
+
+    return bitmapData.image != null ? bitmapData : null;
+  }
+
+  override function __drawGL(source:IBitmapDrawable, renderer:OpenGLRenderer):Void
+  {
+    if (Std.isOfType(source, DisplayObject))
+    {
+      final object:DisplayObjectContainer = cast source;
+      renderer.__stage = object.stage;
+    }
+
+    super.__drawGL(source, renderer);
+  }
+
+  /**
+   * Uploads this `FunkinBitmapData` image to the GPU.
+   */
+  public function uploadToGPU():Void
+  {
+    var context3D:Context3D = Lib.current.stage.context3D;
+
+    if (context3D == null || this.image == null)
+      return;
+
+    #if openfl_power_of_two this.image.powerOfTwo = true; #end
+    this.image.premultiplied = true;
+    this.image.format = BGRA32;
+
+    if (this.__texture == null)
+    {
+      this.__texture = context3D.createTexture(this.image.width, this.image.height, BGRA, true);
+      this.__textureContext = context3D.__context;
+    }
+
+    this.getTexture(context3D);
+
+    this.readable = false;
+    this.__surface = null;
+    this.image = null;
+  }
+}

src/funkin/util/path/PathsCache.hx src/funkin/graphics/FunkinCache.hxsrc/funkin/util/path/PathsCache.hx renamed to src/funkin/graphics/FunkinCache.hx

@@ -1,19 +1,21 @@
-package funkin.util.path;
+package funkin.graphics;
 
 import flixel.graphics.FlxGraphic;
 import haxe.Http;
 import haxe.io.Bytes;
+import lime.app.Future;
+import lime.graphics.Image;
 import lime.media.AudioBuffer;
+import lime.utils.Assets as LimeAssets;
 import openfl.display.BitmapData;
 import openfl.media.Sound;
 import openfl.system.System;
 
 /**
- * A caching system for PathsContent.
- *
- * This caches content like audios and images for faster returning rather than taking a long time each time.
+ * The main caching system.
  */
-class PathsCache
+@:access(flixel.system.frontEnds.AssetFrontEnd)
+class FunkinCache
 {
   /**
    * The content that doesn't get wiped from a cache clean.
@@ -86,7 +88,33 @@ class PathsCache
     return cachedAudio.get(key);
   }
 
-  // TODO: Maybe add gpu caching to images when we get options?
+  /**
+   * Returns an `Image` instance.
+   * @param key Image key to return.
+   * @return `Image` Instance.
+   */
+  function getImage(key:String):Image
+  {
+    var useOpenFL:Bool = {
+      #if FLX_CUSTOM_ASSETS_DIRECTORY
+      FlxG.assets.useOpenflAssets(key);
+      #else
+      true;
+      #end
+    };
+
+    var isURL:Bool = StringUtil.isURL(key);
+
+    if (!useOpenFL)
+    {
+      var path:String = isURL ? key : FlxG.assets.getPath(key);
+      return Image.fromFile(path);
+    }
+    else
+    {
+      return LimeAssets.getImage(key, false);
+    }
+  }
 
   /**
    * Caches and returns an BitmapData instance.
@@ -101,16 +129,11 @@ class PathsCache
 
       try
       {
-        if (StringUtil.isURL(key))
-        {
-          var imageRequest:Http = new Http(key);
-          imageRequest.request();
-          bitmapData = BitmapData.fromBytes(imageRequest.responseBytes);
-        }
-        else
-        {
-          bitmapData = FlxG.assets.getBitmapDataUnsafe(key, false);
-        }
+        var image:Image = getImage(key);
+        bitmapData = FunkinBitmapData.fromImage(image);
+
+        // TODO: Put this behind an option.
+        cast(bitmapData, FunkinBitmapData)?.uploadToGPU();
       }
       catch (e:Exception)
       {

src/funkin/ui/FunkinTransition.hx

@@ -53,6 +53,7 @@ class FunkinTransition extends FunkinSubState
 
     initCamera();
 
+    // TODO: put the gradient into cache.
     transGradient = FlxGradient.createGradientFlxSprite(transitionCamera.width, transitionCamera.height, [0xFF000000, 0x0]);
 
     black = new FunkinSprite(0, 0);

src/funkin/ui/freeplay/backingcards/BoyfriendBackingCard.hx

@@ -1,8 +1,11 @@
 package funkin.ui.freeplay.backingcards;
 
+import animate.internal.filters.MaskShader;
+import flixel.graphics.FlxGraphic;
 import flixel.util.FlxSpriteUtil;
 import funkin.ui.freeplay.BGScrollingText;
 import funkin.ui.freeplay.FreeplayState;
+import openfl.geom.Rectangle;
 
 class BoyfriendBackingCard extends BackingCard
 {
@@ -25,8 +28,13 @@ class BoyfriendBackingCard extends BackingCard
   {
     super(instance);
 
-    orangeBack = new FunkinSprite(84, 440).loadTexture('#FEDA00', Std.int(pinkBack.width), 75);
-    FlxSpriteUtil.alphaMaskFlxSprite(orangeBack, pinkBack, orangeBack);
+    var rectangle:Rectangle = new Rectangle(84, 440);
+
+    var orangeBackGraphic:FlxGraphic = FlxG.bitmap.create(Std.int(pinkBack.width), 75, 0xFFFEDA00);
+    MaskShader.maskAlpha(orangeBackGraphic.bitmap, pinkBack.graphic.bitmap, rectangle);
+
+    orangeBack = new FunkinSprite(rectangle.x, rectangle.y);
+    orangeBack.loadGraphic(orangeBackGraphic);
     add(orangeBack);
 
     orangeBackTwo = new FunkinSprite(0, 440).loadTexture('#FFD400', 100, Std.int(orangeBack.height));

src/funkin/util/path/PathsContent.hx

@@ -4,6 +4,7 @@ import animate.FlxAnimateFrames;
 import flixel.graphics.FlxGraphic;
 import flixel.graphics.frames.FlxAtlasFrames;
 import flixel.graphics.frames.FlxFramesCollection;
+import funkin.graphics.FunkinCache;
 import haxe.io.Path;
 import openfl.display.BitmapData;
 import openfl.media.Sound;
@@ -19,14 +20,14 @@ class PathsContent
    *
    * Contains BitmapData, FlxGraphic, and Sound objects.
    */
-  public var cache:PathsCache = null;
+  public var cache:FunkinCache = null;
 
   /**
    * Initializes all variables for use with this class.
    */
   public function new()
   {
-    cache = new PathsCache();
+    cache = new FunkinCache();
   }
 
   /**