Patricks branch

.vscode/launch.json

@@ -1,5 +1,19 @@
 {
     "configurations": [
+        {
+            "type": "java",
+            "name": "LarinasVisual",
+            "request": "launch",
+            "mainClass": "C22328351.LarinasVisual",
+            "projectName": "java"
+        },
+        {
+            "type": "java",
+            "name": "C22328351",
+            "request": "launch",
+            "mainClass": "C22328351.C22328351",
+            "projectName": "java"
+        },
         {
             "type": "java",
             "name": "CodeLens (Launch) - Main",

README.md

@@ -1,8 +1,17 @@
 # Music Visualiser Project
+Name: Michael Ferents
+Student Number: C21325616
 
-Name:
+Name: Patrick Akinsowon
+Student Number: C22371846
+
+
+Name: Larina Yu
+Student Number: C22328351
+
+Name: Noel McCarthy
+Student Number: C22533826
 
-Student Number: 
 
 ## Instructions
 - Fork this repository and use it a starter project for your assignment
@@ -14,6 +23,17 @@ Student Number:
 # Description of the assignment
 
 # Instructions
+Run Main.java inside ie\tudublin, this will run our Heartbeat.java file where we handle rendering each persons visual.
+
+To switch between each persons visuals select 1-X keys. Press R to restart the song and Spacebar to pause the song.
+
+- Noels Visuals: You can interact with the stars in the background by hovering the cursor over them. This creates a 'blackhole' effect where they group around the cursor in a circle.
+
+- atricks Visuals:
+
+- Larinas Visuals: 
+
+- Michaels Visuals: 
 
 # How it works
 

java/.project

@@ -16,12 +16,12 @@
 	</natures>
 	<filteredResources>
 		<filter>
-			<id>1616413840733</id>
+			<id>1710347416250</id>
 			<name></name>
 			<type>30</type>
 			<matcher>
 				<id>org.eclipse.core.resources.regexFilterMatcher</id>
-				<arguments>node_modules|.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
 			</matcher>
 		</filter>
 	</filteredResources>

java/src/C21325616/Box.java

@@ -0,0 +1,39 @@
+package C21325616;
+
+import processing.core.PVector;
+
+import java.util.List;
+
+import example.MyVisual;
+import ie.tudublin.Heartbeat;
+
+import java.util.*; 
+
+import processing.core.PApplet;
+
+public class Box {
+
+    public PVector position;
+    public PVector dimensions;
+
+    public void setDimension(PVector dimension)
+    {
+        this.dimensions = dimension;
+    }
+
+    public void setPosition(PVector position)
+    {
+        this.position = position;
+    }
+
+    public void render(Heartbeat mv)
+    {
+        mv.pushMatrix();
+        mv.translate(position.x, position.y, position.z); 
+        mv.fill(220);
+        mv.noStroke();
+        mv.box(dimensions.x, dimensions.y, dimensions.z);
+        mv.popMatrix();
+    }
+
+}

java/src/C21325616/BoxPlane.java

@@ -0,0 +1,121 @@
+package C21325616;
+
+import example.MyVisual;
+import ie.tudublin.Heartbeat;
+
+import java.util.*; 
+
+import processing.core.PApplet;
+import processing.core.PVector;
+
+enum Side {
+    PositiveX,
+    PositiveY,
+    PositiveZ,
+    NegativeX,
+    NegativeY,
+    NegativeZ,
+}
+
+public class BoxPlane {
+
+    Box[][] plane = new Box[20][20];
+    Random rand = new Random();
+
+    Side currentSide;
+
+    PVector origin;
+
+    public void init(Side side)
+    {
+        this.currentSide = side;
+
+        for(int i = 0; i < 20; i++)
+        {
+            for(int j = 0; j < 20; j++)
+            {
+                plane[i][j] = new Box();
+                plane[i][j].setDimension(new PVector(20, 20, 20));
+
+                switch(side)
+                {
+                    case PositiveX:
+                        plane[i][j].setPosition(new PVector(i * 20,j*20, 0));
+                        break;
+
+                    case PositiveY:
+                        plane[i][j].setPosition(new PVector(i * 20,0, j*20));
+                        break;
+
+                    case PositiveZ:
+                        plane[i][j].setPosition(new PVector( 0 , i * 20, j*20));
+                        break;
+
+                    case NegativeX:
+                        plane[i][j].setPosition(new PVector(i * 20,j*20, 400));
+                        break;
+
+                    case NegativeY:
+                        plane[i][j].setPosition(new PVector(i * 20, 400, j*20));
+                        break;
+
+                    case NegativeZ:
+                        plane[i][j].setPosition(new PVector(400,i * 20, j*20));
+                        break;
+                }
+            }
+        }
+    }
+
+    public void update(Heartbeat mv)
+    {
+        mv.getAudioBuffer().size();
+
+        for(int i = 0; i < 20; i++)
+        {
+            for(int j = 0; j < 20; j++)
+            {
+                switch(currentSide)
+                {
+                    case PositiveX:
+                        plane[i][j].setDimension(new PVector(20, 20,(mv.getAudioBuffer().get(i) * (rand.nextInt(500 - 150 + 1) + 150)) +  20));
+                        break;
+
+                    case PositiveY:
+                        plane[i][j].setDimension(new PVector(20, (mv.getAudioBuffer().get(i) * (rand.nextInt(500 - 150 + 1) + 150)) + 20, 20));
+                        break;
+
+                    case PositiveZ:
+                        plane[i][j].setDimension(new PVector((mv.getAudioBuffer().get(i) * (rand.nextInt(500 - 150 + 1) + 150)) + 20, 20, 20));
+                        break;
+
+                    case NegativeX:
+                        plane[i][j].setDimension(new PVector(20, 20, (mv.getAudioBuffer().get(i) * (rand.nextInt(500 - 150 + 1) + 150)) +  20));
+                        break;
+
+                    case NegativeY:
+                        plane[i][j].setDimension(new PVector(20, (mv.getAudioBuffer().get(i) * (rand.nextInt(500 - 150 + 1) + 150)) + 20, 20));
+                        break;
+
+                    case NegativeZ:
+                        plane[i][j].setDimension(new PVector((mv.getAudioBuffer().get(i) * (rand.nextInt(500 - 150 + 1) + 150)) + 20, 20, 20));
+                        break;
+                }
+
+
+            }
+        }
+    }
+
+    public void render(Heartbeat mv)
+    {
+        for(int i = 0; i < 20; i++)
+        {
+            for(int j = 0; j < 20; j++)
+            {
+                plane[i][j].render(mv);
+            }
+        }
+    }
+
+}

java/src/C21325616/MichaelsVisuals.java

@@ -0,0 +1,143 @@
+package C21325616;
+
+import java.util.Random;
+
+import example.MyVisual;
+import ie.tudublin.Heartbeat;
+import processing.core.PApplet;
+import processing.core.PConstants;
+import processing.core.PVector;
+import processing.event.KeyEvent;
+
+public class MichaelsVisuals {
+
+    Heartbeat mv;
+
+    BoxPlane[] cube;
+    PointCube pc;
+    ParticleSystem ps;
+
+    Random rand = new Random();
+
+    int width;
+    int height;
+
+    float lastX;
+    float lastY;
+
+    int State = 1;
+    boolean first = true;
+
+    float rotation=0;
+
+    public MichaelsVisuals(Heartbeat mv)
+    {
+        this.mv = mv; 
+
+        width = mv.displayWidth;
+        height = mv.displayHeight;
+
+        initializeVisualOne();
+        initializeVisualTwo();
+    }
+
+    private void initializeVisualOne()
+    {
+
+        cube = new BoxPlane[6];
+
+        for(int i = 0; i < 6; i++)
+        {
+            cube[i] = new BoxPlane();
+        }
+
+        cube[0].init(Side.PositiveX);
+        cube[1].init(Side.PositiveY);
+        cube[2].init(Side.PositiveZ);
+        cube[3].init(Side.NegativeX);
+        cube[4].init(Side.NegativeY);
+        cube[5].init(Side.NegativeZ);
+
+    }
+
+    private void initializeVisualTwo()
+    {
+        pc = new PointCube(10);
+        ps = new ParticleSystem(300);
+    }
+
+    private void renderVisualOne()
+    {
+        mv.beginCamera();
+        mv.noFill();
+        mv.background(0);
+        //camera.setCamera(mv);
+        mv.camera(-150, -400 * PApplet.cos(PApplet.radians(rotation)), -400 * PApplet.sin(PApplet.radians(rotation)), 100, 100, 100, 0.0f, 1.0f, 0.0f);
+        mv.directionalLight(100, 0, 300, -1, 1, -1);
+        mv.pointLight(0, 50, 300, 100 , 0, -100);
+        mv.pointLight(0, 50, 300, -100, 0, 100);
+        //mv.rotate(PApplet.atan2(dir.y, dir.x));
+        //rotate2D(dir, PApplet.radians(3));
+        /* 
+        mv.translate(50, 50, 0);
+        mv.rotateX(-PConstants.PI/6);
+        mv.rotateY(PConstants.PI/3);
+        */
+        //mv.box(45);
+        //ico.render(mv);
+        if(mv.frameCount % 5 == 0)
+        {
+            for(int i = 0; i < 6; i++)
+            {
+                cube[i].update(mv);
+            }
+        }
+        for(int i = 0; i < 6; i++)
+        {
+            cube[i].render(mv);
+        }
+        mv.endCamera();
+        rotation++;
+    }
+
+    public void setState(int state)
+    {
+        this.State = state;
+    }
+
+    private void renderVisualTwo()
+    {
+        mv.beginCamera();
+        mv.noFill();
+        mv.background(0);
+        //camera.setCamera(mv);
+        mv.camera(-100, -100  * PApplet.cos(PApplet.radians(rotation)), -100  * PApplet.sin(PApplet.radians(rotation)), 100, 100, 100, 0.0f, 1.0f, 0.0f);
+        pc.update(mv);
+        pc.render(mv);
+        ps.render(mv);
+        ps.update();
+
+        mv.pushMatrix();
+        mv.noStroke();
+        //mv.lights();
+        mv.fill(255);
+        mv.translate(50, 50, 50);
+        mv.calculateAverageAmplitude();
+        System.out.println(mv.getAmplitude());
+        mv.sphere(100 * mv.getAmplitude());
+        mv.popMatrix();
+
+        mv.endCamera();
+        rotation++;
+    }
+
+    public void render()
+    {
+        if(State == 0)
+            renderVisualOne();
+
+        if(State == 1)
+            renderVisualTwo();
+    }
+
+}