public void refreshFlameImage(
Flame flame, boolean pDrawTriangles, double pFPS, long pFrame, boolean pDrawFPS) {
FlamePanel imgPanel = getFlamePanel();
if (imgPanel == null) return;
Rectangle bounds = imgPanel.getImageBounds();
int width = bounds.width;
int height = bounds.height;
if (width >= 16 && height >= 16) {
RenderInfo info = new RenderInfo(width, height, RenderMode.PREVIEW);
if (flame != null) {
double oldSpatialFilterRadius = flame.getSpatialFilterRadius();
double oldSampleDensity = flame.getSampleDensity();
imgPanel.setDrawTriangles(pDrawTriangles);
try {
double wScl = (double) info.getImageWidth() / (double) flame.getWidth();
double hScl = (double) info.getImageHeight() / (double) flame.getHeight();
flame.setPixelsPerUnit((wScl + hScl) * 0.5 * flame.getPixelsPerUnit());
flame.setWidth(info.getImageWidth());
flame.setHeight(info.getImageHeight());
Flame renderFlame = new FlamePreparer(prefs).createRenderFlame(flame);
FlameRenderer renderer = new FlameRenderer(renderFlame, prefs, false, false);
renderer.setProgressUpdater(null);
RenderedFlame res = renderer.renderFlame(info);
SimpleImage img = res.getImage();
if (pDrawFPS) {
TextTransformer txt = new TextTransformer();
txt.setText1(
"fps: "
+ Tools.doubleToString(pFPS)
+ ", time: "
+ Tools.doubleToString(pFrame / 1000.0)
+ "s");
txt.setAntialiasing(false);
txt.setColor(Color.LIGHT_GRAY);
txt.setMode(Mode.NORMAL);
txt.setFontStyle(FontStyle.PLAIN);
txt.setFontName("Arial");
txt.setFontSize(10);
txt.setHAlign(HAlignment.LEFT);
txt.setVAlign(VAlignment.BOTTOM);
txt.transformImage(img);
}
imgPanel.setImage(img);
} finally {
flame.setSpatialFilterRadius(oldSpatialFilterRadius);
flame.setSampleDensity(oldSampleDensity);
}
}
} else {
try {
imgPanel.setImage(new SimpleImage(width, height));
} catch (Exception ex) {
ex.printStackTrace();
}
}
flameRootPanel.repaint();
}
protected void readColors(String flameXML, Layer layer) {
// Colors
{
int p = 0;
while (true) {
int ps = flameXML.indexOf("<color ", p + 1);
if (ps < 0) break;
int pe = flameXML.indexOf("/>", ps + 1);
String hs = flameXML.substring(ps + 7, pe);
{
int index = 0;
int r = 0, g = 0, b = 0;
XMLAttributes atts = Tools.parseAttributes(hs);
String attr;
if ((attr = atts.get(ATTR_INDEX)) != null) {
index = Integer.parseInt(attr);
}
if ((attr = atts.get(ATTR_RGB)) != null) {
String s[] = attr.split(" ");
r = Tools.FTOI(Double.parseDouble(s[0]));
g = Tools.FTOI(Double.parseDouble(s[1]));
b = Tools.FTOI(Double.parseDouble(s[2]));
}
layer.getPalette().setColor(index, r, g, b);
}
p = pe + 2;
}
}
// Palette
{
int ps = flameXML.indexOf("<palette ");
if (ps >= 0) {
ps = flameXML.indexOf(">", ps + 1);
int pe = flameXML.indexOf("</palette>", ps + 1);
String hs = flameXML.substring(ps + 1, pe);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < hs.length(); i++) {
char c = hs.charAt(i);
if ((c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')) {
sb.append(c);
}
}
hs = sb.toString();
if ((hs.length() % 6) != 0) throw new RuntimeException("Invalid/unknown palette");
int index = 0;
for (int i = 0; i < hs.length(); i += 6) {
int r = Integer.parseInt(hs.substring(i, i + 2), 16);
int g = Integer.parseInt(hs.substring(i + 2, i + 4), 16);
int b = Integer.parseInt(hs.substring(i + 4, i + 6), 16);
// System.out.println(hs.substring(i, i + 2) + "#" + hs.substring(i + 2, i + 4) + "#" +
// hs.substring(i + 4, i + 6));
// System.out.println(" flame->palette->setColor(" + index + "," + r + "," + g + "," + b
// + ");");
layer.getPalette().setColor(index++, r, g, b);
}
}
}
}
@Override
public void setParameter(String pName, double pValue) {
if (PARAM_MODE.equalsIgnoreCase(pName)) mode = Tools.FTOI(pValue);
else if (PARAM_COLOR_MODE.equalsIgnoreCase(pName)) colorMode = Tools.FTOI(pValue);
else if (PARAM_BIAS.equalsIgnoreCase(pName)) bias = pValue;
else if (PARAM_SCALEX.equalsIgnoreCase(pName)) scaleX = pValue;
else if (PARAM_SCALEY.equalsIgnoreCase(pName)) scaleY = pValue;
else if (PARAM_OFFSETX.equalsIgnoreCase(pName)) offsetX = pValue;
else if (PARAM_OFFSETY.equalsIgnoreCase(pName)) offsetY = pValue;
else if (PARAM_OFFSETZ.equalsIgnoreCase(pName)) offsetZ = pValue;
else if (PARAM_TILEX.equalsIgnoreCase(pName)) tileX = Tools.FTOI(pValue);
else if (PARAM_TILEY.equalsIgnoreCase(pName)) tileY = Tools.FTOI(pValue);
else throw new IllegalArgumentException(pName);
}
private static int morphColorValue(int pValue1, int pValue2, double pFScl) {
if (pFScl < 0.0) {
pFScl = 0.0;
} else if (pFScl > 1.0) {
pFScl = 1.0;
}
return Tools.roundColor((double) pValue1 + (double) (pValue2 - pValue1) * pFScl);
}
private static int morphValue(int pValue1, int pValue2, double pFScl) {
if (pFScl < 0.0) {
pFScl = 0.0;
} else if (pFScl > 1.0) {
pFScl = 1.0;
}
return Tools.FTOI(pValue1 + (double) (pValue2 - pValue1) * pFScl);
}
@Override
public void setParameter(String pName, double pValue) {
if (PARAM_CELLSIZE.equalsIgnoreCase(pName)) cellsize = pValue;
else if (PARAM_SPACE.equalsIgnoreCase(pName)) space = pValue;
else if (PARAM_GAIN.equalsIgnoreCase(pName)) gain = pValue;
else if (PARAM_INNER_TWIST.equalsIgnoreCase(pName)) inner_twist = pValue;
else if (PARAM_OUTER_TWIST.equalsIgnoreCase(pName)) outer_twist = pValue;
else if (PARAM_SEED.equalsIgnoreCase(pName)) seed = Tools.FTOI(pValue);
else if (PARAM_RROT.equalsIgnoreCase(pName)) rrot = limitVal(pValue, 0, 1.0);
else if (PARAM_RMIN.equalsIgnoreCase(pName)) rmin = limitVal(pValue, 0, 1.0);
else if (PARAM_LOONIE_CHANCE.equalsIgnoreCase(pName)) loonie_chance = limitVal(pValue, 0, 1.0);
else if (PARAM_PETALS_CHANCE.equalsIgnoreCase(pName)) petals_chance = limitVal(pValue, 0, 1.0);
else if (PARAM_MIN_PETALS.equalsIgnoreCase(pName))
minpetals = limitIntVal(Tools.FTOI(pValue), 1, 1000);
else if (PARAM_MAX_PETALS.equalsIgnoreCase(pName))
maxpetals = limitIntVal(Tools.FTOI(pValue), 1, 1000);
else throw new IllegalArgumentException(pName);
}
public double evaluate(double pTime) {
if (size() == 0) return 0.0;
else if (size() == 1) return y[0];
else if (pTime <= xmin) return y[0];
else if (pTime >= xmax) return y[size() - 1];
int indl = -1, indr = -1;
InterpolatedPoints iPoints = getInterpolatedPoints(x, y, interpolation);
double vSX[] = iPoints.getvSX();
double vSY[] = iPoints.getvSY();
int vSNum = vSX.length;
if (useBisection) {
int low = 0;
int high = vSNum - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
double midVal = vSX[mid];
if (midVal < pTime) {
low = mid + 1;
indl = mid;
} else if (midVal > pTime) {
indr = mid;
high = mid - 1;
} else {
return vSY[mid];
}
}
} else {
for (int i = 0; i < vSNum; i++) {
if (Tools.FTOI(vSX[i]) <= pTime) {
indl = i;
} else {
indr = i;
break;
}
}
}
if ((indl >= 0) && (indr >= 0)) {
double xdist = vSX[indr] - vSX[indl];
if (xdist < 0.00000001) return vSX[indl];
else return vSY[indl] + (pTime - vSX[indl]) / xdist * (vSY[indr] - vSY[indl]);
} else if (indl >= 0) {
return vSY[indl];
} else if (indr >= 0) {
return vSY[indr];
} else {
return 0.0;
}
}
private void setRandomFlameProperty(Layer pLayer, double pAmount) {
List<VariationFunc> variations = new ArrayList<VariationFunc>();
for (XForm xForm : pLayer.getXForms()) {
addVariations(variations, xForm);
}
for (XForm xForm : pLayer.getFinalXForms()) {
addVariations(variations, xForm);
}
filterVariations(variations);
if (variations.size() > 0) {
int idx = (int) (Math.random() * variations.size());
VariationFunc var = variations.get(idx);
int pIdx = (int) (Math.random() * var.getParameterNames().length);
Object oldVal = var.getParameterValues()[pIdx];
if (oldVal instanceof Integer) {
int o = (Integer) oldVal;
int da = Tools.FTOI(pAmount);
if (da < 1) {
da = 1;
}
if (o >= 0) {
o += da;
} else {
o -= da;
}
var.setParameter(var.getParameterNames()[pIdx], o);
} else if (oldVal instanceof Double) {
double o = (Double) oldVal;
if (o < EPSILON || Math.random() < 0.3) {
if (o >= 0) {
o += 0.1 * pAmount;
} else {
o -= 0.1 * pAmount;
}
} else {
if (o >= 0) {
o += o / 100.0 * pAmount;
} else {
o -= o / 100.0 * pAmount;
}
}
var.setParameter(var.getParameterNames()[pIdx], o);
}
}
}
@Override
public void setParameter(String pName, double pValue) {
if (PARAM_NUMEDGES.equalsIgnoreCase(pName)) numEdges = Tools.FTOI(pValue);
else if (PARAM_NUMSTRIPES.equalsIgnoreCase(pName)) numStripes = Tools.FTOI(pValue);
else if (PARAM_RATIOSTRIPES.equalsIgnoreCase(pName)) ratioStripes = limitVal(pValue, 0.0, 2.0);
else if (PARAM_RATIOHOLE.equalsIgnoreCase(pName)) ratioHole = limitVal(pValue, 0.0, 1.0);
else if (PARAM_CIRCUMCIRCLE.equalsIgnoreCase(pName))
circumCircle = limitIntVal(Tools.FTOI(pValue), 0, 1);
else if (PARAM_ADJUSTTOLINEAR.equalsIgnoreCase(pName))
adjustToLinear = limitIntVal(Tools.FTOI(pValue), 0, 1);
else if (PARAM_EQUALBLUR.equalsIgnoreCase(pName))
equalBlur = limitIntVal(Tools.FTOI(pValue), 0, 1);
else if (PARAM_EXACTCALC.equalsIgnoreCase(pName))
exactCalc = limitIntVal(Tools.FTOI(pValue), 0, 1);
else if (PARAM_HIGHLIGHTEDGES.equalsIgnoreCase(pName)) highlightEdges = pValue;
else throw new IllegalArgumentException(pName);
}
public ShadowCalculator(
int rasterWidth,
int rasterHeight,
float[][] originXBuf,
float[][] originYBuf,
float[][] originZBuf,
double imgSize,
Flame flame) {
this.rasterWidth = rasterWidth;
this.rasterHeight = rasterHeight;
this.originXBuf = originXBuf;
this.originYBuf = originYBuf;
this.originZBuf = originZBuf;
lightCount = flame.getSolidRenderSettings().getLights().size();
shadowZBuf = new float[lightCount][][];
pre_shadowIndex = new int[lightCount];
pre_shadowXBuf = new float[lightCount][];
pre_shadowYBuf = new float[lightCount][];
pre_shadowZBuf = new float[lightCount][];
shadowMapXCentre = new double[lightCount];
shadowMapYCentre = new double[lightCount];
shadowMapXScale = new double[lightCount];
shadowMapYScale = new double[lightCount];
lightX = new double[lightCount];
lightY = new double[lightCount];
shadowIntensity = new double[lightCount];
shadowMapSize = flame.getSolidRenderSettings().getShadowmapSize();
if (shadowMapSize < 64) {
shadowMapSize = 64;
}
shadowDistBias = flame.getSolidRenderSettings().getShadowmapBias();
for (int i = 0; i < lightCount; i++) {
DistantLight light = flame.getSolidRenderSettings().getLights().get(i);
if (light.isCastShadows()) {
shadowZBuf[i] = new float[shadowMapSize][shadowMapSize];
pre_shadowXBuf[i] = new float[PRE_SHADOWMAP_SIZE];
pre_shadowYBuf[i] = new float[PRE_SHADOWMAP_SIZE];
pre_shadowZBuf[i] = new float[PRE_SHADOWMAP_SIZE];
for (int k = 0; k < shadowZBuf[i].length; k++) {
for (int l = 0; l < shadowZBuf[i][0].length; l++) {
shadowZBuf[i][k][l] = NormalsCalculator.ZBUF_ZMIN;
}
}
lightX[i] = light.getAltitude();
lightY[i] = light.getAzimuth();
shadowIntensity[i] = 1.0 - GfxMathLib.clamp(light.getShadowIntensity(), 0.0, 1.0);
} else {
shadowZBuf[i] = null;
pre_shadowXBuf[i] = pre_shadowYBuf[i] = pre_shadowZBuf[i] = null;
}
}
shadowSoften = ShadowType.SMOOTH.equals(flame.getSolidRenderSettings().getShadowType());
double rawSmoothRadius = flame.getSolidRenderSettings().getShadowSmoothRadius();
if (rawSmoothRadius < MathLib.EPSILON) {
rawSmoothRadius = 0.0;
}
shadowSmoothRadius = clipSmoothRadius(Tools.FTOI(rawSmoothRadius * 6.0 * imgSize / 1000.0));
if (shadowSmoothRadius < 1.0) {
shadowSoften = false;
shadowSmoothKernel = null;
} else {
shadowSmoothKernel = getShadowSmoothKernel(shadowSmoothRadius);
}
}
protected void parseFlameAttributes(Flame pFlame, String pXML) {
XMLAttributes atts = Tools.parseAttributes(pXML);
String hs;
if ((hs = atts.get(ATTR_NAME)) != null) {
pFlame.setName(hs);
}
if ((hs = atts.get(ATTR_SIZE)) != null) {
String s[] = hs.split(" ");
pFlame.setWidth(Integer.parseInt(s[0]));
pFlame.setHeight(Integer.parseInt(s[1]));
}
if ((hs = atts.get(ATTR_CENTER)) != null) {
String s[] = hs.split(" ");
pFlame.setCentreX(Double.parseDouble(s[0]));
pFlame.setCentreY(Double.parseDouble(s[1]));
}
if ((hs = atts.get(ATTR_SCALE)) != null) {
pFlame.setPixelsPerUnit(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_ROTATE)) != null) {
// pFlame.setCamRoll(-Double.parseDouble(hs) * 180.0 / Math.PI);
pFlame.setCamRoll(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_FILTER)) != null) {
pFlame.setSpatialFilterRadius(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_FILTER_KERNEL)) != null) {
try {
FilterKernelType kernel = FilterKernelType.valueOf(hs);
pFlame.setSpatialFilterKernel(kernel);
} catch (Exception ex) {
ex.printStackTrace();
}
}
// Disable DE filter and check if it is set explicitely on. There are lots of Apo flames out
// there
// which are carrying DE settings, but they were never used and may look terrible (e. g. DE max
// radius 9.0)
pFlame.setDeFilterEnabled(false);
if ((hs = atts.get(ATTR_DE_FILTER_ENABLED)) != null) {
pFlame.setDeFilterEnabled(Integer.parseInt(hs) == 1);
}
if ((hs = atts.get(ATTR_DE_FILTER_MAX_RADIUS)) != null) {
pFlame.setDeFilterMaxRadius(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_DE_FILTER_MIN_RADIUS)) != null) {
pFlame.setDeFilterMinRadius(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_DE_FILTER_CURVE)) != null) {
pFlame.setDeFilterCurve(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_DE_FILTER_KERNEL)) != null) {
try {
FilterKernelType kernel = FilterKernelType.valueOf(hs);
pFlame.setDeFilterKernel(kernel);
} catch (Exception ex) {
ex.printStackTrace();
}
}
if ((hs = atts.get(ATTR_QUALITY)) != null) {
pFlame.setSampleDensity(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_BACKGROUND)) != null) {
String s[] = hs.split(" ");
pFlame.setBGColorRed(Tools.roundColor(255.0 * Double.parseDouble(s[0])));
pFlame.setBGColorGreen(Tools.roundColor(255.0 * Double.parseDouble(s[1])));
pFlame.setBGColorBlue(Tools.roundColor(255.0 * Double.parseDouble(s[2])));
}
if ((hs = atts.get(ATTR_BRIGHTNESS)) != null) {
pFlame.setBrightness(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_BG_TRANSPARENCY)) != null) {
pFlame.setBGTransparency(Integer.parseInt(hs) == 1);
} else {
pFlame.setBGTransparency(prefs.isTinaDefaultBGTransparency());
}
if ((hs = atts.get(ATTR_GAMMA)) != null) {
pFlame.setGamma(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_GAMMA_THRESHOLD)) != null) {
pFlame.setGammaThreshold(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_VIBRANCY)) != null) {
pFlame.setVibrancy(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_CONTRAST)) != null) {
pFlame.setContrast(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_CAM_PERSP)) != null) {
pFlame.setCamPerspective(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_CAM_PERSPECTIVE)) != null) {
pFlame.setCamPerspective(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_CAM_ZPOS)) != null) {
pFlame.setCamZ(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_CAM_XFOCUS)) != null) {
pFlame.setFocusX(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_CAM_YFOCUS)) != null) {
pFlame.setFocusY(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_CAM_ZFOCUS)) != null) {
pFlame.setFocusZ(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_CAM_ZDIMISH)) != null) {
pFlame.setDimishZ(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_CAM_DOF)) != null) {
pFlame.setCamDOF(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_CAM_DOF_AREA)) != null) {
pFlame.setCamDOFArea(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_CAM_DOF_EXPONENT)) != null) {
pFlame.setCamDOFExponent(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_CAM_PITCH)) != null) {
pFlame.setCamPitch(Double.parseDouble(hs) * 180.0 / Math.PI);
}
if ((hs = atts.get(ATTR_CAM_YAW)) != null) {
pFlame.setCamYaw(Double.parseDouble(hs) * 180.0 / Math.PI);
}
if ((hs = atts.get(ATTR_CAM_ZOOM)) != null) {
pFlame.setCamZoom(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_NEW_DOF)) != null) {
pFlame.setNewCamDOF("1".equals(hs));
}
// preserve-z
if ((hs = atts.get(ATTR_PRESERVE_Z)) != null) {
pFlame.setPreserveZ("1".equals(hs));
}
// profiles
if ((hs = atts.get(ATTR_RESOLUTION_PROFILE)) != null) {
pFlame.setResolutionProfile(hs);
}
if ((hs = atts.get(ATTR_QUALITY_PROFILE)) != null) {
pFlame.setQualityProfile(hs);
}
// Shading
if ((hs = atts.get(ATTR_SHADING_SHADING)) != null) {
try {
pFlame.getShadingInfo().setShading(Shading.valueOf(hs));
} catch (Exception ex) {
pFlame.getShadingInfo().setShading(Shading.FLAT);
ex.printStackTrace();
}
}
if ((hs = atts.get(ATTR_SHADING_AMBIENT)) != null) {
pFlame.getShadingInfo().setAmbient(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_SHADING_DIFFUSE)) != null) {
pFlame.getShadingInfo().setDiffuse(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_SHADING_PHONG)) != null) {
pFlame.getShadingInfo().setPhong(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_SHADING_PHONGSIZE)) != null) {
pFlame.getShadingInfo().setPhongSize(Double.parseDouble(hs));
}
int lightCount;
if ((hs = atts.get(ATTR_SHADING_LIGHTCOUNT)) != null) {
lightCount = Integer.parseInt(hs);
} else {
lightCount = 0;
}
for (int i = 0; i < lightCount; i++) {
if ((hs = atts.get(ATTR_SHADING_LIGHTPOSX_ + i)) != null) {
pFlame.getShadingInfo().setLightPosX(i, Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_SHADING_LIGHTPOSY_ + i)) != null) {
pFlame.getShadingInfo().setLightPosY(i, Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_SHADING_LIGHTPOSZ_ + i)) != null) {
pFlame.getShadingInfo().setLightPosZ(i, Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_SHADING_LIGHTRED_ + i)) != null) {
pFlame.getShadingInfo().setLightRed(i, Integer.parseInt(hs));
}
if ((hs = atts.get(ATTR_SHADING_LIGHTGREEN_ + i)) != null) {
pFlame.getShadingInfo().setLightGreen(i, Integer.parseInt(hs));
}
if ((hs = atts.get(ATTR_SHADING_LIGHTBLUE_ + i)) != null) {
pFlame.getShadingInfo().setLightBlue(i, Integer.parseInt(hs));
}
}
if ((hs = atts.get(ATTR_SHADING_BLUR_RADIUS)) != null) {
pFlame.getShadingInfo().setBlurRadius(Integer.parseInt(hs));
}
if ((hs = atts.get(ATTR_SHADING_BLUR_FADE)) != null) {
pFlame.getShadingInfo().setBlurFade(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_SHADING_BLUR_FALLOFF)) != null) {
pFlame.getShadingInfo().setBlurFallOff(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_NEW_LINEAR)) != null) {
pFlame.setPreserveZ(hs.length() > 0 && Integer.parseInt(hs) == 1);
}
if ((hs = atts.get(ATTR_ANTIALIAS_AMOUNT)) != null) {
pFlame.setAntialiasAmount(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_ANTIALIAS_RADIUS)) != null) {
pFlame.setAntialiasRadius(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_SHADING_DISTANCE_COLOR_RADIUS)) != null) {
pFlame.getShadingInfo().setDistanceColorRadius(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_SHADING_DISTANCE_COLOR_SCALE)) != null) {
pFlame.getShadingInfo().setDistanceColorScale(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_SHADING_DISTANCE_COLOR_EXPONENT)) != null) {
pFlame.getShadingInfo().setDistanceColorExponent(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_SHADING_DISTANCE_COLOR_OFFSETX)) != null) {
pFlame.getShadingInfo().setDistanceColorOffsetX(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_SHADING_DISTANCE_COLOR_OFFSETY)) != null) {
pFlame.getShadingInfo().setDistanceColorOffsetY(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_SHADING_DISTANCE_COLOR_OFFSETZ)) != null) {
pFlame.getShadingInfo().setDistanceColorOffsetZ(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_SHADING_DISTANCE_COLOR_STYLE)) != null) {
pFlame.getShadingInfo().setDistanceColorStyle(Integer.parseInt(hs));
}
if ((hs = atts.get(ATTR_SHADING_DISTANCE_COLOR_COORDINATE)) != null) {
pFlame.getShadingInfo().setDistanceColorCoordinate(Integer.parseInt(hs));
}
if ((hs = atts.get(ATTR_SHADING_DISTANCE_COLOR_SHIFT)) != null) {
pFlame.getShadingInfo().setDistanceColorShift(Double.parseDouble(hs));
}
}
@Override
public void setParameter(String pName, double pValue) {
if (PARAM_PARITY.equalsIgnoreCase(pName)) parity = Tools.FTOI(pValue);
else if (PARAM_N.equalsIgnoreCase(pName)) n = Tools.FTOI(pValue);
else throw new IllegalArgumentException(pName);
}
protected void parseXFormAttributes(Flame pFlame, XForm pXForm, String pXML) {
XMLAttributes atts = Tools.parseAttributes(pXML);
String hs;
if ((hs = atts.get(ATTR_NAME)) != null) {
pXForm.setName(hs);
}
if ((hs = atts.get(ATTR_WEIGHT)) != null) {
pXForm.setWeight(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_COLOR)) != null) {
pXForm.setColor(Double.parseDouble(hs));
}
// legacy
if ((hs = atts.get(ATTR_ANTIALIAS_AMOUNT)) != null) {
double value = Double.parseDouble(hs);
if (value > 0) pFlame.setAntialiasAmount(value);
}
// legacy
if ((hs = atts.get(ATTR_ANTIALIAS_RADIUS)) != null) {
double value = Double.parseDouble(hs);
if (value > 0) pFlame.setAntialiasRadius(value);
}
if ((hs = atts.get(ATTR_OPACITY)) != null) {
double opacity = Double.parseDouble(hs);
pXForm.setOpacity(opacity);
if (Math.abs(opacity) <= MathLib.EPSILON) {
pXForm.setDrawMode(DrawMode.HIDDEN);
} else if (Math.abs(opacity - 1.0) > MathLib.EPSILON) {
pXForm.setDrawMode(DrawMode.OPAQUE);
} else {
pXForm.setDrawMode(DrawMode.NORMAL);
}
}
if ((hs = atts.get(ATTR_SYMMETRY)) != null) {
pXForm.setColorSymmetry(Double.parseDouble(hs));
}
if ((hs = atts.get(ATTR_COEFS)) != null) {
String s[] = hs.split(" ");
pXForm.setCoeff00(Double.parseDouble(s[0]));
pXForm.setCoeff01(Double.parseDouble(s[1]));
pXForm.setCoeff10(Double.parseDouble(s[2]));
pXForm.setCoeff11(Double.parseDouble(s[3]));
pXForm.setCoeff20(Double.parseDouble(s[4]));
pXForm.setCoeff21(Double.parseDouble(s[5]));
}
if ((hs = atts.get(ATTR_POST)) != null) {
String s[] = hs.split(" ");
pXForm.setPostCoeff00(Double.parseDouble(s[0]));
pXForm.setPostCoeff01(Double.parseDouble(s[1]));
pXForm.setPostCoeff10(Double.parseDouble(s[2]));
pXForm.setPostCoeff11(Double.parseDouble(s[3]));
pXForm.setPostCoeff20(Double.parseDouble(s[4]));
pXForm.setPostCoeff21(Double.parseDouble(s[5]));
}
if ((hs = atts.get(ATTR_CHAOS)) != null) {
String s[] = hs.split(" ");
for (int i = 0; i < s.length; i++) {
pXForm.getModifiedWeights()[i] = Double.parseDouble(s[i]);
}
}
// variations
{
List<String> variationNameList = VariationFuncList.getNameList();
Map<String, String> aliasMap = VariationFuncList.getAliasMap();
for (XMLAttribute attr : atts.getAttributes()) {
String rawName = attr.getName();
String name = removeIndexFromAttr(rawName);
String varName = name;
boolean hasVariation = variationNameList.indexOf(varName) >= 0;
if (!hasVariation) {
String aliasName = aliasMap.get(name);
if (aliasName != null) {
varName = aliasName;
hasVariation = variationNameList.indexOf(varName) >= 0;
}
}
if (hasVariation) {
VariationFunc varFunc = VariationFuncList.getVariationFuncInstance(varName);
Variation variation = pXForm.addVariation(Double.parseDouble(atts.get(name)), varFunc);
// params
{
String paramNames[] = variation.getFunc().getParameterNames();
String paramAltNames[] = variation.getFunc().getParameterAlternativeNames();
if (paramNames != null) {
if (paramAltNames != null && paramAltNames.length != paramNames.length) {
paramAltNames = null;
}
for (int i = 0; i < paramNames.length; i++) {
String pName = paramNames[i];
String pHs;
if ((pHs = atts.get(rawName + "_" + pName)) != null) {
variation.getFunc().setParameter(pName, Double.parseDouble(pHs));
}
// altNames can only be come from flames which were not created by JWF, so no need
// to handle index here
else if (paramAltNames != null && ((pHs = atts.get(paramAltNames[i])) != null)) {
variation.getFunc().setParameter(pName, Double.parseDouble(pHs));
}
}
}
}
// ressources
{
String ressNames[] = variation.getFunc().getRessourceNames();
if (ressNames != null) {
for (String pName : ressNames) {
String pHs;
if ((pHs = atts.get(name + "_" + pName)) != null) {
variation.getFunc().setRessource(pName, Tools.hexStringToByteArray(pHs));
}
}
}
}
//
}
}
}
}
private static Flame morphFlames_morph(
Prefs pPrefs, Flame pFlame1, Flame pFlame2, int pFrame, int pFrames) {
if (pFrame < 1 || pFrames < 2) return pFlame1;
double fScl = (double) (pFrame - 1) / (pFrames - 1);
if (fScl <= MathLib.EPSILON) {
return pFlame1;
} else if (fScl >= 1.0 - MathLib.EPSILON) {
return pFlame2;
}
Flame res = pFlame1.makeCopy();
res.getLayers().clear();
int layerSize1 = pFlame1.getLayers().size();
int layerSize2 = pFlame2.getLayers().size();
int maxLayerSize = layerSize1 > layerSize2 ? layerSize1 : layerSize2;
for (int lIdx = 0; lIdx < maxLayerSize; lIdx++) {
Layer layer = new Layer();
res.getLayers().add(layer);
// Morph layers
if (lIdx < layerSize1 && lIdx < layerSize2) {
Layer layer1 = pFlame1.getLayers().get(lIdx);
Layer layer2 = pFlame2.getLayers().get(lIdx);
layer.assign(layer1);
layer.getXForms().clear();
layer.getFinalXForms().clear();
layer.setWeight(morphValue(layer1.getWeight(), layer2.getWeight(), fScl));
// morph XForms
{
int size1 = layer1.getXForms().size();
int size2 = layer2.getXForms().size();
int maxSize = size1 > size2 ? size1 : size2;
for (int i = 0; i < maxSize; i++) {
XForm xForm1 = i < size1 ? layer1.getXForms().get(i) : null;
if (xForm1 == null) {
xForm1 = new XForm();
xForm1.addVariation(
0.0, VariationFuncList.getVariationFuncInstance("linear3D", true));
xForm1.setWeight(0.0);
}
XForm xForm2 = i < size2 ? layer2.getXForms().get(i) : null;
if (xForm2 == null) {
xForm2 = new XForm();
xForm2.addVariation(
0.0, VariationFuncList.getVariationFuncInstance("linear3D", true));
xForm2.setWeight(0.0);
}
XForm morphedXForm = morphXForms(pPrefs, xForm1, xForm2, fScl, pFrame, pFrames);
layer.getXForms().add(morphedXForm);
}
}
// morph final XForms
{
int size1 = layer1.getFinalXForms().size();
int size2 = layer2.getFinalXForms().size();
int maxSize = size1 > size2 ? size1 : size2;
for (int i = 0; i < maxSize; i++) {
XForm xForm1 = i < size1 ? layer1.getFinalXForms().get(i) : null;
if (xForm1 == null) {
xForm1 = new XForm();
xForm1.addVariation(
0.0, VariationFuncList.getVariationFuncInstance("linear3D", true));
xForm1.setWeight(0.0);
}
XForm xForm2 = i < size2 ? layer2.getFinalXForms().get(i) : null;
if (xForm2 == null) {
xForm2 = new XForm();
xForm2.addVariation(
0.0, VariationFuncList.getVariationFuncInstance("linear3D", true));
xForm2.setWeight(0.0);
}
XForm morphedXForm = morphXForms(pPrefs, xForm1, xForm2, fScl, pFrame, pFrames);
layer.getFinalXForms().add(morphedXForm);
}
}
// morph colors
RGBPalette palette1 = layer1.getPalette();
RGBPalette palette2 = layer2.getPalette();
for (int i = 0; i < RGBPalette.PALETTE_SIZE; i++) {
RGBColor color1 = palette1.getColor(i);
RGBColor color2 = palette2.getColor(i);
int red = Tools.roundColor(color1.getRed() + (color2.getRed() - color1.getRed()) * fScl);
int green =
Tools.roundColor(color1.getGreen() + (color2.getGreen() - color1.getGreen()) * fScl);
int blue =
Tools.roundColor(color1.getBlue() + (color2.getBlue() - color1.getBlue()) * fScl);
layer.getPalette().setColor(i, red, green, blue);
}
}
// fade out layer1 to black
else if (lIdx < layerSize1) {
Layer layer1 = pFlame1.getLayers().get(lIdx);
layer.assign(layer1);
layer.setWeight(morphValue(layer1.getWeight(), 0.0, fScl));
}
// fade in layer2 from black
else if (lIdx < layerSize2) {
Layer layer2 = pFlame2.getLayers().get(lIdx);
layer.assign(layer2);
layer.setWeight(morphValue(0.0, layer2.getWeight(), fScl));
}
}
// morph camera settings etc.
morphFlameValues(pFlame1, pFlame2, fScl, res);
return res;
}
@Override
protected void fillImage(SimpleImage res) {
int width = res.getImageWidth();
int height = res.getImageHeight();
Random rnd = new Random();
rnd.setSeed(this.seed);
double cover = 1.0 - this.cover;
double aspect = (double) width / (double) height;
int frequency = this.initialFrequency;
int frequencyX = (int) (frequency * aspect + 0.5);
int frequencyY = (int) (frequency * aspect + 0.5);
double alphaInt = 1.0f;
BufferedImage mainImage = res.getBufferedImg();
Graphics2D mainGr = mainImage.createGraphics();
for (int i = 0; i < this.octaves; i++) {
// create a small random image
BufferedImage rndMap = new BufferedImage(frequencyX, frequencyY, BufferedImage.TYPE_INT_ARGB);
{
Graphics2D g = rndMap.createGraphics();
try {
switch (colorMode) {
case COLOR:
for (int x = 0; x < frequencyX; x++) {
for (int y = 0; y < frequencyY; y++) {
int rVal = rnd.nextInt(255);
int gVal = rnd.nextInt(255);
int bVal = rnd.nextInt(255);
g.setColor(new Color(rVal, gVal, bVal, (int) (255.0 * alphaInt + 0.5)));
g.fillRect(x, y, 1, 1);
}
}
break;
case GREY:
for (int x = 0; x < frequencyX; x++) {
for (int y = 0; y < frequencyY; y++) {
int val = rnd.nextInt(255);
g.setColor(new Color(val, val, val, (int) (255.0 * alphaInt + 0.5)));
g.fillRect(x, y, 1, 1);
}
}
break;
case BASE_COLOR:
int rBase = this.cloudColor.getRed();
int gBase = this.cloudColor.getGreen();
int bBase = this.cloudColor.getBlue();
for (int x = 0; x < frequencyX; x++) {
for (int y = 0; y < frequencyY; y++) {
int val = rnd.nextInt(255);
int rVal = (rBase * val) / 255;
int gVal = (gBase * val) / 255;
int bVal = (bBase * val) / 255;
g.setColor(new Color(rVal, gVal, bVal, (int) (255.0 * alphaInt + 0.5)));
g.fillRect(x, y, 1, 1);
}
}
break;
}
} finally {
g.dispose();
}
}
// scale up the image using Java-built-in interpolation
{
BufferedImage scaledRndMap = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
Graphics2D g = scaledRndMap.createGraphics();
try {
g.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
g.drawImage(rndMap, 0, 0, width, height, 0, 0, frequencyX, frequencyY, null);
} finally {
g.dispose();
}
mainGr.drawImage(scaledRndMap, null, 0, 0);
}
alphaInt *= this.persistence;
frequency += frequency;
frequencyX = (int) (frequency * aspect + 0.5);
frequencyY = (int) (frequency * aspect + 0.5);
}
// apply an exponential filter to let the noise more look like clouds
if (mode == Mode.CLOUDS) {
final double rWeight = 0.2990;
final double gWeight = 0.5880;
final double bWeight = 0.1130;
SimpleImage bgImg = (this.backgroundImg != null) ? backgroundImg.getImage() : null;
Pixel pixel = new Pixel();
Pixel bgPixel = new Pixel();
for (int i = 0; i < mainImage.getWidth(); i++) {
for (int j = 0; j < mainImage.getHeight(); j++) {
pixel.setARGBValue(res.getARGBValue(i, j));
double lum = pixel.r * rWeight + pixel.g * gWeight + pixel.b * bWeight;
double c = lum - (cover * 255);
if (c < 0) c = 0;
int iVal = Tools.roundColor(255.0 - (Math.pow(this.sharpness, c) * 255.0));
int bgRed = 0, bgGreen = 0, bgBlue = 0;
switch (bgMode) {
case IMAGE:
if (bgImg != null) {
bgPixel.setARGBValue(bgImg.getARGBValueIgnoreBounds(i, j));
bgRed = bgPixel.r;
bgGreen = bgPixel.g;
bgBlue = bgPixel.b;
}
break;
case COLOR:
bgRed = this.bgColor.getRed();
bgGreen = this.bgColor.getGreen();
bgBlue = this.bgColor.getBlue();
break;
}
switch (colorMode) {
case GREY:
pixel.r = expose(iVal + 1.5 * bgRed);
pixel.g = expose(iVal + 1.5 * bgGreen);
pixel.b = expose(iVal + 1.5 * bgBlue);
break;
default:
pixel.r = expose((iVal * pixel.r) / 255 + 1.5 * bgRed);
pixel.g = expose((iVal * pixel.g) / 255 + 1.5 * bgGreen);
pixel.b = expose((iVal * pixel.b) / 255 + 1.5 * bgBlue);
break;
}
res.setRGB(i, j, pixel);
}
}
}
}
private int expose(double light) {
double exposure = -0.002;
return Tools.roundColor((1.0 - Math.exp(light * exposure)) * 255.0 + 100);
}
public void transform(
FlameTransformationContext pContext,
XForm pXForm,
XYZPoint pAffineTP,
XYZPoint pVarTP,
double pAmount,
double pInputX,
double pInputY) {
double x = (pInputX - (offsetX + 0.5) + 1.0) / scaleX * (double) (imgWidth - 1);
double y = (pInputY - (offsetY + 0.5) + 1.0) / scaleY * (double) (imgHeight - 1);
int ix = Tools.FTOI(x);
int iy = Tools.FTOI(y);
if (this.tileX == 1) {
if (ix < 0) {
int nx = ix / imgWidth - 1;
ix -= nx * imgWidth;
} else if (ix >= imgWidth) {
int nx = ix / imgWidth;
ix -= nx * imgWidth;
}
}
if (this.tileY == 1) {
if (iy < 0) {
int ny = iy / imgHeight - 1;
iy -= ny * imgHeight;
} else if (iy >= imgHeight) {
int ny = iy / imgHeight;
iy -= ny * imgHeight;
}
}
double r, g, b;
if (ix >= 0 && ix < imgWidth && iy >= 0 && iy < imgHeight) {
if (colorMap instanceof SimpleImage) {
toolPixel.setARGBValue(((SimpleImage) colorMap).getARGBValue(ix, iy));
r = (double) toolPixel.r / 255.0;
g = (double) toolPixel.g / 255.0;
b = (double) toolPixel.b / 255.0;
} else {
((SimpleHDRImage) colorMap).getRGBValues(rgbArray, ix, iy);
r = rgbArray[0];
g = rgbArray[0];
b = rgbArray[0];
}
} else {
return;
}
switch (mode) {
case MODE_TRANSLATE:
{
double amountX = (r - 0.5) * pAmount;
double amountY = (g - 0.5) * pAmount;
pVarTP.x += amountX;
pVarTP.y += amountY;
}
break;
case MODE_SCALE:
{
double intensity = calcIntensity(r, g, b) - bias;
if (intensity > 0.0) {
double scl = 1.0 + (intensity - 0.5) * pAmount;
pVarTP.x *= scl;
pVarTP.y *= scl;
}
}
break;
case MODE_SCISSOR:
{
double amountX = (r - 0.5) * pAmount;
double amountY = (g - 0.5) * pAmount;
double newx = pVarTP.x * amountX * amountY + pVarTP.y * amountY;
double newy = pVarTP.x * amountY - pVarTP.y * amountX * amountY;
pVarTP.x = newx;
pVarTP.y = newy;
}
break;
case MODE_ROTATE:
default:
{
double intensity = calcIntensity(r, g, b) - bias;
if (intensity > 0.0) {
double angle = intensity * M_2PI * pAmount;
double sina = sin(angle);
double cosa = cos(angle);
double xnew = pVarTP.x * cosa - pVarTP.y * sina;
double ynew = pVarTP.x * sina + pVarTP.y * cosa;
pVarTP.x = xnew;
pVarTP.y = ynew;
}
}
}
switch (colorMode) {
case COLOR_MODE_INHERIT:
{
pVarTP.rgbColor = true;
pVarTP.redColor = r;
pVarTP.greenColor = g;
pVarTP.blueColor = b;
pVarTP.color = getColorIdx(r, g, b);
}
break;
}
}
@Override
public void init(
FlameTransformationContext pContext, Layer pLayer, XForm pXForm, double pAmount) {
absPower = iabs(Tools.FTOI(power));
cPower = dist / power * 0.5;
}
