3e:null 3f:["$","title",null,{"children":"GPGPU Billboard Particles | Mika I. | Observable"}] 45:T1199,class GPGPU { constructor(renderer, textureSize) { const gl = renderer.getContext() // we need FLOAT Textures to store positions //https://github.com/KhronosGroup/WebGL/blob/master/sdk/tests/conformance/extensions/oes-texture-float.html if (!gl.getExtension('OES_texture_float')) { alert('client support error - float textures not supported') throw new Error('float textures not supported') } // we need to access textures from within the vertex shader //https://github.com/KhronosGroup/WebGL/blob/90ceaac0c4546b1aad634a6a5c4d2dfae9f4d124/conformance-suites/1.0.0/extra/webgl-info.html if (gl.getParameter(gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS) === 0) { alert('client support error - vertex shader cannot read textures') throw new Error('vertex shader cannot read textures') } this.renderer = renderer // GPGPU buffer textures // A this.positionsA = new THREE.DataTexture( preloadedDataBuffer(textureSize), textureSize, textureSize, THREE.RGBAFormat, THREE.FloatType) // B this.positionsB = new THREE.DataTexture( null, // will be copied over from A // preloadedDataBuffer(textureSize), textureSize, textureSize, THREE.RGBAFormat, THREE.FloatType) this.positionsA.needsUpdate = true // rtt setup this.scene = new THREE.Scene() this.orthoCamera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1) // create a target texture const options = { wrapS: THREE.ClampToEdgeWrapping, wrapT: THREE.ClampToEdgeWrapping, stencilBuffer: false, minFilter: THREE.NearestFilter, // important as we want to sample square pixels magFilter: THREE.NearestFilter, format: THREE.RGBAFormat, type: (/(iPad|iPhone|iPod)/g.test(navigator.userAgent)) ? THREE.HalfFloatType : THREE.FloatType, } this.rtts = [ new THREE.WebGLRenderTarget(textureSize, textureSize, options), new THREE.WebGLRenderTarget(textureSize, textureSize, options) ] this.rttIndex = 0 // the simulation: //create a bi-unit quadrilateral and uses the simulation material to update the Float Texture let geom = new THREE.BufferGeometry() geom.addAttribute('position', new THREE.BufferAttribute(new Float32Array([ -1, -1, 0, 1, -1, 0, 1, 1, 0, -1, -1, 0, 1, 1, 0, -1, 1, 0 ]), 3)) geom.addAttribute('uv', new THREE.BufferAttribute(new Float32Array([0,1, 1,1, 1,0, 0,1, 1,0, 0,0 ]), 2)) this.simulationMaterial = new THREE.ShaderMaterial({ uniforms: { positions: {type: 't', value: this.positionsA }, elapsedTime: {type: 'f', value: 0}, delta: {type: 'f', value: 0}, }, vertexShader: ` varying vec2 vUv; void main() { vUv = vec2(uv.x, uv.y); gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 ); } `, fragmentShader: ` #define PI 3.1415926536 #define PI2 6.28318530718 uniform float elapsedTime; uniform float delta; uniform sampler2D positions; // Data Texture containing original positions varying vec2 vUv; void main() { vec4 sample = texture2D(positions, vec2(vUv.x, 1.0 - vUv.y)); vec3 pos = sample.xyz; float lifetime = sample.a; // increase lifetime by delta, cap it at 1 and start over lifetime = mod(lifetime + delta, 1.0); float radius = 125.0; float radius2 = 250.0; float index = vUv.x * ${textureSize}.0 + vUv.y * ${textureSize}.0 * ${textureSize}.0; /* *************************** */ pos.x = vUv.x * radius2 - radius; pos.y = vUv.y * radius2 - radius; //pos.x += sin(lifetime * 16.1) * 4.0; //pos.z += sin(lifetime * 22.5) * 4.0; //pos.y += lifetime * 25.0; gl_FragColor = vec4(pos.rgb, lifetime); } ` }) this.mesh = new THREE.Mesh(geom, this.simulationMaterial) this.scene.add(this.mesh) } simulate (delta, elapsedTime) { this.rttIndex = (this.rttIndex + 1) % 2 this.simulationMaterial.uniforms.elapsedTime.value = elapsedTime this.simulationMaterial.uniforms.delta.value = delta this.renderer.setRenderTarget(this.rtts[this.rttIndex]) this.renderer.clear() this.renderer.render(this.scene, this.orthoCamera) this.renderer.setRenderTarget(null) const texture = this.rtts[this.rttIndex].texture this.simulationMaterial.uniforms.positions.value = texture return texture } }46:T4a4,function createParticles(textureSize) { const radius = 50 // create an instanced buffer from a plane buffer geometry const geometry = new THREE.InstancedBufferGeometry() geometry.copy(new THREE.PlaneBufferGeometry(1, 1, 1, 1)) // Add/generate attributes buffers for the geometry const offsets = [] const scales = [] const indexes = [] const lifetimes = [] const spacing = 2 const halfOffset = textureSize * spacing / 2 for (let i = 0; i < numberOfParticles; i += 1) { offsets.push( 0, 0, 0 ) scales.push(3) indexes.push(i + 1) lifetimes.push(0, 0.5 + Math.random() / 2) } geometry.addAttribute('offset', new THREE.InstancedBufferAttribute(new Float32Array(offsets), 3)) geometry.addAttribute('scale', new THREE.InstancedBufferAttribute(new Float32Array(scales), 1)) geometry.addAttribute('particleIndex', new THREE.InstancedBufferAttribute(new Float32Array(indexes), 1)) geometry.addAttribute('lifetime', new THREE.InstancedBufferAttribute(new Float32Array(lifetimes), 2)) const material = createRenderMaterial(textureSize) const mesh = new THREE.Mesh(geometry, material) return {geometry, material, mesh} }47:Td61,function createRenderMaterial (textureSize) { const textureLoader = new THREE.TextureLoader() const material = new THREE.RawShaderMaterial( { uniforms: { time: { value: 1.0 }, orientation: {type: 'v4', value: new THREE.Quaternion()}, gpgpuOffsets: {type: 't', value: null }, mapper: textureLoader, // map: new THREE.TextureLoader().load('https://i.imgur.com/h1v0P5s.jpg'), colorBase: new THREE.Uniform(new THREE.Color(0xd9ff0e)), colorStart: new THREE.Uniform(new THREE.Color(0x8674fd)), colorPeak: new THREE.Uniform(new THREE.Color(0x0ed9ff)), colorEnd: new THREE.Uniform(new THREE.Color(0x333333)), }, vertexShader: ` precision highp float; #define PI 3.1415926536 #define PI2 6.28318530718 attribute vec3 position; attribute vec3 offset; attribute float scale; uniform mat4 modelViewMatrix; uniform mat4 projectionMatrix; uniform float time; attribute vec2 uv; varying vec2 vUv; varying vec4 vSample; attribute float particleIndex; uniform sampler2D gpgpuOffsets; varying float vParticleIndex; uniform vec4 orientation; uniform sampler2D mapper; varying vec4 vSample2; vec3 applyQuaternionToVector( vec4 q, vec3 v ){ return v + 2.0 * cross( q.xyz, cross( q.xyz, v ) + q.w * v ); } void main(){ vec4 positions = texture2D(gpgpuOffsets, vec2(mod(particleIndex-1.0, ${textureSize}.0)/${textureSize}.0, floor((particleIndex-1.0)/${textureSize}.0)/${textureSize}.0)); //vSample = sample; float i = particleIndex - 1.0; vec4 sample = texture2D(mapper, vec2( mod(i, ${textureSize}.0) / ${textureSize}.0, 1.0 - i / ${textureSize}.0 / ${textureSize}.0 )); vSample = sample; float lifetime = positions.a; vec3 pos = position * vec3(scale, scale, 1.0); pos = applyQuaternionToVector(orientation, pos); pos = pos + offset; pos.xyz += positions.xyz; pos.z += length(sample.rgb) * 20.0; // vLifetime = lifetime; vParticleIndex = particleIndex; vUv = vec2(uv.x, 1.0-uv.y); gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0 ); } `, fragmentShader: ` precision highp float; varying vec4 vSample; varying vec2 vUv; varying float vParticleIndex; varying vec2 vLifetime; uniform float time; uniform vec3 colorBase; uniform vec3 colorStart; uniform vec3 colorPeak; uniform vec3 colorEnd; uniform sampler2D mapper; #define PI 3.1415926536 #define PI2 6.28318530718 float drawBase (in vec2 uv, in float min, in float max) { float dist = sqrt(dot(uv, uv)); if (dist >= max || dist <= min) { return 0.0; } float sm = smoothstep(max, max - 0.01, dist); float sm2 = smoothstep(min, min - 0.01, dist); float alpha = sm * sm2; return (1.0-alpha); } void main() { float alpha = drawBase(vUv - vec2(0.5), 0.0, 0.5); // discard if not needed if (alpha == 0.0) { discard; } vec4 color = vSample; //color.r = .1;//alpha; color.a = alpha; gl_FragColor = color; } `, // side: THREE.DoubleSide, side: THREE.FrontSide, // only front since the plane will always face the camera transparent: true, alphaTest: 0.1, blending: THREE.NormalBlending // blending: THREE.MultiplyBlending // blending: THREE.AdditiveBlending }) textureLoader.load(imageURI, (texture) => { material.uniforms.mapper.value = texture }) return material }48:Tc3f5,imageURI = { return `data:image/jpeg;base64,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` }49:Tf07d,SVGLoader = { /** * @author mrdoob / http://mrdoob.com/ * @author zz85 / http://joshuakoo.com/ * @author yomboprime / https://yombo.org */ THREE.SVGLoader = function(manager) { this.manager = (manager !== undefined) ? manager : THREE.DefaultLoadingManager; }; THREE.SVGLoader.prototype = { constructor: THREE.SVGLoader, load: function(url, onLoad, onProgress, onError) { var scope = this; var loader = new THREE.FileLoader(scope.manager); loader.setPath(scope.path); loader.load(url, function(text) { onLoad(scope.parse(text)); }, onProgress, onError); }, setPath: function(value) { this.path = value; return this; }, parse: function(text) { function parseNode(node, style) { if (node.nodeType !== 1) return; var transform = getNodeTransform(node); var path = null; switch (node.nodeName) { case 'svg': break; case 'g': style = parseStyle(node, style); break; case 'path': style = parseStyle(node, style); if (node.hasAttribute('d')) path = parsePathNode(node); break; case 'rect': style = parseStyle(node, style); path = parseRectNode(node); break; case 'polygon': style = parseStyle(node, style); path = parsePolygonNode(node); break; case 'polyline': style = parseStyle(node, style); path = parsePolylineNode(node); break; case 'circle': style = parseStyle(node, style); path = parseCircleNode(node); break; case 'ellipse': style = parseStyle(node, style); path = parseEllipseNode(node); break; case 'line': style = parseStyle(node, style); path = parseLineNode(node); break; default: console.log(node); } if (path) { if (style.fill !== undefined && style.fill !== 'none') { path.color.setStyle(style.fill); } transformPath(path, currentTransform); paths.push(path); path.userData = { node: node, style: style }; } var nodes = node.childNodes; for (var i = 0; i < nodes.length; i++) { parseNode(nodes[i], style); } if (transform) { transformStack.pop(); if (transformStack.length > 0) { currentTransform.copy(transformStack[transformStack.length - 1]); } else { currentTransform.identity(); } } } function parsePathNode(node) { var path = new THREE.ShapePath(); var point = new THREE.Vector2(); var control = new THREE.Vector2(); var firstPoint = new THREE.Vector2(); var isFirstPoint = true; var doSetFirstPoint = false; var d = node.getAttribute('d'); // console.log( d ); var commands = d.match(/[a-df-z][^a-df-z]*/ig); for (var i = 0, l = commands.length; i < l; i++) { var command = commands[i]; var type = command.charAt(0); var data = command.substr(1).trim(); if (isFirstPoint === true) { doSetFirstPoint = true; isFirstPoint = false; } switch (type) { case 'M': var numbers = parseFloats(data); for (var j = 0, jl = numbers.length; j < jl; j += 2) { point.x = numbers[j + 0]; point.y = numbers[j + 1]; control.x = point.x; control.y = point.y; if (j === 0) { path.moveTo(point.x, point.y); } else { path.lineTo(point.x, point.y); } if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point); } break; case 'H': var numbers = parseFloats(data); for (var j = 0, jl = numbers.length; j < jl; j++) { point.x = numbers[j]; control.x = point.x; control.y = point.y; path.lineTo(point.x, point.y); if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point); } break; case 'V': var numbers = parseFloats(data); for (var j = 0, jl = numbers.length; j < jl; j++) { point.y = numbers[j]; control.x = point.x; control.y = point.y; path.lineTo(point.x, point.y); if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point); } break; case 'L': var numbers = parseFloats(data); for (var j = 0, jl = numbers.length; j < jl; j += 2) { point.x = numbers[j + 0]; point.y = numbers[j + 1]; control.x = point.x; control.y = point.y; path.lineTo(point.x, point.y); if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point); } break; case 'C': var numbers = parseFloats(data); for (var j = 0, jl = numbers.length; j < jl; j += 6) { path.bezierCurveTo( numbers[j + 0], numbers[j + 1], numbers[j + 2], numbers[j + 3], numbers[j + 4], numbers[j + 5]); control.x = numbers[j + 2]; control.y = numbers[j + 3]; point.x = numbers[j + 4]; point.y = numbers[j + 5]; if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point); } break; case 'S': var numbers = parseFloats(data); for (var j = 0, jl = numbers.length; j < jl; j += 4) { path.bezierCurveTo( getReflection(point.x, control.x), getReflection(point.y, control.y), numbers[j + 0], numbers[j + 1], numbers[j + 2], numbers[j + 3]); control.x = numbers[j + 0]; control.y = numbers[j + 1]; point.x = numbers[j + 2]; point.y = numbers[j + 3]; if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point); } break; case 'Q': var numbers = parseFloats(data); for (var j = 0, jl = numbers.length; j < jl; j += 4) { path.quadraticCurveTo( numbers[j + 0], numbers[j + 1], numbers[j + 2], numbers[j + 3]); control.x = numbers[j + 0]; control.y = numbers[j + 1]; point.x = numbers[j + 2]; point.y = numbers[j + 3]; if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point); } break; case 'T': var numbers = parseFloats(data); for (var j = 0, jl = numbers.length; j < jl; j += 2) { var rx = getReflection(point.x, control.x); var ry = getReflection(point.y, control.y); path.quadraticCurveTo( rx, ry, numbers[j + 0], numbers[j + 1]); control.x = rx; control.y = ry; point.x = numbers[j + 0]; point.y = numbers[j + 1]; if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point); } break; case 'A': var numbers = parseFloats(data); for (var j = 0, jl = numbers.length; j < jl; j += 7) { var start = point.clone(); point.x = numbers[j + 5]; point.y = numbers[j + 6]; control.x = point.x; control.y = point.y; parseArcCommand( path, numbers[j], numbers[j + 1], numbers[j + 2], numbers[j + 3], numbers[j + 4], start, point); if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point); } break; case 'm': var numbers = parseFloats(data); for (var j = 0, jl = numbers.length; j < jl; j += 2) { point.x += numbers[j + 0]; point.y += numbers[j + 1]; control.x = point.x; control.y = point.y; if (j === 0) { path.moveTo(point.x, point.y); } else { path.lineTo(point.x, point.y); } if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point); } break; case 'h': var numbers = parseFloats(data); for (var j = 0, jl = numbers.length; j < jl; j++) { point.x += numbers[j]; control.x = point.x; control.y = point.y; path.lineTo(point.x, point.y); if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point); } break; case 'v': var numbers = parseFloats(data); for (var j = 0, jl = numbers.length; j < jl; j++) { point.y += numbers[j]; control.x = point.x; control.y = point.y; path.lineTo(point.x, point.y); if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point); } break; case 'l': var numbers = parseFloats(data); for (var j = 0, jl = numbers.length; j < jl; j += 2) { point.x += numbers[j + 0]; point.y += numbers[j + 1]; control.x = point.x; control.y = point.y; path.lineTo(point.x, point.y); if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point); } break; case 'c': var numbers = parseFloats(data); for (var j = 0, jl = numbers.length; j < jl; j += 6) { path.bezierCurveTo( point.x + numbers[j + 0], point.y + numbers[j + 1], point.x + numbers[j + 2], point.y + numbers[j + 3], point.x + numbers[j + 4], point.y + numbers[j + 5]); control.x = point.x + numbers[j + 2]; control.y = point.y + numbers[j + 3]; point.x += numbers[j + 4]; point.y += numbers[j + 5]; if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point); } break; case 's': var numbers = parseFloats(data); for (var j = 0, jl = numbers.length; j < jl; j += 4) { path.bezierCurveTo( getReflection(point.x, control.x), getReflection(point.y, control.y), point.x + numbers[j + 0], point.y + numbers[j + 1], point.x + numbers[j + 2], point.y + numbers[j + 3]); control.x = point.x + numbers[j + 0]; control.y = point.y + numbers[j + 1]; point.x += numbers[j + 2]; point.y += numbers[j + 3]; if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point); } break; case 'q': var numbers = parseFloats(data); for (var j = 0, jl = numbers.length; j < jl; j += 4) { path.quadraticCurveTo( point.x + numbers[j + 0], point.y + numbers[j + 1], point.x + numbers[j + 2], point.y + numbers[j + 3]); control.x = point.x + numbers[j + 0]; control.y = point.y + numbers[j + 1]; point.x += numbers[j + 2]; point.y += numbers[j + 3]; if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point); } break; case 't': var numbers = parseFloats(data); for (var j = 0, jl = numbers.length; j < jl; j += 2) { var rx = getReflection(point.x, control.x); var ry = getReflection(point.y, control.y); path.quadraticCurveTo( rx, ry, point.x + numbers[j + 0], point.y + numbers[j + 1]); control.x = rx; control.y = ry; point.x = point.x + numbers[j + 0]; point.y = point.y + numbers[j + 1]; if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point); } break; case 'a': var numbers = parseFloats(data); for (var j = 0, jl = numbers.length; j < jl; j += 7) { var start = point.clone(); point.x += numbers[j + 5]; point.y += numbers[j + 6]; control.x = point.x; control.y = point.y; parseArcCommand( path, numbers[j], numbers[j + 1], numbers[j + 2], numbers[j + 3], numbers[j + 4], start, point); if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point); } break; case 'Z': case 'z': path.currentPath.autoClose = true; if (path.currentPath.curves.length > 0) { // Reset point to beginning of Path point.copy(firstPoint); path.currentPath.currentPoint.copy(point); isFirstPoint = true; } break; default: console.warn(command); } // console.log( type, parseFloats( data ), parseFloats( data ).length ) doSetFirstPoint = false; } return path; } /** * https://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes * https://mortoray.com/2017/02/16/rendering-an-svg-elliptical-arc-as-bezier-curves/ Appendix: Endpoint to center arc conversion * From * rx ry x-axis-rotation large-arc-flag sweep-flag x y * To * aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation */ function parseArcCommand(path, rx, ry, x_axis_rotation, large_arc_flag, sweep_flag, start, end) { x_axis_rotation = x_axis_rotation * Math.PI / 180; // Ensure radii are positive rx = Math.abs(rx); ry = Math.abs(ry); // Compute (x1′, y1′) var dx2 = (start.x - end.x) / 2.0; var dy2 = (start.y - end.y) / 2.0; var x1p = Math.cos(x_axis_rotation) * dx2 + Math.sin(x_axis_rotation) * dy2; var y1p = -Math.sin(x_axis_rotation) * dx2 + Math.cos(x_axis_rotation) * dy2; // Compute (cx′, cy′) var rxs = rx * rx; var rys = ry * ry; var x1ps = x1p * x1p; var y1ps = y1p * y1p; // Ensure radii are large enough var cr = x1ps / rxs + y1ps / rys; if (cr > 1) { // scale up rx,ry equally so cr == 1 var s = Math.sqrt(cr); rx = s * rx; ry = s * ry; rxs = rx * rx; rys = ry * ry; } var dq = (rxs * y1ps + rys * x1ps); var pq = (rxs * rys - dq) / dq; var q = Math.sqrt(Math.max(0, pq)); if (large_arc_flag === sweep_flag) q = -q; var cxp = q * rx * y1p / ry; var cyp = -q * ry * x1p / rx; // Step 3: Compute (cx, cy) from (cx′, cy′) var cx = Math.cos(x_axis_rotation) * cxp - Math.sin(x_axis_rotation) * cyp + (start.x + end.x) / 2; var cy = Math.sin(x_axis_rotation) * cxp + Math.cos(x_axis_rotation) * cyp + (start.y + end.y) / 2; // Step 4: Compute θ1 and Δθ var theta = svgAngle(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry); var delta = svgAngle((x1p - cxp) / rx, (y1p - cyp) / ry, (-x1p - cxp) / rx, (-y1p - cyp) / ry) % (Math.PI * 2); path.currentPath.absellipse(cx, cy, rx, ry, theta, theta + delta, sweep_flag === 0, x_axis_rotation); } function svgAngle(ux, uy, vx, vy) { var dot = ux * vx + uy * vy; var len = Math.sqrt(ux * ux + uy * uy) * Math.sqrt(vx * vx + vy * vy); var ang = Math.acos(Math.max(-1, Math.min(1, dot / len))); // floating point precision, slightly over values appear if ((ux * vy - uy * vx) < 0) ang = -ang; return ang; } /* * According to https://www.w3.org/TR/SVG/shapes.html#RectElementRXAttribute * rounded corner should be rendered to elliptical arc, but bezier curve does the job well enough */ function parseRectNode(node) { var x = parseFloat(node.getAttribute('x') || 0); var y = parseFloat(node.getAttribute('y') || 0); var rx = parseFloat(node.getAttribute('rx') || 0); var ry = parseFloat(node.getAttribute('ry') || 0); var w = parseFloat(node.getAttribute('width')); var h = parseFloat(node.getAttribute('height')); var path = new THREE.ShapePath(); path.moveTo(x + 2 * rx, y); path.lineTo(x + w - 2 * rx, y); if (rx !== 0 || ry !== 0) path.bezierCurveTo(x + w, y, x + w, y, x + w, y + 2 * ry); path.lineTo(x + w, y + h - 2 * ry); if (rx !== 0 || ry !== 0) path.bezierCurveTo(x + w, y + h, x + w, y + h, x + w - 2 * rx, y + h); path.lineTo(x + 2 * rx, y + h); if (rx !== 0 || ry !== 0) { path.bezierCurveTo(x, y + h, x, y + h, x, y + h - 2 * ry); } path.lineTo(x, y + 2 * ry); if (rx !== 0 || ry !== 0) { path.bezierCurveTo(x, y, x, y, x + 2 * rx, y); } return path; } function parsePolygonNode(node) { function iterator(match, a, b) { var x = parseFloat(a); var y = parseFloat(b); if (index === 0) { path.moveTo(x, y); } else { path.lineTo(x, y); } index++; } var regex = /(-?[\d\.?]+)[,|\s](-?[\d\.?]+)/g; var path = new THREE.ShapePath(); var index = 0; node.getAttribute('points').replace(regex, iterator); path.currentPath.autoClose = true; return path; } function parsePolylineNode(node) { function iterator(match, a, b) { var x = parseFloat(a); var y = parseFloat(b); if (index === 0) { path.moveTo(x, y); } else { path.lineTo(x, y); } index++; } var regex = /(-?[\d\.?]+)[,|\s](-?[\d\.?]+)/g; var path = new THREE.ShapePath(); var index = 0; node.getAttribute('points').replace(regex, iterator); path.currentPath.autoClose = false; return path; } function parseCircleNode(node) { var x = parseFloat(node.getAttribute('cx')); var y = parseFloat(node.getAttribute('cy')); var r = parseFloat(node.getAttribute('r')); var subpath = new THREE.Path(); subpath.absarc(x, y, r, 0, Math.PI * 2); var path = new THREE.ShapePath(); path.subPaths.push(subpath); return path; } function parseEllipseNode(node) { var x = parseFloat(node.getAttribute('cx')); var y = parseFloat(node.getAttribute('cy')); var rx = parseFloat(node.getAttribute('rx')); var ry = parseFloat(node.getAttribute('ry')); var subpath = new THREE.Path(); subpath.absellipse(x, y, rx, ry, 0, Math.PI * 2); var path = new THREE.ShapePath(); path.subPaths.push(subpath); return path; } function parseLineNode(node) { var x1 = parseFloat(node.getAttribute('x1')); var y1 = parseFloat(node.getAttribute('y1')); var x2 = parseFloat(node.getAttribute('x2')); var y2 = parseFloat(node.getAttribute('y2')); var path = new THREE.ShapePath(); path.moveTo(x1, y1); path.lineTo(x2, y2); path.currentPath.autoClose = false; return path; } // function parseStyle(node, style) { style = Object.assign({}, style); // clone style function addStyle(svgName, jsName, adjustFunction) { if (adjustFunction === undefined) adjustFunction = function copy(v) { return v; }; if (node.hasAttribute(svgName)) style[jsName] = adjustFunction(node.getAttribute(svgName)); if (node.style[svgName] !== '') style[jsName] = adjustFunction(node.style[svgName]); } function clamp(v) { return Math.max(0, Math.min(1, v)); } function positive(v) { return Math.max(0, v); } addStyle('fill', 'fill'); addStyle('fill-opacity', 'fillOpacity', clamp); addStyle('stroke', 'stroke'); addStyle('stroke-opacity', 'strokeOpacity', clamp); addStyle('stroke-width', 'strokeWidth', positive); addStyle('stroke-linejoin', 'strokeLineJoin'); addStyle('stroke-linecap', 'strokeLineCap'); addStyle('stroke-miterlimit', 'strokeMiterLimit', positive); return style; } // http://www.w3.org/TR/SVG11/implnote.html#PathElementImplementationNotes function getReflection(a, b) { return a - (b - a); } function parseFloats(string) { var array = string.split(/[\s,]+|(?=\s?[+\-])/); for (var i = 0; i < array.length; i++) { var number = array[i]; // Handle values like 48.6037.7.8 // TODO Find a regex for this if (number.indexOf('.') !== number.lastIndexOf('.')) { var split = number.split('.'); for (var s = 2; s < split.length; s++) { array.splice(i + s - 1, 0, '0.' + split[s]); } } array[i] = parseFloat(number); } return array; } function getNodeTransform(node) { if (!node.hasAttribute('transform')) { return null; } var transform = parseNodeTransform(node); if (transform) { if (transformStack.length > 0) { transform.premultiply(transformStack[transformStack.length - 1]); } currentTransform.copy(transform); transformStack.push(transform); } return transform; } function parseNodeTransform(node) { var transform = new THREE.Matrix3(); var currentTransform = tempTransform0; var transformsTexts = node.getAttribute('transform').split(')'); for (var tIndex = transformsTexts.length - 1; tIndex >= 0; tIndex--) { var transformText = transformsTexts[tIndex].trim(); if (transformText === '') continue; var openParPos = transformText.indexOf('('); var closeParPos = transformText.length; if (openParPos > 0 && openParPos < closeParPos) { var transformType = transformText.substr(0, openParPos); var array = parseFloats(transformText.substr(openParPos + 1, closeParPos - openParPos - 1)); currentTransform.identity(); switch (transformType) { case "translate": if (array.length >= 1) { var tx = array[0]; var ty = tx; if (array.length >= 2) { ty = array[1]; } currentTransform.translate(tx, ty); } break; case "rotate": if (array.length >= 1) { var angle = 0; var cx = 0; var cy = 0; // Angle angle = -array[0] * Math.PI / 180; if (array.length >= 3) { // Center x, y cx = array[1]; cy = array[2]; } // Rotate around center (cx, cy) tempTransform1.identity().translate(-cx, - cy); tempTransform2.identity().rotate(angle); tempTransform3.multiplyMatrices(tempTransform2, tempTransform1); tempTransform1.identity().translate(cx, cy); currentTransform.multiplyMatrices(tempTransform1, tempTransform3); } break; case "scale": if (array.length >= 1) { var scaleX = array[0]; var scaleY = scaleX; if (array.length >= 2) { scaleY = array[1]; } currentTransform.scale(scaleX, scaleY); } break; case "skewX": if (array.length === 1) { currentTransform.set( 1, Math.tan(array[0] * Math.PI / 180), 0, 0, 1, 0, 0, 0, 1); } break; case "skewY": if (array.length === 1) { currentTransform.set( 1, 0, 0, Math.tan(array[0] * Math.PI / 180), 1, 0, 0, 0, 1); } break; case "matrix": if (array.length === 6) { currentTransform.set( array[0], array[2], array[4], array[1], array[3], array[5], 0, 0, 1); } break; } } transform.premultiply(currentTransform); } return transform; } function transformPath(path, m) { function transfVec2(v2) { tempV3.set(v2.x, v2.y, 1).applyMatrix3(m); v2.set(tempV3.x, tempV3.y); } var isRotated = isTransformRotated(m); var subPaths = path.subPaths; for (var i = 0, n = subPaths.length; i < n; i++) { var subPath = subPaths[i]; var curves = subPath.curves; for (var j = 0; j < curves.length; j++) { var curve = curves[j]; if (curve.isLineCurve) { transfVec2(curve.v1); transfVec2(curve.v2); } else if (curve.isCubicBezierCurve) { transfVec2(curve.v0); transfVec2(curve.v1); transfVec2(curve.v2); transfVec2(curve.v3); } else if (curve.isQuadraticBezierCurve) { transfVec2(curve.v0); transfVec2(curve.v1); transfVec2(curve.v2); } else if (curve.isEllipseCurve) { if (isRotated) { console.warn("SVGLoader: Elliptic arc or ellipse rotation or skewing is not implemented."); } tempV2.set(curve.aX, curve.aY); transfVec2(tempV2); curve.aX = tempV2.x; curve.aY = tempV2.y; curve.xRadius *= getTransformScaleX(m); curve.yRadius *= getTransformScaleY(m); } } } } function isTransformRotated(m) { return m.elements[1] !== 0 || m.elements[3] !== 0; } function getTransformScaleX(m) { var te = m.elements; return Math.sqrt(te[0] * te[0] + te[1] * te[1]); } function getTransformScaleY(m) { var te = m.elements; return Math.sqrt(te[3] * te[3] + te[4] * te[4]); } // console.log('THREE.SVGLoader'); var paths = []; var transformStack = []; var tempTransform0 = new THREE.Matrix3(); var tempTransform1 = new THREE.Matrix3(); var tempTransform2 = new THREE.Matrix3(); var tempTransform3 = new THREE.Matrix3(); var tempV2 = new THREE.Vector2(); var tempV3 = new THREE.Vector3(); var currentTransform = new THREE.Matrix3(); console.time('THREE.SVGLoader: DOMParser'); var xml = new DOMParser().parseFromString(text, 'image/svg+xml'); // application/xml console.timeEnd('THREE.SVGLoader: DOMParser'); console.time('THREE.SVGLoader: Parse'); parseNode(xml.documentElement, { fill: '#000', fillOpacity: 1, strokeOpacity: 1, strokeWidth: 1, strokeLineJoin: 'miter', strokeLineCap: 'butt', strokeMiterLimit: 4 }); var data = { paths: paths, xml: xml.documentElement }; // console.log( paths ); console.timeEnd('THREE.SVGLoader: Parse'); return data; } }; THREE.SVGLoader.getStrokeStyle = function(width, color, opacity, lineJoin, lineCap, miterLimit) { // Param width: Stroke width // Param color: As returned by THREE.Color.getStyle() // Param opacity: 0 (transparent) to 1 (opaque) // Param lineJoin: One of "round", "bevel", "miter" or "miter-limit" // Param lineCap: One of "round", "square" or "butt" // Param miterLimit: Maximum join length, in multiples of the "width" parameter (join is truncated if it exceeds that distance) // Returns style object width = width !== undefined ? width : 1; color = color !== undefined ? color : '#000'; opacity = opacity !== undefined ? opacity : 1; lineJoin = lineJoin !== undefined ? lineJoin : 'miter'; lineCap = lineCap !== undefined ? lineCap : 'butt'; miterLimit = miterLimit !== undefined ? miterLimit : 4; return { strokeColor: color, strokeWidth: width, strokeLineJoin: lineJoin, strokeLineCap: lineCap, strokeMiterLimit: miterLimit }; }; THREE.SVGLoader.pointsToStroke = function(points, style, arcDivisions, minDistance) { // Generates a stroke with some witdh around the given path. // The path can be open or closed (last point equals to first point) // Param points: Array of Vector2D (the path). Minimum 2 points. // Param style: Object with SVG properties as returned by SVGLoader.getStrokeStyle(), or SVGLoader.parse() in the path.userData.style object // Params arcDivisions: Arc divisions for round joins and endcaps. (Optional) // Param minDistance: Points closer to this distance will be merged. (Optional) // Returns BufferGeometry with stroke triangles (In plane z = 0). UV coordinates are generated ('u' along path. 'v' across it, from left to right) var vertices = []; var normals = []; var uvs = []; if (THREE.SVGLoader.pointsToStrokeWithBuffers(points, style, arcDivisions, minDistance, vertices, normals, uvs) === 0) { return null; } var geometry = new THREE.BufferGeometry(); geometry.addAttribute('position', new THREE.Float32BufferAttribute(vertices, 3)); geometry.addAttribute('normal', new THREE.Float32BufferAttribute(normals, 3)); geometry.addAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2)); return geometry; }; THREE.SVGLoader.pointsToStrokeWithBuffers = function() { var tempV2_1 = new THREE.Vector2(); var tempV2_2 = new THREE.Vector2(); var tempV2_3 = new THREE.Vector2(); var tempV2_4 = new THREE.Vector2(); var tempV2_5 = new THREE.Vector2(); var tempV2_6 = new THREE.Vector2(); var tempV2_7 = new THREE.Vector2(); var lastPointL = new THREE.Vector2(); var lastPointR = new THREE.Vector2(); var point0L = new THREE.Vector2(); var point0R = new THREE.Vector2(); var currentPointL = new THREE.Vector2(); var currentPointR = new THREE.Vector2(); var nextPointL = new THREE.Vector2(); var nextPointR = new THREE.Vector2(); var innerPoint = new THREE.Vector2(); var outerPoint = new THREE.Vector2(); return function(points, style, arcDivisions, minDistance, vertices, normals, uvs, vertexOffset) { // This function can be called to update existing arrays or buffers. // Accepts same parameters as pointsToStroke, plus the buffers and optional offset. // Param vertexOffset: Offset vertices to start writing in the buffers (3 elements/vertex for vertices and normals, and 2 elements/vertex for uvs) // Returns number of written vertices / normals / uvs pairs // if 'vertices' parameter is undefined no triangles will be generated, but the returned vertices count will still be valid (useful to preallocate the buffers) // 'normals' and 'uvs' buffers are optional arcDivisions = arcDivisions !== undefined ? arcDivisions : 12; minDistance = minDistance !== undefined ? minDistance : 0.001; vertexOffset = vertexOffset !== undefined ? vertexOffset : 0; // First ensure there are no duplicated points points = removeDuplicatedPoints(points); var numPoints = points.length; if (numPoints < 2) return 0; var isClosed = points[0].equals(points[numPoints - 1]); var currentPoint; var previousPoint = points[0]; var nextPoint; var strokeWidth2 = style.strokeWidth / 2; var deltaU = 1 / (numPoints - 1); var u0 = 0; var innerSideModified; var joinIsOnLeftSide; var isMiter; var initialJoinIsOnLeftSide = false; var numVertices = 0; var currentCoordinate = vertexOffset * 3; var currentCoordinateUV = vertexOffset * 2; // Get initial left and right stroke points getNormal(points[0], points[1], tempV2_1).multiplyScalar(strokeWidth2); lastPointL.copy(points[0]).sub(tempV2_1); lastPointR.copy(points[0]).add(tempV2_1); point0L.copy(lastPointL); point0R.copy(lastPointR); for (var iPoint = 1; iPoint < numPoints; iPoint++) { currentPoint = points[iPoint]; // Get next point if (iPoint === numPoints - 1) { if (isClosed) { // Skip duplicated initial point nextPoint = points[1]; } else nextPoint = undefined; } else { nextPoint = points[iPoint + 1]; } // Normal of previous segment in tempV2_1 var normal1 = tempV2_1; getNormal(previousPoint, currentPoint, normal1); tempV2_3.copy(normal1).multiplyScalar(strokeWidth2); currentPointL.copy(currentPoint).sub(tempV2_3); currentPointR.copy(currentPoint).add(tempV2_3); var u1 = u0 + deltaU; innerSideModified = false; if (nextPoint !== undefined) { // Normal of next segment in tempV2_2 getNormal(currentPoint, nextPoint, tempV2_2); tempV2_3.copy(tempV2_2).multiplyScalar(strokeWidth2); nextPointL.copy(currentPoint).sub(tempV2_3); nextPointR.copy(currentPoint).add(tempV2_3); joinIsOnLeftSide = true; tempV2_3.subVectors(nextPoint, previousPoint); if (normal1.dot(tempV2_3) < 0) { joinIsOnLeftSide = false; } if (iPoint === 1) initialJoinIsOnLeftSide = joinIsOnLeftSide; tempV2_3.subVectors(nextPoint, currentPoint); tempV2_3.normalize(); var dot = Math.abs(normal1.dot(tempV2_3)); // If path is straight, don't create join if (dot !== 0) { // Compute inner and outer segment intersections var miterSide = strokeWidth2 / dot; tempV2_3.multiplyScalar(-miterSide); tempV2_4.subVectors(currentPoint, previousPoint); tempV2_5.copy(tempV2_4).setLength(miterSide).add(tempV2_3); innerPoint.copy(tempV2_5).negate(); var miterLength2 = tempV2_5.length(); var segmentLengthPrev = tempV2_4.length(); tempV2_4.divideScalar(segmentLengthPrev); tempV2_6.subVectors(nextPoint, currentPoint); var segmentLengthNext = tempV2_6.length(); tempV2_6.divideScalar(segmentLengthNext); // Check that previous and next segments doesn't overlap with the innerPoint of intersection if (tempV2_4.dot(innerPoint) < segmentLengthPrev && tempV2_6.dot(innerPoint) < segmentLengthNext) { innerSideModified = true; } outerPoint.copy(tempV2_5).add(currentPoint); innerPoint.add(currentPoint); isMiter = false; if (innerSideModified) { if (joinIsOnLeftSide) { nextPointR.copy(innerPoint); currentPointR.copy(innerPoint); } else { nextPointL.copy(innerPoint); currentPointL.copy(innerPoint); } } else { // The segment triangles are generated here if there was overlapping makeSegmentTriangles(); } switch (style.strokeLineJoin) { case 'bevel': makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u1); break; case 'round': // Segment triangles createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified); // Join triangles if (joinIsOnLeftSide) { makeCircularSector(currentPoint, currentPointL, nextPointL, u1, 0); } else { makeCircularSector(currentPoint, nextPointR, currentPointR, u1, 1); } break; case 'miter': case 'miter-clip': default: var miterFraction = (strokeWidth2 * style.strokeMiterLimit) / miterLength2; if (miterFraction < 1) { // The join miter length exceeds the miter limit if (style.strokeLineJoin !== 'miter-clip') { makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u1); break; } else { // Segment triangles createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified); // Miter-clip join triangles if (joinIsOnLeftSide) { tempV2_6.subVectors(outerPoint, currentPointL).multiplyScalar(miterFraction).add(currentPointL); tempV2_7.subVectors(outerPoint, nextPointL).multiplyScalar(miterFraction).add(nextPointL); addVertex(currentPointL, u1, 0); addVertex(tempV2_6, u1, 0); addVertex(currentPoint, u1, 0.5); addVertex(currentPoint, u1, 0.5); addVertex(tempV2_6, u1, 0); addVertex(tempV2_7, u1, 0); addVertex(currentPoint, u1, 0.5); addVertex(tempV2_7, u1, 0); addVertex(nextPointL, u1, 0); } else { tempV2_6.subVectors(outerPoint, currentPointR).multiplyScalar(miterFraction).add(currentPointR); tempV2_7.subVectors(outerPoint, nextPointR).multiplyScalar(miterFraction).add(nextPointR); addVertex(currentPointR, u1, 1); addVertex(tempV2_6, u1, 1); addVertex(currentPoint, u1, 0.5); addVertex(currentPoint, u1, 0.5); addVertex(tempV2_6, u1, 1); addVertex(tempV2_7, u1, 1); addVertex(currentPoint, u1, 0.5); addVertex(tempV2_7, u1, 1); addVertex(nextPointR, u1, 1); } } } else { // Miter join segment triangles if (innerSideModified) { // Optimized segment + join triangles if (joinIsOnLeftSide) { addVertex(lastPointR, u0, 1); addVertex(lastPointL, u0, 0); addVertex(outerPoint, u1, 0); addVertex(lastPointR, u0, 1); addVertex(outerPoint, u1, 0); addVertex(innerPoint, u1, 1); } else { addVertex(lastPointR, u0, 1); addVertex(lastPointL, u0, 0); addVertex(outerPoint, u1, 1); addVertex(lastPointL, u0, 0); addVertex(innerPoint, u1, 0); addVertex(outerPoint, u1, 1); } if (joinIsOnLeftSide) { nextPointL.copy(outerPoint); } else { nextPointR.copy(outerPoint); } } else { // Add extra miter join triangles if (joinIsOnLeftSide) { addVertex(currentPointL, u1, 0); addVertex(outerPoint, u1, 0); addVertex(currentPoint, u1, 0.5); addVertex(currentPoint, u1, 0.5); addVertex(outerPoint, u1, 0); addVertex(nextPointL, u1, 0); } else { addVertex(currentPointR, u1, 1); addVertex(outerPoint, u1, 1); addVertex(currentPoint, u1, 0.5); addVertex(currentPoint, u1, 0.5); addVertex(outerPoint, u1, 1); addVertex(nextPointR, u1, 1); } } isMiter = true; } break; } } else { // The segment triangles are generated here when two consecutive points are collinear makeSegmentTriangles(); } } else { // The segment triangles are generated here if it is the ending segment makeSegmentTriangles(); } if (!isClosed && iPoint === numPoints - 1) { // Start line endcap addCapGeometry(points[0], point0L, point0R, joinIsOnLeftSide, true, u0); } // Increment loop variables u0 = u1; previousPoint = currentPoint; lastPointL.copy(nextPointL); lastPointR.copy(nextPointR); } if (!isClosed) { // Ending line endcap addCapGeometry(currentPoint, currentPointL, currentPointR, joinIsOnLeftSide, false, u1); } else if (innerSideModified && vertices) { // Modify path first segment vertices to adjust to the segments inner and outer intersections var lastOuter = outerPoint; var lastInner = innerPoint; if (initialJoinIsOnLeftSide !== joinIsOnLeftSide) { lastOuter = innerPoint; lastInner = outerPoint; } if (joinIsOnLeftSide) { lastInner.toArray(vertices, 0 * 3); lastInner.toArray(vertices, 3 * 3); if (isMiter) { lastOuter.toArray(vertices, 1 * 3); } } else { lastInner.toArray(vertices, 1 * 3); lastInner.toArray(vertices, 3 * 3); if (isMiter) { lastOuter.toArray(vertices, 0 * 3); } } } return numVertices; // -- End of algorithm // -- Functions function getNormal(p1, p2, result) { result.subVectors(p2, p1); return result.set(-result.y, result.x).normalize(); } function addVertex(position, u, v) { if (vertices) { vertices[currentCoordinate] = position.x; vertices[currentCoordinate + 1] = position.y; vertices[currentCoordinate + 2] = 0; if (normals) { normals[currentCoordinate] = 0; normals[currentCoordinate + 1] = 0; normals[currentCoordinate + 2] = 1; } currentCoordinate += 3; if (uvs) { uvs[currentCoordinateUV] = u; uvs[currentCoordinateUV + 1] = v; currentCoordinateUV += 2; } } numVertices += 3; } function makeCircularSector(center, p1, p2, u, v) { // param p1, p2: Points in the circle arc. // p1 and p2 are in clockwise direction. tempV2_1.copy(p1).sub(center).normalize(); tempV2_2.copy(p2).sub(center).normalize(); var angle = Math.PI; var dot = tempV2_1.dot(tempV2_2); if (Math.abs(dot) < 1) angle = Math.abs(Math.acos(dot)); angle /= arcDivisions; tempV2_3.copy(p1); for (var i = 0, il = arcDivisions - 1; i < il; i++) { tempV2_4.copy(tempV2_3).rotateAround(center, angle); addVertex(tempV2_3, u, v); addVertex(tempV2_4, u, v); addVertex(center, u, 0.5); tempV2_3.copy(tempV2_4); } addVertex(tempV2_4, u, v); addVertex(p2, u, v); addVertex(center, u, 0.5); } function makeSegmentTriangles() { addVertex(lastPointR, u0, 1); addVertex(lastPointL, u0, 0); addVertex(currentPointL, u1, 0); addVertex(lastPointR, u0, 1); addVertex(currentPointL, u1, 1); addVertex(currentPointR, u1, 0); } function makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u) { if (innerSideModified) { // Optimized segment + bevel triangles if (joinIsOnLeftSide) { // Path segments triangles addVertex(lastPointR, u0, 1); addVertex(lastPointL, u0, 0); addVertex(currentPointL, u1, 0); addVertex(lastPointR, u0, 1); addVertex(currentPointL, u1, 0); addVertex(innerPoint, u1, 1); // Bevel join triangle addVertex(currentPointL, u, 0); addVertex(nextPointL, u, 0); addVertex(innerPoint, u, 0.5); } else { // Path segments triangles addVertex(lastPointR, u0, 1); addVertex(lastPointL, u0, 0); addVertex(currentPointR, u1, 1); addVertex(lastPointL, u0, 0); addVertex(innerPoint, u1, 0); addVertex(currentPointR, u1, 1); // Bevel join triangle addVertex(currentPointR, u, 1); addVertex(nextPointR, u, 0); addVertex(innerPoint, u, 0.5); } } else { // Bevel join triangle. The segment triangles are done in the main loop if (joinIsOnLeftSide) { addVertex(currentPointL, u, 0); addVertex(nextPointL, u, 0); addVertex(currentPoint, u, 0.5); } else { addVertex(currentPointR, u, 1); addVertex(nextPointR, u, 0); addVertex(currentPoint, u, 0.5); } } } function createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified) { if (innerSideModified) { if (joinIsOnLeftSide) { addVertex(lastPointR, u0, 1); addVertex(lastPointL, u0, 0); addVertex(currentPointL, u1, 0); addVertex(lastPointR, u0, 1); addVertex(currentPointL, u1, 0); addVertex(innerPoint, u1, 1); addVertex(currentPointL, u0, 0); addVertex(currentPoint, u1, 0.5); addVertex(innerPoint, u1, 1); addVertex(currentPoint, u1, 0.5); addVertex(nextPointL, u0, 0); addVertex(innerPoint, u1, 1); } else { addVertex(lastPointR, u0, 1); addVertex(lastPointL, u0, 0); addVertex(currentPointR, u1, 1); addVertex(lastPointL, u0, 0); addVertex(innerPoint, u1, 0); addVertex(currentPointR, u1, 1); addVertex(currentPointR, u0, 1); addVertex(innerPoint, u1, 0); addVertex(currentPoint, u1, 0.5); addVertex(currentPoint, u1, 0.5); addVertex(innerPoint, u1, 0); addVertex(nextPointR, u0, 1); } } } function addCapGeometry(center, p1, p2, joinIsOnLeftSide, start, u) { // param center: End point of the path // param p1, p2: Left and right cap points switch (style.strokeLineCap) { case 'round': if (start) { makeCircularSector(center, p2, p1, u, 0.5); } else { makeCircularSector(center, p1, p2, u, 0.5); } break; case 'square': if (start) { tempV2_1.subVectors(p1, center); tempV2_2.set(tempV2_1.y, - tempV2_1.x); tempV2_3.addVectors(tempV2_1, tempV2_2).add(center); tempV2_4.subVectors(tempV2_2, tempV2_1).add(center); // Modify already existing vertices if (joinIsOnLeftSide) { tempV2_3.toArray(vertices, 1 * 3); tempV2_4.toArray(vertices, 0 * 3); tempV2_4.toArray(vertices, 3 * 3); } else { tempV2_3.toArray(vertices, 1 * 3); tempV2_3.toArray(vertices, 3 * 3); tempV2_4.toArray(vertices, 0 * 3); } } else { tempV2_1.subVectors(p2, center); tempV2_2.set(tempV2_1.y, - tempV2_1.x); tempV2_3.addVectors(tempV2_1, tempV2_2).add(center); tempV2_4.subVectors(tempV2_2, tempV2_1).add(center); var vl = vertices.length; // Modify already existing vertices if (joinIsOnLeftSide) { tempV2_3.toArray(vertices, vl - 1 * 3); tempV2_4.toArray(vertices, vl - 2 * 3); tempV2_4.toArray(vertices, vl - 4 * 3); } else { tempV2_3.toArray(vertices, vl - 2 * 3); tempV2_4.toArray(vertices, vl - 1 * 3); tempV2_4.toArray(vertices, vl - 4 * 3); } } break; case 'butt': default: // Nothing to do here break; } } function removeDuplicatedPoints(points) { // Creates a new array if necessary with duplicated points removed. // This does not remove duplicated initial and ending points of a closed path. var dupPoints = false; for (var i = 1, n = points.length - 1; i < n; i++) { if (points[i].distanceTo(points[i + 1]) < minDistance) { dupPoints = true; break; } } if (!dupPoints) return points; var newPoints = []; newPoints.push(points[0]); for (var i = 1, n = points.length - 1; i < n; i++) { if (points[i].distanceTo(points[i + 1]) >= minDistance) { newPoints.push(points[i]); } } newPoints.push(points[points.length - 1]); return newPoints; } }; }(); return THREE.SVGLoader }4a:[] 43:{"id":"4e6e48fa2cc191b3","slug":"gpgpu-billboard-particles","title":"GPGPU Billboard Particles","thumbnail":"cc2d8d8367d17c3a11cb7f4baf6a992184d9537edfd102713f78bfde9b91d92e","access_level":"public","create_time":"$D2019-07-13T23:37:28.425Z","update_time":"$D2023-01-14T15:44:27.176Z","view_time":null,"first_public_time":"$D2019-07-16T02:18:03.131Z","has_unpublished_edits":null,"fork":{"id":"296ed98054213501","slug":"gpgpu-billboard-particles/2","title":"GPGPU Billboard Particles","owner":{"id":"eb91583c3281c8c7","login":"mikatalk","name":"Mika I."}},"stars":6,"starred":false,"owner":{"type":"team","id":"eb91583c3281c8c7","login":"mikatalk","name":"Mika I.","avatar_url":"https://avatars-next.observableusercontent.com/5a387c3adea16a6322506254c59eb1a0bc11a7023baf6b6ddab7ab1bc5384ab6","tier":"starter_2024","bio":""},"version":1142,"publish_version":null,"role":null,"authored":false,"authors":[{"type":"individual","id":"41889b11ceafc215","login":"mikatalk","name":"Mika I.","avatar_url":"https://avatars-next.observableusercontent.com/5a387c3adea16a6322506254c59eb1a0bc11a7023baf6b6ddab7ab1bc5384ab6","tier":null,"bio":""}],"members":[{"type":"individual","id":"41889b11ceafc215","login":"mikatalk","name":"Mika I.","avatar_url":"https://avatars-next.observableusercontent.com/5a387c3adea16a6322506254c59eb1a0bc11a7023baf6b6ddab7ab1bc5384ab6","tier":null,"role":"editor"}],"comments":[],"custom_thumbnail":false,"trashed":false,"lapsed":null,"subscribed":null,"forks":1,"collection":null,"type":"notebook","body":{"titling":"auto","title":"GPGPU Billboard Particles","cells":[{"id":598,"value":"md`# GPGPU Billboard Particles`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":11,"value":"{\n const context = initialize()\n const {scene, camera, renderer, clock} = context \n invalidation.then(() => renderer.dispose())\n\n const particles = createParticles(textureSize)\n scene.add(particles.mesh)\n\n const gpgpu = new GPGPU(renderer, textureSize)\n \n// var geometry = new THREE.PlaneGeometry( 50, 50, 1 );\n// var material = new THREE.MeshBasicMaterial( {\n// // wireframe: true,\n// color: 0xffffff,\n// side: THREE.DoubleSide,\n// map: new THREE.TextureLoader().load(imageURI)\n// } );\n// var plane = new THREE.Mesh( geometry, material );\n// scene.add( plane );\n \n while (true) {\n particles.mesh.material.uniforms.orientation.value.copy(camera.quaternion)\n const delta = clock.getDelta() * 1\n const elapsedTime = clock.getElapsedTime()\n particles.material.uniforms.gpgpuOffsets.value = gpgpu.simulate(delta, elapsedTime)\n renderer.render(scene, camera)\n yield renderer.domElement\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":7,"value":"width = window.innerWidth","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":433,"value":"textureSize = 64","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":110,"value":"numberOfParticles = textureSize * textureSize","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":8,"value":"height = 950","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":441,"value":"$45","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":447,"value":"function preloadedDataBuffer (textureSize) {\n let len = textureSize * textureSize * 4\n const data = new Float32Array(len)\n const maxLifeTime = 5\n const radius = 10\n const height = 50\n const PI2 = Math.PI * 2\n for (let i4 = 0; i4 < len; i4 += 4) {\n const ratio = i4 / len\n const ratioMod = (ratio * 4) % 1\n data[i4] = 0 // x\n data[i4 + 1] = 0 // y\n data[i4 + 2] = 0 // z\n data[i4 + 3] = Math.random() // lifetime\n }\n return data\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":4,"value":"function initialize () {\n const scene = new THREE.Scene()\n const camera = new THREE.PerspectiveCamera(45, width / height, 1, 10000)\n const renderer = new THREE.WebGLRenderer({\n antialias: true,\n })\n const controls = new THREE.OrbitControls(camera, renderer.domElement)\n const clock = new THREE.Clock(true)\n\n// const color = 0xFF00FF\n// const near = 0.1\n// const far = 2\n// scene.fog = new THREE.Fog(color, near, far)\n \n renderer.setSize(width, height)\n renderer.setPixelRatio(devicePixelRatio)\n \n camera.position.set(0, 0, 100)\n \n return {scene, camera, renderer, controls, clock}\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":21,"value":"$46","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":499,"value":"$47","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":964,"value":"$48","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1128,"value":"$49","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":0,"value":"THREE = {\n const THREE = window.THREE = await require('three@0.105/build/three.min.js')\n await require('three@0.105/examples/js/controls/OrbitControls.js').catch(() => {})\n return THREE\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"}],"files":"$W4a","stdlib":"1"}} 44:"$43:body"