package scenes;
import javax.media.opengl.GL;
import models.Quad;
import codeanticode.glgraphics.GLModel;
import codeanticode.glgraphics.GLTexture;
import processing.*;
import processing.core.*;
import traer.physics.*;
import utils.Util;
public class Grid extends Scene {
///////////////////////////////////////////////////////////////////
// sistema de particulas
//
///////////////////////////////////////////////////////////////////
ParticleSystem ps;
private float drag = .75f;
private PVector gravity = new PVector(0,.00051f,0);
private Particle[][] vertices;
private Spring[][] verticesConnections;
// tengo que pasarle algun tamano para
// no tener problema con los resortes.
// si dejo 1 colapsa todo
// TODO investigar esto...
private float gridSize = 200;
private int columns = 25;
private int rows = 25;
private float columnWidth = gridSize / columns;
private float columnHeigth = gridSize / rows;
private float force = 0.2f;
private float damping = .25f;
private float restLength = columnWidth * 1.0f;
private float pushForce = 20;
//////////////////////////////////////////////////////////////////////////////////
private Quad[][] rectangles;
private GLTexture texture;
private float rectangleSize = 0.9f;
private float color[] = new float[4];
//////////////////////////////////////////////////////////////////////////////////
public Grid(PApplet parent, int w, int h){
super(parent, w, h);
// TODO implementar un mecanismo que me permita renderear en la textura
// que despues uso para la grilla
texture = new GLTexture(parent, parent.dataPath("textura_11.png"));
}
// la idea es: hay una particula para cada punto de un resorte.
// cada particula es un objeto dibujable
// los resortes estan conectados formando una grilla. Los 4 de las puntas
// se encuentran fijos en algun lugar del espacio.
// despues se agregan fuerzas a diferentes particulas
public void setup(){
//////////////////////////////////////////////////
// creo las particulas y los resortes
///////////////////////////////////////////////////
ps = new ParticleSystem(0.0f,0.0f,gravity.y, drag);
vertices = new Particle[columns][rows];
verticesConnections = new Spring[columns*rows][2];
//////////////////////////////////////////////////
// ESTRUCTURA GRILLA CENTRADA
///////////////////////////////////////////////////
for (int i = 0; i < columns; i++){
for (int j = 0; j < rows; j++){ // para centrar la grilla
vertices[i][j] = ps.makeParticle(1.0f, (-gridSize/2.f) + i * columnWidth , (-gridSize/2.f) + j * columnHeigth , 0.0f);
}
}
// dejo fijas las cuatro de las esquinas
vertices[0][0].makeFixed();
vertices[0][vertices[0].length - 1].makeFixed();
vertices[vertices.length - 1][0].makeFixed();
vertices[vertices.length - 1][vertices[0].length - 1].makeFixed();
// hacia abajo evitando la ultima fila porque no conecta con nada
// hacia la derecha evitando la ultima columna porque no conecta con nada
for (int j = 0; j < rows - 1; j++){
for (int i = 0; i < columns - 1; i++) {
// la diferencia entre los resortes tiene que ser poca
// para que no colapse
force = Util.map(
(float) random.nextGaussian(),
0, 1,
.8f, .82f);
// conecto este con el de abajo
verticesConnections[i+j][0] = ps.makeSpring(
vertices[i][j], vertices[i][j+1],
force ,
damping,
restLength);
// conecto este con el de la derecha
verticesConnections[i+j][1] = ps.makeSpring(
vertices[i][j], vertices[i + 1][j],
force ,
damping,
restLength);
}
}
// como no conecte ni la ultima fila ni la ultima columna
// el ultimo nodo lo conecto a mano pero al reves...
verticesConnections[(columns * rows) - 1][0] = ps.makeSpring(
vertices[columns-1][rows-1], vertices[columns-1][ rows - 2],
force ,
.75f,
restLength);
verticesConnections[(columns * rows) - 1][1] = ps.makeSpring(
vertices[columns-1][rows-1], vertices[columns-2][ rows - 1],
force ,
.75f,
restLength);
//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////
rectangles = new Quad[columns][rows];
for(int i = 0; i < columns ; i++){
for(int j = 0; j < rows; j ++){
rectangles[i][j] = new Quad(parent, texture);
// TODO Sarasa
// implementar un metodo para pasar el color desde afuera
color[0] = 0.15f; // RED
color[1] = 0.70f + random.nextFloat() * 0.2f; // GREEN
color[2] = 0.15f + random.nextFloat() * 0.2f; // BLUE
color[3] = 0.5f; // ALPHA;
rectangles[i][j].setFillColor(color);
rectangles[i][j].setScale(new PVector(columnWidth * 2,columnHeigth * 2, 1.f));
// rectangles[i][j].setRotation(Util.x, 1.f * (rectangles[i].length * rectangles.length) / (i + j * rectangles[i].length) * TWO_PI);
}
}
}
public void update(){
int cualX = 0, cualY = 0;
ps.tick(0.01f);
// muevo una del monton
if(Math.random() < 0.2) {
cualX = (int) ( random.nextFloat() * (vertices.length ));
cualY = (int) ( random.nextFloat() * (vertices.length ));
vertices[cualX][cualY].velocity().add(0, 0, pushForce);
}
for(int i = 0; i< columns; i++){
for (int j = 0; j < rows; j++) {
PVector pos = new PVector(
vertices[i][j].position().x(),
vertices[i][j].position().y(),
vertices[i][j].position().z());
rectangles[i][j].setPosition(pos);
}
}
}
protected void renderScene(){
for(int i = 0; i< columns; i++){
for (int j = 0; j < rows; j++) {
rectangles[i][j].draw();
}
}
}
}