[orx-fx] convert to MPP

orx-fx/src/commonMain/kotlin/distort/BlockRepeat.kt

@@ -0,0 +1,44 @@
+package org.openrndr.extra.fx.distort
+
+import org.openrndr.draw.Filter
+import org.openrndr.extra.fx.fx_block_repeat
+import org.openrndr.extra.fx.mppFilterShader
+import org.openrndr.extra.parameters.Description
+import org.openrndr.extra.parameters.DoubleParameter
+
+@Description("Block repeat")
+class BlockRepeat : Filter(mppFilterShader(fx_block_repeat, "block-repeat")) {
+    @DoubleParameter("block width", 0.0, 1.0, order = 0)
+    var blockWidth: Double by parameters
+
+    @DoubleParameter("block height", 0.0, 1.0, order = 1)
+    var blockHeight: Double by parameters
+
+    @DoubleParameter("block x-offset", -0.5, 0.5, order = 2)
+    var blockOffsetX: Double by parameters
+
+    @DoubleParameter("block y-offset", -0.5, 0.5, order = 3)
+    var blockOffsetY: Double by parameters
+
+    /**
+     * Source scale, 0.0 is a 1:1 mapping, 1.0 fits entire source image in block
+     */
+    @DoubleParameter("source scale", 0.0, 1.0, order = 4)
+    var sourceScale: Double by parameters
+
+    @DoubleParameter("source x-offset", -0.5, 0.5, order = 5)
+    var sourceOffsetX: Double by parameters
+
+    @DoubleParameter("source y-offset", -.5, .5, order = 6)
+    var sourceOffsetY: Double by parameters
+
+    init {
+        blockWidth = 0.25
+        blockHeight = 0.25
+        blockOffsetX = 0.0
+        blockOffsetY = 0.0
+        sourceOffsetX = 0.0
+        sourceOffsetY = 0.0
+        sourceScale = 0.0
+    }
+}

orx-fx/src/commonMain/kotlin/distort/DisplaceBlend.kt

@@ -0,0 +1,58 @@
+package org.openrndr.extra.fx.distort
+
+import org.openrndr.draw.*
+import org.openrndr.extra.fx.fx_displace_blend
+import org.openrndr.extra.fx.mppFilterShader
+import org.openrndr.extra.parameters.Description
+import org.openrndr.extra.parameters.DoubleParameter
+import org.openrndr.math.Vector3
+
+@Description("Displace blend")
+class DisplaceBlend : Filter(mppFilterShader(fx_displace_blend, "displace-blend")) {
+    var seed: Vector3 by parameters
+
+    @DoubleParameter("offset", -1.0, 1.0)
+    var offset: Double by parameters
+
+    @DoubleParameter("gain", 0.0, 4.0)
+    var gain: Double by parameters
+
+    @DoubleParameter("feather", 1.0, 100.0)
+    var feather: Double by parameters
+
+    @DoubleParameter("rotation", -180.0, 180.0)
+    var rotation: Double by parameters
+
+    @DoubleParameter("source opacity", 0.0, 1.0)
+    var sourceOpacity: Double by parameters
+
+    @DoubleParameter("target opacity", 0.0, 1.0)
+    var targetOpacity: Double by parameters
+
+    init {
+        gain = 0.1
+        offset = 0.5
+        rotation = 0.0
+        feather = 1.0
+        sourceOpacity = 1.0
+        targetOpacity = 1.0
+    }
+
+    var bicubicFiltering = true
+    private var intermediate: ColorBuffer? = null
+    override fun apply(source: Array<ColorBuffer>, target: Array<ColorBuffer>) {
+        if (source.size >= 2) {
+            if (target[0] === source[0] || target[0] === source[1]) {
+                if (intermediate == null) {
+                    intermediate = colorBuffer(target[0].width, target[0].height, type = target[0].type, format = target[0].format)
+                }
+            }
+            if (bicubicFiltering && source.isNotEmpty()) {
+                source[0].generateMipmaps()
+                source[0].filter(MinifyingFilter.LINEAR_MIPMAP_LINEAR, MagnifyingFilter.LINEAR)
+            }
+            super.apply(source, arrayOf(intermediate ?: target[0]))
+            intermediate?.copyTo(target[0])
+        }
+    }
+}

orx-fx/src/commonMain/kotlin/distort/Fisheye.kt

@@ -0,0 +1,38 @@
+package org.openrndr.extra.fx.distort
+
+import org.openrndr.draw.*
+import org.openrndr.extra.fx.fx_fisheye
+import org.openrndr.extra.fx.mppFilterShader
+import org.openrndr.extra.parameters.Description
+import org.openrndr.extra.parameters.DoubleParameter
+
+@Description("Fisheye")
+class Fisheye : Filter(mppFilterShader(fx_fisheye, "fisheye")) {
+    @DoubleParameter("strength", -1.0, 1.0, order = 0)
+    var strength: Double by parameters
+
+    @DoubleParameter("scale", 0.0, 2.0, order = 0)
+    var scale: Double by parameters
+
+    @DoubleParameter("feather", 0.0, 100.0, order = 1)
+    var feather: Double by parameters
+
+    @DoubleParameter("rotation", -180.0, 180.0, order = 1)
+    var rotation: Double by parameters
+
+    init {
+        strength = 0.1
+        feather = 1.0
+        scale = 1.0
+        rotation = 0.0
+    }
+
+    var bicubicFiltering = true
+    override fun apply(source: Array<ColorBuffer>, target: Array<ColorBuffer>) {
+        if (bicubicFiltering && source.isNotEmpty()) {
+            source[0].generateMipmaps()
+            source[0].filter(MinifyingFilter.LINEAR_MIPMAP_LINEAR, MagnifyingFilter.LINEAR)
+        }
+        super.apply(source, target)
+    }
+}

orx-fx/src/commonMain/kotlin/distort/FluidDistort.kt

@@ -0,0 +1,68 @@
+package org.openrndr.extra.fx.distort
+
+import org.openrndr.draw.ColorBuffer
+import org.openrndr.draw.Filter
+import org.openrndr.draw.createEquivalent
+import org.openrndr.draw.isEquivalentTo
+import org.openrndr.extra.fx.fx_fluid_distort
+import org.openrndr.extra.fx.fx_uvmap
+import org.openrndr.extra.fx.mppFilterShader
+import kotlin.math.cos
+
+private class UVMap: Filter( mppFilterShader(fx_uvmap, "uvmap"))
+
+private class FluidDistortFilter : Filter(mppFilterShader(fx_fluid_distort, "fluid-distort")) {
+    var blend : Double by parameters
+    var random: Double by parameters
+    init {
+        blend = 0.0
+        random = 0.0
+    }
+}
+
+class FluidDistort : Filter() {
+    var blend: Double = 1.0
+
+    var outputUV = false
+
+    private val distort = FluidDistortFilter()
+    private val uvmap = UVMap()
+
+    private var buffer0: ColorBuffer? = null
+    private var buffer1: ColorBuffer? = null
+    private var index = 0
+    override fun apply(source: Array<ColorBuffer>, target: Array<ColorBuffer>) {
+
+        distort.blend = blend
+        distort.random = cos(index*0.5)*0.5+0.5
+
+        buffer0?.let {
+            if (!it.isEquivalentTo(target[0])) {
+                it.destroy()
+            }
+        }
+        if (buffer0 == null) {
+            buffer0 = target[0].createEquivalent()
+        }
+
+        buffer1?.let {
+            if (!it.isEquivalentTo(target[0])) {
+                it.destroy()
+            }
+        }
+        if (buffer1 == null) {
+            buffer1 = target[0].createEquivalent()
+        }
+        val buffers = arrayOf(buffer0!!, buffer1!!)
+        distort.apply(buffers[index%2], buffers[(index+1)%2])
+
+        if (!outputUV) {
+            uvmap.apply(arrayOf(buffers[(index + 1) % 2], source[0]), target[0])
+        } else {
+            buffers[(index+1)%2].copyTo(target[0])
+        }
+        index++
+        blend = 0.0
+    }
+
+}

orx-fx/src/commonMain/kotlin/distort/PerspectivePlane.kt

@@ -0,0 +1,58 @@
+package org.openrndr.extra.fx.distort
+
+import org.openrndr.draw.*
+import org.openrndr.extra.fx.fx_perspective_plane
+import org.openrndr.extra.fx.mppFilterShader
+import org.openrndr.extra.parameters.BooleanParameter
+import org.openrndr.extra.parameters.Description
+import org.openrndr.extra.parameters.DoubleParameter
+import org.openrndr.math.Vector3
+import org.openrndr.math.transforms.transform
+
+@Description("Perspective plane")
+class PerspectivePlane : Filter(mppFilterShader(fx_perspective_plane, "perspective-plane")) {
+    //    @DoubleParameter("camera x", -1.0, 1.0, order = 0)
+    var cameraX: Double = 0.0
+    //    @DoubleParameter("camera y", -1.0, 1.0, order = 1)
+    var cameraY: Double = 0.0
+    //    @DoubleParameter("camera z", -1.0, 1.0, order = 2)
+    var cameraZ: Double = 1.0
+
+
+    @DoubleParameter("plane x", -1.0, 1.0, order = 3)
+    var planeX: Double = 0.0
+    @DoubleParameter("plane y", -1.0, 1.0, order = 4)
+    var planeY: Double = 0.0
+    @DoubleParameter("plane z", -1.0, 1.0, order = 5)
+    var planeZ: Double = 0.5
+
+    @DoubleParameter("plane yaw", -180.0, 180.0, order = 6)
+    var planeYaw: Double = 0.0
+    @DoubleParameter("plane pitch", -180.0, 180.0, order = 7)
+    var planePitch: Double = 0.0
+    @DoubleParameter("plane roll", -180.0, 180.0, order = 8)
+    var planeRoll: Double = 0.0
+
+
+    @BooleanParameter("tile input")
+    var tile: Boolean by parameters
+
+    init {
+        tile = false
+    }
+
+    override fun apply(source: Array<ColorBuffer>, target: Array<ColorBuffer>) {
+        source[0].generateMipmaps()
+        source[0].filter(MinifyingFilter.LINEAR_MIPMAP_LINEAR, MagnifyingFilter.LINEAR)
+        source[0].wrapU = WrapMode.REPEAT
+        source[0].wrapV = WrapMode.REPEAT
+        parameters["cameraPosition"] = Vector3(cameraX, cameraY, cameraZ)
+        parameters["planePosition"] = Vector3(planeX, planeY, planeZ)
+        parameters["planeMatrix"] = transform {
+            rotate(Vector3.UNIT_X, planePitch)
+            rotate(Vector3.UNIT_Y, planeYaw)
+            rotate(Vector3.UNIT_Z, planeRoll)
+        }
+        super.apply(source, target)
+    }
+}

orx-fx/src/commonMain/kotlin/distort/Perturb.kt

@@ -0,0 +1,75 @@
+package org.openrndr.extra.fx.distort
+
+import org.openrndr.draw.*
+import org.openrndr.extra.fx.fx_perturb
+import org.openrndr.extra.fx.mppFilterShader
+import org.openrndr.extra.parameters.*
+import org.openrndr.math.Vector2
+import org.openrndr.math.Vector3
+
+@Description("Perturb")
+class Perturb : Filter(mppFilterShader(fx_perturb, "perturb")) {
+    var seed: Vector3 by parameters
+    /**
+     * base noise scale, default is Vector3(1.0, 1.0, 1.0)
+     */
+    @DoubleParameter("scale", 0.01, 8.0, order = 0)
+    var scale: Double by parameters
+
+    @DoubleParameter("phase", -2.0, 2.0, order = 1)
+    var phase: Double by parameters
+
+    /**
+     * lacunarity is the amount by which scale is modulated per octave, default is Vector3(2.0, 2.0, 2.0)
+     */
+    @DoubleParameter("lacunarity", 0.0, 1.0, order = 2)
+    var lacunarity: Double by parameters
+
+    @DoubleParameter("gain", 0.0, 1.0, order = 3)
+    var gain: Double by parameters
+
+    @DoubleParameter("decay", 0.0, 1.0, order = 4)
+    var decay: Double by parameters
+
+    /**
+     * the number of octaves of noise to generate, default is 4
+     */
+    @IntParameter("octaves", 1, 10, order = 5)
+    var octaves: Int by parameters
+
+    @IntParameter("x segments", 0, 256, order = 6)
+    var xSegments: Int by parameters
+
+    @IntParameter("y segments", 0, 256, order = 7)
+    var ySegments: Int by parameters
+
+    @BooleanParameter("output UV", order = 8)
+    var outputUV: Boolean by parameters
+
+    @Vector2Parameter("offset", -1.0, 1.0, order = 9)
+    var offset: Vector2 by parameters
+
+
+    init {
+        seed = Vector3.ZERO
+        scale = 1.0
+        lacunarity = 2.0
+        gain = 0.5
+        decay = 0.5
+        octaves = 4
+        phase = 0.0
+        xSegments = 0
+        ySegments = 0
+        outputUV = false
+        offset = Vector2.ZERO
+
+    }
+    var bicubicFiltering = true
+    override fun apply(source: Array<ColorBuffer>, target: Array<ColorBuffer>) {
+        if (bicubicFiltering && source.isNotEmpty()) {
+            source[0].generateMipmaps()
+            source[0].filter(MinifyingFilter.LINEAR_MIPMAP_LINEAR, MagnifyingFilter.LINEAR)
+        }
+        super.apply(source, target)
+    }
+}

orx-fx/src/commonMain/kotlin/distort/StackRepeat.kt

@@ -0,0 +1,51 @@
+package org.openrndr.extra.fx.distort
+
+import org.openrndr.draw.*
+import org.openrndr.extra.fx.fx_stack_repeat
+import org.openrndr.extra.fx.mppFilterShader
+import org.openrndr.extra.parameters.Description
+import org.openrndr.extra.parameters.DoubleParameter
+import org.openrndr.extra.parameters.IntParameter
+
+@Description("Stack repeat")
+class StackRepeat : Filter(mppFilterShader(fx_stack_repeat, "stack-repeat")) {
+    @DoubleParameter("zoom", -1.0, 1.0, order = 0)
+    var zoom: Double by parameters
+
+    @DoubleParameter("x-origin", -1.0, 1.0, order = 1)
+    var xOrigin: Double by parameters
+
+    @DoubleParameter("y-origin", -1.0, 1.0, order = 2)
+    var yOrigin: Double by parameters
+
+    @DoubleParameter("x-offset", -1.0, 1.0, order = 3)
+    var xOffset: Double by parameters
+
+    @DoubleParameter("y-offset", -1.0, 1.0, order = 4)
+    var yOffset: Double by parameters
+
+    @DoubleParameter("rotation", -180.0, 180.0, order = 5)
+    var rotation: Double by parameters
+
+    @IntParameter("repeats", 0, 16, order = 6)
+    var repeats: Int by parameters
+
+    init {
+        zoom = 0.0
+        repeats = 2
+        xOffset = 0.0
+        yOffset = 0.0
+        xOrigin = 0.0
+        yOrigin = 0.0
+        rotation = 0.0
+    }
+
+    var bicubicFiltering = true
+    override fun apply(source: Array<ColorBuffer>, target: Array<ColorBuffer>) {
+        if (bicubicFiltering && source.isNotEmpty()) {
+            source[0].generateMipmaps()
+            source[0].filter(MinifyingFilter.LINEAR_MIPMAP_LINEAR, MagnifyingFilter.LINEAR)
+        }
+        super.apply(source, target)
+    }
+}

orx-fx/src/commonMain/kotlin/distort/StretchWaves.kt

@@ -0,0 +1,42 @@
+package org.openrndr.extra.fx.distort
+
+import org.openrndr.draw.*
+import org.openrndr.extra.fx.fx_stretch_waves
+import org.openrndr.extra.fx.mppFilterShader
+import org.openrndr.extra.parameters.Description
+import org.openrndr.extra.parameters.DoubleParameter
+
+@Description("Stretch waves")
+class StretchWaves : Filter(mppFilterShader(fx_stretch_waves, "stretch-waves")) {
+    @DoubleParameter("distortion", -0.0,1.0, 1)
+    var distortion: Double by parameters
+
+    @DoubleParameter("rotation", -180.0, 180.0)
+    var rotation: Double by parameters
+
+    @DoubleParameter("phase", -1.0, 1.0)
+    var phase: Double by parameters
+
+    @DoubleParameter("frequency", 0.0, 100.0)
+    var frequency: Double by parameters
+
+    @DoubleParameter("feather", 0.0, 100.0, order = 1)
+    var feather: Double by parameters
+
+    init {
+        distortion = 0.0
+        rotation = 0.0
+        phase = 0.0
+        frequency = 10.0
+        feather = 1.0
+    }
+
+    var bicubicFiltering = true
+    override fun apply(source: Array<ColorBuffer>, target: Array<ColorBuffer>) {
+        if (bicubicFiltering && source.isNotEmpty()) {
+            source[0].generateMipmaps()
+            source[0].filter(MinifyingFilter.LINEAR_MIPMAP_LINEAR, MagnifyingFilter.LINEAR)
+        }
+        super.apply(source, target)
+    }
+}

orx-fx/src/commonMain/kotlin/distort/TapeNoise.kt

@@ -0,0 +1,55 @@
+package org.openrndr.extra.fx.distort
+
+import org.openrndr.color.ColorRGBa
+import org.openrndr.draw.Filter
+import org.openrndr.extra.fx.fx_tape_noise
+import org.openrndr.extra.fx.mppFilterShader
+import org.openrndr.extra.parameters.BooleanParameter
+import org.openrndr.extra.parameters.ColorParameter
+import org.openrndr.extra.parameters.Description
+import org.openrndr.extra.parameters.DoubleParameter
+
+@Description("Tape noise")
+class TapeNoise : Filter(mppFilterShader(fx_tape_noise, "tape-noise")) {
+    var time: Double by parameters
+
+    @DoubleParameter("gain", 0.0, 1.0)
+    var gain: Double by parameters
+
+    @DoubleParameter("noise low", 0.0, 1.0)
+    var noiseLow: Double by parameters
+
+    @DoubleParameter("noise high", 0.0, 1.0)
+    var noiseHigh: Double by parameters
+
+    @DoubleParameter("gap frequency", 0.0, 2.0)
+    var gapFrequency: Double by parameters
+
+    @DoubleParameter("gap low", -1.0, 1.0)
+    var gapLow: Double by parameters
+    @DoubleParameter("gap high", -1.0, 1.0)
+    var gapHigh: Double by parameters
+
+    @DoubleParameter("deform amplitude", 0.0, 1.0)
+    var deformAmplitude: Double by parameters
+
+    @DoubleParameter("deform frequency", 0.0, 1.0)
+    var deformFrequency: Double by parameters
+
+    @ColorParameter("tint")
+    var tint: ColorRGBa by parameters
+
+    @BooleanParameter("monochrome")
+    var monochrome: Boolean by parameters
+
+    init {
+        gain = 0.5
+        noiseLow = 0.5
+        noiseHigh = 0.8
+        tint = ColorRGBa.WHITE
+        monochrome = false
+        gapFrequency = 10.0
+        gapLow = -1.0
+        gapHigh = -0.99
+     }
+}

orx-fx/src/commonMain/kotlin/distort/Tiles.kt

@@ -0,0 +1,35 @@
+package org.openrndr.extra.fx.distort
+
+import org.openrndr.draw.*
+import org.openrndr.extra.fx.fx_tiles
+import org.openrndr.extra.fx.mppFilterShader
+import org.openrndr.extra.parameters.Description
+import org.openrndr.extra.parameters.DoubleParameter
+import org.openrndr.extra.parameters.IntParameter
+
+@Description("Tiles")
+class Tiles : Filter(mppFilterShader(fx_tiles, "tiles")) {
+    @DoubleParameter("rotation", -180.0, 180.0, order = 2)
+    var rotation: Double by parameters
+
+    @IntParameter("x segments", 0, 256, order = 0)
+    var xSegments: Int by parameters
+
+    @IntParameter("y segments", 0, 256, order = 0)
+    var ySegments: Int by parameters
+
+    init {
+        rotation = 0.0
+        xSegments = 32
+        ySegments = 32
+    }
+
+    var bicubicFiltering = false
+    override fun apply(source: Array<ColorBuffer>, target: Array<ColorBuffer>) {
+        if (bicubicFiltering && source.isNotEmpty()) {
+            source[0].generateMipmaps()
+            source[0].filter(MinifyingFilter.LINEAR_MIPMAP_LINEAR, MagnifyingFilter.LINEAR)
+        }
+        super.apply(source, target)
+    }
+}

orx-fx/src/commonMain/kotlin/distort/VideoGlitch.kt

@@ -0,0 +1,56 @@
+package org.openrndr.extra.fx.distort
+
+import org.openrndr.draw.Filter
+import org.openrndr.extra.fx.fx_video_glitch
+import org.openrndr.extra.fx.mppFilterShader
+import org.openrndr.extra.parameters.BooleanParameter
+import org.openrndr.extra.parameters.Description
+import org.openrndr.extra.parameters.DoubleParameter
+
+@Description("Video glitch")
+class VideoGlitch : Filter(mppFilterShader(fx_video_glitch, "video-glitch")) {
+    var time: Double by parameters
+
+    @DoubleParameter("amplitude", 0.0, 10.0)
+    var amplitude: Double by parameters
+
+    @DoubleParameter("border height", 0.0, 0.5)
+    var borderHeight: Double by parameters
+
+    @DoubleParameter("vertical frequency", 0.0, 10.0)
+    var vfreq: Double by parameters
+
+    @DoubleParameter("horizontal frequency", 0.0, 80.0)
+    var hfreq: Double by parameters
+
+    @DoubleParameter("p frequency", 0.0, 10.0)
+    var pfreq: Double by parameters
+
+    @DoubleParameter("p offset", -1.0, 1.0)
+    var poffset: Double by parameters
+
+    @DoubleParameter("scroll offset 0", 0.0, 1.0)
+    var scrollOffset0: Double by parameters
+
+    @DoubleParameter("scroll offset 1", 0.0, 1.0)
+    var scrollOffset1: Double by parameters
+
+    @BooleanParameter("linear input")
+    var linearInput: Boolean by parameters
+
+    @BooleanParameter("linear output")
+    var linearOutput: Boolean by parameters
+
+    init {
+        amplitude = 1.0
+        vfreq = 4.0
+        pfreq = 10.0
+        hfreq = 80.0
+        poffset = 0.0
+        scrollOffset0 = 0.0
+        scrollOffset1 = 0.0
+        borderHeight = 0.05
+        linearInput = false
+        linearOutput = false
+    }
+}

orx-fx/src/commonMain/kotlin/distort/Wave.kt

@@ -0,0 +1,71 @@
+package org.openrndr.extra.fx.distort
+
+import org.openrndr.draw.*
+import org.openrndr.extra.fx.fx_horizontal_wave
+import org.openrndr.extra.fx.fx_vertical_wave
+import org.openrndr.extra.fx.mppFilterShader
+import org.openrndr.extra.parameters.Description
+import org.openrndr.extra.parameters.DoubleParameter
+import org.openrndr.extra.parameters.IntParameter
+
+@Description("Horizontal wave")
+class HorizontalWave : Filter(mppFilterShader(fx_horizontal_wave, "horizontal-wave")) {
+    @DoubleParameter("frequency", 0.0, 64.0, order = 1)
+    var frequency: Double by parameters
+
+    @DoubleParameter("amplitude", 0.0, 1.0, order = 0)
+    var amplitude: Double by parameters
+
+    @DoubleParameter("phase", -0.5, 0.5, order = 2)
+    var phase: Double by parameters
+
+    @IntParameter("segments", 0, 256, order = 3)
+    var segments: Int by parameters
+
+    init {
+        frequency = 1.0
+        amplitude = 0.1
+        phase = 0.0
+        segments = 0
+    }
+
+    var bicubicFiltering = true
+    override fun apply(source: Array<ColorBuffer>, target: Array<ColorBuffer>) {
+        if (bicubicFiltering && source.isNotEmpty()) {
+            source[0].generateMipmaps()
+            source[0].filter(MinifyingFilter.LINEAR_MIPMAP_LINEAR, MagnifyingFilter.LINEAR)
+        }
+        super.apply(source, target)
+    }
+}
+
+@Description("Vertical wave")
+class VerticalWave : Filter(mppFilterShader(fx_vertical_wave, "vertical-wave")) {
+    @DoubleParameter("frequency", 0.0, 64.0, order = 1)
+    var frequency: Double by parameters
+
+    @DoubleParameter("amplitude", 0.0, 1.0, order = 0)
+    var amplitude: Double by parameters
+
+    @DoubleParameter("phase", -0.5, 0.5, order = 2)
+    var phase: Double by parameters
+
+    @IntParameter("segments", 0, 256, order = 3)
+    var segments: Int by parameters
+
+    init {
+        frequency = 1.0
+        amplitude = 0.1
+        phase = 0.0
+        segments = 0
+    }
+    var bicubicFiltering = true
+
+    override fun apply(source: Array<ColorBuffer>, target: Array<ColorBuffer>) {
+        if (bicubicFiltering && source.isNotEmpty()) {
+            source[0].generateMipmaps()
+            source[0].filter(MinifyingFilter.LINEAR_MIPMAP_LINEAR, MagnifyingFilter.LINEAR)
+        }
+        super.apply(source, target)
+    }
+}