HomeCustom VariationsGlitchy1

Glitchy1

Glitchy1

* Mix of lazysensen and pixel flow by bezo97, https://bezo97.tk/plugins.html
* Variables added by Brad Stefanov and Rick Sidwell and special thanks to
* dark-beam

 

info on variables – from Rick Sidwell

scale_x, scale_y, and scale_z are the scales of the lazysensen swapping for each axis, same as lazysensen.

shift_x, shift_y, and shift_z are the offsets of the lazysensen swapping

n_x, n_y, and n_z are the swap counts; it swaps every n strips (2 for lazysensen behavior)

width controls the size of the shards; larger values make smaller pieces

seed is for the random number generator; change to create different patterns

angle is the sharding angle, in degrees

u, v, and w control the shard randomization in three angles

/*
  JWildfire - an image and animation processor written in Java
  Copyright (C) 1995-2011 Andreas Maschke
 
  This is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser
  General Public License as published by the Free Software Foundation; either version 2.1 of the
  License, or (at your option) any later version.
 
  This software is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
  even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public License along with this software;
  if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jwildfire.create.tina.variation;
 
import org.jwildfire.create.tina.base.Layer;
import org.jwildfire.create.tina.base.XForm;
import org.jwildfire.create.tina.base.XYZPoint;
import org.jwildfire.create.tina.variation.FlameTransformationContext;
import static org.jwildfire.base.mathlib.MathLib.*;
 
import org.jwildfire.base.Tools;
 
public class Glitchy1Func extends VariationFunc {
    private static final long serialVersionUID = 1L;
 
    private static final String PARAM_SCALEX = "scale_x";
    private static final String PARAM_SHIFTX = "shift_x";
    private static final String PARAM_NX = "n_x";
    private static final String PARAM_SCALEY = "scale_y";
    private static final String PARAM_SHIFTY = "shift_y";
    private static final String PARAM_NY = "n_y";
    private static final String PARAM_SCALEZ = "scale_z";
    private static final String PARAM_SHIFTZ = "shift_z";
    private static final String PARAM_NZ = "n_z";
    private static final String PARAM_WIDTH = "width";
    private static final String PARAM_SEED = "seed";
    private static final String PARAM_ANGLE = "angle";
    private static final String PARAM_UU = "u";
    private static final String PARAM_VV = "v";
    private static final String PARAM_WW = "w";
 
    private static final String[] paramNames = { PARAM_SCALEX, PARAM_SHIFTX, PARAM_NX, PARAM_SCALEY, PARAM_SHIFTY,
            PARAM_NY, PARAM_SCALEZ, PARAM_SHIFTZ, PARAM_NZ, PARAM_WIDTH, PARAM_SEED, PARAM_ANGLE, PARAM_UU, PARAM_VV,
            PARAM_WW };
    private double scale_x = 1;
    private double scale_y = 1;
    private double scale_z = 0;
    private double shift_x = 0;
    private double shift_y = 0;
    private double shift_z = 0;
    private int nx = 2;
    private int ny = 2;
    private int nz = 2;;
    private double width = 1.0;
    private int seed = 42;
    private double angle = 30;
    private double u = 1.0;
    private double v = 1.0;
    private double w = 1.0;
   
    private double h, k;
 
    private double hash(int a) { // http://burtleburtle.net/bob/hash/integer.html
        a = (a ^ 61) ^ (a >> 16);
        a = a + (a << 3);
        a = a ^ (a >> 4);
        a = a * 0x27d4eb2d;
        a = a ^ (a >> 15);
        return (double) a / (double) Integer.MAX_VALUE;
    }
 
    @Override
    public void init(FlameTransformationContext pContext, Layer pLayer, XForm pXForm, double pAmount) {
      h = sin(Math.toRadians(angle));
      k = cos(Math.toRadians(angle));      
    }
   
    @Override
    public void transform(FlameTransformationContext pContext, XForm pXForm, XYZPoint pAffineTP, XYZPoint pVarTP,
            double pAmount) {
        /*
         * Mix of lazysensen and pixel flow by bezo97, https://bezo97.tk/plugins.html
         * Variables added by Brad Stefanov and Rick Sidwell and special thanks to
         * dark-beam
         */
        double x = pAffineTP.x;
        double y = pAffineTP.y;
        double z = pAffineTP.z;
 
        if (scale_x != 0.0) {
            double nr = (int) floor((x - shift_x) * scale_x);
            if (nr >= 0) {
                if (nr % nx == (nx - 1))
                    x = 2 * shift_x - x;
            } else {
                if (nr % nx == 0)
                    x = 2 * shift_x - x;
            }
        }
        if (scale_y != 0.0) {
            double nr = (int) floor((y - shift_y) * scale_y);
            if (nr >= 0) {
                if (nr % ny == (ny - 1))
                    y = 2 * shift_y - y;
            } else {
                if (nr % ny == 0)
                    y = 2 * shift_y - y;
            }
        }
        if (scale_z != 0.0) {
            double nr = (int) floor((z - shift_z) * scale_z);
            if (nr >= 0) {
                if (nr % nz == (nz - 1))
                    z = 2 * shift_z - z;
            } else {
                if (nr % nz == 0)
                    z = 2 * shift_z - z;
            }
        }
 
        double uu = u * pAffineTP.x;
        double vv = v * (k * uu + h * pAffineTP.y);
        double ww = w * (k * uu - h * pAffineTP.y);
        int blocku = (int) floor(uu * width);
        blocku += (2.0 - 4.0 * hash(blocku * seed + 1));// varying width and length
        int blockv = (int) floor(vv * width);
        blockv += (2.0 - 4.0 * hash(blockv * seed + 1));
        int blockw = (int) floor(ww * width);
        blockw += (2.0 - 4.0 * hash(blockw * seed + 1));
        double fLen = (hash(blocku + blockv + blockw * -seed) + hash(blocku + blockv + blockw * seed / 2));
        // Doesn't matter just needs to be random enough
 
        pVarTP.x += pAmount * x * fLen;
        pVarTP.y += pAmount * y * fLen;
        pVarTP.z += pAmount * z * fLen;
 
    }
 
    @Override
    public String[] getParameterNames() {
        return paramNames;
    }
 
    @Override
    public Object[] getParameterValues() {
        return new Object[] { scale_x, shift_x, nx, scale_y, shift_y, ny, scale_z, shift_z, nz, width, seed, angle, u,
                v, w };
    }
 
    @Override
    public void setParameter(String pName, double pValue) {
        if (PARAM_SCALEX.equalsIgnoreCase(pName))
            scale_x = pValue;
        else if (PARAM_SHIFTX.equalsIgnoreCase(pName))
            shift_x = pValue;
        else if (PARAM_NX.equalsIgnoreCase(pName))
            nx = Tools.limitValue(Tools.FTOI(pValue), 1, 100);
        else if (PARAM_SCALEY.equalsIgnoreCase(pName))
            scale_y = pValue;
        else if (PARAM_SHIFTY.equalsIgnoreCase(pName))
            shift_y = pValue;
        else if (PARAM_NY.equalsIgnoreCase(pName))
            ny = Tools.limitValue(Tools.FTOI(pValue), 1, 100);
        else if (PARAM_SCALEZ.equalsIgnoreCase(pName))
            scale_z = pValue;
        else if (PARAM_SHIFTZ.equalsIgnoreCase(pName))
            shift_z = pValue;
        else if (PARAM_NZ.equalsIgnoreCase(pName))
            nz = Tools.limitValue(Tools.FTOI(pValue), 1, 100);
        else if (PARAM_WIDTH.equalsIgnoreCase(pName))
            width = pValue;
        else if (PARAM_SEED.equalsIgnoreCase(pName))
            seed = Tools.FTOI(pValue);
        else if (PARAM_ANGLE.equalsIgnoreCase(pName))
            angle = pValue;
        else if (PARAM_UU.equalsIgnoreCase(pName)) {
            u = pValue;
        } else if (PARAM_VV.equalsIgnoreCase(pName)) {
            v = pValue;
        } else if (PARAM_WW.equalsIgnoreCase(pName)) {
            w = pValue;
        }
 
        else
            throw new IllegalArgumentException(pName);
    }
 
    @Override
    public String getName() {
        return "glitchy1";
    }
 
}

 

download java file here

Glitchy1Func

You may be interested in ...

Leave a Comment