String platformName = platformNames[i];

String platformName32 = platformName + "32";

String platformName64 = platformName + "64";

String platformNameArmv6hh = platformName + "-armv6hf";

// First check for things like 'application.macosx=' or 'application.windows32' in the export.txt file.

// These will override anything in the platform-specific subfolders.

String[] platformList32 = platform32 == null ? null : PApplet.splitTokens(platform32, ", ");

String platform64 = exportTable.get("application." + platformName + "64");

String[] platformList64 = platform64 == null ? null : PApplet.splitTokens(platform64, ", ");

String platformArmv6hf = exportTable.get("application." + platformName + "-armv6hf");

String[] platformListArmv6hf = platformArmv6hf == null ? null : PApplet.splitTokens(platformArmv6hf, ", ");

// If nothing specified in the export.txt entries, look for the platform-specific folders.

if (platformAll == null) {

if (platform64 == null) {

platformList64 = listPlatformEntries(libraryFolder, platformName64, baseList);

}

if (platformListArmv6hf == null) {

platformListArmv6hf = listPlatformEntries(libraryFolder, platformNameArmv6hh, baseList);

}

if (platformList32 != null || platformList64 != null || platformListArmv6hf != null) {

multipleArch[i] = true;

}

// if there aren't any relevant imports specified or in their own folders,

// then use the baseList (root of the library folder) as the default.

if (platformList == null && platformList32 == null && platformList64 == null && platformListArmv6hf == null) {

exportList.put(platformName, baseList);

} else {

if (platformList64 != null) {

exportList.put(platformName64, platformList64);

}

if (platformListArmv6hf != null) {

exportList.put(platformNameArmv6hh, platformListArmv6hf);

}

}

}

}

public File[] getApplicationExports(int platform, String variant) {

String[] list = getApplicationExportList(platform, variant);

return wrapFiles(list);

}

public String[] getApplicationExportList(int platform, String variant) {

String platformName = PConstants.platformNames[platform];

if (variant.equals("32")) {

String[] pieces = exportList.get(platformName + "32");

if (pieces != null) return pieces;

} else if (variant.equals("64")) {

String[] pieces = exportList.get(platformName + "64");

if (pieces != null) return pieces;

} else if (variant.equals("armv6hf")) {

String[] pieces = exportList.get(platformName + "-armv6hf");

if (pieces != null) return pieces;

}

return exportList.get(platformName);

}

}

public boolean supportsArch(int platform, String variant) {

// If this is a universal library, or has no natives, then we're good.

if (multipleArch[platform] == false) {

return true;

}

return getApplicationExportList(platform, variant) != null;

}

<!-- there is currently no JRE available -->

<property name="jre.download.jdk" value="true" />

<property name="jre.downloader" value="linux-arm-vfp-hflt.tar.gz" />

<property name="linux.dist" value="linux/processing-${version}-linux-armv6hf.tgz" />

</target>

<!-- Require Java 8 everywhere. -->

<!-- Copy shaders to bin. (Eclipse does this automatically.) -->

<copy todir="bin">

<fileset dir="src">

<include name="processing/opengl/shaders/*.glsl" />

<include name="icon/*.png" />

</fileset>

</copy>

</target>

application.windows64=core.jar,jogl-all.jar,gluegen-rt.jar,jogl-all-natives-windows-amd64.jar,gluegen-rt-natives-windows-amd64.jar

application.linux32=core.jar,jogl-all.jar,gluegen-rt.jar,jogl-all-natives-linux-i586.jar,gluegen-rt-natives-linux-i586.jar

application.linux64=core.jar,jogl-all.jar,gluegen-rt.jar,jogl-all-natives-linux-amd64.jar,gluegen-rt-natives-linux-amd64.jar

application.linux-armv6hf=core.jar,jogl-all.jar,gluegen-rt.jar,jogl-all-natives-linux-armv6hf.jar,gluegen-rt-natives-linux-armv6hf.jar

if (smooth < 1) {

pgl.disable(PGL.MULTISAMPLE);

} else {

// work around runtime exceptions in Broadcom's VC IV driver

if (false == OPENGL_RENDERER.equals("VideoCore IV HW")) {

pgl.enable(PGL.MULTISAMPLE);

}

}

// work around runtime exceptions in Broadcom's VC IV driver

if (false == OPENGL_RENDERER.equals("VideoCore IV HW")) {

pgl.disable(PGL.POLYGON_SMOOTH);

}

if (sized) {

pgl.getIntegerv(PGL.MAX_TEXTURE_SIZE, intBuffer);

maxTextureSize = intBuffer.get(0);

// work around runtime exceptions in Broadcom's VC IV driver

if (false == OPENGL_RENDERER.equals("VideoCore IV HW")) {

pgl.getIntegerv(PGL.MAX_SAMPLES, intBuffer);

maxSamples = intBuffer.get(0);

}

if (anisoSamplingSupported) {

pgl.getFloatv(PGL.MAX_TEXTURE_MAX_ANISOTROPY, floatBuffer);

maxAnisoAmount = floatBuffer.get(0);

}

// overwrite the default shaders with vendor specific versions

// if needed

if (OPENGL_RENDERER.equals("VideoCore IV HW") || // Broadcom's binary driver for Raspberry Pi

OPENGL_RENDERER.equals("Gallium 0.4 on VC4")) { // Mesa driver for same hardware

defLightShaderVertURL =

PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/LightVert-vc4.glsl");

defTexlightShaderVertURL =

PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/TexLightVert-vc4.glsl");

}

glParamsRead = true;

}

if (profile == null) {

if (PJOGL.profile == 2) {

try {

if ("arm".equals(System.getProperty("os.arch"))) {

// request at least GL2 or GLES2

profile = GLProfile.getGL2ES2();

} else {

// stay compatible with previous versions for now

profile = GLProfile.getGL2ES1();

}

} catch (GLException ex) {

profile = GLProfile.getMaxFixedFunc(true);

}

#define PROCESSING_LIGHT_SHADER

uniform mat4 modelviewMatrix;

uniform mat4 transformMatrix;

uniform mat3 normalMatrix;

uniform int lightCount;

uniform vec4 lightPosition[8];

uniform vec3 lightNormal[8];

uniform vec3 lightAmbient[8];

uniform vec3 lightDiffuse[8];

uniform vec3 lightSpecular[8];

uniform vec3 lightFalloff[8];

uniform vec2 lightSpot[8];

attribute vec4 position;

attribute vec4 color;

attribute vec3 normal;

attribute vec4 ambient;

attribute vec4 specular;

attribute vec4 emissive;

attribute float shininess;

varying vec4 vertColor;

varying vec4 backVertColor;

const float zero_float = 0.0;

const float one_float = 1.0;

const vec3 zero_vec3 = vec3(0);

float falloffFactor(vec3 lightPos, vec3 vertPos, vec3 coeff) {

vec3 lpv = lightPos - vertPos;

vec3 dist = vec3(one_float);

dist.z = dot(lpv, lpv);

dist.y = sqrt(dist.z);

return one_float / dot(dist, coeff);

}

float spotFactor(vec3 lightPos, vec3 vertPos, vec3 lightNorm, float minCos, float spotExp) {

vec3 lpv = normalize(lightPos - vertPos);

vec3 nln = -one_float * lightNorm;

float spotCos = dot(nln, lpv);

return spotCos <= minCos ? zero_float : pow(spotCos, spotExp);

}

float lambertFactor(vec3 lightDir, vec3 vecNormal) {

return max(zero_float, dot(lightDir, vecNormal));

}

float blinnPhongFactor(vec3 lightDir, vec3 vertPos, vec3 vecNormal, float shine) {

vec3 np = normalize(vertPos);

vec3 ldp = normalize(lightDir - np);

return pow(max(zero_float, dot(ldp, vecNormal)), shine);

}

void main() {

// Vertex in clip coordinates

gl_Position = transformMatrix * position;

// Vertex in eye coordinates

vec3 ecVertex = vec3(modelviewMatrix * position);

// Normal vector in eye coordinates

vec3 ecNormal = normalize(normalMatrix * normal);

vec3 ecNormalInv = ecNormal * -one_float;

// Light calculations

vec3 totalAmbient = vec3(0, 0, 0);

vec3 totalFrontDiffuse = vec3(0, 0, 0);

vec3 totalFrontSpecular = vec3(0, 0, 0);

vec3 totalBackDiffuse = vec3(0, 0, 0);

vec3 totalBackSpecular = vec3(0, 0, 0);

// prevent register allocation failure by limiting ourselves to

// two lights for now

for (int i = 0; i < 2; i++) {

if (lightCount == i) break;

vec3 lightPos = lightPosition[i].xyz;

bool isDir = zero_float < lightPosition[i].w;

float spotCos = lightSpot[i].x;

float spotExp = lightSpot[i].y;

vec3 lightDir;

float falloff;

float spotf;

if (isDir) {

falloff = one_float;

lightDir = -one_float * lightNormal[i];

} else {

falloff = falloffFactor(lightPos, ecVertex, lightFalloff[i]);

lightDir = normalize(lightPos - ecVertex);

}

spotf = spotExp > zero_float ? spotFactor(lightPos, ecVertex, lightNormal[i],

spotCos, spotExp)

: one_float;

if (any(greaterThan(lightAmbient[i], zero_vec3))) {

totalAmbient += lightAmbient[i] * falloff;

}

if (any(greaterThan(lightDiffuse[i], zero_vec3))) {

totalFrontDiffuse += lightDiffuse[i] * falloff * spotf *

lambertFactor(lightDir, ecNormal);

totalBackDiffuse += lightDiffuse[i] * falloff * spotf *

lambertFactor(lightDir, ecNormalInv);

}

if (any(greaterThan(lightSpecular[i], zero_vec3))) {

totalFrontSpecular += lightSpecular[i] * falloff * spotf *

blinnPhongFactor(lightDir, ecVertex, ecNormal, shininess);

totalBackSpecular += lightSpecular[i] * falloff * spotf *

blinnPhongFactor(lightDir, ecVertex, ecNormalInv, shininess);

}

}

// Calculating final color as result of all lights (plus emissive term).

// Transparency is determined exclusively by the diffuse component.

vertColor = vec4(totalAmbient, 0) * ambient +

vec4(totalFrontDiffuse, 1) * color +

vec4(totalFrontSpecular, 0) * specular +

vec4(emissive.rgb, 0);

backVertColor = vec4(totalAmbient, 0) * ambient +

vec4(totalBackDiffuse, 1) * color +

vec4(totalBackSpecular, 0) * specular +

vec4(emissive.rgb, 0);

}

uniform vec3 lightNormal[8];

uniform vec3 lightAmbient[8];

uniform vec3 lightDiffuse[8];

uniform vec3 lightSpecular[8];

uniform vec3 lightFalloff[8];

uniform vec2 lightSpot[8];