218 lines
6.3 KiB
Plaintext
218 lines
6.3 KiB
Plaintext
/*
|
|
|
|
This file is part of "Interface Fractures III - Silicon".
|
|
Copyright (c) 2015 Luka Prinčič, All rights reserved.
|
|
This program is free software distributed under
|
|
GNU General Public Licence. See COPYING for more info.
|
|
- - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
functions.pde
|
|
*/
|
|
|
|
|
|
|
|
// function to shuffle an array of integers
|
|
void shuffle(int[] a)
|
|
{
|
|
int temp, pick;
|
|
|
|
for(int i=0; i<a.length; i++)
|
|
{
|
|
temp = a[i];
|
|
pick = (int)random(a.length);
|
|
a[i] = a[pick];
|
|
a[pick] = temp;
|
|
}
|
|
}
|
|
|
|
void screenClean(color c) { // -----------------------------------------
|
|
fill(c);
|
|
noStroke();
|
|
rect(0, 0, width, height);
|
|
}
|
|
|
|
|
|
|
|
void displayFps(boolean render) { // -----------------------------------
|
|
if (render){
|
|
// Display Fps
|
|
//fill(0); noStroke(); rect(width-80, 10, 80, 30, 4);
|
|
fill(255);
|
|
textFont(fpsFont);
|
|
textSize(16);
|
|
text(int(frameRate)+"fps", width-60, 20, 5);}
|
|
}
|
|
|
|
void autoSnap(boolean render) { // -------------------------------------
|
|
if (render) {
|
|
// auto-save snapshots
|
|
if (frameCount == 1000) {
|
|
saveFrame("../snapshots/"
|
|
+ year() + nf(month(),2)
|
|
+ nf(day(),2)
|
|
+ nf(hour(),2)
|
|
+ nf(minute(),2)
|
|
+ nf(second(),2)
|
|
+ "_.png");
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// SPHERES -----------------------------------------------------------
|
|
//offscreen render spheres
|
|
|
|
void drawSpheres( boolean render
|
|
)
|
|
{
|
|
if (render) {
|
|
|
|
/*
|
|
sphere.beginDraw();
|
|
sphere.blendMode(BLEND);
|
|
sphere.rect(0, 0, width, height);
|
|
sphere.blendMode(DARKEST);
|
|
sphere.noStroke();
|
|
sphere.pushMatrix();
|
|
sphere.translate(width/2+(width/8), height/2, 580);
|
|
sphere.rotateX(radians(float(frameCount) * 0.1));
|
|
sphere.rotateY(radians(float(frameCount) * 0.23));
|
|
sphere.rotateZ(radians(float(frameCount) * 0.2));
|
|
textureSphere(sphere, 400, 400, 400, imgPool[3][1]);
|
|
sphere.popMatrix();
|
|
|
|
sphere.pushMatrix();
|
|
sphere.translate(width/2+(width/8), height/2, 580);
|
|
sphere.rotateX(radians(float(frameCount) * 0.2));
|
|
sphere.rotateY(radians(float(frameCount) * 0.13));
|
|
sphere.rotateZ(radians(float(frameCount) * 0.01));
|
|
textureSphere(sphere, 390, 390, 390, imgPool[3][1]);
|
|
sphere.popMatrix();
|
|
|
|
sphere.endDraw();
|
|
|
|
|
|
// tint(0);
|
|
// image(sphere, 0, 0);
|
|
|
|
textureWrap(REPEAT);
|
|
//textureMode(NORMAL);
|
|
|
|
pushMatrix();
|
|
//tint(255);
|
|
translate(width/2, height/2); // center coordinate system
|
|
translate(((frameCount*1) % width) - width/2,0);
|
|
//stroke(0,50);
|
|
//strokeWeight(1);
|
|
noStroke();
|
|
|
|
float quadW = 500;
|
|
float quadH = height;
|
|
|
|
float v1x = 0; // sin(radians(frameCount))*250+400;
|
|
|
|
pushMatrix() ;
|
|
//rotate(PI/PI);
|
|
|
|
beginShape(QUADS);
|
|
texture(sphere);
|
|
vertex(-quadW/2, -quadH/2, 0, 0);
|
|
vertex( quadW/2, -quadH/2, quadW, 0);
|
|
vertex( quadW/2, quadH/2, quadW, quadH);
|
|
vertex(-quadW/2, quadH/2, 0, quadH);
|
|
endShape();
|
|
popMatrix();
|
|
popMatrix();
|
|
|
|
*/
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// SPHERES - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
// A 3D textured sphere with simple rotation control.
|
|
// thanks to https://processing.org/examples/texturesphere.html
|
|
// Texture Sphere written by Gillian Ramsay to better display the poles.
|
|
// Previous version by Mike 'Flux' Chang (and cleaned up by Aaron Koblin).
|
|
// Original based on code by Toxi.
|
|
// modified to accomodate offscreen PGraphics
|
|
|
|
void initializeSphere(int numPtsW, int numPtsH_2pi) {
|
|
|
|
// The number of points around the width and height
|
|
numPointsW=numPtsW+1;
|
|
numPointsH_2pi=numPtsH_2pi; // How many actual pts around the sphere (not just from top to bottom)
|
|
numPointsH=ceil((float)numPointsH_2pi/2)+1; // How many pts from top to bottom (abs(....) b/c of the possibility of an odd numPointsH_2pi)
|
|
|
|
coorX=new float[numPointsW]; // All the x-coor in a horizontal circle radius 1
|
|
coorY=new float[numPointsH]; // All the y-coor in a vertical circle radius 1
|
|
coorZ=new float[numPointsW]; // All the z-coor in a horizontal circle radius 1
|
|
multXZ=new float[numPointsH]; // The radius of each horizontal circle (that you will multiply with coorX and coorZ)
|
|
|
|
for (int i=0; i<numPointsW ;i++) { // For all the points around the width
|
|
float thetaW=i*2*PI/(numPointsW-1);
|
|
coorX[i]=sin(thetaW);
|
|
coorZ[i]=cos(thetaW);
|
|
}
|
|
|
|
for (int i=0; i<numPointsH; i++) { // For all points from top to bottom
|
|
if (int(numPointsH_2pi/2) != (float)numPointsH_2pi/2 && i==numPointsH-1) { // If the numPointsH_2pi is odd and it is at the last pt
|
|
float thetaH=(i-1)*2*PI/(numPointsH_2pi);
|
|
coorY[i]=cos(PI+thetaH);
|
|
multXZ[i]=0;
|
|
}
|
|
else {
|
|
//The numPointsH_2pi and 2 below allows there to be a flat bottom if the numPointsH is odd
|
|
float thetaH=i*2*PI/(numPointsH_2pi);
|
|
|
|
//PI+ below makes the top always the point instead of the bottom.
|
|
coorY[i]=cos(PI+thetaH);
|
|
multXZ[i]=sin(thetaH);
|
|
}
|
|
}
|
|
}
|
|
|
|
void textureSphere(PGraphics pg, float rx, float ry, float rz, PImage t) {
|
|
// These are so we can map certain parts of the image on to the shape
|
|
float changeU=t.width/(float)(numPointsW-1);
|
|
float changeV=t.height/(float)(numPointsH-1);
|
|
float u=0; // Width variable for the texture
|
|
float v=0; // Height variable for the texture
|
|
|
|
pg.beginShape(TRIANGLE_STRIP);
|
|
pg.texture(t);
|
|
for (int i=0; i<(numPointsH-1); i++) { // For all the rings but top and bottom
|
|
// Goes into the array here instead of loop to save time
|
|
float coory=coorY[i];
|
|
float cooryPlus=coorY[i+1];
|
|
|
|
float multxz=multXZ[i];
|
|
float multxzPlus=multXZ[i+1];
|
|
|
|
for (int j=0; j<numPointsW; j++) { // For all the pts in the ring
|
|
pg.normal(coorX[j]*multxz, coory, coorZ[j]*multxz);
|
|
pg.vertex(coorX[j]*multxz*rx, coory*ry, coorZ[j]*multxz*rz, u, v);
|
|
pg.normal(coorX[j]*multxzPlus, cooryPlus, coorZ[j]*multxzPlus);
|
|
pg.vertex(coorX[j]*multxzPlus*rx, cooryPlus*ry, coorZ[j]*multxzPlus*rz, u, v+changeV);
|
|
u+=changeU;
|
|
}
|
|
v+=changeV;
|
|
u=0;
|
|
}
|
|
pg.endShape();
|
|
}
|
|
|
|
|
|
|
|
|
|
|