LFJGにあるすべてのEffectを紹介します。
まずはじめに構造をお伝えします。
Textureを例に

Texture.createTexture("Texture1").textureName("Test1")

{エフェクト名}.classでcreate{エフェクト名}({識別子}).{エフェクトごとの固有関数}(引数)...etc このような形になります。識別子とはキャッシュからの検索時に使用します。

Texture

このエフェクトはオブジェクトにテクスチャを貼り付けます。

textureName(String textureName)
テクスチャキャッシュに登録されている識別子から検索しテクスチャを貼り付けます。

textureId(int textureId)
すでに作成されたテクスチャIdを渡すことでそのテクスチャを貼り付けます。

blendType(BlendType blendType)
貼り付け前のオブジェクトの色とテクスチャの色をブレンドします。

public class EffectTexture implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectTexture().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "EffectTexture");
    }
}

alt

Translate

このエフェクトは指定した数値の分だけ並行移動を行います。

x(float x)
X軸に並行移動します。 y(float y)
Y軸に並行移動します。 z(float z)
Z軸に並行移動します。

public class EffectTranslate implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectTranslate().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(Translate.createTranslate("Translate").x(100).y(100))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "EffectTranslate");
    }
}

alt

Rotate

このエフェクトはオブジェクトを回転させます

xRadian(float xRadian)
指定した数値のラジアン分だけX軸回転します

yRadian(float yRadian)
指定した数値のラジアン分だけY軸回転します

zRadian(float zRadian)
指定した数値のラジアン分だけZ軸回転します

xDegree(int xDegree)
指定した数値の角度分だけX軸回転します

yDegree(int yDegree)
指定した数値の角度分だけY軸回転します

zDegree(int zDegree)
指定した数値の角度分だけZ軸回転します

autoCenter(boolean autoCenter)
有効にすると自動的にオブジェクトの中心を計算し回転軸を合わせます

cx(float cx)
X軸の回転軸を設定します

cy(float cy)
Y軸の回転軸を設定します

cz(float cz)
Z軸の回転軸を設定します

public class EffectRotate implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectRotate().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(Rotate.createRotate("Rotate").autoCenter(true).zDegree(45))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "EffectRotate");
    }
}

alt

Scale

このエフェクトはオブジェクトのスケールを変更します

x(float x) / x(double x)
X軸にスケールをします

y(float y) / y(double y)
Y軸にスケールをします

z(float z) / z(double z)
Z軸にスケールをします

autoCenter(boolean autoCenter)
有効にすると自動的にオブジェクトの中心を計算しスケール軸を合わせます

cx(float cx)
X軸のスケール軸を設定します

cy(float cy)
Y軸のスケール軸を設定します

cz(float cz)
Z軸のスケール軸を設定します

public class EffectScale implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectScale().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(Scale.createScale("Scale").x(2))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "EffectScale");
    }
}

alt

Bloom

このエフェクトはオブジェクトにブルーム効果（光のにじみ）を付与します

intensity(float intensity)
ブルームの強さを設定します。値が大きいほど光のにじみが強くなります

spread(float spread)
ブルームの広がり具合を設定します。値が大きいほど光が広範囲に拡散します

threshold(float threshold)
ブルーム効果を適用する明るさの閾値を設定します。この値以上の輝度を持つ部分にのみブルームが適用されます

public class EffectBloom implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectBloom().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(Bloom.createBloom("Bloom"))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "EffectBloom");
    }
}

alt

BoxBlur

このエフェクトはオブジェクトにボックスブラー（ぼかし）効果を適用します

kernelX(int kernelX)
X方向のカーネルサイズを設定します。値が大きいほど横方向に強くぼかされます

kernelY(int kernelY)
Y方向のカーネルサイズを設定します。値が大きいほど縦方向に強くぼかされます

public class EffectBoxBlur implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectBoxBlur().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(BoxBlur.createBoxBlur("BoxBlur"))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "EffectBoxBlur");
    }
}

alt

ChromaKey

このエフェクトはクロマキー合成を行い、指定した色を透過します

chromaKeyColor(Color chromaKeyColor)
透過させるクロマキーの基準色を設定します

hueRange(float hueRange) / hueRange(double hueRange) / hueRange(int hueRange)
色相の許容範囲を設定します。値が大きいほど基準色に近い色相が広く透過されます。int の場合は 0〜255 の値を 0〜1 に正規化して使用します

saturationRange(float saturationRange) / saturationRange(double saturationRange) / saturationRange(int saturationRange)
彩度の許容範囲を設定します。値が大きいほど基準色に近い彩度が広く透過されます。int の場合は 0〜255 の値を 0〜1 に正規化して使用します

boundarySmoothness(float boundarySmoothness) / boundarySmoothness(double boundarySmoothness)
クロマキーの境界を滑らかにする強さを設定します。値が大きいほど透過の境界が柔らかくなります

colorAdjustment(Color colorAdjustment)
クロマキー適用後の色を補正するためのカラーを設定します

public class EffectChromaKey implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectChromaKey().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(ChromaKey.createChromaKey("ChromaKey").chromaKeyColor(Color.of(26, 40, 113, 255)))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "ChromaKey");
    }
}

alt

ChromaticAberration

このエフェクトはクロマチックアバレーション（色収差）を表現し、RGBチャンネルをずらして映像に歪みや光学的なにじみを加えます

offsetAmount(float offsetAmount) / offsetAmount(double offsetAmount)
色収差でチャンネルをずらす量を設定します。値が大きいほどRGBのズレが目立ちます

angleRadian(float angle) / angleRadian(double angle)
色収差の方向をラジアンで指定します

angleDegree(float angle) / angleDegree(double angle)
色収差の方向を角度で指定します

strength(float strength) / strength(double strength)
色収差の強さを設定します。値が大きいほど効果が強調されます

aberrationType(AberrationType aberrationType)
適用する色収差のチャンネル組み合わせを指定します

AberrationType 一覧

RED_GREEN_A : 赤と緑のチャンネルをずらします（タイプA）
RED_BLUE_A : 赤と青のチャンネルをずらします（タイプA）
GREEN_BLUE_A : 緑と青のチャンネルをずらします（タイプA）
RED_GREEN_B : 赤と緑のチャンネルをずらします（タイプB）
RED_BLUE_B : 赤と青のチャンネルをずらします（タイプB）
GREEN_BLUE_B : 緑と青のチャンネルをずらします（タイプB）

public class EffectChromaticAberration implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectChromaticAberration().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(ChromaticAberration.createChromaticAberration("ChromaticAberration"))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "EffectChromaticAberration");
    }
}

alt

ClippingRect

このエフェクトは描画領域を矩形でクリッピング（切り抜き）します

x1(float x1) / x1(double x1) / x1(int x1)
クリッピング矩形の左上（または左下）のX座標を設定します

y1(float y1) / y1(double y1) / y1(int y1)
クリッピング矩形の左上（または左下）のY座標を設定します

x2(float x2) / x2(double x2) / x2(int x2)
クリッピング矩形の右下（または右上）のX座標を設定します

y2(float y2) / y2(double y2) / y2(int y2)
クリッピング矩形の右下（または右上）のY座標を設定します

invert(boolean invert)
有効にすると矩形内ではなく矩形外を描画対象にします（クリッピング範囲を反転）

public class EffectClippingRect implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectClippingRect().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(ClippingRect.createClippingRect("ClippingRect").x2(400).y2(400))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "ClippingRect");
    }
}

alt

ColorChanger

このエフェクトは指定した色を別の色に変換します

alpha(boolean alpha)
有効にするとアルファ値（透明度）も変換対象に含めます。無効の場合は色のみを置き換えます

targetColor(Color targetColor)
変換元の色を設定します。この色が描画内で検出されると newColor に置き換えられます

newColor(Color newColor)
変換後の色を設定します。targetColor に一致した部分がこの色で描画されます

public class EffectColorChanger implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectColorChanger().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(ColorChanger.createColorChanger("ColorChanger").targetColor(Color.of(10, 31, 112, 255)))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "ColorChanger");
    }
}

alt

ColorCorrection

このエフェクトは明るさ・コントラスト・彩度・色相を補正します

brightness(float brightness) / brightness(double brightness) / brightness(int brightness)
明るさを調整します。値を大きくすると全体が明るくなり、小さくすると暗くなります。int の場合は 0〜255 の値を 0〜1 に正規化して使用します

contrast(float contrast) / contrast(double contrast) / contrast(int contrast)
コントラストを調整します。値を大きくすると明暗差が強調され、小さくすると淡いトーンになります。int の場合は 0〜255 の値を 0〜1 に正規化して使用します

saturation(float saturation) / saturation(double saturation) / saturation(int saturation)
彩度を調整します。値を大きくすると色が鮮やかになり、小さくするとモノクロに近づきます。int の場合は 0〜255 の値を 0〜1 に正規化して使用します

hue(float hue) / hue(double hue) / hue(int hue)
色相を調整します。値を変えることで色相環に沿って色がシフトします。int の場合は 0〜255 の値を 0〜1 に正規化して使用します

public class EffectColorCorrection implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectColorCorrection().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(ColorCorrection.createColorCorrection("ColorCorrection"))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "ColorCorrection");
    }
}

alt

DiagonalClipping

このエフェクトは斜めのクリッピングを行い、指定した角度の線を境界として描画領域を制御します

centerX(float centerX) / centerX(double centerX)
クリッピング境界線の基準となる中心X座標を設定します

centerY(float centerY) / centerY(double centerY)
クリッピング境界線の基準となる中心Y座標を設定します

clipAngleRadian(float clipAngleRadian) / clipAngleRadian(double clipAngleRadian)
クリッピング境界線の角度をラジアンで指定します

clipAngleDegree(float clipAngleDegree)
クリッピング境界線の角度を角度（度数法）で指定します

blurWidth(float blurWidth) / blurWidth(double blurWidth)
クリッピング境界付近をぼかす幅を設定します。値が大きいほど境界が滑らかになります

invertClip(boolean invertClip)
有効にするとクリッピング範囲を反転し、通常は描画されない領域を描画対象にします

public class EffectDiagonalClipping implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectDiagonalClipping().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("T   est1"))
                .createCache(DiagonalClipping.createDiagonalClipping("DiagonalClipping").centerX(500).centerY(500))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "DiagonalClipping");
    }
}

alt

DirectionalBlur

このエフェクトは指定方向に沿ったブラー（ぼかし）を適用します

radius(float radius) / radius(double radius)
ブラーの半径を設定します。値が大きいほどぼかしが強くなります

angleRadian(float angleRadian) / angleRadian(double angleRadian)
ブラーの方向をラジアンで指定します

angleDegree(float angleDegree)
ブラーの方向を角度（度数法）で指定します

public class EffectDirectionalBlur implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectDirectionalBlur().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(DirectionalBlur.createDirectionBlur("DirectionalBlur"))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "DirectionalBlur");
    }
}

alt

EdgeExtraction

このエフェクトはオブジェクトの輪郭を抽出し、エッジを強調します

edgeStrength(float edgeStrength) / edgeStrength(double edgeStrength)
エッジの強さを設定します。値が大きいほど輪郭が際立ちます

threshold(float threshold) / threshold(double threshold)
エッジ検出の閾値を設定します。この値以上の変化量がある部分のみエッジとして強調されます

enableLuminanceEdge(boolean enableLuminanceEdge)
有効にすると輝度変化に基づいてエッジを検出します

enableAlphaEdge(boolean enableAlphaEdge)
有効にするとアルファ値（透明度）の変化に基づいてエッジを検出します

edgeColor(Color edgeColor)
検出したエッジに適用する色を設定します

public class EffectEdgeExtraction implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectEdgeExtraction().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(EdgeExtraction.createEdgeExtraction("EdgeExtraction"))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "EdgeExtraction");
    }
}

alt

Flash

このエフェクトはオブジェクトや画面にフラッシュライトを適用します

intensity(float intensity) / intensity(double intensity)
フラッシュの強さを設定します。値が大きいほど明るく光ります

x(float x) / x(double x)
フラッシュの中心X座標を設定します

y(float y) / y(double y)
フラッシュの中心Y座標を設定します

flashBlendMode(FlashBlendMode flashBlendMode)
フラッシュの合成方法を指定します。以下のモードがあります：

FORWARD_SYNTHESIS : 通常の前方合成
BACKWARD_SYNTHESIS : 後方合成

LIGHT_COMPONENT_ONLY : 光成分のみ反映

ORIGINAL_COLOR : 元の色を保持

lightColor(Color lightColor)
フラッシュの光の色を設定します

public class EffectFlash implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectFlash().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(Flash.createFlash("Flash"))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "EffectFlash");
    }
}

alt

FXAA

このエフェクトはオブジェクトや画面のエッジを滑らかにしてジャギー（ギザギザ）を軽減します

useAlpha(boolean useAlpha)
有効にするとアルファチャンネル（透明度）も考慮してアンチエイリアシングを適用します。無効の場合は色成分のみが処理されます

public class EffectFXAA implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectFXAA().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(FXAA.createFXAA("FXAA"))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "EffectFXAA");
    }
}

alt

GaussianBlurHorizontal

このエフェクトはオブジェクトや画面に水平方向のガウシアンブラーを適用します

radiusX(float radiusX) / radiusX(double radiusX)
水平方向のぼかし半径を設定します。値が大きいほど横方向に強くぼかされます

public class EffectGaussianBlurHorizontal implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectGaussianBlurHorizontal().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(GaussianBlurHorizontal.createGaussianBlurHorizontal("GaussianBlurHorizontal"))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "EffectGaussianBlurHorizontal");
    }
}

alt

GaussianBlurVertical

このエフェクトはオブジェクトや画面に垂直方向のガウシアンブラーを適用します

radiusX(float radiusX) / radiusX(double radiusX)
垂直方向のぼかし半径を設定します。値が大きいほど縦方向に強くぼかされます

public class EffectGaussianBlurVertical implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectGaussianBlurVertical().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(GaussianBlurVertical.createGaussianBlurVertical("GaussianBlurVertical"))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "EffectGaussianBlurVertical");
    }
}

alt

Glow

このエフェクトはオブジェクトや画面に発光（グロー）効果を適用します

intensity(float intensity) / intensity(double intensity)
グローの強さを設定します。値が大きいほど明るく発光します

threshold(float threshold) / threshold(double threshold)
グロー効果を適用する明るさの閾値を設定します。値以上の明るさの部分のみが発光します

spread(float spread) / spread(double spread)
発光の広がり（拡散）を設定します。値が大きいほど光が広がります

useOriginalColor(boolean useOriginalColor)
有効にすると元の色も保持したままグローを加えます。無効の場合は光の色のみが描画されます

glowColor(Color glowColor)
発光の色を設定します

glowOnly(boolean glowOnly)
有効にすると元のオブジェクトの色を描画せず、グロー部分だけを描画します

public class EffectGlow implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectGlow().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(Glow.createGlow("Glow"))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "EffectGlow");
    }
}

alt

Gradation

このエフェクトは指定した形状に沿ってグラデーションを描画します

centerX(float centerX) / centerX(double centerX)
グラデーションの中心X座標を設定します

centerY(float centerY) / centerY(double centerY)
グラデーションの中心Y座標を設定します

angleRadian(float angleRadian) / angleRadian(double angleRadian)
グラデーションの角度をラジアンで指定します

angleDegree(int angleDegree)
グラデーションの角度を度数法で指定します

width(float width) / width(double width)
グラデーションの幅を設定します

shapeMode(ShapeMode shapeMode)
グラデーションの形状を指定します：

LINE : 線形
CIRCLE : 円形
RECTANGLE : 四角形

blendType(BlendType blendType)
グラデーションのブレンド方法を指定します（描画における色の合成方法）

startColor(Color startColor)
グラデーションの開始色を設定します

endColor(Color endColor)
グラデーションの終了色を設定します

intensity(float intensity) / intensity(double intensity)
グラデーションの強さを設定します。値が大きいほど色の変化が際立ちます

public class EffectGradation implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectGradation().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(Gradation.createGradation("Gradation"))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "EffectGradation");
    }
}

alt

Inversion

このエフェクトはオブジェクトや画面の色・輝度・透明度を反転させます

flipVertical(boolean flipVertical)
有効にすると縦方向に反転（上下逆）します

flipHorizontal(boolean flipHorizontal)
有効にすると横方向に反転（左右逆）します

invertBrightness(boolean invertBrightness)
有効にすると輝度を反転します。明るい部分は暗く、暗い部分は明るくなります

invertHue(boolean invertHue)
有効にすると色相を反転します。色相環で180°反対の色に変化します

invertAlpha(boolean invertAlpha)
有効にするとアルファ値（透明度）を反転します。透明部分は不透明に、不透明部分は透明になります

public class EffectInversion implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectInversion().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(Inversion.createInversion("Inversion"))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "EffectInversion");
    }
}

alt

LensBlur

このエフェクトはレンズ効果のような円形ブラーをオブジェクトや画面に適用します

range(float range) / range(double range)
ブラーの適用範囲を設定します。値が大きいほど広範囲にぼかしがかかります

intensity(float intensity) / intensity(double intensity)
ブラーの強さを設定します。値が大きいほどぼかしが強くなります

sigma(float sigma) / sigma(double sigma)
ガウシアン関数の標準偏差に相当する値で、ブラーの広がり具合を制御します

radialSteps(int radialSteps)
ブラーを適用する半径方向のサンプル数を設定します。値が大きいほど滑らかな円形ブラーになります

angularSamples(int angularSamples)
ブラーを適用する角度方向のサンプル数を設定します。値が大きいほど滑らかで均一なブラーになります

public class EffectLensBlur implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectLensBlur().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(LensBlur.createLensBlur("LensBlur"))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "EffectLensBlur");
    }
}

alt

LuminanceKey

このエフェクトはオブジェクトや画面の明るさ（輝度）に基づいて選択・強調を行います

threshold(float threshold) / threshold(double threshold)
輝度キーの閾値を設定します。指定した閾値以上または以下の部分が処理対象になります

blurAmount(float blurAmount) / blurAmount(double blurAmount)
輝度キーの境界部分に適用するぼかし量を設定します。値が大きいほど境界が滑らかになります

luminanceMode(LuminanceMode luminanceMode)
輝度選択のモードを指定します：

ONLY_DARK : 暗い部分のみを対象にする
ONLY_Light : 明るい部分のみを対象にする
BOTH : 明るい部分と暗い部分の両方を対象にする

public class EffectLuminanceKey implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectLuminanceKey().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(LuminanceKey.createLuminanceKey("LuminanceKey"))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "EffectLuminanceKey");
    }
}

alt

Monochrome

このエフェクトはオブジェクトや画面を単色化（モノクロ化）します

intensity(float intensity) / intensity(double intensity)
モノクロ化の強さを設定します。値が大きいほど完全な単色になります

color(Color color)
モノクロ化に使用する色を設定します。通常はグレー系ですが任意の色に変更可能です

preserveBrightness(boolean preserveBrightness)
有効にすると元の輝度を保持したまま単色化します。無効の場合は輝度も色に置き換えられます

public class EffectMonochrome implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectMonochrome().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(Monochrome.createMonochrome("Monochrome"))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "EffectMonochrome");
    }
}

alt

Pixelate

このエフェクトはオブジェクトや画面をモザイク化（ピクセル化）します

mosaicSize(float mosaicSize) / mosaicSize(double mosaicSize)
モザイク（ピクセル）のサイズを設定します。値が大きいほど荒いモザイクになります

public class EffectPixelate implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectPixelate().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(Pixelate.createPixelate("Pixelate"))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "EffectPixelate");
    }
}

alt

RadialBlur

このエフェクトはオブジェクトや画面に放射状ブラーを適用します

range(float range) / range(double range)
ブラーの適用範囲を設定します。値が大きいほど中心から遠くまでぼかしが広がります

centerX(float centerX) / centerX(double centerX)
放射状ブラーの中心X座標を設定します

centerY(float centerY) / centerY(double centerY)
放射状ブラーの中心Y座標を設定します

public class EffectRadialBlur implements LFJGFrame {
    Frame frame;
    GLRect glRect1;
    EffectCache effectCache1;

    public static void main(String[] args) {
        new EffectRadialBlur().setFrame();
    }

    @Override
    public void init() {
        frame.updateLFJGLContext();

        textureCache.createCache("Test1", Location.fromResource("texture/test/test1.jpg"));

        glRect1 = new GLRect("GLRect1");
        glRect1.uv(0, 1, 1, 0);
        glRect1.rect(0, 0, frame.getFrameBufferWidth(), frame.getFrameBufferHeight(), Color.of(0, 0, 0, 0));
        effectCache1 = EffectCache.createEffectCache()
                .createCache(Texture.createTexture("Texture1").textureName("Test1"))
                .createCache(RadialBlur.createRadialBlur("RadialBlur"))
                .attachGLObject(glRect1);
    }

    @Override
    public void drawFrame() {
        glRect1.draw();
    }

    @Override
    public void stopFrame() {
        glRect1.cleanup();
        effectCache1.cleanup();
    }

    @Override
    public void setFrameSetting() {

    }

    public void setFrame() {
        frame = new Frame(this, "EffectRadialBlur");
    }
}

alt

07. エフェクト2 - hannsi-to/LFJG-LiteFrameJavaGui GitHub Wiki

Texture

Translate

Rotate

Scale

Bloom

BoxBlur

ChromaKey

ChromaticAberration

ClippingRect

ColorChanger

ColorCorrection

DiagonalClipping

DirectionalBlur

EdgeExtraction

Flash

FXAA

GaussianBlurHorizontal

GaussianBlurVertical

Glow

Gradation

Inversion

LensBlur

LuminanceKey

Monochrome

Pixelate

RadialBlur

⚠️ GitHub.com Fallback ⚠️

07. エフェクト2 - hannsi-to/LFJG-LiteFrameJavaGui GitHub Wiki

Texture

Translate

Rotate

Scale

Bloom

BoxBlur

ChromaKey

ChromaticAberration

ClippingRect

ColorChanger

ColorCorrection

DiagonalClipping

DirectionalBlur

EdgeExtraction

Flash

FXAA

GaussianBlurHorizontal

GaussianBlurVertical

Glow

Gradation

Inversion

LensBlur

LuminanceKey

Monochrome

Pixelate

RadialBlur

⚠️ **GitHub.com Fallback** ⚠️

⚠️ GitHub.com Fallback ⚠️