IF3Si/pde/IF3Si/functions.pde

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();
}