├── AlteHaasGroteskBold.ttf ├── AlteHaasGroteskRegular.ttf ├── Maru ├── AudioController.js ├── AudioTexture.js ├── FurryGroup.js ├── FurryHead.js ├── FurryTail.js ├── GUI.js ├── GeosansLight.ttf ├── LoadedAudio.js ├── Loader.js ├── Looper.js ├── MaruBassKickLoop.mp3 ├── MaruBassModLoop.mp3 ├── MaruBellALoop.mp3 ├── MaruBellBLoop.mp3 ├── MaruBellBrightLoop.mp3 ├── MaruBellCLoop.mp3 ├── MaruClapLoop.mp3 ├── MaruHatsLoop.mp3 ├── MaruHiupLoop.mp3 ├── MaruIMPLoop.mp3 ├── MaruKickLoop.mp3 ├── MaruLogritLoop.mp3 ├── MaruLoops.zip ├── MaruLopanLoop.mp3 ├── MaruModALoop.mp3 ├── MaruModBLoop.mp3 ├── MaruRNLLoop.mp3 ├── MaruRollLoop.mp3 ├── MaruSnareLoop.mp3 ├── MaruUpmidLoop.mp3 ├── MaruVocLoop.mp3 ├── OBJLoader.js ├── ObjectControls.js ├── ParticleUtils.js ├── PhysicsRenderer.js ├── PosVelSimulation.js ├── ShaderLoader.js ├── Stream.js ├── TrackballControls.js ├── Tween.js ├── activate.wav ├── andaBit.wav ├── cab_sprite.png ├── dat.gui.min.js ├── deactivate.wav ├── goodJob.wav ├── hover.wav ├── icons │ ├── albumCover.png │ ├── cabbibo.png │ ├── cabbibo_1.png │ ├── connect_1.png │ ├── cursorWhite.png │ ├── download_1.png │ ├── facebook_1.png │ ├── info_1.png │ ├── loadGif.gif │ ├── normals │ │ ├── 08_normalmap.png │ │ ├── 10389-normal.jpg │ │ ├── 3989-normal.jpg │ │ ├── 4706-normal.jpg │ │ ├── 7723-normal.jpg │ │ ├── 7870-normal.jpg │ │ ├── 8158-normal.jpg │ │ ├── 940-normal.jpg │ │ ├── bumpmap_normalmap.jpg │ │ ├── carbonFiber.png │ │ ├── chesterfield.png │ │ ├── moss_normal_map.jpg │ │ ├── other.jpg │ │ ├── rock.jpg │ │ └── rock1.png │ ├── prism_1.png │ ├── rioux_1.png │ ├── sem_metal.jpg │ ├── soundcloud_1.png │ ├── sprite.png │ ├── starMap.png │ ├── thumb.jpg │ ├── thumb.png │ ├── twitter_1.png │ └── warp_1.png ├── index.html ├── initEasterEgg.js ├── initJelly.js ├── initPoly.js ├── initThree.js ├── jelly.wav ├── jquery.min.js ├── lvl4 │ ├── ambient.mp3 │ ├── ambient1.mp3 │ ├── death.mp3 │ ├── part1 │ │ ├── drums.mp3 │ │ ├── hats.mp3 │ │ ├── highSynth.mp3 │ │ ├── lowSynth.mp3 │ │ └── vox.mp3 │ └── part2 │ │ ├── drums.mp3 │ │ ├── hats.mp3 │ │ ├── highSynth.mp3 │ │ ├── lowSynth.mp3 │ │ └── vox.mp3 ├── main.css ├── polymer-sticker.png ├── shaders │ ├── curl.glsl │ ├── curlSim.glsl │ ├── deathSim.glsl │ ├── fs-accel.glsl │ ├── fs-clueLine.glsl │ ├── fs-deathParticles.glsl │ ├── fs-furryHead.glsl │ ├── fs-furryParticles.glsl │ ├── fs-furryTail.glsl │ ├── fs-mainTail.glsl │ ├── fs-poly.glsl │ ├── fs-polyOrg.glsl │ ├── fs-polyOutline.glsl │ ├── fs-render.glsl │ ├── fs-simPos.glsl │ ├── fs-simVel.glsl │ ├── fs-texturePass.glsl │ ├── fs-toFrom.glsl │ ├── gravitySimBug1.glsl │ ├── lightColors.glsl │ ├── room │ │ ├── fs-render.glsl │ │ ├── fs-simPos.glsl │ │ ├── fs-simVel.glsl │ │ └── vs-render.glsl │ ├── semLookup.glsl │ ├── simplex.glsl │ ├── sphereDisrupt.glsl │ ├── ss-furryHead.glsl │ ├── ss-furryTail.glsl │ ├── ss-mainTail.glsl │ ├── triplanarMap.glsl │ ├── vs-furryHead.glsl │ ├── vs-furryParticles.glsl │ ├── vs-furryTail.glsl │ ├── vs-mainTail.glsl │ ├── vs-pass.glsl │ ├── vs-planet.glsl │ ├── vs-planetDisplace.glsl │ ├── vs-poly.glsl │ ├── vs-polyOrg.glsl │ ├── vs-polyOutline.glsl │ └── vs-render.glsl ├── stats.min.js ├── three.js ├── three.min.js └── underscore.js ├── README.md ├── WARP303_Packshot_3000.jpg ├── WARP303_Packshot_3000T.png ├── alte haas grotesk licence.rtf ├── index.html ├── plaid.png ├── plaidlogo.png ├── poly.png ├── polyText.png └── polymer-cover-object-2.png /AlteHaasGroteskBold.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/AlteHaasGroteskBold.ttf -------------------------------------------------------------------------------- /AlteHaasGroteskRegular.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/AlteHaasGroteskRegular.ttf -------------------------------------------------------------------------------- /Maru/AudioController.js: -------------------------------------------------------------------------------- 1 | 2 | function AudioController(){ 3 | 4 | try { 5 | window.AudioContext = window.AudioContext||window.webkitAudioContext; 6 | }catch(e) { 7 | alert( 'WEB AUDIO API NOT SUPPORTED' ); 8 | } 9 | 10 | this.ctx = new AudioContext(); 11 | 12 | this.mute = this.ctx.createGain(); 13 | this.gain = this.ctx.createGain(); 14 | this.analyzer = this.ctx.createAnalyser(); 15 | 16 | this.analyzer.frequencyBinCount = 1024; 17 | this.analyzer.array = new Uint8Array( this.analyzer.frequencyBinCount ); 18 | 19 | this.texture = new AudioTexture( this.analyzer ); 20 | 21 | this.gain.connect( this.analyzer ); 22 | this.analyzer.connect( this.mute ); 23 | this.mute.connect( this.ctx.destination ); 24 | 25 | 26 | this.updateArray = []; 27 | this.notes = []; 28 | this.loops = []; 29 | 30 | 31 | this.noteInput = this.ctx.createGain(); 32 | this.loopInput = this.ctx.createGain(); 33 | 34 | this.noteInput.connect( this.gain ); 35 | this.loopInput.connect( this.gain ); 36 | 37 | } 38 | 39 | 40 | AudioController.prototype.update = function(){ 41 | 42 | this.analyzer.getByteFrequencyData( this.analyzer.array ); 43 | 44 | this.texture.update(); 45 | 46 | for( var i = 0; i < this.updateArray.length; i++ ){ 47 | 48 | this.updateArray[i](); 49 | 50 | } 51 | 52 | } 53 | 54 | 55 | AudioController.prototype.addToUpdateArray = function( callback ){ 56 | 57 | this.updateArray.push( callback ); 58 | 59 | } 60 | 61 | AudioController.prototype.removeFromUpdateArray = function( callback ){ 62 | 63 | for( var i = 0; i< this.updateArray.length; i++ ){ 64 | 65 | if( this.updateArray[i] === callback ){ 66 | 67 | this.updateArray.splice( i , 1 ); 68 | console.log( 'SPLICED' ); 69 | 70 | } 71 | 72 | } 73 | 74 | } 75 | 76 | 77 | -------------------------------------------------------------------------------- /Maru/AudioTexture.js: -------------------------------------------------------------------------------- 1 | function AudioTexture( analyzer ){ 2 | 3 | var analyzer = analyzer; 4 | 5 | var fbc = analyzer.frequencyBinCount; 6 | 7 | // TODO: why 2 * 4 instead of 4 ? 8 | // fudge factor is to make sure texture reachs from 0 -> 1 in vUv coords 9 | var pixels = fbc / 8; 10 | 11 | //creates a canvas element 12 | var canvas = document.createElement('canvas'); 13 | canvas.style.zIndex = 999; 14 | canvas.style.position = 'absolute'; 15 | canvas.style.top = '50px'; 16 | canvas.style.left = '100px'; 17 | canvas.style.border = '1px solid red'; 18 | 19 | // uncomment to see texture in upper left corner 20 | //document.body.appendChild( canvas ); 21 | 22 | 23 | canvas.width = pixels; 24 | canvas.height = 1; 25 | 26 | var c = canvas.getContext('2d'); 27 | 28 | var width = canvas.width; 29 | var height = canvas.height; 30 | 31 | var imageData = c.createImageData( width , height ); 32 | 33 | c.putImageData( imageData , 0 , 0 ); 34 | 35 | texture = new THREE.Texture( canvas ); 36 | texture.update = textureUpdate.bind( texture ) 37 | texture.analyzer = analyzer; 38 | texture.c = c; 39 | texture.pixels = pixels; 40 | texture.width = width; 41 | texture.height = height; 42 | 43 | // console.log( audio ); 44 | 45 | return texture; 46 | 47 | } 48 | 49 | textureUpdate = function(){ 50 | 51 | if( this.analyzer){ 52 | 53 | 54 | var imageData = this.c.createImageData( this.width , this.height ); 55 | 56 | //transfers audio data to rgb values 57 | for (var i = 0; i < this.pixels ; i++) { 58 | 59 | var x = i; 60 | var y = 0; 61 | var r = this.analyzer.array[i] | 0; 62 | var g = this.analyzer.array[i+1] | 0; 63 | var b = this.analyzer.array[i+2] | 0; 64 | var a = this.analyzer.array[i+3] | 0; 65 | setPixelData( imageData , x , y , r , g , b , a ); 66 | 67 | } 68 | 69 | 70 | this.c.putImageData( imageData , 0 , 0 ); 71 | 72 | //updates the texture 73 | this.needsUpdate = true; 74 | 75 | } 76 | 77 | //console.log('ss'); 78 | 79 | } 80 | 81 | //TODO: Move this to canvasFunctions 82 | 83 | setPixelData = function ( imageData, x, y, r, g, b, a) { 84 | 85 | //console.log( r + " : " + g + " : " + b + " : " + a); 86 | index = ( x + y * imageData.width ) * 4; 87 | imageData.data[index+0] = r; 88 | imageData.data[index+1] = g; 89 | imageData.data[index+2] = b; 90 | imageData.data[index+3] = a; 91 | 92 | } 93 | 94 | 95 | -------------------------------------------------------------------------------- /Maru/FurryHead.js: -------------------------------------------------------------------------------- 1 | 2 | var FURRY_HEAD_GEO , FURRY_HEAD_POS; 3 | function FurryHead( page , leader ){ 4 | 5 | 6 | this.page = page; 7 | this.size = 64; 8 | this.sim = shaders.ss.furryHead; 9 | this.leader = leader; 10 | 11 | this.physicsRenderer = new PhysicsRenderer( 12 | this.size, 13 | this.sim, 14 | renderer 15 | ); 16 | 17 | this.physicsRenderer.setUniform( 't_audio' ,G.uniforms.t_audio ); 18 | 19 | this.physicsRenderer.setUniform( 't_column' , { 20 | type:"t", 21 | value:null 22 | }); 23 | 24 | 25 | this.physicsRenderer.setUniform( 'leader' , { 26 | type:"v3" , 27 | value:this.leader.position 28 | }); 29 | 30 | this.physicsRenderer.setUniform( 'dT' , G.uniforms.dT ); 31 | 32 | this.physicsRenderer.setUniform( 'timer' , G.uniforms.time ); 33 | 34 | 35 | 36 | var t_normal = THREE.ImageUtils.loadTexture('icons/normals/moss_normal_map.jpg'); //MATS.textures.normals.moss; 37 | 38 | //console.log( t_normal ); 39 | 40 | var uniforms = { 41 | 42 | t_normal: { type:"t" , value: t_normal }, 43 | //t_audio: { type:"t" , value: audio.texture }, 44 | t_audio: G.uniforms.t_audio, 45 | t_pos: { type:"t" , value: null }, 46 | lightPos: { type:"v3" , value: this.page.position }, 47 | 48 | } 49 | 50 | var material = new THREE.ShaderMaterial({ 51 | 52 | uniforms: uniforms, 53 | vertexShader: shaders.vs.furryHead, 54 | fragmentShader: shaders.fs.furryHead, 55 | side: THREE.DoubleSide 56 | 57 | }); 58 | 59 | if( !FURRY_HEAD_GEO ){ 60 | this.geo = this.createGeo( this.size ); 61 | FURRY_HEAD_GEO = this.geo; 62 | }else{ 63 | this.geo = FURRY_HEAD_GEO; 64 | } 65 | 66 | var m = new THREE.MeshNormalMaterial(); 67 | this.mesh = new THREE.Mesh( this.geo , material ); 68 | 69 | this.mesh.frustumCulled = false; 70 | 71 | var pR = this.physicsRenderer; 72 | 73 | pR.addBoundTexture( this.mesh , 't_pos' , 'output' ); 74 | 75 | var mesh = new THREE.Mesh( new THREE.BoxGeometry( 5 , 5 , 5) ); 76 | var pTexture = this.createPosTexture( this.size ); 77 | 78 | this.pTexture; 79 | 80 | if( !FURRY_HEAD_POS ){ 81 | var mesh = new THREE.Mesh( new THREE.BoxGeometry( 5 , 5 , 5) ); 82 | this.pTexture = this.createPosTexture( this.size ); 83 | FURRY_HEAD_POS = this.pTexture; 84 | }else{ 85 | this.pTexture = FURRY_HEAD_POS;//this.createLineGeo(); 86 | } 87 | 88 | this.physicsRenderer.reset( this.pTexture ); 89 | 90 | //this.physicsRenderer.addDebugScene( scene ); 91 | 92 | } 93 | 94 | FurryHead.prototype.update = function(){ 95 | 96 | this.physicsRenderer.update(); 97 | } 98 | 99 | 100 | FurryHead.prototype.createGeo = function( size ){ 101 | 102 | var geo = new THREE.BufferGeometry(); 103 | 104 | var subSize = (size) * (size-1); 105 | 106 | var posA = new THREE.BufferAttribute( new Float32Array( subSize * 6 * 3 ), 3 ); 107 | var normA = new THREE.BufferAttribute( new Float32Array( subSize * 6 * 3 ), 3 ); 108 | 109 | geo.addAttribute( 'position', posA ); 110 | geo.addAttribute( 'normal', normA ); 111 | 112 | var positions = geo.getAttribute( 'position' ).array; 113 | var normals = geo.getAttribute( 'normal' ).array; 114 | 115 | var uvArray = []; 116 | for( var i = 0; i < size; i++ ){ 117 | for( var j = 0; j < size-1; j++ ){ 118 | 119 | if( i < size-1){ 120 | var x = (i+.5) / size; 121 | var y = (j+.5) / size; 122 | }else{ 123 | var x = 10000; //.5 / size; 124 | var y = (j+.5) / size; 125 | } 126 | 127 | uvArray.push( [ x , y ] ); 128 | } 129 | } 130 | 131 | for( var i=0; i < uvArray.length; i++ ){ 132 | 133 | var x = uvArray[i][0]; 134 | var y = uvArray[i][1]; 135 | 136 | 137 | // Tri 1 138 | 139 | var index = i * 6 * 3; 140 | // var i = //TODO: index 141 | // 142 | 143 | if( x != 10000 ){ 144 | 145 | positions[ index + 0 ] = x - (.5 / size); 146 | positions[ index + 1 ] = y + (.5 / size); 147 | positions[ index + 2 ] = 0; 148 | 149 | positions[ index + 3 ] = x - ( .5 / size ); 150 | positions[ index + 4 ] = y - ( .5 / size) ; 151 | positions[ index + 5 ] = 0; 152 | 153 | positions[ index + 6 ] = x + (.5 / size); 154 | positions[ index + 7 ] = y + (.5 / size); 155 | positions[ index + 8 ] = 0; 156 | 157 | positions[ index + 9 ] = x + (.5 / size); 158 | positions[ index + 10 ] = y + (.5 / size); 159 | positions[ index + 11 ] = 0; 160 | 161 | positions[ index + 12 ] = x - ( .5 / size ); 162 | positions[ index + 13 ] = y - ( .5 / size) ; 163 | positions[ index + 14 ] = 0; 164 | 165 | positions[ index + 15 ] = x + (.5 / size); 166 | positions[ index + 16 ] = y - (.5 / size); 167 | positions[ index + 17 ] = 0; 168 | 169 | 170 | normals[ index + 0 ] = x - (.5 / size); 171 | normals[ index + 1 ] = y + (.5 / size); 172 | normals[ index + 2 ] = 0; 173 | 174 | normals[ index + 3 ] = x - ( .5 / size ); 175 | normals[ index + 4 ] = y - ( .5 / size) ; 176 | normals[ index + 5 ] = 0; 177 | 178 | normals[ index + 6 ] = x + (.5 / size); 179 | normals[ index + 7 ] = y + (.5 / size); 180 | normals[ index + 8 ] = 0; 181 | 182 | normals[ index + 9 ] = x + (.5 / size); 183 | normals[ index + 10 ] = y + (.5 / size); 184 | normals[ index + 11 ] = 0; 185 | 186 | normals[ index + 12 ] = x - ( .5 / size ); 187 | normals[ index + 13 ] = y - ( .5 / size) ; 188 | normals[ index + 14 ] = 0; 189 | 190 | normals[ index + 15 ] = x + (.5 / size); 191 | normals[ index + 16 ] = y - (.5 / size); 192 | normals[ index + 17 ] = 0; 193 | 194 | }else{ 195 | 196 | positions[ index + 0 ] = 1 - (.5 / size); 197 | positions[ index + 1 ] = y + (.5 / size); 198 | positions[ index + 2 ] = 0; 199 | 200 | positions[ index + 3 ] = 1 - ( .5 / size ); 201 | positions[ index + 4 ] = y - ( .5 / size) ; 202 | positions[ index + 5 ] = 0; 203 | 204 | positions[ index + 6 ] = 0 + (.5 / size); 205 | positions[ index + 7 ] = y + (.5 / size); 206 | positions[ index + 8 ] = 0; 207 | 208 | positions[ index + 9 ] = 0 + (.5 / size); 209 | positions[ index + 10 ] = y + (.5 / size); 210 | positions[ index + 11 ] = 0; 211 | 212 | positions[ index + 12 ] = 1 - ( .5 / size ); 213 | positions[ index + 13 ] = y - ( .5 / size) ; 214 | positions[ index + 14 ] = 0; 215 | 216 | positions[ index + 15 ] = 0 + (.5 / size); 217 | positions[ index + 16 ] = y - (.5 / size); 218 | positions[ index + 17 ] = 0; 219 | 220 | 221 | normals[ index + 0 ] = 1 - (.5 / size); 222 | normals[ index + 1 ] = y + (.5 / size); 223 | normals[ index + 2 ] = 0; 224 | 225 | normals[ index + 3 ] = 1 - ( .5 / size ); 226 | normals[ index + 4 ] = y - ( .5 / size) ; 227 | normals[ index + 5 ] = 0; 228 | 229 | normals[ index + 6 ] = 0 + (.5 / size); 230 | normals[ index + 7 ] = y + (.5 / size); 231 | normals[ index + 8 ] = 0; 232 | 233 | normals[ index + 9 ] = 0 + (.5 / size); 234 | normals[ index + 10 ] = y + (.5 / size); 235 | normals[ index + 11 ] = 0; 236 | 237 | normals[ index + 12 ] = 1 - ( .5 / size ); 238 | normals[ index + 13 ] = y - ( .5 / size) ; 239 | normals[ index + 14 ] = 0; 240 | 241 | normals[ index + 15 ] = 0 + (.5 / size); 242 | normals[ index + 16 ] = y - (.5 / size); 243 | normals[ index + 17 ] = 0; 244 | 245 | 246 | 247 | } 248 | 249 | /* 250 | positions[ i + 3 ] = x + ( .5 / size ); 251 | positions[ i + 4 ] = y - ( .5 / size) ; 252 | positions[ i + 5 ] = 0; 253 | */ 254 | 255 | // Tri 2 256 | 257 | } 258 | 259 | return geo; 260 | 261 | 262 | }; 263 | 264 | 265 | FurryHead.prototype.createPosTexture = function( size ){ 266 | 267 | 268 | var data = new Float32Array( size * size * 4 ); 269 | 270 | for ( var i = 0, l = data.length; i < l; i += 4 ) { 271 | 272 | var y = Math.floor( (i/4) / size ); 273 | var x = (i/4) - (y * size); 274 | 275 | 276 | var theta = 2 * Math.PI * ( x / size ); 277 | 278 | var r =( .1 * Math.random() + .9) * 1; 279 | var posX = r * Math.cos( theta ); 280 | var posZ = r * Math.sin( theta ); 281 | 282 | /*var face = geometry.faces[ Math.floor( Math.random() * facesLength ) ]; 283 | 284 | var vertex1 = geometry.vertices[ face.a ]; 285 | var vertex2 = geometry.vertices[ Math.random() > 0.5 ? face.b : face.c ]; 286 | 287 | point.subVectors( vertex2, vertex1 ); 288 | point.multiplyScalar( Math.random() ); 289 | point.add( vertex1 );*/ 290 | 291 | data[ i ] = 1000 +posX; 292 | data[ i + 1 ] = 100 +posZ; 293 | data[ i + 2 ] = 100 + (1 - (y/size))*100; 294 | data[ i + 3 ] = 1; 295 | 296 | } 297 | 298 | var positionsTexture = new THREE.DataTexture( 299 | data, 300 | size, 301 | size, 302 | THREE.RGBAFormat, 303 | THREE.FloatType 304 | ); 305 | 306 | positionsTexture.minFilter = THREE.NearestFilter; 307 | positionsTexture.magFilter = THREE.NearestFilter; 308 | positionsTexture.generateMipmaps = false; 309 | positionsTexture.needsUpdate = true; 310 | 311 | return positionsTexture; 312 | 313 | }; 314 | -------------------------------------------------------------------------------- /Maru/GUI.js: -------------------------------------------------------------------------------- 1 | 2 | 3 | function GUI( PARAMS , params ){ 4 | 5 | this.params = _.defaults( params || {} ,{ 6 | domElement: document.body, 7 | }); 8 | 9 | 10 | //console.log( this.params ); 11 | this.PARAMS = PARAMS; 12 | 13 | this.gui = new dat.GUI({autoPlace:false}); 14 | this.gui.close(); 15 | 16 | // TODO: make passable 17 | this.domElement = this.params.domElement; 18 | this.domElement.appendChild(this.gui.domElement); 19 | 20 | 21 | this.soul = this.gui.addFolder( 'Soul' ); 22 | this.body = this.gui.addFolder( 'Body' ); 23 | 24 | for( var propt in PARAMS.soul ){ 25 | 26 | var p = PARAMS.soul[propt]; 27 | 28 | if( p.type === "f" ){ 29 | 30 | if(p.constraints ){ 31 | this.addFloat( 'soul' , p , propt , p.constraints ); 32 | }else{ 33 | this.addFloat( 'soul' , p , propt ); 34 | } 35 | 36 | } 37 | } 38 | 39 | 40 | 41 | 42 | for( var propt in PARAMS.body ){ 43 | 44 | var p = PARAMS.body[propt]; 45 | 46 | if( p.type === "f" ){ 47 | 48 | if(p.constraints ){ 49 | this.addFloat( 'body' , p , propt , p.constraints ); 50 | }else{ 51 | this.addFloat( 'body' , p , propt ); 52 | } 53 | 54 | }else if( p.type === "color" ){ 55 | 56 | this.addColor( 'body' , p , propt ); 57 | 58 | } 59 | 60 | } 61 | 62 | } 63 | 64 | // Need to create an extra varible call tmp_color1 to be able to use 65 | GUI.prototype.addColor = function( folder , object , name ){ 66 | 67 | // console.log('ass'); 68 | var actualObject = name.split( 'tmp_' )[1]; 69 | // console.log( actualObject ); 70 | 71 | // console.log( object ); 72 | this[folder].addColor( object , 'value' ).name( actualObject ).onChange(function(v){ 73 | this.PARAMS[folder][actualObject].value.setHex( v ) 74 | 75 | }.bind( this ) ); 76 | 77 | 78 | } 79 | 80 | GUI.prototype.addFloat = function( folder , object , name , constraints ){ 81 | 82 | if( constraints ){ 83 | this[folder].add( object , 'value' , constraints[0] , constraints[1] ).name( name ); 84 | }else{ 85 | this[folder].add( object , 'value' ).name( name ); 86 | } 87 | 88 | } 89 | 90 | /* 91 | 92 | guiSim.add( PARAMS.simulation.repulsionPower , 'value' , -10 , 100).name( 'Repulsion Power' ); 93 | guiSim.add( PARAMS.simulation.repulsionRadius , 'value' , 10 , 1000).name( 'Repulsion Radius' ); 94 | guiSim.add( PARAMS.simulation.dampening , 'value' , .8 , .999 ).name( 'Dampenening' ); 95 | 96 | guiSim.add( PARAMS , 'toggle').name( 'toggleRepelers' ); 97 | 98 | 99 | 100 | guiSim.add( PARAMS, 'objectType' , [ 101 | 'cube', 102 | 'sphere' , 103 | //'hand' , 104 | //'skull' , 105 | //'logo' , 106 | //'bieb' , 107 | //'rickAndBarney', 108 | //'ring', 109 | 'torus' 110 | ] ).onChange( function(value){ 111 | 112 | recreateGeometry(value); 113 | console.log(value); 114 | 115 | }); 116 | 117 | 118 | guiRender.add( PARAMS.render.audioDisplacement , 'value' , -3 , 3).name( 'Audio Displacement' ); 119 | guiRender.add( PARAMS.render.custom1 , 'value' , 0 , 1).name( 'Custom1' ); 120 | guiRender.add( PARAMS.render.custom2 , 'value' , 0 , 1).name( 'Custom2' ); 121 | guiRender.add( PARAMS.render.custom3 , 'value' , 0 , 1).name( 'Custom3' ); 122 | 123 | guiRender.addColor( PARAMS.render , 'lambTemp' ).name( 'Lambert' ).onChange( function( value ){ 124 | 125 | PARAMS.render.c_lamb.value.r =value.r / 256; 126 | PARAMS.render.c_lamb.value.g =value.g / 256; 127 | PARAMS.render.c_lamb.value.b =value.b / 256; 128 | 129 | }).listen(); 130 | 131 | guiRender.addColor( PARAMS.render , 'specTemp' ).name( 'Specular' ).onChange( function( value ){ 132 | 133 | PARAMS.render.c_spec.value.r =value.r / 256; 134 | PARAMS.render.c_spec.value.g =value.g / 256; 135 | PARAMS.render.c_spec.value.b =value.b / 256; 136 | 137 | }).listen(); 138 | 139 | guiRender.addColor( PARAMS.render , 'audioTemp' ).name( 'Fresnel?' ).onChange( function( value ){ 140 | 141 | PARAMS.render.c_audio.value.r =value.r / 256; 142 | PARAMS.render.c_audio.value.g =value.g / 256; 143 | PARAMS.render.c_audio.value.b =value.b / 256; 144 | 145 | }).listen(); 146 | 147 | 148 | PARAMS.render.lambTemp.r = PARAMS.render.c_lamb.value.r * 256; 149 | PARAMS.render.lambTemp.g = PARAMS.render.c_lamb.value.g * 256; 150 | PARAMS.render.lambTemp.b = PARAMS.render.c_lamb.value.b * 256; 151 | 152 | PARAMS.render.specTemp.r = PARAMS.render.c_spec.value.r * 256; 153 | PARAMS.render.specTemp.g = PARAMS.render.c_spec.value.g * 256; 154 | PARAMS.render.specTemp.b = PARAMS.render.c_spec.value.b * 256; 155 | 156 | PARAMS.render.audioTemp.r = PARAMS.render.c_audio.value.r * 256; 157 | PARAMS.render.audioTemp.g = PARAMS.render.c_audio.value.g * 256; 158 | PARAMS.render.audioTemp.b = PARAMS.render.c_audio.value.b * 256; 159 | 160 | 161 | 162 | 163 | guiRender.add( PARAMS,'visualType' , [ 164 | 'plastic' , 165 | 'wireframe' , 166 | 'striped' , 167 | 'ambient', 168 | 'fractal' 169 | ]).onChange(function(value){ 170 | 171 | */ 172 | -------------------------------------------------------------------------------- /Maru/GeosansLight.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/GeosansLight.ttf -------------------------------------------------------------------------------- /Maru/LoadedAudio.js: -------------------------------------------------------------------------------- 1 | function LoadedAudio( controller , file , params ){ 2 | 3 | this.loader; 4 | this.params = _.defaults( params || {}, { 5 | 6 | looping: false, 7 | fbc: 128, 8 | fadeTime: 1, 9 | texture: true, 10 | 11 | }); 12 | 13 | this.controller = controller; 14 | 15 | this.file = file; 16 | 17 | this.playing = false; 18 | 19 | this.looping = this.params.looping; 20 | 21 | this.buffer; 22 | 23 | this.filterOn = false; 24 | this.filter = this.controller.ctx.createBiquadFilter(); 25 | this.analyser = this.controller.ctx.createAnalyser(); 26 | this.analyser.array = new Uint8Array( this.params.fbc ); 27 | this.gain = this.controller.ctx.createGain(); 28 | 29 | this.analyzer = this.analyser; //I hate spelling 30 | 31 | this.analyser.connect( this.gain ); 32 | 33 | if( this.looping ){ 34 | this.gain.connect( this.controller.loopInput ); 35 | }else{ 36 | this.gain.connect( this.controller.noteInput ); 37 | } 38 | 39 | 40 | 41 | this.time = 0; 42 | 43 | if( this.params.texture ){ 44 | 45 | this.texture = AudioTexture( this.analyser ); 46 | 47 | } 48 | 49 | this.loadFile(); 50 | 51 | } 52 | 53 | 54 | LoadedAudio.prototype._loadProgress = function(e){ 55 | 56 | this.loaded = e.loaded / e.total; 57 | 58 | this.loadProgress( e ); 59 | 60 | //tween.start(); 61 | } 62 | 63 | LoadedAudio.prototype.loadProgress = function(){ 64 | 65 | 66 | } 67 | 68 | 69 | LoadedAudio.prototype.loadFile = function(){ 70 | 71 | 72 | var request=new XMLHttpRequest(); 73 | request.open("GET",this.file,true); 74 | request.responseType="arraybuffer"; 75 | 76 | var self = this; 77 | request.onerror = function(){ 78 | alert( 'ERROR LOADING SONG' ); 79 | //self.womb.loader.addFailue( 'Capability to load song' , 'http://womble.com' 80 | } 81 | 82 | 83 | 84 | request.onprogress = this._loadProgress.bind( this ); 85 | 86 | var self = this; 87 | 88 | request.onload = function(){ 89 | 90 | self.controller.ctx.decodeAudioData(request.response,function(buffer){ 91 | 92 | if(!buffer){ 93 | alert('error decoding file data: '+url); 94 | return; 95 | } 96 | 97 | self.buffer = buffer; 98 | self.onDecode(); 99 | 100 | }) 101 | }, 102 | 103 | request.send(); 104 | 105 | } 106 | 107 | LoadedAudio.prototype.onDecode = function(){ 108 | 109 | //gets just the track name, removing the mp3 110 | this.trackID= this.file.split('.')[this.file.split('.').length-2]; 111 | 112 | this.createSource(); 113 | 114 | //var self = this; 115 | //if( this.params.onLoad ) this.params.onLoad( self ); 116 | 117 | this._onLoad(); 118 | 119 | } 120 | 121 | 122 | LoadedAudio.prototype.createSource = function() { 123 | 124 | this.source = this.controller.ctx.createBufferSource(); 125 | this.source.buffer = this.buffer; 126 | this.source.loop = false;//this.looping; 127 | 128 | this.source.connect( this.analyser ); 129 | 130 | if( !this.looping ){ 131 | 132 | //this.gain.gain.value = 1; 133 | 134 | } 135 | 136 | 137 | 138 | 139 | }; 140 | 141 | LoadedAudio.prototype.destroySource = function(){ 142 | 143 | this.source.disconnect(this.analyser); 144 | this.analyser.disconnect(this.gain); 145 | this.source = undefined; 146 | this.analyser = undefined; 147 | 148 | }; 149 | 150 | LoadedAudio.prototype.fadeOut = function( time ){ 151 | 152 | var t = this.controller.ctx.currentTime; 153 | if( !time ) time = this.params.fadeTime; 154 | this.gain.gain.linearRampToValueAtTime( this.gain.gain.value , t ); 155 | this.gain.gain.linearRampToValueAtTime( 0.0 , t + time ); 156 | 157 | } 158 | 159 | LoadedAudio.prototype.fadeIn = function( time , value ){ 160 | 161 | if( !time ) time = this.params.fadeTime; 162 | if( !value ) value = 1; 163 | 164 | var t = this.controller.ctx.currentTime; 165 | this.gain.gain.linearRampToValueAtTime( this.gain.gain.value , t ); 166 | this.gain.gain.linearRampToValueAtTime( 1.0 , t + time ); 167 | 168 | } 169 | 170 | LoadedAudio.prototype.turnOffFilter = function(){ 171 | this.filterOn = false; 172 | this.filter.disconnect(0); 173 | this.source.disconnect( 0 ); 174 | this.source.connect( this.gain ); 175 | } 176 | 177 | LoadedAudio.prototype.turnOnFilter = function(){ 178 | this.filterOn = true; 179 | this.source.disconnect( 0 ); 180 | this.source.connect( this.filter ); 181 | this.filter.connect( this.gain ); 182 | } 183 | 184 | 185 | 186 | LoadedAudio.prototype.stop = function(){ 187 | 188 | this.playing = false; 189 | 190 | if( this.source.noteOff ){ 191 | this.source.noteOff(0); 192 | }else{ 193 | this.source.stop(); 194 | } 195 | 196 | this.createSource(); 197 | 198 | }; 199 | 200 | LoadedAudio.prototype.play = function( vol ){ 201 | 202 | if( vol ){ this.gain.gain.value = vol } 203 | //this.startTime = this.controller.womb.time.value; 204 | 205 | this.playing = true; 206 | 207 | if( this.source.noteOn ){ 208 | this.source.noteOn(0); 209 | } 210 | 211 | 212 | this.source.start(); 213 | 214 | // Creates a new source for the audio right away 215 | // so we can play the next one with no delay 216 | // if(this.looping == false){ 217 | this.createSource(); 218 | // } 219 | // 220 | //this.controller.addToUpdateArray( this.update.bind( this ) ); 221 | 222 | }; 223 | 224 | LoadedAudio.prototype._onLoad = function(){ 225 | 226 | if( this.looping ){ 227 | 228 | 229 | looper.everyLoop( function(){ 230 | 231 | if( this.playing ){ 232 | this.play() 233 | } 234 | 235 | }.bind( this )); 236 | 237 | this.gain.gain.value = 0; 238 | 239 | } 240 | 241 | this.onLoad(); 242 | 243 | this.controller.addToUpdateArray( this.update.bind( this ) ); 244 | 245 | } 246 | LoadedAudio.prototype.onLoad = function(){} 247 | 248 | 249 | LoadedAudio.prototype.update = function(){ 250 | 251 | if( this.playing ){ 252 | 253 | //this.time = this.controller.womb.time.value - this.startTime; 254 | this.analyser.getByteFrequencyData( this.analyser.array ); 255 | this.averageVolume = this.getAverage( this.analyser.array ); 256 | 257 | //console.log( this.averageVolume ); 258 | if( this.texture ) 259 | this.texture.update(); 260 | 261 | } 262 | 263 | } 264 | 265 | LoadedAudio.prototype.getAverage = function( array ){ 266 | 267 | var ave = 0; 268 | var l = array.length; 269 | 270 | for( var i = 0; i< array.length; i++ ){ 271 | 272 | ave += array[i]; 273 | 274 | } 275 | 276 | ave /= l; 277 | 278 | return ave; 279 | 280 | } 281 | 282 | 283 | 284 | -------------------------------------------------------------------------------- /Maru/Looper.js: -------------------------------------------------------------------------------- 1 | 2 | function Looper( controller , timer , params ){ 3 | 4 | this.controller = controller; 5 | this.params = _.defaults( params || {}, { 6 | 7 | beatsPerMinute: 120, 8 | beatsPerMeasure: 4, 9 | beatType: 4, 10 | measuresPerLoop: 4, // number of measures in loop 11 | 12 | }); 13 | 14 | this.timer = timer; 15 | 16 | this.beatsPerMinute = this.params.beatsPerMinute; 17 | this.bpm = this.beatsPerMinute; 18 | 19 | this.beatsPerSecond = this.bpm / 60; 20 | this.bps = this.beatsPerSecond; 21 | 22 | this.secondsPerBeat = 1 / this.bps; 23 | this.spb = this.secondsPerBeat; 24 | 25 | this.beatsPerMeasure = this.params.beatsPerMeasure; 26 | 27 | this.measureLength = this.spb * this.beatsPerMeasure; 28 | 29 | this.measuresPerLoop = this.params.measuresPerLoop; 30 | this.mpl = this.measuresPerLoop; 31 | 32 | this.loopLength = this.measureLength * this.mpl; 33 | 34 | this.measure = 0; 35 | this.oMeasure = 0; 36 | 37 | this.timeInMeasure = 0; 38 | this.measureStartTime = 0; 39 | this.percentOfMeasure = 0; 40 | this.oPercentOfMeasure = 0; 41 | 42 | this.timeInLoop = 0; 43 | this.loopStartTime = 0; 44 | this.percentOfLoop = 0; 45 | this.oPercentOfLoop = 0; 46 | 47 | this.loop = -1; 48 | this.oLoop = -1; 49 | 50 | this.hits = []; 51 | 52 | this.onNextLoopArray = []; 53 | this.onNextMeasureArray = []; 54 | this.everyLoopArray = []; 55 | 56 | this.controller.addToUpdateArray( this._update.bind( this ) ); 57 | 58 | 59 | } 60 | 61 | Looper.prototype._update = function(){ 62 | 63 | this.updateTime(); 64 | this.checkHits(); 65 | 66 | this.update(); 67 | 68 | } 69 | 70 | Looper.prototype.start =function(){ 71 | 72 | this._onNewLoop(); 73 | this._onNewMeasure(); 74 | 75 | } 76 | 77 | Looper.prototype.update = function(){ 78 | 79 | 80 | }; 81 | 82 | 83 | Looper.prototype.tweenGain = function( gainNode , newValue ){ 84 | 85 | var percentTilEnd = 1 - this.percentOfLoop; 86 | var timeTilEnd = percentTilEnd * this.loopLength; 87 | 88 | var endValue = newValue * 1; 89 | var i = { gain: gainNode.gain.value } 90 | var t = { gain: endValue } 91 | 92 | var tween = new TWEEN.Tween( i ).to( t , timeTilEnd * 1000 ); 93 | 94 | tween.easing( TWEEN.Easing.Quartic.In ) 95 | tween.gainNode = gainNode; 96 | tween.newValue = newValue; 97 | tween.endValue = endValue 98 | 99 | tween.onUpdate(function( ){ 100 | 101 | this.gainNode.gain.value = i.gain; 102 | 103 | }.bind(tween)); 104 | 105 | tween.onComplete( function(){ 106 | this.gain.value = newValue; 107 | }.bind( gainNode )); 108 | 109 | tween.start(); 110 | 111 | } 112 | 113 | Looper.prototype.onNextMeasure = function( callback ){ 114 | 115 | this.onNextMeasureArray.push( callback ) 116 | 117 | } 118 | 119 | Looper.prototype.onNextLoop = function( callback ){ 120 | 121 | this.onNextLoopArray.push( callback ) 122 | 123 | } 124 | 125 | Looper.prototype.everyLoop = function( callback ){ 126 | 127 | this.everyLoopArray.push( callback ); 128 | 129 | } 130 | 131 | 132 | 133 | Looper.prototype.updateTime = function(){ 134 | 135 | this.newMeasure = false; 136 | 137 | this.oPercentOfMeasure = this.percentOfMeasure; 138 | 139 | this.timeInMeasure = this.timer.value - this.measureStartTime; 140 | this.percentOfMeasure = this.timeInMeasure / this.measureLength; 141 | 142 | 143 | this.timeInLoop = this.timer.value - this.loopStartTime; 144 | this.percentOfLoop = this.timeInLoop / this.loopLength; 145 | 146 | 147 | if( this.percentOfLoop >= 1.0 ){ 148 | this._onNewLoop(); 149 | } 150 | 151 | if( this.percentOfMeasure >= 1.0 ){ 152 | this._onNewMeasure(); 153 | } 154 | 155 | 156 | } 157 | 158 | Looper.prototype._onNewLoop = function(){ 159 | 160 | 161 | this.oLoop = this.loop; 162 | 163 | this.loopStartTime += this.loopLength * this.percentOfLoop; 164 | this.loop += 1; 165 | 166 | this.newLoop = true; 167 | 168 | for( var i = 0; i < this.onNextLoopArray.length; i++ ){ 169 | 170 | this.onNextLoopArray[i](); 171 | 172 | } 173 | 174 | for( var i = 0; i < this.everyLoopArray.length; i++ ){ 175 | 176 | this.everyLoopArray[i](); 177 | 178 | } 179 | this.onNextLoopArray = []; 180 | this.onNewLoop(); 181 | 182 | 183 | } 184 | 185 | Looper.prototype.onNewLoop = function(){} 186 | 187 | Looper.prototype._onNewMeasure = function(){ 188 | 189 | this.oMeasure = this.measure; 190 | this.measure +=1; 191 | this.measureStartTime = this.measure * this.measureLength; 192 | 193 | this.newMeasure = true; 194 | 195 | 196 | for( var i = 0; i < this.onNextMeasureArray.length; i++ ){ 197 | this.onNextMeasureArray[i](); 198 | } 199 | 200 | this.onNextMeasureArray = []; 201 | 202 | this.onNewMeasure(); 203 | 204 | 205 | //this.measureInLoop = 206 | 207 | } 208 | 209 | 210 | Looper.prototype.onNewMeasure = function(){} 211 | 212 | Looper.prototype.addHit = function( callback , params ){ 213 | 214 | var hit = _.defaults( params || {}, { 215 | 216 | callback: callback, 217 | 218 | percents: [ .0 , .25 , .50 , .75 ], 219 | measureFrequency: 1, 220 | measureOffset: 0, 221 | duration: [ 0 , 1000000000 ], 222 | 223 | }); 224 | 225 | 226 | this.hits.push( hit ); 227 | 228 | } 229 | 230 | Looper.prototype.addSequence = function( callback , sequenceLength , hitArray , duration ){ 231 | 232 | for( var i = 0; i < hitArray.length; i++ ){ 233 | 234 | if( !duration ) duration = [0 , 10000000000 ]; 235 | this.addHit( callback , { 236 | 237 | measureFrequency: sequenceLength, 238 | measureOffset: hitArray[i][0], 239 | percents: hitArray[i][1], 240 | duration: duration 241 | 242 | }); 243 | 244 | } 245 | 246 | 247 | 248 | } 249 | 250 | Looper.prototype.checkHits = function(){ 251 | 252 | for( var i = 0; i < this.hits.length; i++ ){ 253 | 254 | var hit = this.hits[i]; 255 | 256 | var t = this.audio.time; 257 | 258 | // only check if within the duration of hit 259 | if( t >= hit.duration[0] && t <= hit.duration[1] ){ 260 | 261 | // only check if on proper measure 262 | if( this.measure % hit.measureFrequency == hit.measureOffset ){ 263 | 264 | for( var j = 0; j < hit.percents.length; j ++ ){ 265 | 266 | var p = hit.percents[j]; 267 | 268 | if( 269 | this.percentOfMeasure >= p && 270 | this.oPercentOfMeasure < p 271 | ){ 272 | 273 | 274 | hit.callback(); 275 | 276 | // In this case the percentage is at 0 277 | }else if( p == 0 && this.newMeasure ){ 278 | 279 | hit.callback(); 280 | 281 | } 282 | 283 | } 284 | 285 | } 286 | 287 | } 288 | 289 | } 290 | 291 | 292 | }; 293 | 294 | -------------------------------------------------------------------------------- /Maru/MaruBassKickLoop.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/MaruBassKickLoop.mp3 -------------------------------------------------------------------------------- /Maru/MaruBassModLoop.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/MaruBassModLoop.mp3 -------------------------------------------------------------------------------- /Maru/MaruBellALoop.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/MaruBellALoop.mp3 -------------------------------------------------------------------------------- /Maru/MaruBellBLoop.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/MaruBellBLoop.mp3 -------------------------------------------------------------------------------- /Maru/MaruBellBrightLoop.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/MaruBellBrightLoop.mp3 -------------------------------------------------------------------------------- /Maru/MaruBellCLoop.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/MaruBellCLoop.mp3 -------------------------------------------------------------------------------- /Maru/MaruClapLoop.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/MaruClapLoop.mp3 -------------------------------------------------------------------------------- /Maru/MaruHatsLoop.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/MaruHatsLoop.mp3 -------------------------------------------------------------------------------- /Maru/MaruHiupLoop.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/MaruHiupLoop.mp3 -------------------------------------------------------------------------------- /Maru/MaruIMPLoop.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/MaruIMPLoop.mp3 -------------------------------------------------------------------------------- /Maru/MaruKickLoop.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/MaruKickLoop.mp3 -------------------------------------------------------------------------------- /Maru/MaruLogritLoop.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/MaruLogritLoop.mp3 -------------------------------------------------------------------------------- /Maru/MaruLoops.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/MaruLoops.zip -------------------------------------------------------------------------------- /Maru/MaruLopanLoop.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/MaruLopanLoop.mp3 -------------------------------------------------------------------------------- /Maru/MaruModALoop.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/MaruModALoop.mp3 -------------------------------------------------------------------------------- /Maru/MaruModBLoop.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/MaruModBLoop.mp3 -------------------------------------------------------------------------------- /Maru/MaruRNLLoop.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/MaruRNLLoop.mp3 -------------------------------------------------------------------------------- /Maru/MaruRollLoop.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/MaruRollLoop.mp3 -------------------------------------------------------------------------------- /Maru/MaruSnareLoop.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/MaruSnareLoop.mp3 -------------------------------------------------------------------------------- /Maru/MaruUpmidLoop.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/MaruUpmidLoop.mp3 -------------------------------------------------------------------------------- /Maru/MaruVocLoop.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/MaruVocLoop.mp3 -------------------------------------------------------------------------------- /Maru/OBJLoader.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @author mrdoob / http://mrdoob.com/ 3 | */ 4 | 5 | THREE.OBJLoader = function ( manager ) { 6 | 7 | this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager; 8 | 9 | }; 10 | 11 | THREE.OBJLoader.prototype = { 12 | 13 | constructor: THREE.OBJLoader, 14 | 15 | load: function ( url, onLoad, onProgress, onError ) { 16 | 17 | var scope = this; 18 | 19 | var loader = new THREE.XHRLoader( scope.manager ); 20 | loader.setCrossOrigin( this.crossOrigin ); 21 | loader.load( url, function ( text ) { 22 | 23 | onLoad( scope.parse( text ) ); 24 | 25 | } ); 26 | 27 | }, 28 | 29 | parse: function ( text ) { 30 | 31 | function vector( x, y, z ) { 32 | 33 | return new THREE.Vector3( parseFloat( x ), parseFloat( y ), parseFloat( z ) ); 34 | 35 | } 36 | 37 | function uv( u, v ) { 38 | 39 | return new THREE.Vector2( parseFloat( u ), parseFloat( v ) ); 40 | 41 | } 42 | 43 | function face3( a, b, c, normals ) { 44 | 45 | return new THREE.Face3( a, b, c, normals ); 46 | 47 | } 48 | 49 | var object = new THREE.Object3D(); 50 | var geometry, material, mesh; 51 | 52 | function parseVertexIndex( index ) { 53 | 54 | index = parseInt( index ); 55 | 56 | return index >= 0 ? index - 1 : index + vertices.length; 57 | 58 | } 59 | 60 | function parseNormalIndex( index ) { 61 | 62 | index = parseInt( index ); 63 | 64 | return index >= 0 ? index - 1 : index + normals.length; 65 | 66 | } 67 | 68 | function parseUVIndex( index ) { 69 | 70 | index = parseInt( index ); 71 | 72 | return index >= 0 ? index - 1 : index + uvs.length; 73 | 74 | } 75 | 76 | function add_face( a, b, c, normals_inds ) { 77 | 78 | if ( normals_inds === undefined ) { 79 | 80 | geometry.faces.push( face3( 81 | vertices[ parseVertexIndex( a ) ] - 1, 82 | vertices[ parseVertexIndex( b ) ] - 1, 83 | vertices[ parseVertexIndex( c ) ] - 1 84 | ) ); 85 | 86 | } else { 87 | 88 | geometry.faces.push( face3( 89 | vertices[ parseVertexIndex( a ) ] - 1, 90 | vertices[ parseVertexIndex( b ) ] - 1, 91 | vertices[ parseVertexIndex( c ) ] - 1, 92 | [ 93 | normals[ parseNormalIndex( normals_inds[ 0 ] ) ].clone(), 94 | normals[ parseNormalIndex( normals_inds[ 1 ] ) ].clone(), 95 | normals[ parseNormalIndex( normals_inds[ 2 ] ) ].clone() 96 | ] 97 | ) ); 98 | 99 | } 100 | 101 | } 102 | 103 | function add_uvs( a, b, c ) { 104 | 105 | geometry.faceVertexUvs[ 0 ].push( [ 106 | uvs[ parseUVIndex( a ) ].clone(), 107 | uvs[ parseUVIndex( b ) ].clone(), 108 | uvs[ parseUVIndex( c ) ].clone() 109 | ] ); 110 | 111 | } 112 | 113 | function handle_face_line(faces, uvs, normals_inds) { 114 | 115 | if ( faces[ 3 ] === undefined ) { 116 | 117 | add_face( faces[ 0 ], faces[ 1 ], faces[ 2 ], normals_inds ); 118 | 119 | if ( uvs !== undefined && uvs.length > 0 ) { 120 | 121 | add_uvs( uvs[ 0 ], uvs[ 1 ], uvs[ 2 ] ); 122 | 123 | } 124 | 125 | } else { 126 | 127 | if ( normals_inds !== undefined && normals_inds.length > 0 ) { 128 | 129 | add_face( faces[ 0 ], faces[ 1 ], faces[ 3 ], [ normals_inds[ 0 ], normals_inds[ 1 ], normals_inds[ 3 ] ] ); 130 | add_face( faces[ 1 ], faces[ 2 ], faces[ 3 ], [ normals_inds[ 1 ], normals_inds[ 2 ], normals_inds[ 3 ] ] ); 131 | 132 | } else { 133 | 134 | add_face( faces[ 0 ], faces[ 1 ], faces[ 3 ] ); 135 | add_face( faces[ 1 ], faces[ 2 ], faces[ 3 ] ); 136 | 137 | } 138 | 139 | if ( uvs !== undefined && uvs.length > 0 ) { 140 | 141 | add_uvs( uvs[ 0 ], uvs[ 1 ], uvs[ 3 ] ); 142 | add_uvs( uvs[ 1 ], uvs[ 2 ], uvs[ 3 ] ); 143 | 144 | } 145 | 146 | } 147 | 148 | } 149 | 150 | // create mesh if no objects in text 151 | 152 | if ( /^o /gm.test( text ) === false ) { 153 | 154 | geometry = new THREE.Geometry(); 155 | material = new THREE.MeshLambertMaterial(); 156 | mesh = new THREE.Mesh( geometry, material ); 157 | object.add( mesh ); 158 | 159 | } 160 | 161 | var vertices = []; 162 | var normals = []; 163 | var uvs = []; 164 | 165 | // v float float float 166 | 167 | var vertex_pattern = /v( +[\d|\.|\+|\-|e]+)( +[\d|\.|\+|\-|e]+)( +[\d|\.|\+|\-|e]+)/; 168 | 169 | // vn float float float 170 | 171 | var normal_pattern = /vn( +[\d|\.|\+|\-|e]+)( +[\d|\.|\+|\-|e]+)( +[\d|\.|\+|\-|e]+)/; 172 | 173 | // vt float float 174 | 175 | var uv_pattern = /vt( +[\d|\.|\+|\-|e]+)( +[\d|\.|\+|\-|e]+)/; 176 | 177 | // f vertex vertex vertex ... 178 | 179 | var face_pattern1 = /f( +-?\d+)( +-?\d+)( +-?\d+)( +-?\d+)?/; 180 | 181 | // f vertex/uv vertex/uv vertex/uv ... 182 | 183 | var face_pattern2 = /f( +(-?\d+)\/(-?\d+))( +(-?\d+)\/(-?\d+))( +(-?\d+)\/(-?\d+))( +(-?\d+)\/(-?\d+))?/; 184 | 185 | // f vertex/uv/normal vertex/uv/normal vertex/uv/normal ... 186 | 187 | var face_pattern3 = /f( +(-?\d+)\/(-?\d+)\/(-?\d+))( +(-?\d+)\/(-?\d+)\/(-?\d+))( +(-?\d+)\/(-?\d+)\/(-?\d+))( +(-?\d+)\/(-?\d+)\/(-?\d+))?/; 188 | 189 | // f vertex//normal vertex//normal vertex//normal ... 190 | 191 | var face_pattern4 = /f( +(-?\d+)\/\/(-?\d+))( +(-?\d+)\/\/(-?\d+))( +(-?\d+)\/\/(-?\d+))( +(-?\d+)\/\/(-?\d+))?/ 192 | 193 | // 194 | 195 | var lines = text.split( '\n' ); 196 | 197 | for ( var i = 0; i < lines.length; i ++ ) { 198 | 199 | var line = lines[ i ]; 200 | line = line.trim(); 201 | 202 | var result; 203 | 204 | if ( line.length === 0 || line.charAt( 0 ) === '#' ) { 205 | 206 | continue; 207 | 208 | } else if ( ( result = vertex_pattern.exec( line ) ) !== null ) { 209 | 210 | // ["v 1.0 2.0 3.0", "1.0", "2.0", "3.0"] 211 | 212 | vertices.push( 213 | geometry.vertices.push( 214 | vector( 215 | result[ 1 ], result[ 2 ], result[ 3 ] 216 | ) 217 | ) 218 | ); 219 | 220 | } else if ( ( result = normal_pattern.exec( line ) ) !== null ) { 221 | 222 | // ["vn 1.0 2.0 3.0", "1.0", "2.0", "3.0"] 223 | 224 | normals.push( 225 | vector( 226 | result[ 1 ], result[ 2 ], result[ 3 ] 227 | ) 228 | ); 229 | 230 | } else if ( ( result = uv_pattern.exec( line ) ) !== null ) { 231 | 232 | // ["vt 0.1 0.2", "0.1", "0.2"] 233 | 234 | uvs.push( 235 | uv( 236 | result[ 1 ], result[ 2 ] 237 | ) 238 | ); 239 | 240 | } else if ( ( result = face_pattern1.exec( line ) ) !== null ) { 241 | 242 | // ["f 1 2 3", "1", "2", "3", undefined] 243 | 244 | handle_face_line( 245 | [ result[ 1 ], result[ 2 ], result[ 3 ], result[ 4 ] ] 246 | ); 247 | 248 | } else if ( ( result = face_pattern2.exec( line ) ) !== null ) { 249 | 250 | // ["f 1/1 2/2 3/3", " 1/1", "1", "1", " 2/2", "2", "2", " 3/3", "3", "3", undefined, undefined, undefined] 251 | 252 | handle_face_line( 253 | [ result[ 2 ], result[ 5 ], result[ 8 ], result[ 11 ] ], //faces 254 | [ result[ 3 ], result[ 6 ], result[ 9 ], result[ 12 ] ] //uv 255 | ); 256 | 257 | } else if ( ( result = face_pattern3.exec( line ) ) !== null ) { 258 | 259 | // ["f 1/1/1 2/2/2 3/3/3", " 1/1/1", "1", "1", "1", " 2/2/2", "2", "2", "2", " 3/3/3", "3", "3", "3", undefined, undefined, undefined, undefined] 260 | 261 | handle_face_line( 262 | [ result[ 2 ], result[ 6 ], result[ 10 ], result[ 14 ] ], //faces 263 | [ result[ 3 ], result[ 7 ], result[ 11 ], result[ 15 ] ], //uv 264 | [ result[ 4 ], result[ 8 ], result[ 12 ], result[ 16 ] ] //normal 265 | ); 266 | 267 | } else if ( ( result = face_pattern4.exec( line ) ) !== null ) { 268 | 269 | // ["f 1//1 2//2 3//3", " 1//1", "1", "1", " 2//2", "2", "2", " 3//3", "3", "3", undefined, undefined, undefined] 270 | 271 | handle_face_line( 272 | [ result[ 2 ], result[ 5 ], result[ 8 ], result[ 11 ] ], //faces 273 | [ ], //uv 274 | [ result[ 3 ], result[ 6 ], result[ 9 ], result[ 12 ] ] //normal 275 | ); 276 | 277 | } else if ( /^o /.test( line ) ) { 278 | 279 | geometry = new THREE.Geometry(); 280 | material = new THREE.MeshLambertMaterial(); 281 | 282 | mesh = new THREE.Mesh( geometry, material ); 283 | mesh.name = line.substring( 2 ).trim(); 284 | object.add( mesh ); 285 | 286 | } else if ( /^g /.test( line ) ) { 287 | 288 | // group 289 | 290 | } else if ( /^usemtl /.test( line ) ) { 291 | 292 | // material 293 | 294 | material.name = line.substring( 7 ).trim(); 295 | 296 | } else if ( /^mtllib /.test( line ) ) { 297 | 298 | // mtl file 299 | 300 | } else if ( /^s /.test( line ) ) { 301 | 302 | // smooth shading 303 | 304 | } else { 305 | 306 | // console.log( "THREE.OBJLoader: Unhandled line " + line ); 307 | 308 | } 309 | 310 | } 311 | 312 | var children = object.children; 313 | 314 | for ( var i = 0, l = children.length; i < l; i ++ ) { 315 | 316 | var geometry = children[ i ].geometry; 317 | 318 | geometry.computeFaceNormals(); 319 | geometry.computeBoundingSphere(); 320 | 321 | } 322 | 323 | return object; 324 | 325 | } 326 | 327 | }; -------------------------------------------------------------------------------- /Maru/ObjectControls.js: -------------------------------------------------------------------------------- 1 | // TODO Make it so you can pass in renderer w / h 2 | function ObjectControls( eye , params ){ 3 | 4 | this.intersected; 5 | this.selected; 6 | 7 | this.eye = eye; 8 | 9 | this.mouse = new THREE.Vector3(); 10 | this.unprojectedMouse = new THREE.Vector3(); 11 | 12 | this.objects = []; 13 | 14 | var params = params || {}; 15 | var p = params; 16 | 17 | this.domElement = p.domElement || document; 18 | 19 | // Recursively check descendants of objects in this.objects for intersections. 20 | this.recursive = p.recursive || false; 21 | 22 | this.raycaster = new THREE.Raycaster(); 23 | 24 | this.raycaster.near = this.eye.near; 25 | this.raycaster.far = this.eye.far; 26 | 27 | 28 | var addListener = this.domElement.addEventListener; 29 | 30 | var cb1 = this.mouseDown.bind( this ); 31 | var cb2 = this.mouseUp.bind( this ); 32 | var cb3 = this.mouseMove.bind( this ); 33 | 34 | this.domElement.addEventListener( 'mousedown', cb1 , false ) 35 | this.domElement.addEventListener( 'mouseup' , cb2 , false ) 36 | this.domElement.addEventListener( 'mousemove', cb3 , false ) 37 | 38 | this.domElement.addEventListener( 'touchdown', cb1 , false ) 39 | this.domElement.addEventListener( 'touchup' , cb2 , false ) 40 | this.domElement.addEventListener( 'touchmove', cb3 , false ) 41 | 42 | this.unprojectMouse(); 43 | 44 | } 45 | 46 | 47 | 48 | 49 | /* 50 | 51 | EVENTS 52 | 53 | */ 54 | 55 | 56 | // You can think of _up and _down as mouseup and mouse down 57 | ObjectControls.prototype._down = function(){ 58 | 59 | this.down(); 60 | 61 | if( this.intersected ){ 62 | 63 | this._select( this.intersected ); 64 | 65 | } 66 | 67 | } 68 | 69 | ObjectControls.prototype.down = function(){} 70 | 71 | 72 | 73 | ObjectControls.prototype._up = function(){ 74 | 75 | this.up(); 76 | 77 | if( this.selected ){ 78 | 79 | this._deselect( this.selected ); 80 | 81 | } 82 | 83 | } 84 | 85 | ObjectControls.prototype.up = function(){} 86 | 87 | 88 | 89 | ObjectControls.prototype._hoverOut = function( object ){ 90 | 91 | this.hoverOut(); 92 | 93 | this.objectHovered = false; 94 | 95 | if( object.hoverOut ){ 96 | object.hoverOut( this ); 97 | } 98 | 99 | }; 100 | 101 | ObjectControls.prototype.hoverOut = function(){}; 102 | 103 | 104 | 105 | ObjectControls.prototype._hoverOver = function( object ){ 106 | 107 | this.hoverOver(); 108 | 109 | this.objectHovered = true; 110 | 111 | if( object.hoverOver ){ 112 | object.hoverOver( this ); 113 | } 114 | 115 | }; 116 | 117 | ObjectControls.prototype.hoverOver = function(){} 118 | 119 | 120 | 121 | ObjectControls.prototype._select = function( object ){ 122 | 123 | this.select(); 124 | 125 | var intersectionPoint = this.getIntersectionPoint( this.intersected ); 126 | 127 | this.selected = object; 128 | this.intersectionPoint = intersectionPoint; 129 | 130 | if( object.select ){ 131 | object.select( this ); 132 | } 133 | 134 | }; 135 | 136 | ObjectControls.prototype.select = function(){} 137 | 138 | 139 | 140 | ObjectControls.prototype._deselect = function( object ){ 141 | 142 | //console.log('DESELECT'); 143 | 144 | this.selected = undefined; 145 | this.intersectionPoint = undefined; 146 | 147 | if( object.deselect ){ 148 | object.deselect( this ); 149 | } 150 | 151 | this.deselect(); 152 | 153 | }; 154 | 155 | ObjectControls.prototype.deselect = function(){} 156 | 157 | 158 | 159 | 160 | /* 161 | 162 | Changing what objects we are controlling 163 | 164 | */ 165 | 166 | ObjectControls.prototype.add = function( object ){ 167 | 168 | this.objects.push( object ); 169 | 170 | }; 171 | 172 | ObjectControls.prototype.remove = function( object ){ 173 | 174 | for( var i = 0; i < this.objects.length; i++ ){ 175 | 176 | if( this.objects[i] == object ){ 177 | 178 | this.objects.splice( i , 1 ); 179 | 180 | } 181 | 182 | } 183 | 184 | }; 185 | 186 | 187 | 188 | 189 | /* 190 | 191 | Update Loop 192 | 193 | */ 194 | 195 | ObjectControls.prototype.update = function(){ 196 | 197 | this.setRaycaster( this.unprojectedMouse ); 198 | if( !this.selected ){ 199 | 200 | this.checkForIntersections( this.unprojectedMouse ); 201 | 202 | }else{ 203 | 204 | this._updateSelected( this.unprojectedMouse ); 205 | 206 | } 207 | 208 | }; 209 | 210 | ObjectControls.prototype._updateSelected = function(){ 211 | 212 | if( this.selected.update ){ 213 | 214 | this.selected.update( this ); 215 | 216 | } 217 | 218 | } 219 | 220 | ObjectControls.prototype.updateSelected = function(){}; 221 | 222 | 223 | 224 | 225 | ObjectControls.prototype.setRaycaster = function( position ){ 226 | 227 | var origin = position; 228 | var direction = origin.clone() 229 | 230 | direction.sub( this.eye.position ); 231 | direction.normalize(); 232 | 233 | this.raycaster.set( this.eye.position , direction ); 234 | 235 | } 236 | 237 | 238 | 239 | /* 240 | 241 | Checks 242 | 243 | */ 244 | 245 | ObjectControls.prototype.checkForIntersections = function( position ){ 246 | 247 | var intersected = this.raycaster.intersectObjects( this.objects, this.recursive ); 248 | 249 | 250 | if( intersected.length > 0 ){ 251 | 252 | for (var n = 0; n < intersected.length; n++ ) { 253 | 254 | if ( this.recursive ) { 255 | 256 | var topLevelObj = this._findTopLevelAncestor( intersected[n].object ); 257 | if ( topLevelObj ) { 258 | 259 | // Reset intersected.object, leave intersected.point etc. unchanged. 260 | // This works since in the two most common use cases the ancestor: 261 | // (1) contains the child object (and the intersection point) 262 | // (2) is not a THREE.Mesh and thus doesn't appear in the scene, 263 | // e.g. an Object3D used for grouping other related objects. 264 | intersected[n].object = topLevelObj; 265 | 266 | } 267 | 268 | } 269 | 270 | } 271 | 272 | this._objectIntersected( intersected ); 273 | 274 | }else{ 275 | 276 | this._noObjectIntersected(); 277 | 278 | } 279 | 280 | }; 281 | 282 | ObjectControls.prototype.checkForUpDown = function( hand , oHand ){ 283 | 284 | if( this.upDownEvent( this.selectionStrength , hand , oHand ) === true ){ 285 | 286 | this._down(); 287 | 288 | }else if( this.upDownEvent( this.selectionStrength , hand , oHand ) === false ){ 289 | 290 | this._up(); 291 | 292 | } 293 | 294 | }; 295 | 296 | 297 | 298 | 299 | ObjectControls.prototype.getIntersectionPoint = function( i ){ 300 | 301 | var intersected = this.raycaster.intersectObjects( this.objects, this.recursive ); 302 | 303 | return intersected[0].point.sub( i.position ); 304 | 305 | } 306 | 307 | ObjectControls.prototype._findTopLevelAncestor = function( object ){ 308 | 309 | // Traverse back up until we find the first ancestor that is a top-level 310 | // object then return it (or null), since only top-level objects (which 311 | // were passed to objectControls.add) handle events, even if their child 312 | // objects are the ones intersected. 313 | 314 | while ( this.objects.indexOf(object) === -1) { 315 | 316 | if ( !object.parent ) { 317 | 318 | return null; 319 | 320 | } 321 | 322 | object = object.parent; 323 | 324 | } 325 | 326 | return object; 327 | 328 | } 329 | 330 | 331 | 332 | /* 333 | 334 | Raycast Events 335 | 336 | */ 337 | 338 | ObjectControls.prototype._objectIntersected = function( intersected ){ 339 | 340 | // Assigning out first intersected object 341 | // so we don't get changes everytime we hit 342 | // a new face 343 | var firstIntersection = intersected[0].object; 344 | 345 | if( !this.intersected ){ 346 | 347 | this.intersected = firstIntersection; 348 | 349 | this._hoverOver( this.intersected ); 350 | 351 | 352 | }else{ 353 | 354 | if( this.intersected != firstIntersection ){ 355 | 356 | this._hoverOut( this.intersected ); 357 | 358 | this.intersected = firstIntersection; 359 | 360 | this._hoverOver( this.intersected ); 361 | 362 | } 363 | 364 | } 365 | 366 | this.objectIntersected(); 367 | 368 | }; 369 | 370 | ObjectControls.prototype.objectIntersected = function(){} 371 | 372 | ObjectControls.prototype._noObjectIntersected = function(){ 373 | 374 | if( this.intersected ){ 375 | 376 | this._hoverOut( this.intersected ); 377 | this.intersected = undefined; 378 | 379 | } 380 | 381 | this.noObjectIntersected(); 382 | 383 | }; 384 | 385 | ObjectControls.prototype.noObjectIntersected = function(){} 386 | 387 | 388 | ObjectControls.prototype.mouseMove = function(event){ 389 | 390 | this.mouseMoved = true; 391 | 392 | this.mouse.x = ( event.clientX / window.innerWidth ) * 2 - 1; 393 | this.mouse.y = -( event.clientY / window.innerHeight ) * 2 + 1; 394 | this.mouse.z = 1; 395 | 396 | this.unprojectMouse(); 397 | 398 | } 399 | 400 | ObjectControls.prototype.unprojectMouse = function(){ 401 | 402 | this.unprojectedMouse.copy( this.mouse ); 403 | this.unprojectedMouse.unproject( this.eye ); 404 | 405 | } 406 | 407 | ObjectControls.prototype.mouseDown = function( event ){ 408 | this.mouseMove( event ); 409 | this._down(); 410 | } 411 | 412 | ObjectControls.prototype.mouseUp = function(){ 413 | this.mouseMove( event ); 414 | this._up(); 415 | } 416 | 417 | 418 | ObjectControls.prototype.touchStart = function(event){ 419 | this.touchMove( event ); 420 | this._down(); 421 | } 422 | 423 | ObjectControls.prototype.touchEnd = function(event){ 424 | this.touchMove( event ); 425 | this._up(); 426 | } 427 | 428 | ObjectControls.prototype.touchMove= function(event){ 429 | 430 | this.mouseMoved = true; 431 | 432 | this.mouse.x = ( event.touches[ 0 ].pageX / window.innerWidth ) * 2 - 1; 433 | this.mouse.y = -( event.touches[ 0 ].pageY / window.innerHeight ) * 2 + 1; 434 | this.mouse.z = 1; 435 | 436 | this.unprojectMouse(); 437 | 438 | } 439 | -------------------------------------------------------------------------------- /Maru/ParticleUtils.js: -------------------------------------------------------------------------------- 1 | var ParticleUtils = { 2 | 3 | 4 | /* From @mrdoob's Sporel Demo */ 5 | createPositionsTexture: function( size , mesh ){ 6 | 7 | var geometry = new THREE.Geometry(); 8 | 9 | geometry.merge( mesh.geometry , mesh.matrix ); 10 | 11 | var point = new THREE.Vector3(); 12 | var facesLength = geometry.faces.length; 13 | 14 | var data = new Float32Array( size * size * 4 ); 15 | 16 | for ( var i = 0, l = data.length; i < l; i += 4 ) { 17 | 18 | var face = geometry.faces[ Math.floor( Math.random() * facesLength ) ]; 19 | 20 | var vertex1 = geometry.vertices[ face.a ]; 21 | var vertex2 = geometry.vertices[ Math.random() > 0.5 ? face.b : face.c ]; 22 | 23 | point.subVectors( vertex2, vertex1 ); 24 | point.multiplyScalar( Math.random() ); 25 | point.add( vertex1 ); 26 | 27 | data[ i ] = point.x; 28 | data[ i + 1 ] = point.y; 29 | data[ i + 2 ] = point.z; 30 | data[ i + 3 ] = 1; 31 | 32 | } 33 | 34 | var positionsTexture = new THREE.DataTexture( 35 | data, 36 | size, 37 | size, 38 | THREE.RGBAFormat, 39 | THREE.FloatType 40 | ); 41 | 42 | positionsTexture.minFilter = THREE.NearestFilter; 43 | positionsTexture.magFilter = THREE.NearestFilter; 44 | positionsTexture.generateMipmaps = false; 45 | positionsTexture.needsUpdate = true; 46 | 47 | positionsTexture.mesh = mesh; 48 | 49 | return positionsTexture; 50 | 51 | }, 52 | 53 | 54 | createLookupGeometry: function( size ){ 55 | 56 | var geo = new THREE.BufferGeometry(); 57 | 58 | // geo.addAttribute( 'position', Float32Array , size * size , 3 ); 59 | 60 | var pos = new THREE.BufferAttribute( new Float32Array( size * size * 3 ) , 3 ); 61 | 62 | var positions = pos.array; 63 | 64 | for ( var i = 0, j = 0, l = positions.length / 3; i < l; i ++, j += 3 ) { 65 | 66 | positions[ j ] = ( i % size ) / size; 67 | positions[ j + 1 ] = Math.floor( i / size ) / size; 68 | //positions[ j + 2 ] = Math.sin( (i / size) * Math.PI ); 69 | 70 | } 71 | 72 | geo.addAttribute( 'position', pos ); 73 | 74 | 75 | return geo; 76 | 77 | }, 78 | 79 | 80 | 81 | createParticleLookupGeometry: function( size ){ 82 | 83 | 84 | 85 | var geo = new THREE.BufferGeometry(); 86 | 87 | //var posBuffer = new THREE.BufferAttribute( new Float32Array( 32 * 32 * 4 ) , 3 ); 88 | 89 | var positions = []; 90 | var uvs = []; 91 | var indices = []; 92 | 93 | 94 | for ( var i = 0; i < size * size; i++ ) { 95 | 96 | positions[ i * 4 * 3 + 0 ] = ( i % size ) / size; 97 | positions[ i * 4 * 3 + 1 ] = Math.floor( i / size ) / size; 98 | positions[ i * 4 * 3 + 2 ] = 0; 99 | 100 | positions[ i * 4 * 3 + 3 ] = ( i % size ) / size; 101 | positions[ i * 4 * 3 + 4 ] = Math.floor( i / size ) / size; 102 | positions[ i * 4 * 3 + 5 ] = 0; 103 | 104 | positions[ i * 4 * 3 + 6 ] = ( i % size ) / size; 105 | positions[ i * 4 * 3 + 7 ] = Math.floor( i / size ) / size; 106 | positions[ i * 4 * 3 + 8 ] = 0; 107 | 108 | positions[ i * 4 * 3 + 9 ] = ( i % size ) / size; 109 | positions[ i * 4 * 3 + 10 ] = Math.floor( i / size ) / size; 110 | positions[ i * 4 * 3 + 11 ] = 0; 111 | 112 | 113 | uvs[ i * 4 * 2 + 0 ] = 0; 114 | uvs[ i * 4 * 2 + 1 ] = 0; 115 | 116 | uvs[ i * 4 * 2 + 2 ] = 1; 117 | uvs[ i * 4 * 2 + 3 ] = 0; 118 | 119 | uvs[ i * 4 * 2 + 4 ] = 0; 120 | uvs[ i * 4 * 2 + 5 ] = 1; 121 | 122 | uvs[ i * 4 * 2 + 6 ] = 1; 123 | uvs[ i * 4 * 2 + 7 ] = 1; 124 | 125 | 126 | //uvs[ j + 2 ] = Math.sin( (i / size) * Math.PI ); 127 | 128 | } 129 | 130 | 131 | for( var i = 0; i < size*size; i++ ){ 132 | 133 | indices.push( i * 4 + 0 ); 134 | indices.push( i * 4 + 3 ); 135 | indices.push( i * 4 + 1 ); 136 | indices.push( i * 4 + 0 ); 137 | indices.push( i * 4 + 2 ); 138 | indices.push( i * 4 + 3 ); 139 | 140 | } 141 | 142 | 143 | geo.setIndex(indices); 144 | geo.addAttribute('position',new THREE.Float32BufferAttribute(positions,3)); 145 | geo.addAttribute('uv2',new THREE.Float32BufferAttribute(uvs,2)); 146 | 147 | 148 | return geo; 149 | 150 | } 151 | 152 | } 153 | -------------------------------------------------------------------------------- /Maru/PhysicsRenderer.js: -------------------------------------------------------------------------------- 1 | function PhysicsRenderer( size , shader , renderer ){ 2 | 3 | // First Make sure everything Works 4 | this.checkCompatibility( renderer ); 5 | this.renderer = renderer; 6 | 7 | this.size = size || 128; 8 | this.s2 = size * size; 9 | 10 | this.renderer = renderer; 11 | 12 | this.clock = new THREE.Clock(); 13 | 14 | 15 | // Sets up our render targets 16 | this.rt_1 = new THREE.WebGLRenderTarget( this.size, this.size, { 17 | minFilter: THREE.NearestFilter, 18 | magFilter: THREE.NearestFilter, 19 | format: THREE.RGBAFormat, 20 | type:THREE.FloatType, 21 | stencilBuffer: false 22 | }); 23 | 24 | this.rt_2 = this.rt_1.clone(); 25 | this.rt_3 = this.rt_1.clone(); 26 | 27 | this.counter = 0; 28 | 29 | this.debugScene = this.createDebugScene(); 30 | this.texturePassProgram = this.createTexturePassProgram(); 31 | 32 | // WHERE THE MAGIC HAPPENS 33 | this.simulation = this.createSimulationProgram( shader ); 34 | this.material = this.simulation; 35 | 36 | this.boundTextures = []; 37 | 38 | /* 39 | 40 | GPGPU Utilities 41 | From Sporel by Mr.Doob 42 | @author mrdoob / http://www.mrdoob.com 43 | 44 | */ 45 | 46 | this.camera = new THREE.OrthographicCamera( - 0.5, 0.5, 0.5, - 0.5, 0, 1 ); 47 | this.scene = new THREE.Scene(); 48 | this.mesh = new THREE.Mesh( new THREE.PlaneGeometry( 1, 1 ) ); 49 | this.scene.add( this.mesh ); 50 | 51 | } 52 | 53 | PhysicsRenderer.prototype.checkCompatibility = function( renderer ){ 54 | 55 | var gl = renderer.context; 56 | 57 | if ( gl.getExtension( "OES_texture_float" ) === null ) { 58 | this.onError( "No Float Textures"); 59 | return; 60 | } 61 | 62 | if ( gl.getParameter( gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS ) === 0 ) { 63 | this.onError( "Vert Shader Textures don't work"); 64 | return; 65 | } 66 | 67 | } 68 | 69 | PhysicsRenderer.prototype.onError = function( e ){ 70 | console.log( e ); 71 | } 72 | 73 | PhysicsRenderer.prototype.createDebugScene= function(){ 74 | 75 | var debugScene = new THREE.Object3D(); 76 | debugScene.position.z = 0; 77 | 78 | var geo = new THREE.PlaneGeometry( 100 , 100 ); 79 | 80 | var debugMesh = new THREE.Mesh( geo , new THREE.MeshBasicMaterial({ 81 | map: this.rt_1 82 | })); 83 | debugMesh.position.set( -105 , 0 , 0 ); 84 | 85 | debugScene.add( debugMesh ); 86 | 87 | var debugMesh = new THREE.Mesh( geo , new THREE.MeshBasicMaterial({ 88 | map: this.rt_2 89 | })); 90 | debugMesh.position.set( 0 , 0 , 0 ); 91 | debugScene.add( debugMesh ); 92 | 93 | var debugMesh = new THREE.Mesh( geo , new THREE.MeshBasicMaterial({ 94 | map: this.rt_3 95 | })); 96 | debugMesh.position.set( 105, 0 , 0 ); 97 | debugScene.add( debugMesh ); 98 | 99 | return debugScene; 100 | 101 | } 102 | 103 | PhysicsRenderer.prototype.removeDebugScene = function( scene ){ 104 | scene.remove( this.debugScene ); 105 | } 106 | 107 | PhysicsRenderer.prototype.addDebugScene = function( scene ){ 108 | scene.add( this.debugScene ); 109 | } 110 | 111 | 112 | PhysicsRenderer.prototype.createTexturePassProgram = function(){ 113 | 114 | var uniforms = { 115 | texture:{ type:"t" , value:null }, 116 | } 117 | 118 | var texturePassShader = new THREE.ShaderMaterial({ 119 | uniforms:uniforms, 120 | vertexShader:this.VSPass, 121 | fragmentShader:this.FSPass, 122 | }); 123 | 124 | return texturePassShader; 125 | 126 | } 127 | 128 | PhysicsRenderer.prototype.createSimulationProgram = function(sim){ 129 | 130 | this.simulationUniforms = { 131 | t_oPos:{ type:"t" , value:null }, 132 | t_pos:{ type:"t" , value:null }, 133 | } 134 | 135 | 136 | var program = new THREE.ShaderMaterial({ 137 | 138 | uniforms:this.simulationUniforms, 139 | vertexShader:this.VSPass, 140 | fragmentShader:sim 141 | 142 | }); 143 | 144 | return program; 145 | 146 | } 147 | 148 | 149 | PhysicsRenderer.prototype.VSPass = [ 150 | "varying vec2 vUv;", 151 | "void main() {", 152 | " vUv = uv;", 153 | " gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );", 154 | "}" 155 | ].join("\n"); 156 | 157 | PhysicsRenderer.prototype.FSPass = [ 158 | "uniform sampler2D texture;", 159 | "varying vec2 vUv;", 160 | "void main() {", 161 | " vec4 c = texture2D( texture , vUv );", 162 | " gl_FragColor = c ;", 163 | "}" 164 | ].join("\n"); 165 | 166 | 167 | PhysicsRenderer.prototype.update = function(){ 168 | 169 | var flipFlop = this.counter % 3; 170 | 171 | if( flipFlop == 0 ){ 172 | 173 | this.simulation.uniforms.t_oPos.value = this.rt_1; 174 | this.simulation.uniforms.t_pos.value = this.rt_2; 175 | 176 | this.pass( this.simulation, this.rt_3 ); 177 | 178 | this.ooOutput = this.rt_1; 179 | this.oOutput = this.rt_2; 180 | this.output = this.rt_3; 181 | 182 | }else if( flipFlop == 1 ){ 183 | 184 | this.simulation.uniforms.t_oPos.value = this.rt_2; 185 | this.simulation.uniforms.t_pos.value = this.rt_3; 186 | 187 | this.pass( this.simulation , this.rt_1 ); 188 | 189 | this.ooOutput = this.rt_2; 190 | this.oOutput = this.rt_3; 191 | this.output = this.rt_1; 192 | 193 | 194 | }else if( flipFlop == 2 ){ 195 | 196 | this.simulation.uniforms.t_oPos.value = this.rt_3; 197 | this.simulation.uniforms.t_pos.value = this.rt_1; 198 | 199 | this.pass( this.simulation , this.rt_2 ); 200 | 201 | this.ooOutput = this.rt_3; 202 | this.oOutput = this.rt_1; 203 | this.output = this.rt_2; 204 | 205 | } 206 | 207 | this.counter ++; 208 | 209 | this.bindTextures(); 210 | 211 | } 212 | 213 | // Some GPGPU Utilities author: @mrdoob 214 | PhysicsRenderer.prototype.render = function ( scene, camera, target ) { 215 | renderer.render( scene, camera, target, false ); 216 | }; 217 | 218 | PhysicsRenderer.prototype.pass = function ( shader , target ) { 219 | this.mesh.material = shader; 220 | this.renderer.render( this.scene, this.camera, target, false ); 221 | }; 222 | 223 | PhysicsRenderer.prototype.out = function ( shader ) { 224 | this.mesh.material = shader.material; 225 | this.renderer.render( this.scene, this.camera ); 226 | }; 227 | 228 | // Used if he have uniforms we want to update! 229 | PhysicsRenderer.prototype.setUniforms = function( uniforms ){ 230 | 231 | this.simulation.uniforms = uniforms || {}; 232 | 233 | // Have to make sure that these always remain! 234 | this.simulation.uniforms.t_pos = { value:"t" , value:null }; 235 | this.simulation.uniforms.t_oPos = { value:"t" , value:null }; 236 | 237 | console.log( this.simulation.uniforms ); 238 | 239 | } 240 | 241 | PhysicsRenderer.prototype.setUniform = function( name , u ){ 242 | this.simulation.uniforms[name] = u; 243 | } 244 | 245 | // resets the render targets to the from position 246 | PhysicsRenderer.prototype.reset = function( texture ){ 247 | 248 | this.texture = texture; 249 | this.texturePassProgram.uniforms.texture.value = texture; 250 | 251 | this.pass( this.texturePassProgram , this.rt_1 ); 252 | this.pass( this.texturePassProgram , this.rt_2 ); 253 | this.pass( this.texturePassProgram , this.rt_3 ); 254 | 255 | } 256 | 257 | PhysicsRenderer.prototype.addBoundTexture = function( system , uniform , value ){ 258 | this.boundTextures.push( [ system , uniform , value ] ); 259 | } 260 | 261 | PhysicsRenderer.prototype.bindTextures = function(){ 262 | 263 | for( var i = 0; i < this.boundTextures.length; i++ ){ 264 | 265 | var boundSystem = this.boundTextures[i][0]; 266 | var boundUniform = this.boundTextures[i][1]; 267 | var textureToBind = this.boundTextures[i][2]; 268 | 269 | if( !boundSystem.material ){ 270 | console.log( boundSystem ); 271 | console.log( boundUniform ); 272 | } 273 | 274 | var uniform = boundSystem.material.uniforms[ boundUniform ]; 275 | 276 | uniform.value = this[ textureToBind ]; 277 | 278 | 279 | } 280 | 281 | } 282 | 283 | -------------------------------------------------------------------------------- /Maru/PosVelSimulation.js: -------------------------------------------------------------------------------- 1 | function PosVelSimulation( size , posShader , velShader , renderer ){ 2 | 3 | // First Make sure everything Works 4 | this.checkCompatibility( renderer ); 5 | this.renderer = renderer; 6 | 7 | this.size = size || 128; 8 | this.s2 = size * size; 9 | 10 | this.renderer = renderer; 11 | 12 | this.clock = new THREE.Clock(); 13 | 14 | 15 | // Sets up our render targets 16 | this.rt_pos1 = new THREE.WebGLRenderTarget( this.size, this.size, { 17 | minFilter: THREE.NearestFilter, 18 | magFilter: THREE.NearestFilter, 19 | format: THREE.RGBAFormat, 20 | type:THREE.FloatType, 21 | stencilBuffer: false 22 | }); 23 | 24 | this.rt_pos2 = this.rt_pos1.clone(); 25 | this.rt_vel1 = this.rt_pos1.clone(); 26 | this.rt_vel2 = this.rt_pos1.clone(); 27 | 28 | this.counter = 0; 29 | 30 | this.debugScene = this.createDebugScene(); 31 | this.texturePassProgram = this.createTexturePassProgram(); 32 | 33 | // WHERE THE MAGIC HAPPENS 34 | this.posSimulation = this.createSimulationProgram( posShader ); 35 | this.velSimulation = this.createSimulationProgram( velShader ); 36 | 37 | this.boundTextures = []; 38 | 39 | /* 40 | 41 | GPGPU Utilities 42 | From Sporel by Mr.Doob 43 | @author mrdoob / http://www.mrdoob.com 44 | 45 | */ 46 | 47 | this.camera = new THREE.OrthographicCamera( - 0.5, 0.5, 0.5, - 0.5, 0, 1 ); 48 | this.scene = new THREE.Scene(); 49 | this.mesh = new THREE.Mesh( new THREE.PlaneGeometry( 1, 1 ) ); 50 | this.scene.add( this.mesh ); 51 | 52 | } 53 | 54 | PosVelSimulation.prototype.checkCompatibility = function( renderer ){ 55 | 56 | var gl = renderer.context; 57 | 58 | if ( gl.getExtension( "OES_texture_float" ) === null ) { 59 | this.onError( "No Float Textures"); 60 | return; 61 | } 62 | 63 | if ( gl.getParameter( gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS ) === 0 ) { 64 | this.onError( "Vert Shader Textures don't work"); 65 | return; 66 | } 67 | 68 | } 69 | 70 | PosVelSimulation.prototype.onError = function( e ){ 71 | console.log( e ); 72 | } 73 | 74 | PosVelSimulation.prototype.createDebugScene= function(){ 75 | 76 | var debugScene = new THREE.Object3D(); 77 | debugScene.position.z = 0; 78 | 79 | var geo = new THREE.PlaneGeometry( 100 , 100 ); 80 | 81 | var debugMesh = new THREE.Mesh( geo , new THREE.MeshBasicMaterial({ 82 | map: this.rt_pos1 83 | })); 84 | debugMesh.position.set( -55 , 55 , 0 ); 85 | 86 | debugScene.add( debugMesh ); 87 | 88 | var debugMesh = new THREE.Mesh( geo , new THREE.MeshBasicMaterial({ 89 | map: this.rt_pos2 90 | })); 91 | debugMesh.position.set( 55 , 55 , 0 ); 92 | debugScene.add( debugMesh ); 93 | 94 | var debugMesh = new THREE.Mesh( geo , new THREE.MeshBasicMaterial({ 95 | map: this.rt_vel1 96 | })); 97 | debugMesh.position.set( -55, -55 , 0 ); 98 | debugScene.add( debugMesh ); 99 | 100 | var debugMesh = new THREE.Mesh( geo , new THREE.MeshBasicMaterial({ 101 | map: this.rt_vel2 102 | })); 103 | debugMesh.position.set( 55, -55 , 0 ); 104 | debugScene.add( debugMesh ); 105 | 106 | return debugScene; 107 | 108 | } 109 | 110 | PosVelSimulation.prototype.removeDebugScene = function( scene ){ 111 | scene.remove( this.debugScene ); 112 | } 113 | 114 | PosVelSimulation.prototype.addDebugScene = function( scene ){ 115 | scene.add( this.debugScene ); 116 | } 117 | 118 | 119 | PosVelSimulation.prototype.createTexturePassProgram = function(){ 120 | 121 | var uniforms = { 122 | texture:{ type:"t" , value:null }, 123 | } 124 | 125 | var texturePassShader = new THREE.ShaderMaterial({ 126 | uniforms:uniforms, 127 | vertexShader:this.VSPass, 128 | fragmentShader:this.FSPass, 129 | }); 130 | 131 | return texturePassShader; 132 | 133 | } 134 | 135 | PosVelSimulation.prototype.createSimulationProgram = function(sim){ 136 | 137 | var simulationUniforms = { 138 | t_pos:{ type:"t" , value:null }, 139 | t_vel:{ type:"t" , value:null }, 140 | delta:{ type:"f" , value:0 } 141 | } 142 | 143 | 144 | var program = new THREE.ShaderMaterial({ 145 | 146 | uniforms: simulationUniforms, 147 | vertexShader:this.VSPass, 148 | fragmentShader:sim 149 | 150 | }); 151 | 152 | return program; 153 | 154 | } 155 | 156 | 157 | PosVelSimulation.prototype.VSPass = [ 158 | "varying vec2 vUv;", 159 | "void main() {", 160 | " vUv = uv;", 161 | " gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );", 162 | "}" 163 | ].join("\n"); 164 | 165 | PosVelSimulation.prototype.FSPass = [ 166 | "uniform sampler2D texture;", 167 | "varying vec2 vUv;", 168 | "void main() {", 169 | " vec4 c = texture2D( texture , vUv );", 170 | " gl_FragColor = c ;", 171 | "}" 172 | ].join("\n"); 173 | 174 | 175 | PosVelSimulation.prototype.update = function(){ 176 | 177 | var flipFlop = this.counter % 2; 178 | var delta = this.clock.getDelta(); 179 | 180 | this.posSimulation.uniforms.delta.value = delta; 181 | this.velSimulation.uniforms.delta.value = delta; 182 | 183 | if( flipFlop == 0 ){ 184 | 185 | this.posSimulation.uniforms.t_pos.value = this.rt_pos2; 186 | this.velSimulation.uniforms.t_vel.value = this.rt_vel2; 187 | 188 | this.pass( this.velSimulation , this.rt_vel1 ); 189 | 190 | this.posSimulation.uniforms.t_pos.value = this.rt_pos2; 191 | this.posSimulation.uniforms.t_vel.value = this.rt_vel1; 192 | 193 | this.pass( this.posSimulation , this.rt_pos1 ); 194 | 195 | this.oOutputPos = this.rt_pos2; 196 | this.oOutputVel = this.rt_vel2; 197 | 198 | this.outputPos = this.rt_pos1; 199 | this.outputVel = this.rt_vel1; 200 | 201 | }else if( flipFlop == 1 ){ 202 | 203 | this.posSimulation.uniforms.t_pos.value = this.rt_pos1; 204 | this.velSimulation.uniforms.t_vel.value = this.rt_vel1; 205 | 206 | this.pass( this.velSimulation , this.rt_vel2 ); 207 | 208 | this.posSimulation.uniforms.t_pos.value = this.rt_pos1; 209 | this.posSimulation.uniforms.t_vel.value = this.rt_vel2; 210 | 211 | this.pass( this.posSimulation , this.rt_pos2 ); 212 | 213 | this.oOutputPos = this.rt_pos1; 214 | this.oOutputVel = this.rt_vel1; 215 | 216 | this.outputPos = this.rt_pos2; 217 | this.outputVel = this.rt_vel2; 218 | 219 | } 220 | 221 | this.counter ++; 222 | 223 | this.bindTextures(); 224 | 225 | } 226 | 227 | // Some GPGPU Utilities author: @mrdoob 228 | PosVelSimulation.prototype.render = function ( scene, camera, target ) { 229 | renderer.render( scene, camera, target, false ); 230 | }; 231 | 232 | PosVelSimulation.prototype.pass = function ( shader , target ) { 233 | this.mesh.material = shader; 234 | this.renderer.render( this.scene, this.camera, target, false ); 235 | }; 236 | 237 | PosVelSimulation.prototype.out = function ( shader ) { 238 | this.mesh.material = shader.material; 239 | this.renderer.render( this.scene, this.camera ); 240 | }; 241 | 242 | // Used if he have uniforms we want to update! 243 | PosVelSimulation.prototype.setUniforms = function( uniforms ){ 244 | 245 | this.simulation.uniforms = uniforms || {}; 246 | 247 | // Have to make sure that these always remain! 248 | this.simulation.uniforms.t_pos = { value:"t" , value:null }; 249 | this.simulation.uniforms.t_oPos = { value:"t" , value:null }; 250 | 251 | console.log( this.simulation.uniforms ); 252 | 253 | } 254 | 255 | PosVelSimulation.prototype.setPosUniform = function( name , u ){ 256 | this.posSimulation.uniforms[name] = u; 257 | } 258 | 259 | PosVelSimulation.prototype.setVelUniform = function( name , u ){ 260 | this.velSimulation.uniforms[name] = u; 261 | } 262 | 263 | 264 | // resets the render targets to the from position 265 | PosVelSimulation.prototype.reset = function( posTexture , velTexture ){ 266 | 267 | this.texturePassProgram.uniforms.texture.value = posTexture; 268 | 269 | this.pass( this.texturePassProgram , this.rt_pos1 ); 270 | this.pass( this.texturePassProgram , this.rt_pos2 ); 271 | 272 | this.texturePassProgram.uniforms.texture.value = velTexture; 273 | 274 | this.pass( this.texturePassProgram , this.rt_vel1 ); 275 | this.pass( this.texturePassProgram , this.rt_vel2 ); 276 | 277 | } 278 | 279 | PosVelSimulation.prototype.addBoundTexture = function( system , uniform , value ){ 280 | this.boundTextures.push( [ system , uniform , value ] ); 281 | } 282 | 283 | PosVelSimulation.prototype.bindTextures = function(){ 284 | 285 | for( var i = 0; i < this.boundTextures.length; i++ ){ 286 | 287 | var boundSystem = this.boundTextures[i][0]; 288 | var boundUniform = this.boundTextures[i][1]; 289 | var textureToBind = this.boundTextures[i][2]; 290 | 291 | var uniform = boundSystem.material.uniforms[ boundUniform ]; 292 | 293 | uniform.value = this[ textureToBind ]; 294 | 295 | 296 | } 297 | 298 | } 299 | 300 | -------------------------------------------------------------------------------- /Maru/ShaderLoader.js: -------------------------------------------------------------------------------- 1 | 2 | // Shader Loader will Load any shader you want, 3 | // And be able to add in large functions ( such as noise ) 4 | // with regex inside the shader 5 | function ShaderLoader( pathToShaders , pathToChunks ){ 6 | 7 | this.fragmentShaders = {}; 8 | this.vertexShaders = {}; 9 | this.simulationShaders = {}; 10 | 11 | this.vs = this.vertexShaders; 12 | this.fs = this.fragmentShaders; 13 | this.ss = this.simulationShaders; 14 | 15 | this.pathToShaders = pathToShaders || "/" ; 16 | this.pathToChunks = pathToChunks || pathToShaders; 17 | 18 | this.shaderChunks = {}; 19 | 20 | this.shadersLoaded = 0; 21 | this.shadersToLoad = 0; 22 | 23 | } 24 | 25 | 26 | 27 | /* 28 | 29 | Loads in a shader chunk when told to by 30 | onShaderLoaded. 31 | 32 | it is important to know that the title of the 33 | chunk needs to be the same as the reference in the shader 34 | 35 | AKA, if I use: 36 | 37 | $simplexNoise 38 | 39 | I will need to create a file in the pathToChunks directory 40 | called 41 | 42 | simplexNoise.js 43 | 44 | 45 | */ 46 | ShaderLoader.prototype.loadShaderChunk = function( type ){ 47 | 48 | var path = this.pathToChunks + "/" + type + ".glsl"; 49 | 50 | var self = this; 51 | $.ajax({ 52 | url:path, 53 | dataType:'text', 54 | context:{ 55 | title:type, 56 | path: path 57 | }, 58 | complete: function( r ){ 59 | self.onChunkLoaded( r.responseText , this.title ); 60 | }, 61 | error:function( r ){ 62 | console.log( 'ERROR: Unable to Load Shader' + this.path ); 63 | self.onChunkLoaded( " NO SHADER LOADED " , this.title ); 64 | } 65 | }); 66 | 67 | } 68 | 69 | ShaderLoader.prototype.onChunkLoaded = function( chunk , title ){ 70 | 71 | this.shaderChunks[title] = chunk; 72 | 73 | } 74 | 75 | /* 76 | 77 | This function Loads a shader with whatever title/ 78 | type we prefer. 79 | 80 | */ 81 | ShaderLoader.prototype.load = function( shader , title , type ){ 82 | 83 | var self = this; 84 | 85 | this._beginLoad( shader , title , type ); 86 | 87 | 88 | // request the file over AJAX 89 | $.ajax({ 90 | url: self.pathToShaders +"/" + shader + ".glsl" , 91 | dataType: 'text', 92 | context: { 93 | type: type 94 | }, 95 | complete: function(r){ 96 | self.onShaderLoaded( r.responseText , title , this.type ); 97 | } 98 | }); 99 | 100 | } 101 | 102 | /* 103 | 104 | Once a Shader is loaded, check to see if there are any extra chunks 105 | we need to find and pull in. 106 | 107 | Will recall itself, until the chunk has been loaded in 108 | 109 | */ 110 | ShaderLoader.prototype.onShaderLoaded = function( shaderText , title , type ){ 111 | 112 | var finalShader = shaderText; 113 | 114 | var readyToLoad = true; 115 | 116 | 117 | var array = finalShader.split( "$" ); 118 | 119 | for( var i = 1; i < array.length; i++ ){ 120 | 121 | var chunkName = array[i].split("\n")[0]; 122 | 123 | if( this.shaderChunks[chunkName] ){ 124 | 125 | var tmpShader = finalShader.split( "$" + chunkName ); 126 | 127 | finalShader = tmpShader.join( this.shaderChunks[chunkName] ); 128 | 129 | }else{ 130 | 131 | readyToLoad = false; 132 | this.loadShaderChunk( chunkName ); 133 | 134 | } 135 | 136 | } 137 | 138 | if( readyToLoad ){ 139 | 140 | if( type == 'vertex' ){ 141 | this.vertexShaders[ title ] = finalShader; 142 | }else if( type == 'fragment' ){ 143 | this.fragmentShaders[ title ] = finalShader; 144 | }else if( type == 'simulation' ){ 145 | this.simulationShaders[ title ] = finalShader; 146 | } 147 | 148 | this._endLoad( finalShader , title , type ); 149 | 150 | }else{ 151 | 152 | var self = this; 153 | setTimeout( function(){ 154 | self.onShaderLoaded( finalShader , title , type ) 155 | }, 300 ); 156 | 157 | } 158 | 159 | } 160 | 161 | 162 | // might add something later... 163 | ShaderLoader.prototype._beginLoad = function( shader , title , type ){ 164 | this.shadersToLoad ++; 165 | this.beginLoad( shader , title , type ); 166 | } 167 | 168 | ShaderLoader.prototype._endLoad = function( shaderText , title , type ){ 169 | this.shadersLoaded ++; 170 | 171 | if( this.shadersLoaded == this.shadersToLoad ){ 172 | this.shaderSetLoaded(); 173 | } 174 | 175 | this.endLoad( shaderText , title , type ); 176 | 177 | } 178 | 179 | 180 | ShaderLoader.prototype.setValue = function( shader , name , value ){ 181 | 182 | //console.log( name , value ); 183 | 184 | 185 | var a = '@'+name; 186 | // console.log( a ); 187 | 188 | var replaced = false; 189 | 190 | var newStr = shader.replace( a , function(token){replaced = true; return value;}); 191 | 192 | // console.log( 'replaced' , replaced ); 193 | return newStr; 194 | 195 | } 196 | 197 | ShaderLoader.prototype.shaderSetLoaded = function(){} 198 | ShaderLoader.prototype.endLoad = function(){} 199 | ShaderLoader.prototype.beginLoad = function(){} 200 | -------------------------------------------------------------------------------- /Maru/Stream.js: -------------------------------------------------------------------------------- 1 | 2 | STREAMS = []; 3 | 4 | var ULTIMATE_STREAM, ULTIMATE_SOURCE , ULTIMATE_GAIN , ULTIMATE_CONTROLLER ; 5 | 6 | function Stream( file , controller, looping ){ 7 | 8 | this.file = file; 9 | this.controller = controller; 10 | this.ctx = this.controller.ctx; 11 | 12 | if( !ULTIMATE_STREAM ){ 13 | 14 | ULTIMATE_STREAM = new Audio(); 15 | 16 | 17 | 18 | var ctx = controller.ctx; 19 | 20 | ULTIMATE_SOURCE = ctx.createMediaElementSource( ULTIMATE_STREAM ); 21 | ULTIMATE_GAIN = ctx.createGain(); 22 | 23 | ULTIMATE_SOURCE.connect( ULTIMATE_GAIN ); 24 | 25 | 26 | ULTIMATE_GAIN.connect( controller.gain ); 27 | //ULTIMATE_SOURCE.connect( controller.gain ); 28 | 29 | ULTIMATE_CONTROLLER = controller; 30 | 31 | } 32 | 33 | this.looping = looping; 34 | 35 | this.controller.notes.push( this ); 36 | 37 | STREAMS.push( this ); 38 | 39 | } 40 | 41 | 42 | Stream.prototype.play = function(){ 43 | 44 | this.playing = true; 45 | 46 | ULTIMATE_STREAM.src = this.file; 47 | ULTIMATE_STREAM.play(); 48 | //ULTIMATE_GAIN.gain.value = 0.5; 49 | var t = ULTIMATE_CONTROLLER.ctx.currentTime; 50 | ULTIMATE_GAIN.gain.linearRampToValueAtTime( 1 , ULTIMATE_CONTROLLER.ctx.currentTime + .1 ); 51 | 52 | } 53 | 54 | Stream.prototype.stop = function(){ 55 | 56 | this.playing = false; 57 | 58 | var t = ULTIMATE_CONTROLLER.ctx.currentTime; 59 | 60 | console.log('TIME' ); 61 | console.log( t ); 62 | ULTIMATE_GAIN.gain.linearRampToValueAtTime( ULTIMATE_GAIN.gain.value , t ); 63 | 64 | ULTIMATE_GAIN.gain.linearRampToValueAtTime( 0.0 , t + .1); 65 | 66 | setTimeout( function(){ 67 | ULTIMATE_STREAM.pause(); 68 | },99); 69 | 70 | } 71 | 72 | 73 | 74 | 75 | 76 | /*Stream.prototype.fadeOut = function( time , callback ){ 77 | 78 | var t = this.controller.ctx.currentTime; 79 | if( !time ) time = this.params.fadeTime; 80 | this.gain.gain.linearRampToValueAtTime( this.gain.gain.value , t ); 81 | this.gain.gain.linearRampToValueAtTime( 0.0 , t + time ); 82 | 83 | setTimeout( callback.bind( this ) , time * 1000 ); 84 | 85 | } 86 | 87 | ULTIMATE_GAIN.fadeIn = function( time , value ){ 88 | 89 | this.gain.gain.linearRampToValueAtTime( 1 , this.controller.ctx.currentTime + time ); 90 | 91 | }*/ 92 | 93 | /*Stream.prototype.play = function(){ 94 | 95 | var self = this; 96 | 97 | if(!this.source){ 98 | this.createSource(); 99 | } 100 | 101 | 102 | setTimeout(function(){ 103 | 104 | 105 | 106 | self.audio.play(); 107 | self.fadeIn( .5 , 1 ); 108 | self.playing = true; 109 | 110 | },10); 111 | 112 | 113 | } 114 | 115 | Stream.prototype.stop = function(){ 116 | 117 | this.fadeOut( .4 , function(){ 118 | 119 | this.audio.pause(); 120 | this.playing = false; 121 | 122 | this.audio.currentTime = 0; 123 | this.audio = undefined; 124 | //this.audio.currentTime = 0; 125 | //this.source.currentTime = 0; 126 | // this.gain.disconnect( this.source ); 127 | 128 | //this.gain.disconnect( this.source ); 129 | //this.source = undefined; 130 | 131 | }); 132 | 133 | }*/ 134 | 135 | 136 | Stream.prototype.update = function(){ 137 | 138 | //this.analyzer.getByteFrequencyData( this.analyzer.array ); 139 | 140 | } 141 | -------------------------------------------------------------------------------- /Maru/activate.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/activate.wav -------------------------------------------------------------------------------- /Maru/andaBit.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/andaBit.wav -------------------------------------------------------------------------------- /Maru/cab_sprite.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/cab_sprite.png -------------------------------------------------------------------------------- /Maru/deactivate.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/deactivate.wav -------------------------------------------------------------------------------- /Maru/goodJob.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/goodJob.wav -------------------------------------------------------------------------------- /Maru/hover.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/hover.wav -------------------------------------------------------------------------------- /Maru/icons/albumCover.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/albumCover.png -------------------------------------------------------------------------------- /Maru/icons/cabbibo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/cabbibo.png -------------------------------------------------------------------------------- /Maru/icons/cabbibo_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/cabbibo_1.png -------------------------------------------------------------------------------- /Maru/icons/connect_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/connect_1.png -------------------------------------------------------------------------------- /Maru/icons/cursorWhite.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/cursorWhite.png -------------------------------------------------------------------------------- /Maru/icons/download_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/download_1.png -------------------------------------------------------------------------------- /Maru/icons/facebook_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/facebook_1.png -------------------------------------------------------------------------------- /Maru/icons/info_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/info_1.png -------------------------------------------------------------------------------- /Maru/icons/loadGif.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/loadGif.gif -------------------------------------------------------------------------------- /Maru/icons/normals/08_normalmap.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/normals/08_normalmap.png -------------------------------------------------------------------------------- /Maru/icons/normals/10389-normal.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/normals/10389-normal.jpg -------------------------------------------------------------------------------- /Maru/icons/normals/3989-normal.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/normals/3989-normal.jpg -------------------------------------------------------------------------------- /Maru/icons/normals/4706-normal.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/normals/4706-normal.jpg -------------------------------------------------------------------------------- /Maru/icons/normals/7723-normal.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/normals/7723-normal.jpg -------------------------------------------------------------------------------- /Maru/icons/normals/7870-normal.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/normals/7870-normal.jpg -------------------------------------------------------------------------------- /Maru/icons/normals/8158-normal.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/normals/8158-normal.jpg -------------------------------------------------------------------------------- /Maru/icons/normals/940-normal.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/normals/940-normal.jpg -------------------------------------------------------------------------------- /Maru/icons/normals/bumpmap_normalmap.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/normals/bumpmap_normalmap.jpg -------------------------------------------------------------------------------- /Maru/icons/normals/carbonFiber.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/normals/carbonFiber.png -------------------------------------------------------------------------------- /Maru/icons/normals/chesterfield.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/normals/chesterfield.png -------------------------------------------------------------------------------- /Maru/icons/normals/moss_normal_map.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/normals/moss_normal_map.jpg -------------------------------------------------------------------------------- /Maru/icons/normals/other.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/normals/other.jpg -------------------------------------------------------------------------------- /Maru/icons/normals/rock.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/normals/rock.jpg -------------------------------------------------------------------------------- /Maru/icons/normals/rock1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/normals/rock1.png -------------------------------------------------------------------------------- /Maru/icons/prism_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/prism_1.png -------------------------------------------------------------------------------- /Maru/icons/rioux_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/rioux_1.png -------------------------------------------------------------------------------- /Maru/icons/sem_metal.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/sem_metal.jpg -------------------------------------------------------------------------------- /Maru/icons/soundcloud_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/soundcloud_1.png -------------------------------------------------------------------------------- /Maru/icons/sprite.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/sprite.png -------------------------------------------------------------------------------- /Maru/icons/starMap.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/starMap.png -------------------------------------------------------------------------------- /Maru/icons/thumb.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/thumb.jpg -------------------------------------------------------------------------------- /Maru/icons/thumb.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/thumb.png -------------------------------------------------------------------------------- /Maru/icons/twitter_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/twitter_1.png -------------------------------------------------------------------------------- /Maru/icons/warp_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/icons/warp_1.png -------------------------------------------------------------------------------- /Maru/initEasterEgg.js: -------------------------------------------------------------------------------- 1 | function initEasterEgg(){ 2 | 3 | 4 | 5 | var geo = new THREE.IcosahedronGeometry(10,1); 6 | var mat = new THREE.MeshNormalMaterial(); 7 | 8 | EasterEgg = new THREE.Mesh( geo , mat ); 9 | EasterEgg.scale.multiplyScalar( 100 ); 10 | 11 | EasterEgg.added = false; 12 | EasterEgg.textAdded = false; 13 | 14 | EasterEgg.addDistance = 3950; 15 | 16 | EasterEgg.gui = new dat.GUI({autoPlace:false}); 17 | 18 | 19 | var gHolder = document.createElement('div'); 20 | 21 | var tHolder = document.createElement('h1'); 22 | 23 | tHolder.innerHTML ='EasterEgg'; 24 | 25 | gHolder.appendChild( tHolder ); 26 | var guis = document.getElementById( 'GUI' ); 27 | 28 | guis.appendChild( gHolder ); 29 | gHolder.appendChild(EasterEgg.gui.domElement); 30 | 31 | 32 | EasterEgg.furryTails = []; 33 | 34 | var center = new THREE.Mesh( 35 | new THREE.IcosahedronGeometry( 1.1 , 1 ), 36 | new THREE.MeshNormalMaterial({side:THREE.DoubleSide}) 37 | ); 38 | 39 | //EasterEgg.gui.domElement = this.params.domElement; 40 | 41 | var bait = center.clone(); 42 | 43 | var c = [ 44 | new THREE.Color( '#ed0000' ), 45 | new THREE.Color( '#fff000' ), 46 | new THREE.Color( '#ff8700' ), 47 | new THREE.Color( '#e82626' ), 48 | ]; 49 | 50 | 51 | var col1 = new THREE.Vector3( c[0].r , c[0].g , c[0].b ); 52 | var col2 = new THREE.Vector3( c[1].r , c[1].g , c[1].b ); 53 | var col3 = new THREE.Vector3( c[2].r , c[2].g , c[2].b ); 54 | var col4 = new THREE.Vector3( c[3].r , c[3].g , c[3].b ); 55 | var friends = new FurryGroup( EasterEgg , 'friends' , audioController , 10 ,{ 56 | center: center, 57 | bait: bait, 58 | color1: col1, 59 | color2: col2, 60 | color3: col3, 61 | color4: col4 62 | 63 | }); 64 | 65 | 66 | /*var m = new THREE.Mesh( new THREE.IcosahedronGeometry( 1 , 0 ) , new THREE.MeshNormalMaterial() ); 67 | m.scale.multiplyScalar( .02 ); 68 | EasterEgg.add( m );*/ 69 | 70 | /* EasterEgg.text = new PhysicsText( 71 | [ 'You can live.', 72 | '','', 73 | 'Remember this miracle on your journey, and realize that no matter how far you go, already you have made it here.', 74 | '','', 75 | 'Find joy in the short existance you have, because even if you make it, it will not be enough' 76 | ].join("\n") 77 | );*/ 78 | EasterEgg.update = function(){ 79 | 80 | 81 | var p = camera.position.clone(); 82 | 83 | // console.log( this.added ); 84 | if( this.added == false ){ 85 | 86 | //console.log('YA'); 87 | this.added = true; 88 | scene.add( this ); 89 | 90 | //this.position.copy( p ); 91 | 92 | var f = new THREE.Vector3( 0 , 0 , -1 ); 93 | f.applyQuaternion( camera.quaternion ); 94 | f.multiplyScalar( this.addDistance / 2 ); 95 | //this.position.add( f ); 96 | 97 | for( var i = 0; i < this.furryTails.length; i++ ){ 98 | 99 | this.furryTails[i].activate(); 100 | this.furryTails[i].line.scale.multiplyScalar( .001 ); 101 | this.furryTails[i].physicsParticles.scale.multiplyScalar( .001 ); 102 | this.furryTails[i].head.mesh.scale.multiplyScalar( .001 ); 103 | this.furryTails[i].leader.scale.multiplyScalar( .001 ); 104 | //this.furryTails[i].bait 105 | 106 | var position = new THREE.Vector3( 107 | (Math.random() - .5 ) * 10, 108 | (Math.random() - .5 ) * 10, 109 | (Math.random() - .5 ) * 10 110 | ); 111 | 112 | this.furryTails[i].addCollisionForce( position , 10 ); 113 | this.furryTails[i].addDistanceForce( position , .00004 ); 114 | 115 | this.furryTails[i].velocity.set( 116 | (Math.random() - .5) * 300, 117 | (Math.random() - .5) * 300, 118 | (Math.random() - .5) * 300 119 | ); 120 | 121 | for( var j = 0; j < this.furryTails.length; j++ ){ 122 | 123 | if( j != i ){ 124 | 125 | 126 | var oP = this.furryTails[j].position; 127 | this.furryTails[i].addDistanceForce( oP , .000004 ); 128 | this.furryTails[i].addCollisionForce( oP , 10 ); 129 | 130 | //this.furryTails[i].addDistanceInverseSquaredForce( oP , -.000000001 ); 131 | 132 | } 133 | 134 | 135 | } 136 | //scene.add( this.furryTails[i].leader ); 137 | //this.furryTails[i].updatePhysics(); 138 | 139 | 140 | 141 | // this.startText. 142 | 143 | } 144 | } 145 | 146 | if( this.added == true ){ 147 | 148 | for( var i = 0; i < this.furryTails.length; i++ ){ 149 | 150 | this.furryTails[i].updateTail(); 151 | this.furryTails[i].updatePhysics(); 152 | 153 | } 154 | 155 | } 156 | 157 | 158 | } 159 | 160 | ////////////////// scene.add( EasterEgg ); 161 | 162 | } 163 | -------------------------------------------------------------------------------- /Maru/initPoly.js: -------------------------------------------------------------------------------- 1 | 2 | DLD = false; 3 | 4 | var raycaster = new THREE.Raycaster(); 5 | function initPoly(){ 6 | 7 | for( var i = 0; i < loopList.length; i++ ){ 8 | 9 | POLYS[loopList[i]] = new Poly( i, LOOPS[loopList[i]] , loopList[i]); 10 | 11 | console.log(POLYS[loopList[i]]); 12 | 13 | } 14 | 15 | 16 | } 17 | 18 | function Poly( id , note ,name){ 19 | 20 | this.note = note; 21 | this.note.gain.gain.value = 0; 22 | this.id = id; 23 | this.name = name; 24 | 25 | this.active = false; 26 | 27 | 28 | this.mesh = new THREE.Mesh( 29 | new THREE.IcosahedronGeometry( 40.1 , 2 ), 30 | new THREE.ShaderMaterial({ 31 | uniforms:{ 32 | t_audio:{type:"t",value:this.note.texture}, 33 | time:G.uniforms.time, 34 | jelly:{type:"v3",value:headMesh.position}, 35 | active:{type:"f",value:1} 36 | }, 37 | vertexShader: shaders.vs.poly, 38 | fragmentShader: shaders.fs.poly, 39 | flatShading:true 40 | }) 41 | ); 42 | 43 | this.bgMesh = new THREE.Mesh( 44 | new THREE.IcosahedronGeometry( 40.1 , 2 ), 45 | new THREE.ShaderMaterial({ 46 | uniforms:{ 47 | t_audio:{type:"t",value:this.note.texture}, 48 | time:G.uniforms.time, 49 | jelly:{type:"v3",value:headMesh.position}, 50 | color:{type:"v4", value:new THREE.Vector4(44/255,43/255,71/255,1)}//new THREE.Vector4(44/255,43/255,71/255,1); 51 | 52 | }, 53 | vertexShader: shaders.vs.polyOutline, 54 | fragmentShader: shaders.fs.polyOutline, 55 | flatShading:true 56 | }) 57 | ); 58 | 59 | this.organicMesh = new THREE.Mesh( 60 | new THREE.IcosahedronGeometry( 40.1 , 5 ), 61 | new THREE.ShaderMaterial({ 62 | uniforms:{ 63 | t_audio:{type:"t",value:this.note.texture}, 64 | time:G.uniforms.time, 65 | jelly:{type:"v3",value:headMesh.position}, 66 | active:{type:"f",value:1}, 67 | hovered:{type:"f",value:0}, 68 | }, 69 | vertexShader: shaders.vs.polyOrg, 70 | fragmentShader: shaders.fs.polyOrg, 71 | flatShading:true 72 | })); 73 | 74 | 75 | this.mesh.add(this.bgMesh); 76 | 77 | 78 | var row = Math.floor(id %4); 79 | row = (row+1)%2; 80 | 81 | 82 | var targetZ = 150; 83 | var distance = -1000; 84 | 85 | 86 | var vec = new THREE.Vector3(); // create once and reuse 87 | var pos = new THREE.Vector3(); // create once and reuse 88 | 89 | var topLeft = new THREE.Vector3(); 90 | var topRight = new THREE.Vector3(); 91 | var bottomLeft = new THREE.Vector3(); 92 | var bottomRight = new THREE.Vector3(); 93 | 94 | 95 | vec.set( -.8, 1, 0.5 ); 96 | raycaster.setFromCamera( vec, camera ); 97 | vec.copy(camera.position); 98 | vec.add( raycaster.ray.direction.clone().multiplyScalar(1300)); 99 | 100 | topLeft.copy( vec ); 101 | 102 | vec.set( .8, 1, 0.5 ); 103 | raycaster.setFromCamera( vec, camera ); 104 | vec.copy(camera.position); 105 | vec.add( raycaster.ray.direction.clone().multiplyScalar(1300)); 106 | 107 | topRight.copy( vec ); 108 | 109 | vec.set( -.8, -1, 0.5 ); 110 | raycaster.setFromCamera( vec, camera ); 111 | vec.copy(camera.position); 112 | vec.add( raycaster.ray.direction.clone().multiplyScalar(1300)); 113 | 114 | bottomLeft.copy( vec ); 115 | 116 | vec.set( .8, -1, 0.5 ); 117 | raycaster.setFromCamera( vec, camera ); 118 | vec.copy(camera.position); 119 | vec.add( raycaster.ray.direction.clone().multiplyScalar(1300)); 120 | 121 | bottomRight.copy( vec ); 122 | 123 | left = new THREE.Vector3().copy( topLeft ).sub( topRight ); 124 | up = new THREE.Vector3().copy( topLeft ).sub( bottomLeft ); 125 | 126 | 127 | var leftVal = ((id % 4)+.5)/4 128 | var upVal = (((Math.floor(id /4)+.25)+(row * .5))/5) 129 | 130 | this.mesh.position.copy(topLeft).add(left.multiplyScalar(-upVal)).add(up.multiplyScalar(-leftVal)); 131 | 132 | console.log( this.mesh.position ); 133 | 134 | 135 | /* this.mesh.position.y = 1.3*((((id % 4)+.5)/4)-.5) * window.innerHeight; 136 | 137 | this.mesh.position.x = (row-.5) * (.5 *window.innerWidth / 5) + 1*(((Math.floor(id /4)+.5)/5)-.5) * window.innerWidth; 138 | this.mesh.position.z = 0;//(Math.random()-.5) * 100; 139 | */ 140 | 141 | this.organicMesh.position.copy( this.mesh.position ); 142 | this.mesh.material.map = this.note.texture; 143 | 144 | this.mesh.hoverOver = function(){ 145 | this.hoverOver(); 146 | }.bind( this ); 147 | 148 | this.mesh.hoverOut = function(){ 149 | this.hoverOut(); 150 | }.bind( this ); 151 | 152 | this.mesh.select = function(){ 153 | this.select(); 154 | }.bind( this ); 155 | 156 | this.mesh.deselect = function(){ 157 | this.deselect(); 158 | }.bind( this ); 159 | 160 | objectControls.add( this.mesh ); 161 | 162 | this.deactivate 163 | 164 | } 165 | 166 | Poly.prototype = { 167 | 168 | update:function(){ 169 | 170 | //this.bgMesh.position.copy( this.mesh.position ); 171 | this.mesh.rotation.x += .01 * Math.sin(this.id * 10); 172 | this.mesh.rotation.y += .01 * Math.sin(this.id * 10+20); 173 | this.mesh.rotation.z += .01 * Math.sin(this.id * 10+40); 174 | 175 | 176 | 177 | //this.mesh.add(this.bgMesh); 178 | }, 179 | 180 | 181 | play:function(){ 182 | this.note.play(); 183 | scene.add( this.mesh ); 184 | }, 185 | 186 | activate:function(){ 187 | this.active = true; 188 | //this.mesh.material.uniforms.active.value = 1; 189 | this.organicMesh.material.uniforms.active.value = 1; 190 | 191 | scene.remove( this.mesh ); 192 | scene.add( this.organicMesh ); 193 | 194 | this.note.gain.gain.value = 1; 195 | 196 | 197 | 198 | var canDL = true; 199 | for( var i = 0; i < loopList.length; i++ ){ 200 | if( POLYS[loopList[i]].active == false ){ canDL = false; } 201 | } 202 | 203 | 204 | if( canDL && DLD == false ){ 205 | var url="MaruLoops.zip"; 206 | //window.open(url); 207 | 208 | 209 | /*var zip_file_path = url; //put inside "" your path with file.zip 210 | var zip_file_name = "Maru Loops" //put inside "" file name or something 211 | var a = document.createElement("a"); 212 | document.body.appendChild(a); 213 | a.style = "display: none"; 214 | a.href = zip_file_path; 215 | a.download = zip_file_name; 216 | a.click(); 217 | document.body.removeChild(a); 218 | DLD = true;*/ 219 | DLD = true; 220 | 221 | displaySignUp(); 222 | NOTES.goodJob.play(); 223 | 224 | }else{ 225 | NOTES.activate.play(); 226 | } 227 | }, 228 | 229 | deactivate: function(){ 230 | this.active = false; 231 | 232 | this.mesh.material.uniforms.active.value = 1; 233 | this.organicMesh.material.uniforms.active.value = 1; 234 | this.note.gain.gain.value = 0; 235 | 236 | scene.add( this.mesh ); 237 | scene.remove( this.organicMesh ); 238 | }, 239 | 240 | 241 | hoverOver: function(){ 242 | 243 | 244 | if( this.active == false ){ 245 | this.mesh.scale.x = 1.1; 246 | this.mesh.scale.y = 1.1; 247 | this.mesh.scale.z = 1.1; 248 | 249 | this.organicMesh.scale.x = 1.1; 250 | this.organicMesh.scale.y = 1.1; 251 | this.organicMesh.scale.z = 1.1; 252 | 253 | this.bgMesh.scale.x = 1; 254 | this.bgMesh.scale.y = 1; 255 | this.bgMesh.scale.z = 1; 256 | //vec3(44.,43.,71.)/255.; 257 | this.bgMesh.material.uniforms.color.value = new THREE.Vector4( 174/255, 197/255, 212/255,1);;//new THREE.Vector4(44/255,43/255,71/255,1); 258 | 259 | 260 | } 261 | NOTES.hover.play(); 262 | 263 | this.organicMesh.material.uniforms.hovered.value = 1; 264 | 265 | document.getElementById("TITLE").innerHTML="

"+this.name+"

"; 266 | 267 | console.log( this); 268 | }, 269 | 270 | 271 | hoverOut: function(){ 272 | 273 | if( this.active == false ){ 274 | this.mesh.scale.x = 1; 275 | this.mesh.scale.y = 1; 276 | this.mesh.scale.z = 1; 277 | 278 | this.organicMesh.scale.x = 1; 279 | this.organicMesh.scale.y = 1; 280 | this.organicMesh.scale.z = 1; 281 | 282 | this.bgMesh.scale.x = 1; 283 | this.bgMesh.scale.y = 1; 284 | this.bgMesh.scale.z = 1; 285 | this.bgMesh.material.uniforms.color.value = new THREE.Vector4(44/255,43/255,71/255,1);//new THREE.Vector4( 174/255, 197/255, 212/255,1); 286 | 287 | } 288 | 289 | this.organicMesh.material.uniforms.hovered.value = 0; 290 | 291 | document.getElementById("TITLE").innerHTML="

"; 292 | 293 | 294 | console.log( this); 295 | }, 296 | 297 | select:function(){ 298 | 299 | if( this.active == false ){ 300 | this.mesh.scale.x = 1.5; 301 | this.mesh.scale.y = 1.5; 302 | this.mesh.scale.z = 1.5; 303 | 304 | this.organicMesh.scale.x = 1.5; 305 | this.organicMesh.scale.y = 1.5; 306 | this.organicMesh.scale.z = 1.5; 307 | this.activate(); 308 | 309 | Jelly.updateBaitPos( this.mesh.position ); 310 | Jelly.bait.searching = this; 311 | 312 | }else{ 313 | this.mesh.scale.x = 1; 314 | this.mesh.scale.y = 1; 315 | this.mesh.scale.z = 1; 316 | 317 | 318 | this.organicMesh.scale.x = 1.5; 319 | this.organicMesh.scale.y = 1.5; 320 | this.organicMesh.scale.z = 1.5; 321 | NOTES.deactivate.play(); 322 | this.deactivate(); 323 | } 324 | }, 325 | 326 | jellyDeactivate:function(){ 327 | 328 | console.log("HEY"); 329 | 330 | this.mesh.scale.x = 1; 331 | this.mesh.scale.y = 1; 332 | this.mesh.scale.z = 1; 333 | 334 | 335 | this.organicMesh.scale.x = 1.5; 336 | this.organicMesh.scale.y = 1.5; 337 | this.organicMesh.scale.z = 1.5; 338 | NOTES.jelly.play(); 339 | this.deactivate(); 340 | 341 | }, 342 | 343 | 344 | deselect:function(){ 345 | 346 | 347 | } 348 | 349 | 350 | 351 | } 352 | 353 | 354 | 355 | -------------------------------------------------------------------------------- /Maru/initThree.js: -------------------------------------------------------------------------------- 1 | function initThree(){ 2 | 3 | 4 | scene = new THREE.Scene(); 5 | 6 | camera = new THREE.PerspectiveCamera( 7 | 50 , 8 | window.innerWidth / window.innerHeight, 9 | sceneSize / 10 , 10 | sceneSize * 1000 11 | ); 12 | 13 | // placing our camera position so it can see everything 14 | camera.position.y = 0; 15 | camera.position.z = 150; 16 | camera.position.x = 0; 17 | 18 | //camera.lookAt( new THREE.Vector3() ); 19 | 20 | objectControls = new ObjectControls(camera); 21 | 22 | 23 | var m = new THREE.Mesh( 24 | new THREE.IcosahedronGeometry( 300 , 1), 25 | new THREE.MeshBasicMaterial({map:G.uniforms.t_audio.value}) 26 | ); 27 | 28 | 29 | //scene.add( m); 30 | 31 | //controls = new THREE.TrackballControls(camera); 32 | 33 | clock = new THREE.Clock(); 34 | // Getting the container in the right location 35 | container = document.createElement( 'div' ); 36 | container.id = "container"; 37 | 38 | document.body.appendChild( container ); 39 | 40 | // Getting the stats in the right position 41 | stats = new Stats(); 42 | 43 | stats.domElement.style.position = 'absolute'; 44 | stats.domElement.style.bottom = '0px'; 45 | stats.domElement.style.right = '0px'; 46 | stats.domElement.style.zIndex = '999'; 47 | 48 | // document.body.appendChild( stats.domElement ); 49 | 50 | // Setting up our Renderer 51 | renderer = new THREE.WebGLRenderer(); 52 | 53 | var r = window.devicePixelRatio || 1; 54 | renderer.setPixelRatio(r); 55 | 56 | 57 | renderer.setSize( window.innerWidth, window.innerHeight ); 58 | renderer.setClearColor( 0x000519 , 1 ); 59 | container.appendChild( renderer.domElement ); 60 | 61 | // Making sure our renderer is always the right size 62 | window.addEventListener( 'resize', onWindowResize , false ); 63 | 64 | 65 | 66 | 67 | } 68 | 69 | // Resets the renderer to be the proper size 70 | function onWindowResize(){ 71 | 72 | camera.aspect = window.innerWidth / window.innerHeight; 73 | camera.updateProjectionMatrix(); 74 | 75 | renderer.setSize( window.innerWidth, window.innerHeight ); 76 | 77 | } 78 | 79 | 80 | 81 | -------------------------------------------------------------------------------- /Maru/jelly.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/jelly.wav -------------------------------------------------------------------------------- /Maru/lvl4/ambient.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/lvl4/ambient.mp3 -------------------------------------------------------------------------------- /Maru/lvl4/ambient1.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/lvl4/ambient1.mp3 -------------------------------------------------------------------------------- /Maru/lvl4/death.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/lvl4/death.mp3 -------------------------------------------------------------------------------- /Maru/lvl4/part1/drums.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/lvl4/part1/drums.mp3 -------------------------------------------------------------------------------- /Maru/lvl4/part1/hats.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/lvl4/part1/hats.mp3 -------------------------------------------------------------------------------- /Maru/lvl4/part1/highSynth.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/lvl4/part1/highSynth.mp3 -------------------------------------------------------------------------------- /Maru/lvl4/part1/lowSynth.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/lvl4/part1/lowSynth.mp3 -------------------------------------------------------------------------------- /Maru/lvl4/part1/vox.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/lvl4/part1/vox.mp3 -------------------------------------------------------------------------------- /Maru/lvl4/part2/drums.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/lvl4/part2/drums.mp3 -------------------------------------------------------------------------------- /Maru/lvl4/part2/hats.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/lvl4/part2/hats.mp3 -------------------------------------------------------------------------------- /Maru/lvl4/part2/highSynth.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/lvl4/part2/highSynth.mp3 -------------------------------------------------------------------------------- /Maru/lvl4/part2/lowSynth.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/lvl4/part2/lowSynth.mp3 -------------------------------------------------------------------------------- /Maru/lvl4/part2/vox.mp3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/lvl4/part2/vox.mp3 -------------------------------------------------------------------------------- /Maru/polymer-sticker.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/Maru/polymer-sticker.png -------------------------------------------------------------------------------- /Maru/shaders/curl.glsl: -------------------------------------------------------------------------------- 1 | vec3 snoiseVec3( vec3 x ){ 2 | 3 | float s = snoise(vec3( x )); 4 | float s1 = snoise(vec3( x.y - 19.1 , x.z + 33.4 , x.x + 47.2 )); 5 | float s2 = snoise(vec3( x.z + 74.2 , x.x - 124.5 , x.y + 99.4 )); 6 | vec3 c = vec3( s , s1 , s2 ); 7 | return c; 8 | 9 | } 10 | 11 | 12 | vec3 curlNoise( vec3 p ){ 13 | 14 | const float e = 1e-1; 15 | vec3 dx = vec3( e , 0.0 , 0.0 ); 16 | vec3 dy = vec3( 0.0 , e , 0.0 ); 17 | vec3 dz = vec3( 0.0 , 0.0 , e ); 18 | 19 | vec3 p_x0 = snoiseVec3( p - dx ); 20 | vec3 p_x1 = snoiseVec3( p + dx ); 21 | vec3 p_y0 = snoiseVec3( p - dy ); 22 | vec3 p_y1 = snoiseVec3( p + dy ); 23 | vec3 p_z0 = snoiseVec3( p - dz ); 24 | vec3 p_z1 = snoiseVec3( p + dz ); 25 | 26 | float x = p_y1.z - p_y0.z - p_z1.y + p_z0.y; 27 | float y = p_z1.x - p_z0.x - p_x1.z + p_x0.z; 28 | float z = p_x1.y - p_x0.y - p_y1.x + p_y0.x; 29 | 30 | const float divisor = 1.0 / ( 2.0 * e ); 31 | return normalize( vec3( x , y , z ) * divisor ); 32 | } 33 | -------------------------------------------------------------------------------- /Maru/shaders/curlSim.glsl: -------------------------------------------------------------------------------- 1 | 2 | uniform sampler2D t_oPos; 3 | uniform sampler2D t_pos; 4 | 5 | uniform float justHit; 6 | 7 | uniform sampler2D t_audio; 8 | uniform sampler2D t_start; 9 | uniform float time; 10 | uniform float delta; 11 | 12 | uniform vec3 deathPos; 13 | uniform vec3 uPos; 14 | uniform vec3 uVel; 15 | 16 | varying vec2 vUv; 17 | 18 | $simplex 19 | $curl 20 | 21 | 22 | float rand(vec2 co){ 23 | return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453); 24 | } 25 | void main(){ 26 | 27 | vec4 oPos = texture2D( t_oPos , vUv ); 28 | vec4 pos = texture2D( t_pos , vUv ); 29 | 30 | vec3 vel = oPos.xyz - pos.xyz; 31 | 32 | float life = pos.w; 33 | 34 | vec3 dif = pos.xyz - deathPos; 35 | 36 | 37 | 38 | vec4 audioX = texture2D( t_audio , vec2( vUv.x , 0. ) ); 39 | vec4 audioY = texture2D( t_audio , vec2( vUv.y , 0. ) ); 40 | 41 | 42 | vec3 curl = curlNoise( pos.xyz * .2 ); 43 | vel += curl * .1; 44 | 45 | if( life == 1. ){ 46 | 47 | 48 | float r = rand( vec2( audioX.x , audioY.y )); 49 | 50 | // vel = uVel.xyz * 10. * normalize( uVel ) * r; 51 | vel = 1. * vec3( sin( r * 3.14159 ) , cos( r * 3.142 ) , cos( sin( r * 10.0 ) )); 52 | 53 | } 54 | 55 | 56 | vec3 p = pos.xyz + vel * .6 * audioX.x * audioX.y* audioX.x * audioX.y ; 57 | 58 | 59 | p = pos.xyz + vel + normalize( dif ); 60 | 61 | 62 | life -= .004 * audioX.x * audioY.y ; 63 | 64 | if( justHit >= .5 ){ 65 | 66 | 67 | life -= .5; 68 | 69 | //p = uPos; 70 | 71 | 72 | } 73 | 74 | if( life <= 0.0 ){ 75 | 76 | life = 1.; 77 | p = uPos; 78 | 79 | 80 | 81 | } 82 | 83 | 84 | 85 | gl_FragColor = vec4( p , life ); 86 | 87 | 88 | } 89 | -------------------------------------------------------------------------------- /Maru/shaders/deathSim.glsl: -------------------------------------------------------------------------------- 1 | 2 | uniform sampler2D t_oPos; 3 | uniform sampler2D t_pos; 4 | 5 | uniform float justHit; 6 | uniform float beingChased; 7 | 8 | uniform sampler2D t_audio; 9 | uniform sampler2D t_start; 10 | uniform float time; 11 | uniform float delta; 12 | 13 | uniform vec3 uDeathPos; 14 | uniform vec3 uPos; 15 | uniform vec3 uVel; 16 | 17 | varying vec2 vUv; 18 | 19 | $simplex 20 | $curl 21 | 22 | 23 | float rand(vec2 co){ 24 | return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453); 25 | } 26 | void main(){ 27 | 28 | /* vec4 oPos = texture2D( t_oPos , vUv ); 29 | vec4 pos = texture2D( t_pos , vUv ); 30 | 31 | vec3 vel = oPos.xyz - pos.xyz; 32 | 33 | float life = pos.w; 34 | 35 | vec3 dif = pos.xyz - uDeathPos; 36 | 37 | 38 | 39 | vec4 audioX = texture2D( t_audio , vec2( vUv.x , 0. ) ); 40 | vec4 audioY = texture2D( t_audio , vec2( vUv.y , 0. ) ); 41 | 42 | 43 | vec3 curl = curlNoise( pos.xyz * .2 ); 44 | vel += curl * .1; 45 | 46 | if( life == 1. ){ 47 | 48 | vel = vec3( 0. ); 49 | 50 | } 51 | 52 | 53 | vec3 p = pos.xyz + vel * .6 * audioX.x * audioX.y* audioX.x * audioX.y ; 54 | 55 | 56 | p = pos.xyz + vel - normalize( dif );//*(abs(sin(vUv.x*100.))+10.)/40.; 57 | 58 | 59 | life -= .004 * rand( vec2( vUv.x , vUv.y ));// ;* audioX.x * audioY.y ; 60 | 61 | if( justHit >= .5 ){ 62 | 63 | 64 | life -= .5; 65 | 66 | //p = uPos; 67 | 68 | 69 | } 70 | 71 | if( beingChased > .5 ){ 72 | 73 | if( life <= 0.0 ){ 74 | 75 | life = 1.; 76 | p = uPos; 77 | 78 | 79 | 80 | } 81 | 82 | }*/ 83 | 84 | vec4 oPos = texture2D( t_oPos , vUv ); 85 | vec4 pos = texture2D( t_pos , vUv ); 86 | 87 | vec3 vel = oPos.xyz - pos.xyz; 88 | 89 | float life = pos.w; 90 | 91 | vec3 dif = pos.xyz - uDeathPos; 92 | 93 | 94 | 95 | vec4 audioX = texture2D( t_audio , vec2( vUv.x , 0. ) ); 96 | vec4 audioY = texture2D( t_audio , vec2( vUv.y , 0. ) ); 97 | 98 | 99 | vec3 curl = curlNoise( pos.xyz * .2 ); 100 | vel += curl * .1; 101 | 102 | if( life == 1. ){ 103 | 104 | 105 | float r = rand( vec2( audioX.x , audioY.y )); 106 | 107 | // vel = uVel.xyz * 10. * normalize( uVel ) * r; 108 | vel = 1. * vec3( sin( r * 3.14159 ) , cos( r * 3.142 ) , cos( sin( r * 10.0 ) )); 109 | 110 | } 111 | 112 | 113 | vec3 p = pos.xyz + vel * .6 * audioX.x * audioX.y* audioX.x * audioX.y ; 114 | 115 | 116 | p = pos.xyz + vel - normalize( dif ); 117 | 118 | 119 | life -= .004 * audioX.x * audioY.y ; 120 | 121 | if( justHit >= .5 ){ 122 | 123 | 124 | life -= .5; 125 | 126 | //p = uPos; 127 | 128 | 129 | } 130 | 131 | if( life <= 0.0 ){ 132 | 133 | life = 1.; 134 | p = uPos; 135 | 136 | 137 | 138 | } 139 | 140 | 141 | 142 | 143 | gl_FragColor = vec4( p , life ); 144 | 145 | 146 | } 147 | -------------------------------------------------------------------------------- /Maru/shaders/fs-accel.glsl: -------------------------------------------------------------------------------- 1 | 2 | varying vec2 vUv; 3 | 4 | uniform sampler2D t_pos; 5 | uniform sampler2D t_oPos; 6 | uniform sampler2D t_ooPos; 7 | 8 | void main(){ 9 | 10 | vec4 pos = texture2D( t_pos , vUv ); 11 | vec4 oPos = texture2D( t_oPos , vUv ); 12 | vec4 ooPos = texture2D( t_ooPos , vUv ); 13 | 14 | vec3 vel1 = oPos.xyz - pos.xyz; 15 | vec3 vel2 = ooPos.xyz - oPos.xyz; 16 | 17 | vec3 accel = vel2 - vel1; 18 | gl_FragColor = vec4( abs(normalize(accel)) , 1.0 ); 19 | } 20 | -------------------------------------------------------------------------------- /Maru/shaders/fs-clueLine.glsl: -------------------------------------------------------------------------------- 1 | 2 | uniform vec3 color; 3 | varying vec3 vPos; 4 | varying vec4 vAudio; 5 | void main(){ 6 | 7 | gl_FragColor = vec4( color *vAudio.xyz, 1. ) +vec4( vec3(.3) , 0. ); 8 | 9 | } 10 | -------------------------------------------------------------------------------- /Maru/shaders/fs-deathParticles.glsl: -------------------------------------------------------------------------------- 1 | uniform sampler2D t_audio; 2 | uniform sampler2D sprite; 3 | uniform vec3 color; 4 | uniform float id; 5 | uniform vec3 uDeathPos; 6 | uniform vec3 uPos; 7 | uniform vec3 uVel; 8 | 9 | varying vec2 vUv; 10 | 11 | 12 | varying vec4 vPos; 13 | varying vec4 vVel; 14 | varying vec4 vAudio; 15 | 16 | void main(){ 17 | 18 | /*float y = smoothstep( -5.0 , 5. , vVel.y ); 19 | 20 | vec4 s = texture2D( sprite , vec2( gl_PointCoord.x , 1.0 - gl_PointCoord.y) ); 21 | 22 | vec2 sample = vec2( abs( vPos.y / 20. ) , 0.0 ); 23 | vec4 a = texture2D( t_audio , sample ); 24 | 25 | float newY = vVel.y * -1.; 26 | vec3 vNorm = normalize( vVel.xyz + vec3( 0. , newY* .99 , 0. ) ); 27 | // vNorm = normalize( vPos.xyz ); 28 | 29 | vec3 c1 = y * normalize(abs(sin( vNorm * 20. ) ) + abs(sin( vNorm * 20.2 ) )); 30 | vec3 c2 = vec3( .5 , .5 , .5 ); 31 | 32 | vec3 newC = smoothstep( c1 , c2 , abs(vNorm) ); 33 | vec3 finalC = normalize( vec3( .8 , .2 , 1.9 ) + newC ); 34 | gl_FragColor = vec4( color * normalize( vec3( s.x * (.9 + (.5 * vUv.x) ) , s.yz* ((finalC + vAudio.xyz*.6) -.4).xy)) , s.w * s.x ); 35 | 36 | gl_FragColor = vec4( color + vec3( normalize(s * a * normalize( vVel ) * normalize( vPos )).xyz), s.w * s.x ); 37 | 38 | 39 | vec3 cTest = smoothstep( vec3( 1. , 1. , 1. ), vec3( id , 1. - id , cos( id)), vec3( .0 , 2. , 1. ) ); 40 | vec3 shimmer = vec3( (.8+ (.2 * a.y)) * 5.3 ,(.8+ (.2 * a.x)) * .6 , .1 );// - a.xyz * 5.; 41 | gl_FragColor = vec4( shimmer * (1. / vPos.w ) , (.5 / vPos.w ) * s.w * s.x * .6);*/ 42 | 43 | vec4 s = texture2D( sprite , vec2( gl_PointCoord.x , 1.0 - gl_PointCoord.y) ); 44 | vec2 sample = vec2( abs( vPos.y / 20. ) , 0.0 ); 45 | 46 | if( s.a < .1 ){ 47 | discard; 48 | } 49 | 50 | float l = 2000. / length( uPos - uDeathPos ); 51 | vec4 a = texture2D( t_audio , sample ); 52 | 53 | //gl_FragColor = vec4( a * s * vec4(color , 1.0 )); 54 | gl_FragColor = s * a + vec4( l * 1. , 0. , 0. , 0.); 55 | 56 | 57 | } 58 | -------------------------------------------------------------------------------- /Maru/shaders/fs-furryHead.glsl: -------------------------------------------------------------------------------- 1 | 2 | uniform sampler2D t_normal; 3 | uniform sampler2D t_audio; 4 | 5 | uniform vec3 lightPos; 6 | 7 | uniform vec3 color1; 8 | uniform vec3 color2; 9 | uniform vec3 color3; 10 | uniform vec3 color4; 11 | 12 | varying vec3 vNormal; 13 | varying vec3 vView; 14 | varying vec2 vUv; 15 | 16 | varying vec3 vLightDir; 17 | varying mat3 vNormalMat; 18 | 19 | const float noise_strength = .2; 20 | 21 | $simplex 22 | 23 | vec3 cubicCurve( float t , vec3 c0 , vec3 c1 , vec3 c2 , vec3 c3 ){ 24 | 25 | float s = 1. - t; 26 | 27 | vec3 v1 = c0 * ( s * s * s ); 28 | vec3 v2 = 3. * c1 * ( s * s ) * t; 29 | vec3 v3 = 3. * c2 * s * ( t * t ); 30 | vec3 v4 = c3 * ( t * t * t ); 31 | 32 | vec3 value = v1 + v2 + v3 + v4; 33 | 34 | return value; 35 | 36 | } 37 | 38 | void main(void) { 39 | 40 | 41 | 42 | 43 | vec3 tNorm = texture2D( t_normal , vUv ).xyz; 44 | tNorm = normalize( vec3( sin( tNorm.x * 10. ) , sin( tNorm.y * 10. ),sin( tNorm.z* 10. ))) ; 45 | 46 | vec3 newNormal = normalize( vNormal + tNorm * .001); 47 | 48 | vec3 nNormal = normalize( vNormalMat * newNormal ); 49 | vec3 nView = normalize(vView); 50 | vec3 nReflection = normalize( reflect( vView , nNormal )); 51 | 52 | vec3 refl = reflect( vLightDir , nNormal ); 53 | float facingRatio = abs( dot( nNormal, refl) ); 54 | 55 | float newDot = dot( normalize( nNormal ), nView ); 56 | float inverse_dot_view = 1.0 - max( newDot , 0.0); 57 | 58 | vec3 p1 = color1; 59 | vec3 p2 = color2; 60 | vec3 p3 = color3; 61 | vec3 p4 = color4; 62 | 63 | vec3 v1 = vec3(0.); 64 | vec3 v2 = .2 * p1-p3; 65 | vec3 v3 = .5 * p2-p4; 66 | vec3 v4 = vec3(0.); 67 | 68 | vec3 c1 = p1; 69 | vec3 c2 = p2 + v1/3.; 70 | vec3 c3 = p3 - v2/3.; 71 | vec3 c4 = p4; 72 | 73 | 74 | vec3 lookup_table_color = cubicCurve( inverse_dot_view * facingRatio , c1 , c2 , c3 , c4 ); 75 | 76 | vec3 audioColor = texture2D( t_audio , vec2( abs(newDot) * .5 , 0. ) ).xyz; 77 | 78 | vec3 halfv = normalize( vLightDir + nView ); 79 | float specDot = max( 0. , dot( nNormal , halfv )); 80 | float specularity = pow( specDot , 50. ); 81 | 82 | vec3 sC = vec3( 1. , 1. , 1. ) * specularity; 83 | 84 | gl_FragColor.rgb = audioColor + vec3(44.,43.,71.)/400.; ///newNormal * .5 + .5 ;///lookup_table_color * (vec3(.3) + audioColor*.7) +sC; 85 | if( vUv.y < .03 ){ discard;}//gl_FragColor.rgb=vec3(1.,1.,1.); } 86 | 87 | gl_FragColor.a = 1.; 88 | 89 | } 90 | -------------------------------------------------------------------------------- /Maru/shaders/fs-furryParticles.glsl: -------------------------------------------------------------------------------- 1 | 2 | uniform sampler2D t_audio; 3 | uniform sampler2D t_sprite; 4 | 5 | varying vec2 vUv; 6 | varying vec2 vID; 7 | varying vec3 vColor; 8 | 9 | 10 | 11 | 12 | const float size = 1. / 32.; 13 | const float hSize = size / 2.; 14 | 15 | void main(){ 16 | 17 | 18 | /* float mIx = floor( (vUv.x + hSize ) / size ); 19 | float mIy = floor( (vUv.y + hSize) / size ); 20 | 21 | // Main Index 22 | vec2 mI = vec2( mIx , mIy ); 23 | //vec4 s = texture2D( t_sprite , vec2( gl_PointCoord.x , 1.0 - gl_PointCoord.y) ); 24 | 25 | 26 | 27 | //float c = mod(( vUv.y -hSize ) / size , 2. );*/ 28 | 29 | vec4 a = texture2D( t_audio , vec2(length(vUv-.5) * .1 + vID.x * .4 ,0.)); 30 | 31 | if( length(vUv-.5) >.5){ 32 | discard; 33 | } 34 | 35 | gl_FragColor = a*a*a * 3.;//vec4( 1.,1.,1.,1. ); 36 | } 37 | -------------------------------------------------------------------------------- /Maru/shaders/fs-furryTail.glsl: -------------------------------------------------------------------------------- 1 | 2 | uniform sampler2D t_audio; 3 | 4 | varying vec3 vColor; 5 | varying vec3 vNorm; 6 | 7 | varying vec3 vView; 8 | varying vec3 vLightDir; 9 | varying vec2 vUv; 10 | varying vec2 vID; 11 | 12 | void main(){ 13 | 14 | vec3 nNormal = vNorm; 15 | 16 | vec3 nReflection = normalize( reflect( vView , nNormal )); 17 | 18 | float nViewDot = dot( normalize( nNormal ), normalize( vView ) ); 19 | float iNViewDot = 1.0 - max( nViewDot , 0.0); 20 | 21 | vec3 refl = reflect( vLightDir , nNormal ); 22 | float facingRatio = abs( dot( nNormal, refl) ); 23 | 24 | 25 | 26 | vec4 aColor = texture2D( t_audio , vec2( vUv.y * .2 + vID.y * .5, 0.0)); 27 | 28 | vec3 aC = ((aColor.xyz * aColor.xyz * aColor.xyz) - .2) * 1.4 ; 29 | 30 | if( abs(vUv.x - .5) > .5 - length( aC ) ){ discard;} 31 | 32 | 33 | gl_FragColor = vec4( vColor + aColor.xyz , 1.0 ); 34 | 35 | } 36 | -------------------------------------------------------------------------------- /Maru/shaders/fs-mainTail.glsl: -------------------------------------------------------------------------------- 1 | 2 | uniform sampler2D t_audio; 3 | 4 | varying vec3 vColor; 5 | varying vec3 vNorm; 6 | 7 | varying vec3 vView; 8 | varying vec3 vLightDir; 9 | 10 | void main(){ 11 | 12 | vec3 nNormal = vNorm; 13 | 14 | 15 | 16 | vec3 nReflection = normalize( reflect( vView , nNormal )); 17 | 18 | float nViewDot = dot( normalize( nNormal ), normalize( vView ) ); 19 | float iNViewDot = 1.0 - max( nViewDot , 0.0); 20 | 21 | vec3 refl = reflect( vLightDir , nNormal ); 22 | float facingRatio = abs( dot( nNormal, refl) ); 23 | 24 | vec4 aColor = texture2D( t_audio , vec2( iNViewDot * facingRatio , 0.0)); 25 | 26 | vec3 aC = ((aColor.xyz * aColor.xyz * aColor.xyz) - .2) * 1.4 ; 27 | gl_FragColor = vec4( vColor + aC, 1.0 ); 28 | 29 | } 30 | -------------------------------------------------------------------------------- /Maru/shaders/fs-poly.glsl: -------------------------------------------------------------------------------- 1 | 2 | uniform sampler2D t_audio; 3 | uniform vec3 jelly; 4 | uniform float active; 5 | 6 | varying vec3 vPos; 7 | varying vec3 vNorm; 8 | varying vec3 vView; 9 | 10 | varying mat3 vNormalMat; 11 | varying vec3 vLightDir; 12 | varying float vDisplacement; 13 | 14 | varying vec3 vMVPos; 15 | varying vec3 vWorld; 16 | 17 | void main(){ 18 | 19 | vec3 x = dFdx(vWorld); 20 | vec3 y = dFdy(vWorld); 21 | 22 | vec3 nNormal = normalize(cross(x,y)); 23 | 24 | vec3 nReflection = normalize( reflect( vView , nNormal )); 25 | 26 | float nViewDot = dot( nNormal , normalize( vView ) ); 27 | float iNViewDot = 1.0 - max( -nViewDot , 0.0); 28 | 29 | vec3 refl = reflect( -vec3(0.,1.,0.) , nNormal ); 30 | float facingRatio = abs( dot( nNormal, refl) ); 31 | 32 | vec4 aColor = texture2D( t_audio , vec2( abs(iNViewDot) , 0.0)); 33 | 34 | vec3 lamb = dot( nNormal , normalize(jelly - vWorld)) * vec3(1.,.8,.2); 35 | vec3 fres = -dot( nNormal ,normalize(vView)) * vec3(1.,.5,.1); 36 | 37 | vec3 aC = ((aColor.xyz * aColor.xyz * aColor.xyz) - .2) * 1.4 ; 38 | gl_FragColor = vec4((lamb+fres + vec3(.8,.1,.1)) * active, 1.0 ); 39 | 40 | } 41 | -------------------------------------------------------------------------------- /Maru/shaders/fs-polyOrg.glsl: -------------------------------------------------------------------------------- 1 | 2 | uniform sampler2D t_audio; 3 | uniform vec3 jelly; 4 | uniform float active; 5 | 6 | uniform float hovered; 7 | 8 | varying vec3 vPos; 9 | varying vec3 vNorm; 10 | varying vec3 vView; 11 | 12 | varying vec3 vCol; 13 | 14 | varying mat3 vNormalMat; 15 | varying vec3 vLightDir; 16 | varying float vDisplacement; 17 | 18 | varying vec3 vMVPos; 19 | varying vec3 vWorld; 20 | 21 | void main(){ 22 | 23 | vec3 x = dFdx(vWorld); 24 | vec3 y = dFdy(vWorld); 25 | 26 | vec3 nNormal = vNorm;//normalize(cross(x,y)); 27 | 28 | vec3 nReflection = normalize( reflect( vView , nNormal )); 29 | 30 | float nViewDot = dot( nNormal , normalize( vView ) ); 31 | float iNViewDot = 1.0 - max( -nViewDot , 0.0); 32 | 33 | vec3 refl = reflect( -vec3(0.,1.,0.) , nNormal ); 34 | float facingRatio = abs( dot( nNormal, refl) ); 35 | 36 | vec4 aColor = texture2D( t_audio , vec2( abs(iNViewDot) , 0.0)); 37 | 38 | vec3 lamb = dot( nNormal , normalize(jelly - vWorld)) * vec3(1.,.4,.2); 39 | 40 | 41 | 42 | vec3 aC = ((aColor.xyz * aColor.xyz * aColor.xyz) - .2) * 1.4 + hovered * .5;// (1.+hovered); 43 | gl_FragColor = vec4(max(vCol , aC ), 1.0 ); 44 | 45 | } -------------------------------------------------------------------------------- /Maru/shaders/fs-polyOutline.glsl: -------------------------------------------------------------------------------- 1 | 2 | uniform sampler2D t_audio; 3 | uniform vec4 color; 4 | 5 | varying vec3 vPos; 6 | varying vec3 vNorm; 7 | varying vec3 vView; 8 | 9 | varying mat3 vNormalMat; 10 | varying vec3 vLightDir; 11 | varying float vDisplacement; 12 | 13 | //varying vec3 vMVPos; 14 | 15 | void main(){ 16 | gl_FragColor = color;//vec4( 1.,1.,0., 1.0 ); 17 | 18 | } 19 | -------------------------------------------------------------------------------- /Maru/shaders/fs-render.glsl: -------------------------------------------------------------------------------- 1 | uniform sampler2D t_audio; 2 | uniform sampler2D sprite; 3 | uniform vec3 color; 4 | uniform float id; 5 | uniform vec3 uPos; 6 | uniform vec3 uVel; 7 | 8 | varying vec2 vUv; 9 | 10 | 11 | varying vec4 vPos; 12 | varying vec4 vVel; 13 | varying vec4 vAudio; 14 | 15 | void main(){ 16 | 17 | /*float y = smoothstep( -5.0 , 5. , vVel.y ); 18 | 19 | vec4 s = texture2D( sprite , vec2( gl_PointCoord.x , 1.0 - gl_PointCoord.y) ); 20 | 21 | vec2 sample = vec2( abs( vPos.y / 20. ) , 0.0 ); 22 | vec4 a = texture2D( t_audio , sample ); 23 | 24 | float newY = vVel.y * -1.; 25 | vec3 vNorm = normalize( vVel.xyz + vec3( 0. , newY* .99 , 0. ) ); 26 | // vNorm = normalize( vPos.xyz ); 27 | 28 | vec3 c1 = y * normalize(abs(sin( vNorm * 20. ) ) + abs(sin( vNorm * 20.2 ) )); 29 | vec3 c2 = vec3( .5 , .5 , .5 ); 30 | 31 | vec3 newC = smoothstep( c1 , c2 , abs(vNorm) ); 32 | vec3 finalC = normalize( vec3( .8 , .2 , 1.9 ) + newC ); 33 | gl_FragColor = vec4( color * normalize( vec3( s.x * (.9 + (.5 * vUv.x) ) , s.yz* ((finalC + vAudio.xyz*.6) -.4).xy)) , s.w * s.x ); 34 | 35 | gl_FragColor = vec4( color + vec3( normalize(s * a * normalize( vVel ) * normalize( vPos )).xyz), s.w * s.x ); 36 | 37 | 38 | vec3 cTest = smoothstep( vec3( 1. , 1. , 1. ), vec3( id , 1. - id , cos( id)), vec3( .0 , 2. , 1. ) ); 39 | vec3 shimmer = vec3( (.8+ (.2 * a.y)) * 5.3 ,(.8+ (.2 * a.x)) * .6 , .1 );// - a.xyz * 5.; 40 | gl_FragColor = vec4( shimmer * (1. / vPos.w ) , (.5 / vPos.w ) * s.w * s.x * .6);*/ 41 | 42 | vec4 s = texture2D( sprite , vec2( gl_PointCoord.x , 1.0 - gl_PointCoord.y) ); 43 | 44 | vec2 sample = vec2( abs( vPos.y / 20. ) , 0.0 ); 45 | 46 | if( s.a < .1 ){ 47 | discard; 48 | } 49 | 50 | vec4 a = texture2D( t_audio , sample ); 51 | 52 | gl_FragColor = vec4( a * s * vec4(color , 1.0 )); 53 | 54 | 55 | } 56 | -------------------------------------------------------------------------------- /Maru/shaders/fs-simPos.glsl: -------------------------------------------------------------------------------- 1 | uniform sampler2D t_vel; 2 | uniform sampler2D t_pos; 3 | uniform sampler2D t_audio; 4 | uniform sampler2D t_start; 5 | uniform float delta; 6 | uniform float audioLookup; 7 | uniform vec3 uPos; 8 | uniform vec3 uVel; 9 | 10 | //uniform vec3 spherePos; 11 | 12 | varying vec2 vUv; 13 | 14 | vec2 mod289(vec2 x) { 15 | return x - floor(x * (1.0 / 289.0)) * 289.0; 16 | } 17 | 18 | float rand(vec2 co){ 19 | return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453); 20 | } 21 | 22 | 23 | 24 | 25 | void main(){ 26 | 27 | 28 | vec4 vel = texture2D( t_vel , vUv ); 29 | vec4 pos = texture2D( t_pos , vUv ); 30 | vec4 a = texture2D( t_audio , vec2((( vUv.x ) * .5)-.25 + audioLookup , 0.0 ) ); 31 | 32 | //vec4 start = texture2D( t_start , vUv ); 33 | 34 | if( pos.w == 10. || pos.w == 0. ){ 35 | 36 | pos.w = 0.; 37 | 38 | vel.xyz = vec3(0.,0.,0.); 39 | } 40 | 41 | pos.w += delta * ( .9 + (rand( vUv ) * .5 ) ); 42 | 43 | if( pos.w * a.w > 1.){ 44 | 45 | pos.xyz = uPos.xyz; 46 | //pos.xyz += .1 * pos.xyz * (rand( vUv ) -.5); 47 | vel.xyz = vec3(0.,0.,0.); 48 | pos.w = 10.; 49 | 50 | } 51 | 52 | 53 | vec3 finalPoint = pos.xyz + vel.xyz * delta;// * ( a.w ); 54 | gl_FragColor = vec4( finalPoint , pos.w ); 55 | 56 | 57 | 58 | } 59 | 60 | -------------------------------------------------------------------------------- /Maru/shaders/fs-simVel.glsl: -------------------------------------------------------------------------------- 1 | uniform sampler2D t_vel; 2 | uniform sampler2D t_pos; 3 | uniform sampler2D t_audio; 4 | 5 | uniform sampler2D t_start; 6 | uniform float time; 7 | uniform float delta; 8 | 9 | uniform vec3 uPos; 10 | uniform vec3 uVel; 11 | 12 | varying vec2 vUv; 13 | 14 | 15 | vec3 velSphere( vec3 c , float r , vec3 p , vec3 v ){ 16 | 17 | vec3 d = (p +v*delta)- c; 18 | 19 | float l = length ( d ); 20 | 21 | float vL = length( v ); 22 | vec3 refl = reflect( normalize( v ) , normalize( d ) ); 23 | 24 | vec3 finalVel = v; 25 | 26 | if( l < r ){ 27 | finalVel = refl * vL * .9; 28 | } 29 | 30 | return ( finalVel ); 31 | 32 | 33 | } 34 | 35 | float rand(vec2 co){ 36 | return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453); 37 | } 38 | 39 | $simplex 40 | $curl 41 | 42 | void main(){ 43 | 44 | 45 | vec4 vel = texture2D( t_vel , vUv ); 46 | vec4 pos = texture2D( t_pos , vUv ); 47 | vec4 a = texture2D( t_audio , vec2( vUv.x , 0.0 ) ); 48 | vec4 start = texture2D( t_start , vUv ); 49 | 50 | 51 | 52 | vel.xyz += curlNoise( pos.xyz * 1. ) * .005; //* .5 * rand( vUv ); 53 | 54 | if( pos.w == 10. || pos.w == 0. ){ 55 | vel.xyz= vec3( 0. , 0. , 0. ); 56 | //20. * normalize( vec3( .0 , -1. , 0.) + .9 *uVel + 1.5 *vec3( uVel.xy , 0.0 ) ); 57 | 58 | } 59 | 60 | gl_FragColor = vec4( vel.xyz , vel.w ); 61 | 62 | 63 | } 64 | 65 | -------------------------------------------------------------------------------- /Maru/shaders/fs-texturePass.glsl: -------------------------------------------------------------------------------- 1 | uniform sampler2D texture; 2 | varying vec2 vUv; 3 | void main(){ 4 | vec4 c = texture2D( texture , vUv ); 5 | gl_FragColor = c; 6 | } 7 | -------------------------------------------------------------------------------- /Maru/shaders/fs-toFrom.glsl: -------------------------------------------------------------------------------- 1 | uniform sampler2D t_oPos; 2 | uniform sampler2D t_pos; 3 | uniform sampler2D t_toPos; 4 | uniform sampler2D t_fromPos; 5 | varying vec2 vUv; 6 | void main(){ 7 | 8 | vec3 oPos = texture2D( t_oPos , vUv ).xyz; 9 | vec3 pos = texture2D( t_pos , vUv ).xyz; 10 | 11 | vec3 toPos = texture2D( t_toPos , vUv ).xyz; 12 | vec3 fromPos = texture2D( t_fromPos , vUv ).xyz; 13 | 14 | 15 | float direction = texture2D( t_pos , vUv ).w; 16 | 17 | vec3 dif; 18 | 19 | if( direction == 1.0 ){ 20 | dif = toPos - pos; 21 | } 22 | 23 | if( direction == -1.0 ){ 24 | dif = fromPos - pos; 25 | } 26 | 27 | 28 | vec3 sVel = pos - oPos; 29 | 30 | float lv = length( sVel ); 31 | 32 | vec3 acc = normalize( dif ); 33 | 34 | vec3 vel = sVel + acc; 35 | 36 | vec3 newPos = pos + vel * .9; 37 | 38 | 39 | float l = length( dif ); 40 | 41 | if( l < 5.0 ){ 42 | 43 | direction *= -1.; 44 | 45 | } 46 | 47 | 48 | gl_FragColor = vec4( newPos , direction ); 49 | 50 | } 51 | -------------------------------------------------------------------------------- /Maru/shaders/gravitySimBug1.glsl: -------------------------------------------------------------------------------- 1 | uniform sampler2D t_oPos; 2 | uniform sampler2D t_pos; 3 | 4 | uniform vec3 spherePos; 5 | 6 | varying vec2 vUv; 7 | 8 | 9 | $sphereDisrupt 10 | 11 | void main(){ 12 | 13 | vec4 oPos = texture2D( t_oPos , vUv ); 14 | vec4 pos = texture2D( t_pos , vUv ); 15 | 16 | float life = pos.w; 17 | life -= .1; 18 | 19 | vec3 vel = oPos.xyz - pos.xyz; 20 | 21 | 22 | vel += vec3( 0. , -.5 , 0. ); 23 | 24 | vel *= .7; 25 | 26 | vec3 p = pos.xyz + vel; 27 | vec4 disrupt = sphereDisrupt( spherePos , 10. , pos.xyz , vel.xyz ); 28 | 29 | p += disrupt.xyz * disrupt.w * 3.; 30 | 31 | if( p.y < -40.0 ){ 32 | 33 | p = vec3( 0. , 40. , 0. ); 34 | 35 | } 36 | 37 | 38 | 39 | gl_FragColor = vec4( p , life ); 40 | 41 | 42 | 43 | } 44 | 45 | -------------------------------------------------------------------------------- /Maru/shaders/lightColors.glsl: -------------------------------------------------------------------------------- 1 | uniform vec3 lightColors[6]; 2 | uniform vec3 lightDirections[6]; 3 | 4 | 5 | vec3 lambertLightColor( vec3 normToPass ){ 6 | 7 | vec3 fColor = vec3( 0. ); 8 | for( int i = 0; i < 6; i++ ){ 9 | 10 | fColor += max( 0., dot( normToPass , normalize( lightDirections[i] ) )) * lightColors[i] * .5; 11 | 12 | } 13 | 14 | return fColor; 15 | 16 | } 17 | 18 | vec3 lambertAudioLightColor( vec3 normToPass , sampler2D audio ){ 19 | 20 | vec3 fColor = vec3( 0. ); 21 | for( int i = 0; i < 6; i++ ){ 22 | 23 | float match = dot( normToPass , normalize( lightDirections[i] ) ); 24 | vec4 a = texture2D( audio , vec2( abs( sin(match*1.)) , 0. ) ); 25 | fColor += max( 0. , match) * a.xyz * lightColors[i]; 26 | 27 | } 28 | 29 | return fColor; 30 | 31 | } 32 | 33 | vec3 lambertAudioColor( vec3 normToPass , sampler2D audio ){ 34 | 35 | vec3 fColor = vec3( 0. ); 36 | for( int i = 0; i < 2; i++ ){ 37 | 38 | float match = dot( normToPass , normalize( lightDirections[i*2] ) ); 39 | vec4 a = texture2D( audio , vec2( abs( sin(match*1.)) , 0. ) ); 40 | fColor += max( 0. , match) * a.xyz; 41 | 42 | } 43 | 44 | return fColor; 45 | 46 | } 47 | 48 | 49 | 50 | vec3 shineAudioLightColor( vec3 normToPass, vec3 eye , sampler2D audio , float power){ 51 | 52 | vec3 fColor = vec3( 0. ); 53 | for( int i = 0; i < 2; i++ ){ 54 | 55 | vec3 refl = reflect( normToPass , normalize( lightDirections[i*2] ) ); 56 | float match = dot( eye , refl ); 57 | vec4 a = texture2D( audio , vec2( abs( sin(match*1.)) , 0. ) ); 58 | fColor += pow( max( 0. , match) , power ) * a.xyz * lightColors[i*2]; 59 | 60 | } 61 | 62 | return fColor; 63 | 64 | } 65 | -------------------------------------------------------------------------------- /Maru/shaders/room/fs-render.glsl: -------------------------------------------------------------------------------- 1 | uniform sampler2D t_audio; 2 | uniform sampler2D sprite; 3 | uniform float id; 4 | uniform vec3 uPos; 5 | uniform vec3 uVel; 6 | 7 | uniform vec3 color; 8 | varying vec2 vUv; 9 | 10 | 11 | varying vec4 vPos; 12 | varying vec4 vVel; 13 | varying vec4 vAudio; 14 | 15 | void main(){ 16 | 17 | float y = smoothstep( -5.0 , 5. , vVel.y ); 18 | 19 | vec4 s = texture2D( sprite , vec2( gl_PointCoord.x , 1.0 - gl_PointCoord.y) ); 20 | 21 | vec2 sample = vec2( abs( vPos.y / 20. ) , 0.0 ); 22 | vec4 a = texture2D( t_audio , sample ); 23 | 24 | float newY = vVel.y * -1.; 25 | vec3 vNorm = normalize( vVel.xyz + vec3( 0. , newY* .99 , 0. ) ); 26 | // vNorm = normalize( vPos.xyz ); 27 | 28 | vec3 c1 = y * normalize(abs(sin( vNorm * 20. ) ) + abs(sin( vNorm * 20.2 ) )); 29 | vec3 c2 = vec3( .5 , .5 , .5 ); 30 | 31 | vec3 newC = smoothstep( c1 , c2 , abs(vNorm) ); 32 | vec3 finalC = normalize( vec3( .8 , .2 , 1.9 ) + newC ); 33 | gl_FragColor = vec4( color * normalize( vec3( s.x * (.9 + (.5 * vUv.x) ) , s.yz* ((finalC + vAudio.xyz*.6) -.4).xy)) , s.w * s.x ); 34 | 35 | gl_FragColor = vec4( color + vec3( normalize(s * a * normalize( vVel ) * normalize( vPos )).xyz), s.w * s.x ); 36 | 37 | 38 | vec3 cTest = smoothstep( vec3( 1. , 1. , 1. ), vec3( id , 1. - id , cos( id)), vec3( .0 , 2. , 1. ) ); 39 | vec3 shimmer = vec3( (.8+ (.2 * a.y)) * 5.3 ,(.8+ (.2 * a.x)) * .6 , .1 );// - a.xyz * 5.; 40 | gl_FragColor = vec4( shimmer * (1. / vPos.w ) , (.5 / vPos.w ) * s.w * s.x * .6); 41 | 42 | 43 | } 44 | -------------------------------------------------------------------------------- /Maru/shaders/room/fs-simPos.glsl: -------------------------------------------------------------------------------- 1 | uniform sampler2D t_vel; 2 | uniform sampler2D t_pos; 3 | uniform sampler2D t_audio; 4 | uniform sampler2D t_start; 5 | uniform float delta; 6 | uniform float audioLookup; 7 | uniform vec3 uPos; 8 | uniform vec3 uVel; 9 | 10 | //uniform vec3 spherePos; 11 | 12 | varying vec2 vUv; 13 | 14 | vec4 posSphere( vec3 center , float r , vec3 p , vec3 v ){ 15 | 16 | // The line passes through p1 and p2: 17 | vec3 p2 = p + v*delta; 18 | vec3 p1 = p; 19 | 20 | // Sphere center is p3, radius is r: 21 | vec3 p3 = center; 22 | 23 | vec3 d = p2 - p1; 24 | 25 | float a = dot(d, d); 26 | float b = 2.0 * dot(d, p1 - p3); 27 | float c = dot(p3, p3) + dot(p1, p1) - 2.0 * dot(p3, p1) - r*r; 28 | 29 | float test = b*b - 4.0*a*c; 30 | 31 | if (test >= 0.0) { 32 | // Hit (according to Treebeard, "a fine hit"). 33 | float u = (-b - sqrt(test)) / (2.0 * a); 34 | vec3 hitp = p1 + u * (p2 - p1); 35 | // Now use hitp. 36 | 37 | return vec4( hitp , 1.0 ); 38 | }else{ 39 | return vec4( 0.0, 0.0 , 0.0 , 0.0 ); 40 | } 41 | 42 | } 43 | 44 | /*vec3 velSphere( vec3 center , vec3 hitPoint , vec3 vel , vec3 pos ){ 45 | 46 | vec3 d = hitPoint - center; 47 | 48 | float vL = length( vel * delta ); 49 | float pDif = length( hitPoint - pos ); 50 | 51 | vec3 refl = reflect( normalize( vel ) , normalize(d ) ); 52 | 53 | vec3 vFinal = (pDif - vL) * refl; 54 | 55 | return vFinal; 56 | 57 | }*/ 58 | 59 | vec3 velSphere( vec3 c , float r , vec3 p , vec3 v ){ 60 | 61 | vec3 d = (p+v*delta) - c; 62 | 63 | float l = length ( d ); 64 | 65 | float vL = length( v ); 66 | vec3 refl = reflect( normalize( v ) , normalize( d ) ); 67 | 68 | vec3 finalVel = v; 69 | 70 | if( l < r ){ 71 | finalVel = refl * vL; 72 | } 73 | 74 | return ( finalVel ); 75 | 76 | 77 | } 78 | 79 | vec2 mod289(vec2 x) { 80 | return x - floor(x * (1.0 / 289.0)) * 289.0; 81 | } 82 | 83 | float rand(vec2 co){ 84 | return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453); 85 | } 86 | 87 | 88 | 89 | 90 | void main(){ 91 | 92 | 93 | vec4 vel = texture2D( t_vel , vUv ); 94 | vec4 pos = texture2D( t_pos , vUv ); 95 | vec4 a = texture2D( t_audio , vec2((( vUv.x ) * .5)-.25 + audioLookup , 0.0 ) ); 96 | 97 | //vec4 start = texture2D( t_start , vUv ); 98 | 99 | if( pos.w == 10. ){ 100 | 101 | pos.w = 0.; 102 | 103 | } 104 | pos.w += delta * ( .9 + (rand( vUv ) * .5 ) ); 105 | 106 | if( pos.w * a.w > 1.){ 107 | 108 | pos.xyz = uPos.xyz; 109 | vel.xyz = vec3(0.,0.,0.); 110 | pos.w = 10.; 111 | 112 | } 113 | 114 | 115 | vec3 finalPoint = pos.xyz + vel.xyz * delta * ( a.w ); 116 | /*if( hitPoint.w != 0. ){ 117 | finalPoint = hitPoint.xyz+10.0*hitVel*delta; 118 | }*/ 119 | gl_FragColor = vec4( finalPoint , pos.w ); 120 | 121 | 122 | 123 | } 124 | 125 | -------------------------------------------------------------------------------- /Maru/shaders/room/fs-simVel.glsl: -------------------------------------------------------------------------------- 1 | uniform sampler2D t_vel; 2 | uniform sampler2D t_pos; 3 | uniform sampler2D t_audio; 4 | 5 | uniform sampler2D t_start; 6 | uniform float cameraAngle; 7 | uniform float time; 8 | uniform float delta; 9 | 10 | uniform vec3 uPos; 11 | uniform vec3 uVel; 12 | 13 | varying vec2 vUv; 14 | 15 | 16 | vec3 velSphere( vec3 c , float r , vec3 p , vec3 v ){ 17 | 18 | vec3 d = (p +v*delta)- c; 19 | 20 | float l = length ( d ); 21 | 22 | float vL = length( v ); 23 | vec3 refl = reflect( normalize( v ) , normalize( d ) ); 24 | 25 | vec3 finalVel = v; 26 | 27 | if( l < r ){ 28 | finalVel = refl * vL * .9; 29 | } 30 | 31 | return ( finalVel ); 32 | 33 | 34 | } 35 | 36 | float rand(vec2 co){ 37 | return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453); 38 | } 39 | 40 | $simplex 41 | $curl 42 | 43 | void main(){ 44 | 45 | 46 | vec4 vel = texture2D( t_vel , vUv ); 47 | vec4 pos = texture2D( t_pos , vUv ); 48 | vec4 a = texture2D( t_audio , vec2( vUv.x , 0.0 ) ); 49 | vec4 start = texture2D( t_start , vUv ); 50 | 51 | 52 | 53 | if( pos.w == 10. || pos.w == 0. ){ 54 | vel.xyz= 20. * normalize( vec3( .0 , -1. , 0.) + .9 *uVel + 1.5 *vec3( uVel.xy , 0.0 ) ); 55 | } 56 | 57 | vel.xyz += curlNoise( pos.xyz * .1 ) * .1; 58 | vel.y += a.x* 1.5 ; 59 | 60 | gl_FragColor = vec4( vel.xyz , vel.w ); 61 | 62 | 63 | } 64 | 65 | -------------------------------------------------------------------------------- /Maru/shaders/room/vs-render.glsl: -------------------------------------------------------------------------------- 1 | uniform sampler2D t_pos; 2 | uniform sampler2D t_vel; 3 | uniform sampler2D t_audio; 4 | 5 | varying vec4 vVel; 6 | varying vec4 vPos; 7 | varying vec4 vAudio; 8 | 9 | varying vec2 vUv; 10 | 11 | void main(){ 12 | 13 | vUv = position.xy; 14 | 15 | vPos = texture2D( t_pos , position.xy ); 16 | vVel = texture2D( t_vel , position.xy ); 17 | vAudio = texture2D( t_audio , vec2( position.x , 0. ) ); 18 | 19 | vec3 pos = vPos.xyz; 20 | 21 | 22 | 23 | vec4 mvPos = modelViewMatrix * vec4( pos , 1.0 ); 24 | 25 | gl_PointSize = min( 100. ,3.+ 10. * abs(vAudio.x* vAudio.x* vAudio.x)); 26 | //gl_PointSize = 10.; 27 | gl_Position = projectionMatrix * mvPos; 28 | 29 | } 30 | -------------------------------------------------------------------------------- /Maru/shaders/semLookup.glsl: -------------------------------------------------------------------------------- 1 | // Taken from : http://www.clicktorelease.com/blog/creating-spherical-environment-mapping-shader 2 | 3 | vec2 semLookup( vec3 pos , vec3 norm , mat4 mvMat , mat3 nMat ){ 4 | 5 | vec4 p = vec4( pos, 1. ); 6 | 7 | vec3 e = normalize( vec3( mvMat * p ) ); 8 | vec3 n = normalize( nMat * norm ); 9 | 10 | vec3 r = reflect( e, n ); 11 | float m = 2. * sqrt( 12 | pow( r.x, 2. ) + 13 | pow( r.y, 2. ) + 14 | pow( r.z + 1., 2. ) 15 | ); 16 | 17 | return ( r.xy / m + .5 ); 18 | 19 | } 20 | 21 | vec2 semLookup( vec3 e , vec3 n ){ 22 | 23 | vec3 r = reflect( e, n ); 24 | float m = 2. * sqrt( 25 | pow( r.x, 2. ) + 26 | pow( r.y, 2. ) + 27 | pow( r.z + 1., 2. ) 28 | ); 29 | 30 | return ( r.xy / m + .5 ); 31 | 32 | } 33 | -------------------------------------------------------------------------------- /Maru/shaders/simplex.glsl: -------------------------------------------------------------------------------- 1 | 2 | // 3 | // Description : Array and textureless GLSL 2D simplex noise function. 4 | // Author : Ian McEwan, Ashima Arts. 5 | // Maintainer : ijm 6 | // Lastmod : 20110822 (ijm) 7 | // License : Copyright (C) 2011 Ashima Arts. All rights reserved. 8 | // Distributed under the MIT License. See LICENSE file. 9 | // https://github.com/ashima/webgl-noise 10 | // 11 | 12 | vec3 mod289(vec3 x) { 13 | return x - floor(x * (1.0 / 289.0)) * 289.0; 14 | } 15 | 16 | vec2 mod289(vec2 x) { 17 | return x - floor(x * (1.0 / 289.0)) * 289.0; 18 | } 19 | 20 | vec3 permute(vec3 x) { 21 | return mod289(((x*34.0)+1.0)*x); 22 | } 23 | 24 | float snoise(vec2 v) 25 | { 26 | const vec4 C = vec4(0.211324865405187, // (3.0-sqrt(3.0))/6.0 27 | 0.366025403784439, // 0.5*(sqrt(3.0)-1.0) 28 | -0.577350269189626, // -1.0 + 2.0 * C.x 29 | 0.024390243902439); // 1.0 / 41.0 30 | // First corner 31 | vec2 i = floor(v + dot(v, C.yy) ); 32 | vec2 x0 = v - i + dot(i, C.xx); 33 | 34 | // Other corners 35 | vec2 i1; 36 | //i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0 37 | //i1.y = 1.0 - i1.x; 38 | i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0); 39 | // x0 = x0 - 0.0 + 0.0 * C.xx ; 40 | // x1 = x0 - i1 + 1.0 * C.xx ; 41 | // x2 = x0 - 1.0 + 2.0 * C.xx ; 42 | vec4 x12 = x0.xyxy + C.xxzz; 43 | x12.xy -= i1; 44 | 45 | // Permutations 46 | i = mod289(i); // Avoid truncation effects in permutation 47 | vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 )) 48 | + i.x + vec3(0.0, i1.x, 1.0 )); 49 | 50 | vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0); 51 | m = m*m ; 52 | m = m*m ; 53 | 54 | // Gradients: 41 points uniformly over a line, mapped onto a diamond. 55 | // The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287) 56 | 57 | vec3 x = 2.0 * fract(p * C.www) - 1.0; 58 | vec3 h = abs(x) - 0.5; 59 | vec3 ox = floor(x + 0.5); 60 | vec3 a0 = x - ox; 61 | 62 | // Normalise gradients implicitly by scaling m 63 | // Approximation of: m *= inversesqrt( a0*a0 + h*h ); 64 | m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h ); 65 | 66 | // Compute final noise value at P 67 | vec3 g; 68 | g.x = a0.x * x0.x + h.x * x0.y; 69 | g.yz = a0.yz * x12.xz + h.yz * x12.yw; 70 | return 130.0 * dot(m, g); 71 | } 72 | 73 | // 74 | // Description : Array and textureless GLSL 2D/3D/4D simplex 75 | // noise functions. 76 | // Author : Ian McEwan, Ashima Arts. 77 | // Maintainer : ijm 78 | // Lastmod : 20110822 (ijm) 79 | // License : Copyright (C) 2011 Ashima Arts. All rights reserved. 80 | // Distributed under the MIT License. See LICENSE file. 81 | // https://github.com/ashima/webgl-noise 82 | // 83 | 84 | 85 | vec4 mod289(vec4 x) { 86 | return x - floor(x * (1.0 / 289.0)) * 289.0; 87 | } 88 | 89 | vec4 permute(vec4 x) { 90 | return mod289(((x*34.0)+1.0)*x); 91 | } 92 | 93 | vec4 taylorInvSqrt(vec4 r) 94 | { 95 | return 1.79284291400159 - 0.85373472095314 * r; 96 | } 97 | 98 | float snoise(vec3 v) 99 | { 100 | const vec2 C = vec2(1.0/6.0, 1.0/3.0) ; 101 | const vec4 D = vec4(0.0, 0.5, 1.0, 2.0); 102 | 103 | // First corner 104 | vec3 i = floor(v + dot(v, C.yyy) ); 105 | vec3 x0 = v - i + dot(i, C.xxx) ; 106 | 107 | // Other corners 108 | vec3 g = step(x0.yzx, x0.xyz); 109 | vec3 l = 1.0 - g; 110 | vec3 i1 = min( g.xyz, l.zxy ); 111 | vec3 i2 = max( g.xyz, l.zxy ); 112 | 113 | // x0 = x0 - 0.0 + 0.0 * C.xxx; 114 | // x1 = x0 - i1 + 1.0 * C.xxx; 115 | // x2 = x0 - i2 + 2.0 * C.xxx; 116 | // x3 = x0 - 1.0 + 3.0 * C.xxx; 117 | vec3 x1 = x0 - i1 + C.xxx; 118 | vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y 119 | vec3 x3 = x0 - D.yyy; // -1.0+3.0*C.x = -0.5 = -D.y 120 | 121 | // Permutations 122 | i = mod289(i); 123 | vec4 p = permute( permute( permute( 124 | i.z + vec4(0.0, i1.z, i2.z, 1.0 )) 125 | + i.y + vec4(0.0, i1.y, i2.y, 1.0 )) 126 | + i.x + vec4(0.0, i1.x, i2.x, 1.0 )); 127 | 128 | // Gradients: 7x7 points over a square, mapped onto an octahedron. 129 | // The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294) 130 | float n_ = 0.142857142857; // 1.0/7.0 131 | vec3 ns = n_ * D.wyz - D.xzx; 132 | 133 | vec4 j = p - 49.0 * floor(p * ns.z * ns.z); // mod(p,7*7) 134 | 135 | vec4 x_ = floor(j * ns.z); 136 | vec4 y_ = floor(j - 7.0 * x_ ); // mod(j,N) 137 | 138 | vec4 x = x_ *ns.x + ns.yyyy; 139 | vec4 y = y_ *ns.x + ns.yyyy; 140 | vec4 h = 1.0 - abs(x) - abs(y); 141 | 142 | vec4 b0 = vec4( x.xy, y.xy ); 143 | vec4 b1 = vec4( x.zw, y.zw ); 144 | 145 | //vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0; 146 | //vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0; 147 | vec4 s0 = floor(b0)*2.0 + 1.0; 148 | vec4 s1 = floor(b1)*2.0 + 1.0; 149 | vec4 sh = -step(h, vec4(0.0)); 150 | 151 | vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ; 152 | vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ; 153 | 154 | vec3 p0 = vec3(a0.xy,h.x); 155 | vec3 p1 = vec3(a0.zw,h.y); 156 | vec3 p2 = vec3(a1.xy,h.z); 157 | vec3 p3 = vec3(a1.zw,h.w); 158 | 159 | //Normalise gradients 160 | vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3))); 161 | p0 *= norm.x; 162 | p1 *= norm.y; 163 | p2 *= norm.z; 164 | p3 *= norm.w; 165 | 166 | // Mix final noise value 167 | vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0); 168 | m = m * m; 169 | return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1), 170 | dot(p2,x2), dot(p3,x3) ) ); 171 | } 172 | 173 | 174 | // 175 | // Description : Array and textureless GLSL 2D/3D/4D simplex 176 | // noise functions. 177 | // Author : Ian McEwan, Ashima Arts. 178 | // Maintainer : ijm 179 | // Lastmod : 20110822 (ijm) 180 | // License : Copyright (C) 2011 Ashima Arts. All rights reserved. 181 | // Distributed under the MIT License. See LICENSE file. 182 | // https://github.com/ashima/webgl-noise 183 | // 184 | 185 | float mod289(float x) { 186 | return x - floor(x * (1.0 / 289.0)) * 289.0; } 187 | 188 | float permute(float x) { 189 | return mod289(((x*34.0)+1.0)*x); 190 | } 191 | 192 | 193 | float taylorInvSqrt(float r) 194 | { 195 | return 1.79284291400159 - 0.85373472095314 * r; 196 | } 197 | 198 | vec4 grad4(float j, vec4 ip) 199 | { 200 | const vec4 ones = vec4(1.0, 1.0, 1.0, -1.0); 201 | vec4 p,s; 202 | 203 | p.xyz = floor( fract (vec3(j) * ip.xyz) * 7.0) * ip.z - 1.0; 204 | p.w = 1.5 - dot(abs(p.xyz), ones.xyz); 205 | s = vec4(lessThan(p, vec4(0.0))); 206 | p.xyz = p.xyz + (s.xyz*2.0 - 1.0) * s.www; 207 | 208 | return p; 209 | } 210 | 211 | float snoise(vec4 v) 212 | { 213 | const vec4 C = vec4( 0.138196601125011, // (5 - sqrt(5))/20 G4 214 | 0.276393202250021, // 2 * G4 215 | 0.414589803375032, // 3 * G4 216 | -0.447213595499958); // -1 + 4 * G4 217 | 218 | // (sqrt(5) - 1)/4 = F4, used once below 219 | #define F4 0.309016994374947451 220 | 221 | // First corner 222 | vec4 i = floor(v + dot(v, vec4(F4)) ); 223 | vec4 x0 = v - i + dot(i, C.xxxx); 224 | 225 | // Other corners 226 | 227 | // Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI) 228 | vec4 i0; 229 | vec3 isX = step( x0.yzw, x0.xxx ); 230 | vec3 isYZ = step( x0.zww, x0.yyz ); 231 | // i0.x = dot( isX, vec3( 1.0 ) ); 232 | i0.x = isX.x + isX.y + isX.z; 233 | i0.yzw = 1.0 - isX; 234 | // i0.y += dot( isYZ.xy, vec2( 1.0 ) ); 235 | i0.y += isYZ.x + isYZ.y; 236 | i0.zw += 1.0 - isYZ.xy; 237 | i0.z += isYZ.z; 238 | i0.w += 1.0 - isYZ.z; 239 | 240 | // i0 now contains the unique values 0,1,2,3 in each channel 241 | vec4 i3 = clamp( i0, 0.0, 1.0 ); 242 | vec4 i2 = clamp( i0-1.0, 0.0, 1.0 ); 243 | vec4 i1 = clamp( i0-2.0, 0.0, 1.0 ); 244 | 245 | // x0 = x0 - 0.0 + 0.0 * C.xxxx 246 | // x1 = x0 - i1 + 1.0 * C.xxxx 247 | // x2 = x0 - i2 + 2.0 * C.xxxx 248 | // x3 = x0 - i3 + 3.0 * C.xxxx 249 | // x4 = x0 - 1.0 + 4.0 * C.xxxx 250 | vec4 x1 = x0 - i1 + C.xxxx; 251 | vec4 x2 = x0 - i2 + C.yyyy; 252 | vec4 x3 = x0 - i3 + C.zzzz; 253 | vec4 x4 = x0 + C.wwww; 254 | 255 | // Permutations 256 | i = mod289(i); 257 | float j0 = permute( permute( permute( permute(i.w) + i.z) + i.y) + i.x); 258 | vec4 j1 = permute( permute( permute( permute ( 259 | i.w + vec4(i1.w, i2.w, i3.w, 1.0 )) 260 | + i.z + vec4(i1.z, i2.z, i3.z, 1.0 )) 261 | + i.y + vec4(i1.y, i2.y, i3.y, 1.0 )) 262 | + i.x + vec4(i1.x, i2.x, i3.x, 1.0 )); 263 | 264 | // Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope 265 | // 7*7*6 = 294, which is close to the ring size 17*17 = 289. 266 | vec4 ip = vec4(1.0/294.0, 1.0/49.0, 1.0/7.0, 0.0) ; 267 | 268 | vec4 p0 = grad4(j0, ip); 269 | vec4 p1 = grad4(j1.x, ip); 270 | vec4 p2 = grad4(j1.y, ip); 271 | vec4 p3 = grad4(j1.z, ip); 272 | vec4 p4 = grad4(j1.w, ip); 273 | 274 | // Normalise gradients 275 | vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3))); 276 | p0 *= norm.x; 277 | p1 *= norm.y; 278 | p2 *= norm.z; 279 | p3 *= norm.w; 280 | p4 *= taylorInvSqrt(dot(p4,p4)); 281 | 282 | // Mix contributions from the five corners 283 | vec3 m0 = max(0.6 - vec3(dot(x0,x0), dot(x1,x1), dot(x2,x2)), 0.0); 284 | vec2 m1 = max(0.6 - vec2(dot(x3,x3), dot(x4,x4) ), 0.0); 285 | m0 = m0 * m0; 286 | m1 = m1 * m1; 287 | return 49.0 * ( dot(m0*m0, vec3( dot( p0, x0 ), dot( p1, x1 ), dot( p2, x2 ))) 288 | + dot(m1*m1, vec2( dot( p3, x3 ), dot( p4, x4 ) ) ) ) ; 289 | 290 | } 291 | 292 | 293 | -------------------------------------------------------------------------------- /Maru/shaders/sphereDisrupt.glsl: -------------------------------------------------------------------------------- 1 | vec4 sphereDisrupt( vec3 center , float r , vec3 p , vec3 v ){ 2 | 3 | vec3 d = p - center; 4 | float l = length( d ); 5 | 6 | vec3 refl = reflect( normalize( v ) , normalize( d ) ); 7 | 8 | float add = 0.0; 9 | float dDif = r-l; 10 | if( l < r ){ 11 | add = r-l; 12 | } 13 | 14 | p -= add * normalize( p ); 15 | return vec4( refl , add ) ; 16 | 17 | } 18 | -------------------------------------------------------------------------------- /Maru/shaders/ss-furryHead.glsl: -------------------------------------------------------------------------------- 1 | uniform sampler2D t_oPos; 2 | uniform sampler2D t_pos; 3 | uniform sampler2D t_audio; 4 | uniform sampler2D t_column; 5 | 6 | uniform vec3 leader; 7 | uniform float dT; 8 | uniform float timer; 9 | 10 | varying vec2 vUv; 11 | 12 | const float maxVel = 20.; 13 | 14 | const float size = 1. / 32.; 15 | const float hSize = size / 2.; 16 | const float interpolation = .5; 17 | const float springLength = .05; 18 | const float radiusMultiplier = 12.; 19 | const float headSize = 10.; 20 | 21 | $simplex 22 | 23 | vec3 springForce( vec3 toPos , vec3 fromPos , float staticLength ){ 24 | 25 | vec3 dif = fromPos - toPos; 26 | vec3 nDif = normalize( dif ); 27 | vec3 balance = nDif * staticLength; 28 | 29 | vec3 springDif = balance - dif; 30 | 31 | return springDif; 32 | 33 | } 34 | 35 | 36 | float getRadius( float i ){ 37 | 38 | float x = i * 6.5; 39 | 40 | float s1 =((x * ((1./x)*log( x+.1))) + 1.); 41 | float s2 = ( x * x*.1); 42 | float s3 = (x*x*x * .015); 43 | 44 | return s1 - s2 + s3+ .2; 45 | 46 | 47 | } 48 | 49 | vec3 cubicCurve( float t , vec3 c0 , vec3 c1 , vec3 c2 , vec3 c3 ){ 50 | 51 | float s = 1. - t; 52 | 53 | vec3 v1 = c0 * ( s * s * s ); 54 | vec3 v2 = 3. * c1 * ( s * s ) * t; 55 | vec3 v3 = 3. * c2 * s * ( t * t ); 56 | vec3 v4 = c3 * ( t * t * t ); 57 | 58 | vec3 value = v1 + v2 + v3 + v4; 59 | 60 | return value; 61 | 62 | } 63 | 64 | 65 | void main(){ 66 | 67 | 68 | vec4 pos = texture2D( t_pos , vUv.xy ); 69 | vec4 oPos = texture2D( t_oPos , vUv.xy ); 70 | 71 | vec3 vel = pos.xyz - oPos.xyz; 72 | 73 | float sizeOfTail = headSize / (32.); 74 | float base = (vUv.y * sizeOfTail) * headSize; 75 | float baseUp = floor( base ); 76 | float baseDown = ceil( base ); 77 | float amount = base - baseUp; 78 | 79 | vec3 pUp = texture2D( t_column , vec2( 0. , baseUp / headSize ) ).xyz; 80 | vec3 pDown = texture2D( t_column , vec2( 0. , baseDown / headSize ) ).xyz; 81 | 82 | vec3 direction = pUp - pDown; 83 | vec3 dirNorm = normalize( direction ); 84 | 85 | vec3 columnPos = pDown + (direction * (1.-amount)); 86 | 87 | vec3 columnToPos = pos.xyz - columnPos; 88 | 89 | 90 | vec3 p0 = vec3(0.); 91 | vec3 v0 = vec3(0.); 92 | vec3 p1 = vec3(0.); 93 | vec3 v1 = vec3(0.); 94 | 95 | vec3 p2 = vec3(0.); 96 | if( baseUp == 0. ){ 97 | 98 | p0 = texture2D( t_column , vec2( 0. , baseUp / headSize ) ).xyz; 99 | p1 = texture2D( t_column , vec2( 0. , baseDown / headSize ) ).xyz; 100 | 101 | // v0 = 0; 102 | 103 | p2 = texture2D( t_column , vec2( 0. , (baseDown + 1. ) / headSize )).xyz; 104 | v1 = .5 * ( p2 - p0 ); 105 | 106 | }else if( baseDown == headSize ){ 107 | 108 | p0 = texture2D( t_column , vec2( 0. , baseUp / headSize ) ).xyz; 109 | p1 = texture2D( t_column , vec2( 0. , baseDown / headSize ) ).xyz; 110 | 111 | // v1 = 0; 112 | 113 | p2 = texture2D( t_column , vec2( 0. , (baseUp - 1. ) / headSize )).xyz; 114 | v0 = .5 * ( p1 - p2 ); 115 | 116 | }else{ 117 | 118 | p0 = texture2D( t_column , vec2( 0. , baseUp / headSize ) ).xyz; 119 | p1 = texture2D( t_column , vec2( 0. , baseDown / headSize ) ).xyz; 120 | 121 | // v0 = 0; 122 | 123 | vec3 pMinus = texture2D( t_column , vec2( 0. , (baseUp -1.) / headSize ) ).xyz; 124 | p2 = texture2D( t_column , vec2( 0. , (baseDown + 1. ) / headSize )).xyz; 125 | v1 = .5 * ( p2 - p0 ); 126 | v0 = .5 * ( p1 - pMinus ); 127 | 128 | } 129 | 130 | 131 | vec3 c0 = p0; 132 | vec3 c1 = p0 + v0/3.; 133 | vec3 c2 = p1 - v1/3.; 134 | vec3 c3 = p1; 135 | 136 | vec3 centerOfCircle = cubicCurve( amount , c0 , c1 , c2 , c3 ); 137 | vec3 forNormal = cubicCurve( amount - .1 , c0 , c1 , c2 , c3 ); 138 | 139 | dirNorm = normalize(forNormal - centerOfCircle); 140 | 141 | columnPos = centerOfCircle ; 142 | 143 | columnToPos = pos.xyz - columnPos; 144 | 145 | vec3 p = vec3( 0. ); 146 | 147 | // Exact rotation Method 148 | 149 | vec3 upVector = vec3( 0. , 0. , 1. ); 150 | float upVectorProj = dot( upVector , dirNorm ); 151 | vec3 upVectorPara = upVectorProj * dirNorm; 152 | vec3 upVectorPerp = upVector - upVectorPara; 153 | 154 | vec3 basisX = normalize( upVectorPerp ); 155 | vec3 basisY = cross( dirNorm , basisX ); 156 | 157 | float theta = vUv.x * 2. * 3.14195; 158 | 159 | float x = cos( theta ); 160 | float y = sin( theta ); 161 | 162 | float bell = smoothstep( 0. , 1. , vUv.y*vUv.y*1.); 163 | float r = 100. * vUv.y * vUv.y ; 164 | 165 | 166 | c0 = vec3( 0. , 0. , 0. ); 167 | c1 = vec3(.1 , 100. , 0. ); 168 | c2 = vec3( 4. , 100. , 0. ); 169 | c3 = vec3( 5. , 550. , 0. ); 170 | vec3 cc = cubicCurve( vUv.y, c0 , c1 , c2 , c3 ); 171 | 172 | vec2 absVUv = vec2( abs( vUv.x - .5 )*2. , abs( vUv.y - .5 ) * 2. ); 173 | vec2 noiseLookup = absVUv * 5. + vec2( timer * .5 , timer * .5 ); 174 | float noiseAmount = 1.2 + snoise( noiseLookup ) * .4 * vUv.y * vUv.y; 175 | r = getRadius( vUv.y ) * radiusMultiplier;// * noiseAmount; 176 | r *= 3.; 177 | 178 | float pointInCircle = sin((vUv.x+timer*.1)*10.*3.14159); 179 | 180 | vec3 pointToAttractTo = columnPos + ( r * x * basisX ) + ( r * y * basisY ) + pointInCircle * dirNorm * vUv.y * vUv.y * 5.; 181 | vec3 distToPoint = pointToAttractTo - pos.xyz; 182 | 183 | vec3 pointPower = distToPoint ; 184 | vel = vel*.9+( pointPower ); 185 | if( length(vel)> maxVel ){ vel = normalize(vel) * maxVel; } 186 | p = pos.xyz +vel;//* (noiseAmount-.6) + .8 * pointInCircle); 187 | gl_FragColor = vec4( p , 1. ); 188 | 189 | 190 | 191 | } 192 | -------------------------------------------------------------------------------- /Maru/shaders/ss-furryTail.glsl: -------------------------------------------------------------------------------- 1 | 2 | uniform sampler2D t_oPos; 3 | uniform sampler2D t_pos; 4 | uniform sampler2D t_audio; 5 | uniform sampler2D t_posMain; 6 | uniform sampler2D t_posHead; 7 | 8 | uniform vec3 flow; 9 | 10 | uniform float dT;uniform float tailID; 11 | 12 | 13 | uniform float audioPower; 14 | uniform float audioAmount; 15 | 16 | uniform vec3 leader; 17 | uniform vec3 leaderVel; 18 | 19 | // Spine 20 | uniform float dist_spineAttract; // 1.1; 21 | uniform float force_spineAttract; // 1.; 22 | 23 | // SpineBundle 24 | uniform float dist_bundleAttract; // .1; 25 | uniform float dist_bundleRepel; // .4; 26 | 27 | uniform float force_bundleAttract; // .1; 28 | uniform float force_bundleRepel; // .4; 29 | 30 | 31 | // Sub 32 | uniform float dist_subAttract; //5.1 33 | uniform float dist_subRepel; //5.1 34 | 35 | uniform float force_subAttract; //1 36 | uniform float force_subRepel; //.1 37 | 38 | 39 | // Sub Sub 40 | uniform float dist_subSubAttract; //1.1 41 | uniform float dist_subSubRepel; //.1 42 | 43 | uniform float force_subSubAttract; //1 44 | uniform float force_subSubRepel; //1 45 | 46 | varying vec2 vUv; 47 | 48 | 49 | const float size = 1. / 32.; 50 | const float hSize = size / 2.; 51 | 52 | const float maxVel = 250.; 53 | 54 | vec3 springForce( vec3 toPos , vec3 fromPos , float staticLength ){ 55 | 56 | vec3 dif = fromPos - toPos; 57 | vec3 nDif = normalize( dif ); 58 | vec3 balance = nDif * staticLength; 59 | 60 | vec3 springDif = balance - dif; 61 | 62 | return 10. * springDif; 63 | 64 | } 65 | 66 | $simplex 67 | 68 | void main(){ 69 | 70 | 71 | // Making sure the tails don't go outside the heads 72 | float f_dist_spineAttract = dist_spineAttract ; 73 | float f_dist_subSubAttract = 10.;//dist_subSubAttract * vUv.y; 74 | float f_dist_subSubRepel = 10.;//dist_subSubRepel * vUv.y; 75 | float f_dist_subAttract = 10.;//dist_subAttract * vUv.y; 76 | float f_dist_subRepel = 10.;//dist_subRepel * vUv.y; 77 | float f_dist_bundleAttract = 0.;//dist_bundleAttract * vUv.y; 78 | float f_dist_bundleRepel = 0.;//dist_bundleRepel * vUv.y; 79 | 80 | vec4 oPos = texture2D( t_oPos , vUv - (.1 * size) ); 81 | vec4 pos = texture2D( t_pos , vUv - (.1 * size) ); 82 | 83 | float life = pos.w; 84 | life -= .1; 85 | 86 | // Get our velocity 87 | vec3 vel = oPos.xyz - pos.xyz; 88 | 89 | vec3 force = vec3(0.); 90 | 91 | vec4 audioForce = texture2D( t_audio , vec2( vUv.y , 0.0 ) ); 92 | vec2 aL , aL3; 93 | aL.y = length( audioForce); 94 | aL3.y = aL.y * aL.y * aL.y; 95 | 96 | float aF = min( pow( aL.y , audioPower ) , 4.0); 97 | aF *= audioAmount; 98 | aF += ( 1. - audioAmount ); 99 | 100 | audioForce = texture2D( t_audio , vec2( vUv.x , 0.0 ) ); 101 | aL.x = length( audioForce ); 102 | aL3.x = aL.x * aL.x * aL.x; 103 | 104 | // Waveyness 105 | // ( as object moves through simplex noise field, will look different ) 106 | // TODO 107 | // float w = 1. + snoise( pos * .01 ); 108 | 109 | float mIx = floor( (vUv.x -hSize ) / size ); 110 | float mIy = floor( (vUv.y -hSize) / size ); 111 | 112 | // Main Index 113 | vec2 mI = vec2( mIx , mIy ); 114 | 115 | // If we are in the first column ( spine ) 116 | if( mI.x < 1.){ 117 | 118 | 119 | 120 | 121 | 122 | // If we are the upper most spine 123 | // We are connected to the leader 124 | if( mI.y < 1.){ 125 | 126 | force += 1000.*(leader.xyz - pos.xyz); 127 | 128 | 129 | // Every other vertabrae in the spine 130 | // Gets attracted to the one above it 131 | }else{ 132 | 133 | vec4 otherPos = texture2D( t_pos , vec2( vUv.x , vUv.y - size ) ); 134 | 135 | vec3 attract = (otherPos.xyz - pos.xyz );//springForce( otherPos.xyz , pos.xyz , 20. ); 136 | force += attract * 700. * (1.-vUv.y * .5); 137 | 138 | 139 | vec3 x1 = normalize( cross( leaderVel * 1000., vec3(0.,0.,1.)) ); 140 | vec3 y1 = normalize( cross( x1 , leaderVel * 1000. )); 141 | 142 | 143 | float r = (tailID /6.) * 6.28; 144 | force += 1000.* (x1 * sin( r) + y1 * cos( r)); 145 | 146 | // force += flow * ( 1. - vUv.y); 147 | 148 | } 149 | 150 | 151 | 152 | 153 | 154 | 155 | //} 156 | 157 | 158 | // The 'sub' objects 159 | }else{ 160 | 161 | // first level 162 | if( mI.x < 5. ){ 163 | 164 | vec4 otherPos = texture2D( t_pos , vec2( hSize , vUv.y ) ); 165 | 166 | vec3 otherUp = texture2D( t_pos , vec2( hSize , vUv.y - size )).xyz; 167 | 168 | vec3 otherVel = otherUp - otherPos.xyz; 169 | if( vUv.y <= size ){ 170 | otherVel = leaderVel; 171 | } 172 | 173 | // Attract to the column 174 | vec3 attract = (otherPos.xyz - pos.xyz) * 400.;// springForce( otherPos.xyz , pos.xyz , f_dist_subAttract * aF ); 175 | force += attract;// * force_subAttract; 176 | 177 | // Get the 'index' of this verta 178 | // in the 4 first level sub objects 179 | int index = int( (vUv.x - hSize ) / size ); 180 | 181 | 182 | 183 | // Loop through all the other objects in this level 184 | for( int i = 0; i < 4; i++ ){ 185 | 186 | // As long as we are not looking at ourself, 187 | // repel the other ones 188 | if( (i - index) != 0 ){ 189 | 190 | float lookup = (float(i) * size) + 1.5 * hSize; 191 | 192 | vec4 otherPos = texture2D( t_pos , vec2( lookup , vUv.y ) ); 193 | 194 | vec3 attract = springForce( pos.xyz , otherPos.xyz , 100. * vUv.y ); 195 | 196 | 197 | vec3 x1 = normalize( cross( otherVel * 1000., vec3(0.,0.,1.)) ); 198 | vec3 y1 = normalize( cross( x1 , otherVel * 1000. )); 199 | 200 | float tailID = vUv.x * 32. - 1.; 201 | 202 | float r = (tailID /4.) * 6.28; 203 | force += 10000.* (x1 * sin( r) + y1 * cos( r)) * vUv.y; 204 | 205 | // force -= attract * 60.;// force_subRepel; 206 | 207 | } 208 | } 209 | 210 | 211 | // The 'Sub Sub' objects 212 | }else if( mI.x < 21. ){ 213 | 214 | 215 | // Which chunk 216 | 217 | int index = int( ( vUv.x - (5.* size) ) / size ); 218 | 219 | float chunk = floor( float( index / 4) ); 220 | 221 | float lookup = (chunk * size) + size; 222 | 223 | vec4 otherPos = texture2D( t_pos , vec2( lookup , vUv.y ) ); 224 | 225 | vec3 attract = (otherPos.xyz - pos.xyz);//springForce( otherPos.xyz , pos.xyz , f_dist_subSubAttract * aF ); 226 | 227 | force += attract * 100.;//force_subSubAttract; 228 | 229 | int indexInChunk = index - int( chunk * 4. ); 230 | 231 | for( int i = 0; i < 4; i++ ){ 232 | 233 | if( (i - indexInChunk) != 0 ){ 234 | 235 | float lookup = (float(i) * size) + (size*4. + hSize) + (chunk * 4. * size); 236 | 237 | vec4 otherPos = texture2D( t_pos , vec2( lookup , vUv.y ) ); 238 | vec4 otherUp = texture2D( t_pos , vec2( hSize , vUv.y ) ); 239 | vec3 oVel = vec3( otherPos.xyz - otherUp.xyz); 240 | 241 | 242 | vec3 x1 = normalize( cross( oVel * 1000., vec3(0.,0.,1.)) ); 243 | vec3 y1 = normalize( cross( x1 , oVel * 1000. )); 244 | 245 | float tailID = vUv.x * 32. - 1.; 246 | 247 | float r = (tailID /4.) * 6.28; 248 | force += 3000. * (x1 * sin( r) + y1 * cos( r)) * vUv.y; 249 | 250 | //vec3 attract = springForce( pos.xyz , otherPos.xyz , f_dist_subSubRepel * aF ); 251 | 252 | //force -= attract * force_subSubRepel; 253 | } 254 | 255 | } 256 | 257 | 258 | 259 | // Bundle around spine 260 | }else{ 261 | 262 | 263 | 264 | 265 | // If we are the upper most spine 266 | // We are connected to the leader 267 | if( mI.y < 1.){ 268 | 269 | 270 | vec4 otherPos = texture2D( t_posHead , vec2( ((((vUv.x * 32.)-21.)/11.)/6. + (tailID/6.) ) , 1. ) ); 271 | 272 | vec3 attract = (otherPos.xyz - pos.xyz );//springForce( otherPos.xyz , pos.xyz , 20. ); 273 | force += attract * 1000.; 274 | // Every other vertabrae in the spine 275 | // Gets attracted to the one above it 276 | }else{ 277 | 278 | vec4 otherPos = texture2D( t_pos , vec2( vUv.x , vUv.y - size ) ); 279 | 280 | vec3 attract = (otherPos.xyz - pos.xyz );//springForce( otherPos.xyz , pos.xyz , 20. ); 281 | force += attract * 2000.; 282 | 283 | //force += flow * ( 1. - vUv.y); 284 | 285 | } 286 | 287 | /* vec4 otherPos = texture2D( t_pos , vec2( hSize , vUv.y ) ); 288 | 289 | 290 | vec3 attract = springForce( otherPos.xyz , pos.xyz , f_dist_bundleAttract * aF ); 291 | 292 | force += attract * force_bundleAttract; 293 | 294 | int index = int( ( vUv.x - (21.* size) ) / size ); 295 | 296 | 297 | for( int i = 0; i < 11; i++ ){ 298 | 299 | if( i-index != 0 ){ 300 | 301 | float lookup = ( float(i) * size ) + ( size * 21. + hSize ); 302 | 303 | vec4 otherPos = texture2D( t_pos , vec2( lookup , vUv.y ) ); 304 | 305 | vec3 attract = springForce( pos.xyz , otherPos.xyz , f_dist_bundleRepel * aF ); 306 | 307 | force -= attract * force_bundleRepel; 308 | 309 | } 310 | 311 | }*/ 312 | 313 | } 314 | 315 | } 316 | 317 | /*vec3 dampeningForce = vel * -.1; 318 | 319 | force += dampeningForce;*/ 320 | 321 | 322 | vel += force * dT; 323 | 324 | if( length( vel ) > maxVel ){ 325 | 326 | vel = normalize( vel ) * maxVel; 327 | 328 | } 329 | 330 | vel *= .999; 331 | 332 | vec3 p = pos.xyz + vel * dT ; 333 | 334 | if( dT < .5 ){ 335 | 336 | gl_FragColor = vec4( p , life ); 337 | 338 | }else{ 339 | 340 | gl_FragColor = vec4( pos.xyz , life ); 341 | 342 | } 343 | 344 | 345 | 346 | } -------------------------------------------------------------------------------- /Maru/shaders/ss-mainTail.glsl: -------------------------------------------------------------------------------- 1 | 2 | uniform sampler2D t_oPos; 3 | uniform sampler2D t_pos; 4 | uniform sampler2D t_audio; 5 | uniform sampler2D t_posMain; 6 | 7 | uniform vec3 flow; 8 | 9 | uniform float dT; 10 | 11 | uniform float audioPower; 12 | uniform float audioAmount; 13 | 14 | uniform vec3 leader; 15 | uniform vec3 leaderVel; 16 | 17 | // Spine 18 | uniform float dist_spineAttract; // 1.1; 19 | uniform float force_spineAttract; // 1.; 20 | 21 | // SpineBundle 22 | uniform float dist_bundleAttract; // .1; 23 | uniform float dist_bundleRepel; // .4; 24 | 25 | uniform float force_bundleAttract; // .1; 26 | uniform float force_bundleRepel; // .4; 27 | 28 | 29 | // Sub 30 | uniform float dist_subAttract; //5.1 31 | uniform float dist_subRepel; //5.1 32 | 33 | uniform float force_subAttract; //1 34 | uniform float force_subRepel; //.1 35 | 36 | 37 | // Sub Sub 38 | uniform float dist_subSubAttract; //1.1 39 | uniform float dist_subSubRepel; //.1 40 | 41 | uniform float force_subSubAttract; //1 42 | uniform float force_subSubRepel; //1 43 | 44 | varying vec2 vUv; 45 | 46 | 47 | const float size = 1. / 32.; 48 | const float hSize = size / 2.; 49 | 50 | const float maxVel = 250.; 51 | 52 | vec3 springForce( vec3 toPos , vec3 fromPos , float staticLength ){ 53 | 54 | vec3 dif = fromPos - toPos; 55 | vec3 nDif = normalize( dif ); 56 | vec3 balance = nDif * staticLength; 57 | 58 | vec3 springDif = balance - dif; 59 | 60 | return 10. * springDif; 61 | 62 | } 63 | 64 | $simplex 65 | 66 | void main(){ 67 | 68 | 69 | // Making sure the tails don't go outside the heads 70 | float f_dist_spineAttract = dist_spineAttract ; 71 | float f_dist_subSubAttract = 10.;//dist_subSubAttract * vUv.y; 72 | float f_dist_subSubRepel = 10.;//dist_subSubRepel * vUv.y; 73 | float f_dist_subAttract = 10.;//dist_subAttract * vUv.y; 74 | float f_dist_subRepel = 10.;//dist_subRepel * vUv.y; 75 | float f_dist_bundleAttract = 0.;//dist_bundleAttract * vUv.y; 76 | float f_dist_bundleRepel = 0.;//dist_bundleRepel * vUv.y; 77 | 78 | vec4 oPos = texture2D( t_oPos , vUv - (.1 * size) ); 79 | vec4 pos = texture2D( t_pos , vUv - (.1 * size) ); 80 | 81 | float life = pos.w; 82 | life -= .1; 83 | 84 | // Get our velocity 85 | vec3 vel = oPos.xyz - pos.xyz; 86 | 87 | vec3 force = vec3(0.); 88 | 89 | vec4 audioForce = texture2D( t_audio , vec2( vUv.y , 0.0 ) ); 90 | vec2 aL , aL3; 91 | aL.y = length( audioForce); 92 | aL3.y = aL.y * aL.y * aL.y; 93 | 94 | float aF = min( pow( aL.y , audioPower ) , 4.0); 95 | aF *= audioAmount; 96 | aF += ( 1. - audioAmount ); 97 | 98 | audioForce = texture2D( t_audio , vec2( vUv.x , 0.0 ) ); 99 | aL.x = length( audioForce ); 100 | aL3.x = aL.x * aL.x * aL.x; 101 | 102 | // Waveyness 103 | // ( as object moves through simplex noise field, will look different ) 104 | // TODO 105 | // float w = 1. + snoise( pos * .01 ); 106 | 107 | float mIx = floor( (vUv.x -hSize ) / size ); 108 | float mIy = floor( (vUv.y -hSize) / size ); 109 | 110 | // Main Index 111 | vec2 mI = vec2( mIx , mIy ); 112 | 113 | // If we are in the first column ( spine ) 114 | if( mI.x < 1.){ 115 | 116 | 117 | // If we are the upper most spine 118 | // We are connected to the leader 119 | if( mI.y < 1.){ 120 | 121 | vec3 attract = springForce( leader.xyz , pos.xyz , f_dist_spineAttract ); 122 | force += 1000.*(leader.xyz - pos.xyz);//15. * attract * force_spineAttract; 123 | 124 | 125 | // Every other vertabrae in the spine 126 | // Gets attracted to the one above it 127 | }else{ 128 | 129 | vec4 otherPos = texture2D( t_pos , vec2( vUv.x , vUv.y - size ) ); 130 | 131 | vec3 attract = (otherPos.xyz - pos.xyz );//springForce( otherPos.xyz , pos.xyz , 20. ); 132 | force += attract * 200. * (1.-vUv.y * .5); 133 | 134 | // force += flow * ( 1. - vUv.y); 135 | 136 | } 137 | 138 | 139 | 140 | 141 | //} 142 | 143 | 144 | // The 'sub' objects 145 | }else{ 146 | 147 | // first level 148 | if( mI.x < 5. ){ 149 | 150 | vec4 otherPos = texture2D( t_pos , vec2( hSize , vUv.y ) ); 151 | 152 | vec3 otherUp = texture2D( t_pos , vec2( hSize , vUv.y - size )).xyz; 153 | 154 | vec3 otherVel = otherUp - otherPos.xyz; 155 | if( vUv.y <= size ){ 156 | otherVel = leaderVel; 157 | } 158 | 159 | // Attract to the column 160 | vec3 attract = (otherPos.xyz - pos.xyz) * 400.;// springForce( otherPos.xyz , pos.xyz , f_dist_subAttract * aF ); 161 | force += attract;// * force_subAttract; 162 | 163 | // Get the 'index' of this verta 164 | // in the 4 first level sub objects 165 | int index = int( (vUv.x - hSize ) / size ); 166 | 167 | 168 | 169 | // Loop through all the other objects in this level 170 | for( int i = 0; i < 4; i++ ){ 171 | 172 | // As long as we are not looking at ourself, 173 | // repel the other ones 174 | if( (i - index) != 0 ){ 175 | 176 | float lookup = (float(i) * size) + 1.5 * hSize; 177 | 178 | vec4 otherPos = texture2D( t_pos , vec2( lookup , vUv.y ) ); 179 | 180 | vec3 attract = springForce( pos.xyz , otherPos.xyz , 100. * vUv.y ); 181 | 182 | 183 | vec3 x1 = normalize( cross( otherVel * 1000., vec3(0.,0.,1.)) ); 184 | vec3 y1 = normalize( cross( x1 , otherVel * 1000. )); 185 | 186 | float tailID = vUv.x * 32. - 1.; 187 | 188 | float r = (tailID /4.) * 6.28; 189 | force += 10000.* (x1 * sin( r) + y1 * cos( r)) * vUv.y; 190 | 191 | // force -= attract * 60.;// force_subRepel; 192 | 193 | } 194 | } 195 | 196 | 197 | // The 'Sub Sub' objects 198 | }else if( mI.x < 21. ){ 199 | 200 | 201 | // Which chunk 202 | 203 | int index = int( ( vUv.x - (5.* size) ) / size ); 204 | 205 | float chunk = floor( float( index / 4) ); 206 | 207 | float lookup = (chunk * size) + size; 208 | 209 | vec4 otherPos = texture2D( t_pos , vec2( lookup , vUv.y ) ); 210 | 211 | vec3 attract = (otherPos.xyz - pos.xyz);//springForce( otherPos.xyz , pos.xyz , f_dist_subSubAttract * aF ); 212 | 213 | force += attract * 100.;//force_subSubAttract; 214 | 215 | int indexInChunk = index - int( chunk * 4. ); 216 | 217 | for( int i = 0; i < 4; i++ ){ 218 | 219 | if( (i - indexInChunk) != 0 ){ 220 | 221 | float lookup = (float(i) * size) + (size*4. + hSize) + (chunk * 4. * size); 222 | 223 | vec4 otherPos = texture2D( t_pos , vec2( lookup , vUv.y ) ); 224 | vec4 otherUp = texture2D( t_pos , vec2( hSize , vUv.y ) ); 225 | vec3 oVel = vec3( otherPos.xyz - otherUp.xyz); 226 | 227 | 228 | vec3 x1 = normalize( cross( oVel * 1000., vec3(0.,0.,1.)) ); 229 | vec3 y1 = normalize( cross( x1 , oVel * 1000. )); 230 | 231 | float tailID = vUv.x * 32. - 1.; 232 | 233 | float r = (tailID /4.) * 6.28; 234 | force += 3000. * aL.y * (x1 * sin( r) + y1 * cos( r)) * vUv.y; 235 | 236 | //vec3 attract = springForce( pos.xyz , otherPos.xyz , f_dist_subSubRepel * aF ); 237 | 238 | //force -= attract * force_subSubRepel; 239 | } 240 | 241 | } 242 | 243 | 244 | 245 | // Bundle around spine 246 | }else{ 247 | 248 | 249 | 250 | 251 | // If we are the upper most spine 252 | // We are connected to the leader 253 | if( mI.y < 1.){ 254 | 255 | 256 | vec4 otherPos = texture2D( t_posMain , vec2( ((vUv.x * 32.)-21.)/11. , 1. ) ); 257 | 258 | vec3 attract = (otherPos.xyz - pos.xyz );//springForce( otherPos.xyz , pos.xyz , 20. ); 259 | force += attract * 1000.; 260 | // Every other vertabrae in the spine 261 | // Gets attracted to the one above it 262 | }else{ 263 | 264 | vec4 otherPos = texture2D( t_pos , vec2( vUv.x , vUv.y - size ) ); 265 | 266 | vec3 attract = (otherPos.xyz - pos.xyz );//springForce( otherPos.xyz , pos.xyz , 20. ); 267 | force += attract * 1000.; 268 | 269 | //force += flow * ( 1. - vUv.y); 270 | 271 | } 272 | 273 | /* vec4 otherPos = texture2D( t_pos , vec2( hSize , vUv.y ) ); 274 | 275 | 276 | vec3 attract = springForce( otherPos.xyz , pos.xyz , f_dist_bundleAttract * aF ); 277 | 278 | force += attract * force_bundleAttract; 279 | 280 | int index = int( ( vUv.x - (21.* size) ) / size ); 281 | 282 | 283 | for( int i = 0; i < 11; i++ ){ 284 | 285 | if( i-index != 0 ){ 286 | 287 | float lookup = ( float(i) * size ) + ( size * 21. + hSize ); 288 | 289 | vec4 otherPos = texture2D( t_pos , vec2( lookup , vUv.y ) ); 290 | 291 | vec3 attract = springForce( pos.xyz , otherPos.xyz , f_dist_bundleRepel * aF ); 292 | 293 | force -= attract * force_bundleRepel; 294 | 295 | } 296 | 297 | }*/ 298 | 299 | } 300 | 301 | } 302 | 303 | /*vec3 dampeningForce = vel * -.1; 304 | 305 | force += dampeningForce;*/ 306 | 307 | 308 | vel += force * dT; 309 | 310 | if( length( vel ) > maxVel ){ 311 | 312 | vel = normalize( vel ) * maxVel; 313 | 314 | } 315 | 316 | vel *= .999; 317 | 318 | vec3 p = pos.xyz + vel * (.8 + 1.4 * aL.y) * dT ; 319 | 320 | if( dT < .5 ){ 321 | 322 | gl_FragColor = vec4( p , life ); 323 | 324 | }else{ 325 | 326 | gl_FragColor = vec4( pos.xyz , life ); 327 | 328 | } 329 | 330 | 331 | 332 | } 333 | -------------------------------------------------------------------------------- /Maru/shaders/triplanarMap.glsl: -------------------------------------------------------------------------------- 1 | vec3 triplanarMap( vec3 normal , vec3 position , sampler2D normalTexture , float normalScale , float textureScale ){ 2 | 3 | // FROM @thespite 4 | vec3 n = normalize( normal.xyz ); 5 | vec3 blend_weights = abs( n ); 6 | blend_weights = ( blend_weights - 0.2 ) * 7.; 7 | blend_weights = max( blend_weights, 0. ); 8 | blend_weights /= ( blend_weights.x + blend_weights.y + blend_weights.z ); 9 | 10 | vec2 coord1 = position.yz * textureScale; 11 | vec2 coord2 = position.zx * textureScale; 12 | vec2 coord3 = position.xy * textureScale; 13 | 14 | vec3 bump1 = texture2D( normalTexture , coord1 ).rgb; 15 | vec3 bump2 = texture2D( normalTexture , coord2 ).rgb; 16 | vec3 bump3 = texture2D( normalTexture , coord3 ).rgb; 17 | 18 | vec3 blended_bump = bump1 * blend_weights.xxx + 19 | bump2 * blend_weights.yyy + 20 | bump3 * blend_weights.zzz; 21 | 22 | vec3 tanX = vec3( normal.x, -normal.z, normal.y); 23 | vec3 tanY = vec3( normal.z, normal.y, -normal.x); 24 | vec3 tanZ = vec3(-normal.y, normal.x, normal.z); 25 | vec3 blended_tangent = tanX * blend_weights.xxx + 26 | tanY * blend_weights.yyy + 27 | tanZ * blend_weights.zzz; 28 | 29 | vec3 normalTex = blended_bump * 2.0 - 1.0; 30 | normalTex.xy *= normalScale; 31 | normalTex.y *= -1.; 32 | normalTex = normalize( normalTex ); 33 | mat3 tsb = mat3( normalize( blended_tangent ), normalize( cross( normal, blended_tangent ) ), normalize( normal ) ); 34 | vec3 finalNormal = tsb * normalTex; 35 | 36 | 37 | return normalize(finalNormal); 38 | 39 | 40 | 41 | } 42 | -------------------------------------------------------------------------------- /Maru/shaders/vs-furryHead.glsl: -------------------------------------------------------------------------------- 1 | 2 | uniform vec3 lightPos; 3 | uniform sampler2D t_pos; 4 | 5 | varying vec3 vView; 6 | varying vec3 vNormal; 7 | varying vec2 vUv; 8 | 9 | varying mat3 vNormalMat; 10 | varying vec3 vLightDir; 11 | 12 | const float size = 1. / 32.; 13 | const float hSize = size / 2.; 14 | 15 | 16 | 17 | void main(void) 18 | { 19 | 20 | 21 | vec3 pos = texture2D( t_pos , position.xy ).xyz; 22 | 23 | vUv = position.xy; 24 | 25 | vec2 uvL = vUv; 26 | uvL.x -= size; 27 | if( uvL.x < 0. ){ 28 | uvL.x = 1. - hSize; 29 | } 30 | vec4 posL = texture2D( t_pos , uvL ); 31 | 32 | vec2 uvR = vUv; 33 | uvR.x += size; 34 | 35 | if( uvR.x > 1. ){ 36 | uvR.x = 0. + hSize; 37 | } 38 | vec4 posR = texture2D( t_pos , uvR ); 39 | 40 | 41 | vec2 uvU = vUv; 42 | uvU.y -= size; 43 | if( uvU.y < 0. ){ 44 | uvU.y = vUv.y; 45 | } 46 | vec4 posU = texture2D( t_pos , uvU ); 47 | 48 | vec2 uvD = vUv; 49 | uvD.y += size; 50 | 51 | if( uvD.y > 1. ){ 52 | uvD.y = vUv.y; 53 | } 54 | vec4 posD = texture2D( t_pos , uvD ); 55 | 56 | 57 | vec3 difX = posL.xyz - posR.xyz; 58 | vec3 difY = posD.xyz - posU.xyz; 59 | 60 | vec3 normal = normalize( cross( difX , difY ) ); 61 | 62 | 63 | gl_Position = projectionMatrix * modelViewMatrix * vec4( pos , 1.0 ); 64 | 65 | vView = modelViewMatrix[3].xyz; 66 | vNormal = normalMatrix * normal ; 67 | vNormalMat = normalMatrix; 68 | 69 | vec3 lightDir = normalize( lightPos - (modelViewMatrix * vec4( pos , 1.0 )).xyz ); 70 | 71 | vLightDir = lightDir; 72 | 73 | } 74 | -------------------------------------------------------------------------------- /Maru/shaders/vs-furryParticles.glsl: -------------------------------------------------------------------------------- 1 | uniform sampler2D t_pos; 2 | uniform sampler2D t_audio; 3 | 4 | uniform float dpr; 5 | uniform float particleSize; 6 | 7 | attribute vec2 uv2; 8 | 9 | uniform vec3 color1; 10 | uniform vec3 color2; 11 | uniform vec3 color3; 12 | uniform vec3 color4; 13 | 14 | varying vec3 vColor; 15 | 16 | varying vec2 vUv; 17 | 18 | varying vec2 vID; 19 | 20 | const float size = 1. / 32.; 21 | const float hSize = size / 2.; 22 | const vec3 lightPos = vec3( 1.0 , 1.0 , 1.0 ); 23 | 24 | void main(){ 25 | 26 | vec4 a = texture2D( t_audio , vec2( position.y * .5 , 0.)); 27 | 28 | vec4 pos = texture2D( t_pos , position.xy ); 29 | 30 | vec3 left = vec3(1.,0.,0.);///cross( vView , vec3(0.,1.,0.) ); 31 | vec3 up = vec3(0.,1.,0.); 32 | vUv = uv2; 33 | vID = vec2( position.y , 0. ); 34 | 35 | 36 | vec3 fPos = pos.xyz + length(a) * ((uv2.x - .5) * left + (uv2.y-.5) * up) * 10. * position.y; 37 | 38 | 39 | vec4 mvPos = modelViewMatrix * vec4( fPos , 1.0 ); 40 | gl_Position = projectionMatrix * mvPos; 41 | 42 | } 43 | -------------------------------------------------------------------------------- /Maru/shaders/vs-furryTail.glsl: -------------------------------------------------------------------------------- 1 | uniform sampler2D t_pos; 2 | uniform sampler2D t_oPos; 3 | uniform sampler2D t_ooPos; 4 | uniform sampler2D t_audio; 5 | uniform float lineWidth; 6 | 7 | attribute vec3 color; 8 | attribute float idInTail; 9 | 10 | varying vec3 vColor; 11 | varying vec3 vNorm; 12 | 13 | varying vec3 vView; 14 | varying vec3 vLightDir; 15 | varying vec2 vID; 16 | varying vec2 vUv; 17 | 18 | const vec3 lightPos = vec3( 1.0 , 1.0 , 1.0 ); 19 | 20 | 21 | vec3 hsv(vec3 c) 22 | { 23 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 24 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 25 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); 26 | } 27 | 28 | 29 | // Optimised by Alan Zucconi 30 | vec3 bump3y (vec3 x, vec3 yoffset) 31 | { 32 | vec3 y = vec3( 1. - x * x ); 33 | y = clamp(y-yoffset,0.,1.); 34 | return y; 35 | } 36 | vec3 spectral (float w) 37 | { 38 | // w: [400, 700] 39 | // x: [0, 1] 40 | float x = w;// clamp((w - 400.0)/ 300.0,0.,1.); 41 | 42 | const vec3 cs = vec3(3.54541723, 2.86670055, 2.29421995); 43 | const vec3 xs = vec3(0.69548916, 0.49416934, 0.28269708); 44 | const vec3 ys = vec3(0.02320775, 0.15936245, 0.53520021); 45 | 46 | return bump3y ( cs * (x - xs), ys); 47 | } 48 | 49 | 50 | 51 | void main(){ 52 | 53 | vec4 pos = texture2D( t_pos , position.xy ); 54 | vec4 posO = texture2D( t_pos , color.xy ); 55 | 56 | vec4 a = texture2D( t_audio , vec2(position.y ,0.) ); 57 | 58 | vec3 dir = normalize(pos.xyz - posO.xyz) *2. * (color.z-.5); 59 | 60 | 61 | vView = viewMatrix[3].xyz; 62 | 63 | vec3 left = normalize(cross(dir, vec3(0.,0.,1.))); 64 | 65 | vec3 fPos = pos.xyz - left * 10. * position.y * lineWidth * (length(a)+3.)* (position.z -.5); 66 | 67 | 68 | vID = vec2(idInTail,position.y); 69 | 70 | vNorm = vView; 71 | 72 | vUv = vec2( position.z , color.z ); 73 | 74 | 75 | 76 | 77 | vColor = vec3(44.,43.,71.)/255.; 78 | 79 | 80 | if( position.x > 20.5/32. || color.x > 20.5/32. ){ 81 | // fPos = vec3(0.,0.,0.); 82 | } 83 | 84 | 85 | vec3 lightDir = normalize( lightPos - (modelViewMatrix * vec4( fPos , 1.0 )).xyz ); 86 | vLightDir = lightDir; 87 | 88 | //vPos = position; 89 | vec4 mvPos = modelViewMatrix * vec4( fPos , 1.0 ); 90 | gl_Position = projectionMatrix * mvPos; 91 | 92 | 93 | 94 | } 95 | -------------------------------------------------------------------------------- /Maru/shaders/vs-mainTail.glsl: -------------------------------------------------------------------------------- 1 | uniform sampler2D t_pos; 2 | uniform sampler2D t_oPos; 3 | uniform sampler2D t_ooPos; 4 | 5 | 6 | uniform vec3 color1; 7 | uniform vec3 color2; 8 | uniform vec3 color3; 9 | uniform vec3 color4; 10 | 11 | attribute vec3 color; 12 | 13 | varying vec3 vColor; 14 | varying vec3 vNorm; 15 | 16 | varying vec3 vView; 17 | varying vec3 vLightDir; 18 | 19 | const vec3 lightPos = vec3( 1.0 , 1.0 , 1.0 ); 20 | 21 | 22 | void main(){ 23 | 24 | vec4 pos = texture2D( t_pos , position.xy ); 25 | vec4 oPos = texture2D( t_oPos , position.xy ); 26 | vec4 ooPos = texture2D( t_ooPos , position.xy ); 27 | 28 | vec3 oDir1 = normalize( oPos.xyz - pos.xyz ); 29 | vec3 oDir2 = normalize( oPos.xyz - ooPos.xyz ); 30 | 31 | vec3 aveDir = (oDir1 - oDir2) /2.; 32 | vNorm = -normalize(aveDir); 33 | 34 | if( color.g < .1 ){ 35 | 36 | vColor = color1;//color1.xyz; 37 | 38 | }else if( color.g < 1.1 ){ 39 | vColor = color2; 40 | }else if( color.g < 2.1 ){ 41 | vColor = color3; 42 | }else if( color.g < 3.1 ){ 43 | vColor = color4; 44 | } 45 | 46 | vView = modelViewMatrix[3].xyz; 47 | 48 | vec3 lightDir = normalize( lightPos - (modelViewMatrix * vec4( pos.xyz , 1.0 )).xyz ); 49 | vLightDir = lightDir; 50 | 51 | //vPos = position; 52 | vec4 mvPos = modelViewMatrix * vec4( pos.xyz , 1.0 ); 53 | gl_Position = projectionMatrix * mvPos; 54 | 55 | 56 | 57 | } 58 | -------------------------------------------------------------------------------- /Maru/shaders/vs-pass.glsl: -------------------------------------------------------------------------------- 1 | varying vec2 vUv; 2 | 3 | void main() { 4 | vUv = uv; 5 | gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 ); 6 | } 7 | -------------------------------------------------------------------------------- /Maru/shaders/vs-planet.glsl: -------------------------------------------------------------------------------- 1 | 2 | uniform vec3 lightPos; 3 | uniform float time; 4 | 5 | 6 | varying vec3 vPos; 7 | varying vec3 vNorm; 8 | varying vec3 vView; 9 | 10 | varying mat3 vNormalMat; 11 | varying vec3 vLightDir; 12 | varying float vDisplacement; 13 | 14 | varying vec3 vMVPos; 15 | 16 | $simplex 17 | 18 | 19 | vec3 toSpherical( vec3 pos ){ 20 | 21 | float r = length( pos ); 22 | float t = atan( pos.y / pos.x ); 23 | float p = acos( pos.z / r ); 24 | 25 | return vec3( r , t , p ); 26 | 27 | } 28 | 29 | vec3 toCart( vec3 rtp ){ 30 | 31 | float x = rtp.x * cos( rtp.y ) * sin( rtp.z ); 32 | float y = rtp.x * sin( rtp.y ) * sin( rtp.z ); 33 | float z = rtp.x * cos( rtp.z ); 34 | 35 | return vec3( x , y , z ); 36 | 37 | } 38 | 39 | vec3 displace( vec3 p , vec3 o ){ 40 | 41 | float noise = snoise( normalize(p) * 2. + o ); 42 | 43 | vec3 nP = p * (1. + noise * .1 ); 44 | 45 | return nP; 46 | 47 | 48 | } 49 | 50 | void main(){ 51 | 52 | vPos = position; 53 | vNorm = normal; 54 | 55 | vView = modelViewMatrix[3].xyz; 56 | vNormalMat = normalMatrix; 57 | 58 | 59 | vNorm = normal;//normalize( cross( difP , difT )); 60 | 61 | vec3 lightDir = normalize( lightPos - (modelViewMatrix * vec4( vPos , 1.0 )).xyz ); 62 | vLightDir = lightDir; 63 | 64 | vMVPos = (modelViewMatrix * vec4( vPos , 1.0 )).xyz; 65 | 66 | gl_Position = projectionMatrix * modelViewMatrix * vec4( vPos , 1.0 ); 67 | 68 | } 69 | -------------------------------------------------------------------------------- /Maru/shaders/vs-planetDisplace.glsl: -------------------------------------------------------------------------------- 1 | 2 | uniform vec3 lightPos; 3 | uniform float time; 4 | uniform sampler2D t_audio; 5 | 6 | varying vec3 vPos; 7 | varying vec3 vNorm; 8 | varying vec3 vView; 9 | 10 | varying mat3 vNormalMat; 11 | varying vec3 vLightDir; 12 | varying float vDisplacement; 13 | 14 | varying vec3 vMVPos; 15 | 16 | $simplex 17 | 18 | 19 | vec3 toSpherical( vec3 pos ){ 20 | 21 | float r = length( pos ); 22 | float t = atan( pos.y / pos.x ); 23 | float p = acos( pos.z / r ); 24 | 25 | return vec3( r , t , p ); 26 | 27 | } 28 | 29 | vec3 toCart( vec3 rtp ){ 30 | 31 | float x = rtp.x * cos( rtp.y ) * sin( rtp.z ); 32 | float y = rtp.x * sin( rtp.y ) * sin( rtp.z ); 33 | float z = rtp.x * cos( rtp.z ); 34 | 35 | return vec3( x , y , z ); 36 | 37 | } 38 | 39 | vec3 displace( vec3 p , vec3 o ){ 40 | 41 | float noise = snoise( normalize(p) * 2. + o ); 42 | 43 | vec3 nP = p * (1. + noise * .1 ); 44 | 45 | return nP; 46 | 47 | 48 | } 49 | 50 | void main(){ 51 | 52 | vPos = position; 53 | vNorm = normal; 54 | 55 | vView = modelViewMatrix[3].xyz; 56 | vNormalMat = normalMatrix; 57 | 58 | 59 | vNorm = normal;//normalize( cross( difP , difT )); 60 | 61 | vec3 lightDir = normalize( lightPos - (modelViewMatrix * vec4( vPos , 1.0 )).xyz ); 62 | vLightDir = lightDir; 63 | 64 | vec3 a = texture2D( t_audio , vec2( vNorm.x , 0.0 ) ).xyz; 65 | vPos += vNorm * a * 20.; 66 | 67 | vMVPos = (modelViewMatrix * vec4( vPos , 1.0 )).xyz; 68 | 69 | gl_Position = projectionMatrix * modelViewMatrix * vec4( vPos , 1.0 ); 70 | 71 | } 72 | -------------------------------------------------------------------------------- /Maru/shaders/vs-poly.glsl: -------------------------------------------------------------------------------- 1 | 2 | uniform vec3 lightPos; 3 | uniform float time; 4 | uniform sampler2D t_audio; 5 | 6 | varying vec3 vPos; 7 | varying vec3 vNorm; 8 | varying vec3 vView; 9 | 10 | varying mat3 vNormalMat; 11 | varying vec3 vLightDir; 12 | varying float vDisplacement; 13 | 14 | varying vec3 vMVPos; 15 | varying vec3 vWorld; 16 | 17 | $simplex 18 | 19 | 20 | vec3 toSpherical( vec3 pos ){ 21 | 22 | float r = length( pos ); 23 | float t = atan( pos.y / pos.x ); 24 | float p = acos( pos.z / r ); 25 | 26 | return vec3( r , t , p ); 27 | 28 | } 29 | 30 | vec3 toCart( vec3 rtp ){ 31 | 32 | float x = rtp.x * cos( rtp.y ) * sin( rtp.z ); 33 | float y = rtp.x * sin( rtp.y ) * sin( rtp.z ); 34 | float z = rtp.x * cos( rtp.z ); 35 | 36 | return vec3( x , y , z ); 37 | 38 | } 39 | 40 | vec3 displace( vec3 p , vec3 o ){ 41 | 42 | float noise = snoise( normalize(p) * 2. + o ); 43 | 44 | vec3 nP = p * (1. + noise * .1 ); 45 | 46 | return nP; 47 | 48 | 49 | } 50 | 51 | void main(){ 52 | 53 | vPos = position; 54 | vNorm = normal; 55 | 56 | vView = modelViewMatrix[3].xyz; 57 | vNormalMat = normalMatrix; 58 | 59 | 60 | vNorm = normal;//normalize( cross( difP , difT )); 61 | 62 | vec3 lightDir = normalize( lightPos - (modelViewMatrix * vec4( vPos , 1.0 )).xyz ); 63 | vLightDir = lightDir; 64 | 65 | float n = snoise( vPos * .01 + time * .2); 66 | vec3 a = texture2D( t_audio , vec2( abs(n * .5) , 0.0 ) ).xyz; 67 | vPos += vNorm * a * 20.; 68 | 69 | vWorld = (modelMatrix * vec4(vPos,1.)).xyz; 70 | 71 | vMVPos = (modelViewMatrix * vec4( vPos , 1.0 )).xyz; 72 | 73 | gl_Position = projectionMatrix * modelViewMatrix * vec4( vPos , 1.0 ); 74 | 75 | } -------------------------------------------------------------------------------- /Maru/shaders/vs-polyOrg.glsl: -------------------------------------------------------------------------------- 1 | 2 | uniform vec3 lightPos; 3 | uniform float time; 4 | uniform sampler2D t_audio; 5 | 6 | varying vec3 vPos; 7 | varying vec3 vNorm; 8 | varying vec3 vView; 9 | 10 | varying mat3 vNormalMat; 11 | varying vec3 vLightDir; 12 | varying float vDisplacement; 13 | 14 | varying vec3 vMVPos; 15 | varying vec3 vWorld; 16 | varying vec3 vCol; 17 | 18 | $simplex 19 | 20 | 21 | vec3 toSpherical( vec3 pos ){ 22 | 23 | float r = length( pos ); 24 | float t = atan( pos.y / pos.x ); 25 | float p = acos( pos.z / r ); 26 | 27 | return vec3( r , t , p ); 28 | 29 | } 30 | 31 | vec3 toCart( vec3 rtp ){ 32 | 33 | float x = rtp.x * cos( rtp.y ) * sin( rtp.z ); 34 | float y = rtp.x * sin( rtp.y ) * sin( rtp.z ); 35 | float z = rtp.x * cos( rtp.z ); 36 | 37 | return vec3( x , y , z ); 38 | 39 | } 40 | 41 | vec3 displace( vec3 p , vec3 o ){ 42 | 43 | float noise = snoise( normalize(p) * 2. + o ); 44 | 45 | vec3 nP = p * (1. + noise * .1 ); 46 | 47 | return nP; 48 | 49 | 50 | } 51 | 52 | void main(){ 53 | 54 | vPos = position; 55 | vNorm = normal; 56 | 57 | vView = modelViewMatrix[3].xyz; 58 | vNormalMat = normalMatrix; 59 | 60 | 61 | vNorm = normal;//normalize( cross( difP , difT )); 62 | 63 | vec3 lightDir = normalize( lightPos - (modelViewMatrix * vec4( vPos , 1.0 )).xyz ); 64 | vLightDir = lightDir; 65 | 66 | float n = snoise( vPos * .01 + time * .2); 67 | vec3 a = texture2D( t_audio , vec2( abs(n * .5) , 0.0 ) ).xyz; 68 | vPos += vNorm * a * 20.; 69 | vCol = a; 70 | 71 | vWorld = (modelMatrix * vec4(vPos,1.)).xyz; 72 | 73 | vMVPos = (modelViewMatrix * vec4( vPos , 1.0 )).xyz; 74 | 75 | gl_Position = projectionMatrix * modelViewMatrix * vec4( vPos , 1.0 ); 76 | 77 | } -------------------------------------------------------------------------------- /Maru/shaders/vs-polyOutline.glsl: -------------------------------------------------------------------------------- 1 | 2 | uniform vec3 lightPos; 3 | uniform float time; 4 | uniform sampler2D t_audio; 5 | 6 | varying vec3 vPos; 7 | varying vec3 vNorm; 8 | varying vec3 vView; 9 | 10 | varying mat3 vNormalMat; 11 | varying vec3 vLightDir; 12 | varying float vDisplacement; 13 | 14 | //varying vec3 vMVPos; 15 | 16 | $simplex 17 | 18 | 19 | vec3 toSpherical( vec3 pos ){ 20 | 21 | float r = length( pos ); 22 | float t = atan( pos.y / pos.x ); 23 | float p = acos( pos.z / r ); 24 | 25 | return vec3( r , t , p ); 26 | 27 | } 28 | 29 | vec3 toCart( vec3 rtp ){ 30 | 31 | float x = rtp.x * cos( rtp.y ) * sin( rtp.z ); 32 | float y = rtp.x * sin( rtp.y ) * sin( rtp.z ); 33 | float z = rtp.x * cos( rtp.z ); 34 | 35 | return vec3( x , y , z ); 36 | 37 | } 38 | 39 | vec3 displace( vec3 p , vec3 o ){ 40 | 41 | float noise = snoise( normalize(p) * 2. + o ); 42 | 43 | vec3 nP = p * (1. + noise * .1 ); 44 | 45 | return nP; 46 | 47 | 48 | } 49 | 50 | void main(){ 51 | 52 | vPos = position; 53 | vNorm = normal; 54 | 55 | vView = modelViewMatrix[3].xyz; 56 | vNormalMat = normalMatrix; 57 | 58 | 59 | vNorm = normal;//normalize( cross( difP , difT )); 60 | 61 | vec3 lightDir = normalize( lightPos - (modelViewMatrix * vec4( vPos , 1.0 )).xyz ); 62 | vLightDir = lightDir; 63 | float n = snoise( vPos * .01 + time * .2); 64 | vec3 a = texture2D( t_audio , vec2( abs(n * .5) , 0.0 ) ).xyz; 65 | vPos += vNorm * a * 20.; 66 | vPos *= 1.1; 67 | 68 | vec3 wPos = (modelMatrix * vec4( vPos , 1.0 )).xyz; 69 | wPos += normalize(vView) * 40.; 70 | 71 | //vMVPos = (viewMatrix * vec4( wPos , 1.0 )).xyz; 72 | 73 | gl_Position = projectionMatrix * viewMatrix * vec4( wPos , 1.0 ); 74 | 75 | } -------------------------------------------------------------------------------- /Maru/shaders/vs-render.glsl: -------------------------------------------------------------------------------- 1 | uniform sampler2D t_pos; 2 | uniform sampler2D t_vel; 3 | uniform sampler2D t_audio; 4 | 5 | varying vec4 vVel; 6 | varying vec4 vPos; 7 | varying vec4 vAudio; 8 | 9 | varying vec2 vUv; 10 | 11 | void main(){ 12 | 13 | vUv = position.xy; 14 | 15 | vPos = texture2D( t_pos , position.xy ); 16 | vVel = texture2D( t_vel , position.xy ); 17 | vAudio = texture2D( t_audio , vec2( position.x , 0. ) ); 18 | 19 | vec3 pos = vPos.xyz; 20 | 21 | 22 | 23 | vec4 mvPos = modelViewMatrix * vec4( pos , 1.0 ); 24 | 25 | //gl_PointSize = min( 100. ,3.+ 10. * abs(vAudio.x* vAudio.x* vAudio.x)) / length( mvPos) ; 26 | 27 | //gl_PointSize = gl_PointSize * 50.; 28 | 29 | gl_PointSize = min( 100. , 500. * vAudio.x * vAudio.x * vAudio.y / length( mvPos )); 30 | //gl_PointSize = 10.; 31 | gl_Position = projectionMatrix * mvPos; 32 | 33 | } 34 | -------------------------------------------------------------------------------- /Maru/stats.min.js: -------------------------------------------------------------------------------- 1 | // stats.js - http://github.com/mrdoob/stats.js 2 | var Stats=function(){var l=Date.now(),m=l,g=0,n=Infinity,o=0,h=0,p=Infinity,q=0,r=0,s=0,f=document.createElement("div");f.id="stats";f.addEventListener("mousedown",function(b){b.preventDefault();t(++s%2)},!1);f.style.cssText="width:80px;opacity:0.9;cursor:pointer";var a=document.createElement("div");a.id="fps";a.style.cssText="padding:0 0 3px 3px;text-align:left;background-color:#002";f.appendChild(a);var i=document.createElement("div");i.id="fpsText";i.style.cssText="color:#0ff;font-family:Helvetica,Arial,sans-serif;font-size:9px;font-weight:bold;line-height:15px"; 3 | i.innerHTML="FPS";a.appendChild(i);var c=document.createElement("div");c.id="fpsGraph";c.style.cssText="position:relative;width:74px;height:30px;background-color:#0ff";for(a.appendChild(c);74>c.children.length;){var j=document.createElement("span");j.style.cssText="width:1px;height:30px;float:left;background-color:#113";c.appendChild(j)}var d=document.createElement("div");d.id="ms";d.style.cssText="padding:0 0 3px 3px;text-align:left;background-color:#020;display:none";f.appendChild(d);var k=document.createElement("div"); 4 | k.id="msText";k.style.cssText="color:#0f0;font-family:Helvetica,Arial,sans-serif;font-size:9px;font-weight:bold;line-height:15px";k.innerHTML="MS";d.appendChild(k);var e=document.createElement("div");e.id="msGraph";e.style.cssText="position:relative;width:74px;height:30px;background-color:#0f0";for(d.appendChild(e);74>e.children.length;)j=document.createElement("span"),j.style.cssText="width:1px;height:30px;float:left;background-color:#131",e.appendChild(j);var t=function(b){s=b;switch(s){case 0:a.style.display= 5 | "block";d.style.display="none";break;case 1:a.style.display="none",d.style.display="block"}};return{REVISION:11,domElement:f,setMode:t,begin:function(){l=Date.now()},end:function(){var b=Date.now();g=b-l;n=Math.min(n,g);o=Math.max(o,g);k.textContent=g+" MS ("+n+"-"+o+")";var a=Math.min(30,30-30*(g/200));e.appendChild(e.firstChild).style.height=a+"px";r++;b>m+1E3&&(h=Math.round(1E3*r/(b-m)),p=Math.min(p,h),q=Math.max(q,h),i.textContent=h+" FPS ("+p+"-"+q+")",a=Math.min(30,30-30*(h/100)),c.appendChild(c.firstChild).style.height= 6 | a+"px",m=b,r=0);return b},update:function(){l=this.end()}}}; 7 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | 2 | Hey There! I see you are looking at the source and wanted to warn/inform you of a few things: 3 | 4 | First off, as usual you are looking at a piece that is more artistic than technical, 5 | I have no idea what I am doing ( especially in the HTML / CSS ) so please forgive any 6 | hilarious oversights. 7 | 8 | Second off, if you are wondering 'how in the heck does this work', Check out the 9 | library I created for doing physics based gpu programming in the web over at: 10 | 11 | http://cabbi.bo/PhysicsRenderer/ 12 | 13 | There are also a few other pieces of code I think are pretty usuable such as 14 | 15 | ShaderLoader ( http://cabbi.bo/ShaderLoader/ ) 16 | Looper 17 | LoadedAudio 18 | 19 | Other than that, you will be digging into a little bit of code that is like the 20 | original sketch that gets painted over and hidden forever. That being said, if 21 | you want to know more *please* reach out to me on twitter. 22 | 23 | I love you and thanks for stopping by! 24 | @cabbibo 25 | -------------------------------------------------------------------------------- /WARP303_Packshot_3000.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/WARP303_Packshot_3000.jpg -------------------------------------------------------------------------------- /WARP303_Packshot_3000T.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/WARP303_Packshot_3000T.png -------------------------------------------------------------------------------- /alte haas grotesk licence.rtf: -------------------------------------------------------------------------------- 1 | {\rtf1\ansi\ansicpg1252\cocoartf949\cocoasubrtf270 2 | {\fonttbl\f0\fswiss\fcharset0 Helvetica;} 3 | {\colortbl;\red255\green255\blue255;} 4 | \paperw11900\paperh16840\margl1440\margr1440\vieww9000\viewh8400\viewkind0 5 | \pard\tx566\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\ql\qnatural\pardirnatural 6 | 7 | \f0\fs24 \cf0 Alte Haas Grotesk is a typeface that look like an helvetica printed in an old Muller-Brockmann Book.\ 8 | \ 9 | These fonts are freeware and can be distributed as long as they are \ 10 | together with this text file. \ 11 | \ 12 | I would appreciate very much to see what you have done with it anyway.\ 13 | \ 14 | yann le coroller \ 15 | www.yannlecoroller.com\ 16 | yann@lecoroller.com} -------------------------------------------------------------------------------- /index.html: -------------------------------------------------------------------------------- 1 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 50 | 51 | Plaid - Polymer 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 80 | 81 | 82 | 83 | 84 | 85 | 304 | 305 | 306 | 307 | 308 | 310 | 311 | 312 |
313 | 314 |
315 |
316 | 317 |

THE NEW ALBUM. AVAILABLE 7TH JUNE 2019 ON WARP RECORDS

318 |
319 |
320 | 321 | 322 |
ENTER
(DESKTOP ONLY)
323 |
324 |

PRE-ORDER

 325 | 326 |

PRE-SAVE   

 327 |
328 |
329 | 330 | 331 | 332 | 478 | 479 | -------------------------------------------------------------------------------- /plaid.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/plaid.png -------------------------------------------------------------------------------- /plaidlogo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/plaidlogo.png -------------------------------------------------------------------------------- /poly.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/poly.png -------------------------------------------------------------------------------- /polyText.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/polyText.png -------------------------------------------------------------------------------- /polymer-cover-object-2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cabbibo/PlaidPolymer/0fb2ef297d33b560f6fdefe223ba5a72d5e55f38/polymer-cover-object-2.png --------------------------------------------------------------------------------