a4-thearst3rd-harold-hearst

.gitignore

@@ -0,0 +1,8 @@
+*.DS_Store
+node_modules/
+package-lock.json
+.gitconfig
+.glitch-assets
+shrinkwrap.yaml
+db.json
+public/bundle.js

GLITCH-README.md

@@ -0,0 +1,27 @@
+Welcome to Glitch
+=================
+
+Click `Show` in the header to see your app live. Updates to your code will instantly deploy and update live.
+
+**Glitch** is the friendly community where you'll build the app of your dreams. Glitch lets you instantly create, remix, edit, and host an app, bot or site, and you can invite collaborators or helpers to simultaneously edit code with you.
+
+Find out more [about Glitch](https://glitch.com/about).
+
+
+Your Project
+------------
+
+On the front-end,
+- edit `public/client.js`, `public/style.css` and `views/index.html`
+- drag in `assets`, like images or music, to add them to your project
+
+On the back-end,
+- your app starts at `server.js`
+- add frameworks and packages in `package.json`
+- safely store app secrets in `.env` (nobody can see this but you and people you invite)
+
+
+Made by [Glitch](https://glitch.com/)
+-------------------
+
+\ ゜o゜)ノ

README.md

@@ -1,72 +1,38 @@
-Assignment 4 - Creative Coding: Interactive Multimedia Experiences
+LifeGrid
 ===
 
-Due: September 27th, by 11:59 PM.
+https://a4-thearst3rd.glitch.me/
 
-For this assignment we will focus on client-side development using popular audio/graphics/visualization technologies; the server requirements are minimal. The goal of this assignment is to refine our JavaScript knowledge while exploring the multimedia capabilities of the browser.
+LifeGrid is an implementation of Conway's Game of Life using three.js to render each cell as an object. This object grows with complexity the longer the cell is alive, growing from a simple sphere to a complex torus knot.
 
-Baseline Requirements
----
+Some challenges I faced: It took me a while to figure out how to go from 2D mouse coordinates to the 3D world coordinates into `(i, j)` coordinates. In fact, I am totally cheesing it based on numbers that _should_ be correct. I tested it out with multiple different window sizes though and it seems to work perfectly.
 
-Your application is required to implement the following functionalities:
+Figuring out how to line up all of the mesh elements on the grid took a some time. Eventually I got it, but figuring out the equations and making them all work properly was challenging, because sometimes I would mess it up and all of the elements would be totally off screen and I could not see them at all.
 
-- A server created using Express (you can also use an alternative server framework such as Koa) for basic file delivery and middleware. Your middleware stack should include the `compression` and `helmet` [middlewares]((https://expressjs.com/en/resources/middleware.html)) by default. You are not required to use Glitch for this assignment (but using Glitch is fine!); [Heroku](https://www.heroku.com) is another excellent option to explore. The course staff can't be resposible for helping with all other hosting options outside of Glitch, but some of us do have experience with other systems. It also never hurts to ask on Slack, as there's 99 other classmates who might have the experience you're looking for!
-- A client-side interactive experience using at least one of the web technologies frameworks we discussed in class over the past week.
-  - [Three.js](https://threejs.org/): A library for 3D graphics / VR experiences
-  - [D3.js](https://d3js.org): A library that is primarily used for interactive data visualizations
-  - [Canvas](https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API): A 2D raster drawing API included in all modern browsers
-  - [SVG](https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API): A 2D vector drawing framework that enables shapes to be defined via XML.
-  - [Web Audio API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API): An API for audio synthesis, analysis, processing, and file playback.
-- A user interface for interaction with your project, which must expose at least six parameters for user control. [dat.gui](https://workshop.chromeexperiments.com/examples/gui/#1--Basic-Usage) is highly recommended for this. You might also explore interaction by tracking mouse movement via the `window.onmousemove` event handler in tandem with the `event.clientX` and `event.clientY` properties. Consider using the [Pointer Events API](https://developer.mozilla.org/en-US/docs/Web/API/Pointer_events) to ensure that that mouse and touch events will both be supported in your app.
-- Your application should display basic documentation for the user interface when the application first loads. This documentation should be dismissable, however, users should be able to redisplay it via either a help buton (this could, for example, be inside a dat.gui interface) or via a keyboard shortcut (commonly the question mark).
-- Your application should feature at least two different ES6 modules that you write ([read about ES6 modules](https://www.sitepoint.com/understanding-es6-modules/)) and include into a main JavaScript file. This means that you will need to author *at least three JavaScript files* (a `app.js` or `main.js` file and two modules). We'll discuss modules in class on Monday 9/23; for this assignment modules should contain at least two functions.
-- You are required to use a linter for your JavaScript. There are plugins for most IDEs, however it will be difficult to run the linter directly in Glitch. If you haven't moved to developing on your personal laptop and then uploading to Glitch when your project is completed, this is the assignment to do so!
-- Your HTML and CSS should validate. There are options/plugins for most IDEs to check validation.
+I used `standard.js` for my linting. All of the javascript files are properly linted as of this submission. It follows a bunch of rules that I actually really do not prefer but it was easy to set up so whatever... Additionally, my website properly validated with both https://validator.w3.org and http://jigsaw.w3.org/css-validator/. Please don't take my word for it - check!
 
-The interactive experience should possess a reasonable level of complexity. Some examples:
-### Three.js
-- A generative algorithm creates simple agents that move through a virtual world. Your interface controls the behavior / appearance of these agents.
-- A simple 3D game
-- An 3D audio visualization of a song of your choosing. User interaction should control aspects of the visualization. 
-### Canvas
-- Implement a generative algorithm such as [Conway's Game of Life](https://bitstorm.org/gameoflife/) (or 1D cellular automata) and provide interactive controls. Note that the Game of Life has been created by 100s of people using <canvas>; we'll be checking to ensure that your implementation is not a copy of these.
-- Design a 2D audio visualizer of a song of your choosing. User interaction should control visual aspects of the experience. 
-### Web Audio API
-- Create a screen-based musical instrument using the Web Audio API. You can use projects such as [Interface.js](http://charlie-roberts.com/interface/) or [Nexus UI](https://nexus-js.github.io/ui/api/#Piano) to provide common musical interface elements, or use dat.GUI in combination with mouse/touch events (use the Pointer Events API). Your GUI should enable users to control aspects of sound synthesis.
-### D3.js
-- Create visualizations using the datasets found at [Awesome JSON Datasets](https://github.com/jdorfman/Awesome-JSON-Datasets). Experiment with providing different visualizations of the same data set, and providing users interactive control over visualization parameters and/or data filtering. Alternatively, create a single visualization with using one of the more complicated techniques shown at [d3js.org](d3js.org) and provide meaningful points of interaction for users.
+The changeable parameters of my application are:
+- Running state (on/off) - you can also Single Step through
+- How many iterations per second
+- How fast the cells' objects rotate
+- Editing the board - being able to toggle any cell to be on or off
+- The rules of the game - How few cells will cause starvation? How many cells will cause overpopulation? What number of cells will cause a new cell to be born?
+- Technically that's only 5 but the rules of the game are 3 different rules, AND the board is 20x20 so really you can change over 400 things in my project :) In all seriousness I do hope that this fulfills the requirements
 
-Deliverables
----
+My two modules are:
+- My implementation of the Game of Life game mechanics, and
+- A helper that generates my dat.GUI element
 
-Do the following to complete this assignment:
+I used browserify to get the two modules inserted for use with the webpage. The command I use is:
 
-1. Implement your project with the above requirements.
-3. Test your project to make sure that when someone goes to your main page on Glitch/Heroku/etc., it displays correctly.
-4. Ensure that your project has the proper naming scheme `a4-yourname` so we can find it.
-5. Fork this repository and modify the README to the specifications below. *NOTE: If you don't use Glitch for hosting (where we can see the files) then you must include all project files that you author in your repo for this assignment*.
-6. Create and submit a Pull Request to the original repo. Name the pull request using the following template: `a4-gitname-firstname-lastname`.
-
-Sample Readme (delete the above when you're ready to submit, and modify the below so with your links and descriptions)
----
-
-## Your Web Application Title
-
-your hosting link e.g. http://a4-charlieroberts.glitch.me
-
-Include a very brief summary of your project here. Images are encouraged, along with concise, high-level text. Be sure to include:
-
-- the goal of the application
-- challenges you faced in realizing the application
-- a brief description of the JS linter you used and what rules it follows (we'll be looking at your JS files for consistency)
+`$ browserify public/client.js -o public/bundle.js`
 
 ## Technical Achievements
-- **Tech Achievement 1**: I wrote my own custom GLSL shaders to use as a material for my Three.js objects.
-- **Tech Achievement 2**: My audiovisualizer uses both FFT and amplitude analysis to drive visualization.
-- **Tech Achievement 3**: I optimized the efficiency of my reaction-diffusion algorithm by...
-- **Tech Achievement 4**: I visualized the dataset X using three different visualization technqiues provided by D3, andprovided
+- **Complete Implementation of Conway's Game of Life**: The game is fully, properly implemented. You can change the rules using a dat.GUI menu which allows for some interesting results.
+- **Full, efficient board layout using three.js**: I create a small number of geometry and material objects, and then reuse those throughout the board for more efficient memory usage and faster performance. Additionally, I will only change the geometries and materials of the meshes exactly when the contents of the board changes. The objects are not reading the contents of the board every frame, only on the "game" ticks.
+- **Adaptable 2D -> 3D Screen Coordinates**: Upon resizing the window, not only does the canvas properly resize itself, but also the mouse input handler recognizes the new size and will properly determine which cell your mouse is hovering over
 
 ### Design/Evaluation Achievements
-- **Design Achievement 1**: I ensured that my application would run on both desktops / mobile devices by changing X
-- **Design Achievement 2**: I followed best practices for accessibility, including providing alt attributes for images and using semantic HTML. There are no `<div>` or `<span>` elements in my document.
-- **Design Achievement 3**: We tested the application with n=X users, finding that...
+- **Best Practices**: I followed best practices for accessibility, including providing alt attributes for images and using semantic HTML. There are no `<div>` or `<span>` elements in my document. This one was actually quite annoying to do because a lot of the examples had full-screen canvases using a `div`. Also, with the popup element, the HTML validator gave me trouble if I kept them all as a `p` element and I needed to split them up into headers without using a `div` or `span`.
+- **Mouseover Indication in Edit Mode**: I added a simple transparent cube that will move to the cell that you are hovering over in Edit Mode.
+- **Different Models for Each Cell**: I gave different lifespans of each cell a new model and material, so that the board looks much more dynamic. You can observe how long a cell has been alive just by looking at the model and color.

package.json

@@ -0,0 +1,33 @@
+{
+  "//1": "describes your app and its dependencies",
+  "//2": "https://docs.npmjs.com/files/package.json",
+  "//3": "updating this file will download and update your packages",
+  "name": "hello-express",
+  "version": "0.0.1",
+  "description": "A simple Node app built on Express, instantly up and running.",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js"
+  },
+  "dependencies": {
+    "browserify": "^16.5.0",
+    "compression": "^1.7.4",
+    "dat.gui": "^0.7.6",
+    "express": "^4.16.4",
+    "helmet": "^3.21.1",
+    "standard": "^14.3.1",
+    "three": "^0.108.0"
+  },
+  "engines": {
+    "node": "8.x"
+  },
+  "repository": {
+    "url": "https://glitch.com/edit/#!/hello-express"
+  },
+  "license": "MIT",
+  "keywords": [
+    "node",
+    "glitch",
+    "express"
+  ]
+}