简介
“Find Your Way to Oz”是迪士尼推出的一项全新 Google Chrome 实验。您可以在堪萨斯马戏团中进行互动之旅,在被一场大风暴卷走后,您将来到奥兹国。
我们的目标是将电影的丰富性与浏览器的技术能力相结合,打造一种有趣、沉浸式的体验,让用户能够与之建立牢固的联系。
这项工作涉及的内容太多,无法在本文中全面涵盖,因此我们深入探究并挑选了一些我们认为有趣的科技故事章节。在此过程中,我们提取了一些难度逐渐增加的重点教程。
许多人为实现这一体验付出了艰辛的努力,人数众多,无法在此一一列出。请访问该网站,查看菜单部分下的致谢页面,了解完整故事。
解密底层原理
桌面版《Find Your Way to Oz》是一个丰富而沉浸的世界。我们使用 3D 技术和多层传统电影制作效果,共同打造出近乎真实的场景。其中最突出的技术是 WebGL(搭配 Three.js)、自定义着色器和使用 CSS3 功能的 DOM 动画元素。除此之外,还使用了 getUserMedia API (WebRTC) 来实现互动体验,让用户可以直接通过网络摄像头添加自己的图片,并使用 WebAudio 来实现 3D 声音。
但这种技术体验的魅力在于它的整合方式。这也是主要挑战之一:如何将视觉效果和互动元素融合在一个场景中,打造一个和谐统一的整体?这种视觉复杂性很难管理:我们很难随时了解自己处于哪个开发阶段。
为了解决视觉效果和优化相互关联的问题,我们大量使用了控制面板,该面板可以捕获我们在当时正在查看的所有相关设置。场景可以在浏览器中实时调整,从亮度、景深、伽马值等,不一而足。任何人都可以尝试调整体验中的重要参数值,并参与探索最佳效果。
在分享我们的秘密之前,我们想提醒您,这可能会导致崩溃,就像您在汽车引擎内部乱动一样。确保您没有重要事项,然后访问网站的主网址,并在地址后附加 ?debug=on。等待网站加载完毕,进入网站后,按 Ctrl-I 键,右侧会显示一个下拉菜单。如果您取消选中“退出镜头路径”选项,则可以使用 A、W、S、D 键和鼠标在空间中自由移动。
我们不会在此处逐一介绍所有设置,但建议您自行探索:这些按键在不同场景中会显示不同的设置。在最后的风暴序列中,还有一个额外的按键:Ctrl-A,您可以使用它来切换动画播放和飞行。在此场景中,如果您按 Esc(退出鼠标锁定功能),然后再次按 Ctrl-I,则可以访问风暴场景特有的设置。环顾四周,捕捉一些像下面这样适合做明信片的风景。
为了实现这一目标并确保其足够灵活,能够满足我们的需求,我们使用了一个名为 dat.gui 的优秀库(请参阅此处,了解有关如何使用它的过往教程)。它使我们能够快速更改向网站访问者显示的设置。
有点像遮罩绘画
在许多经典迪士尼电影和动画中,场景的创作往往需要将不同的图层组合在一起。其中有实景、赛璐珞动画、甚至实体布景,最上层则是通过在玻璃上绘画创建的,这种技术称为遮罩绘画。
在许多方面,我们打造的体验结构都很相似,尽管其中一些“层”不仅仅是静态视觉效果。事实上,它们会根据更复杂的计算来影响事物的呈现方式。不过,至少从宏观层面来看,我们处理的是视图,它们会相互堆叠。顶部是界面层,下方是 3D 场景,该场景本身由不同的场景组件组成。
顶层界面是使用 DOM 和 CSS 3 创建的,这意味着可以通过多种方式独立于 3D 体验来修改互动,并根据所选事件列表在两者之间进行通信。此通信使用 Backbone Router + onHashChange HTML5 事件来控制哪个区域应以动画形式进入/退出。(项目来源:/develop/coffee/router/Router.coffee)。
教程:雪碧图和 Retina 支持
我们采用了一种有趣的优化技术来处理界面,即将多个界面叠加图片合并为一个 PNG 图片,以减少服务器请求。在这个项目中,界面由 70 多张图片(不包括 3D 纹理)组成,这些图片全部预先加载,以减少网站的延迟。您可以在此处查看实时雪碧图:
http://findyourwaytooz.com/img/home/interface_1x.png http://findyourwaytooz.com/img/home/interface_2x.png
以下是一些关于如何利用雪碧图、如何将其用于视网膜设备以及如何使界面尽可能清晰整洁的提示。
创建精灵表
为了创建 SpriteSheet,我们使用了 TexturePacker,它可以输出您需要的任何格式。在本例中,我们已导出为 EaselJS,它非常简洁,也可用于创建动画精灵。
使用生成的雪碧图
创建雪碧图后,您应该会看到如下所示的 JSON 文件:
{
"images": ["interface_2x.png"],
"frames": [
[2, 1837, 88, 130],
[2, 2, 1472, 112],
[1008, 774, 70, 68],
[562, 1960, 86, 86],
[473, 1960, 86, 86]
],
"animations": {
"allow_web":[0],
"bottomheader":[1],
"button_close":[2],
"button_facebook":[3],
"button_google":[4]
},
}
其中:
- image 是指雪碧图的网址
- frames 是每个界面元素的坐标 [x, y, width, height]
- 动画是每个素材资源的名称
请注意,我们使用了高密度图片来创建雪碧图,然后创建了普通版本,只需将其大小调整为原来的一半即可。
小结
现在一切准备就绪,我们只需要一段 JavaScript 代码来使用它。
var SSAsset = function (asset, div) {
var css, x, y, w, h;
// Divide the coordinates by 2 as retina devices have 2x density
x = Math.round(asset.x / 2);
y = Math.round(asset.y / 2);
w = Math.round(asset.width / 2);
h = Math.round(asset.height / 2);
// Create an Object to store CSS attributes
css = {
width : w,
height : h,
'background-image' : "url(" + asset.image_1x_url + ")",
'background-size' : "" + asset.fullSize[0] + "px " + asset.fullSize[1] + "px",
'background-position': "-" + x + "px -" + y + "px"
};
// If retina devices
if (window.devicePixelRatio === 2) {
/*
set -webkit-image-set
for 1x and 2x
All the calculations of X, Y, WIDTH and HEIGHT is taken care by the browser
*/
css['background-image'] = "-webkit-image-set(url(" + asset.image_1x_url + ") 1x,";
css['background-image'] += "url(" + asset.image_2x_url + ") 2x)";
}
// Set the CSS to the DIV
div.css(css);
};
具体使用方法如下:
logo = new SSAsset(
{
fullSize : [1024, 1024], // image 1x dimensions Array [x,y]
x : 1790, // asset x coordinate on SpriteSheet
y : 603, // asset y coordinate on SpriteSheet
width : 122, // asset width
height : 150, // asset height
image_1x_url : 'img/spritesheet_1x.png', // background image 1x URL
image_2x_url : 'img/spritesheet_2x.png' // background image 2x URL
},$('#logo'));
如需详细了解可变像素密度,您可以阅读 Boris Smus 撰写的这篇文章。
3D 内容流水线
环境体验是在 WebGL 图层上设置的。在考虑 3D 场景时,最棘手的问题之一是如何确保您能够创建内容,从而在建模、动画和效果方面发挥最大的表现潜力。在许多方面,此问题的核心是内容流水线:为 3D 场景创建内容时要遵循的约定流程。
我们希望打造一个令人惊叹的世界,因此需要一个可靠的流程,让 3D 艺术家能够创造出这样的世界。我们需要在 3D 建模和动画软件中为他们提供尽可能多的表达自由,并且需要通过代码在屏幕上渲染这些内容。
我们一直在努力解决这类问题,因为过去每次创建 3D 网站时,我们都会发现可用工具存在局限性。因此,我们创建了这款名为 3D Librarian 的工具,这是一项内部研究。而且已经可以应用于实际工作。
这个工具颇有历史:它最初是为 Flash 设计的,可让您将大型 Maya 场景导入为单个压缩文件,该文件针对解压运行时进行了优化。之所以说它是最佳选择,是因为它基本上在渲染和动画期间操作的同一数据结构中有效地打包了场景。加载文件时,需要对文件进行解析的内容很少。在 Flash 中解压非常快,因为文件采用 AMF 格式,Flash 可以原生解压。在 WebGL 中使用相同的格式需要 CPU 执行更多操作。事实上,我们不得不重新创建一个数据解压 JavaScript 代码层,该代码层基本上会解压这些文件,并重新创建 WebGL 运行所需的数据结构。解压整个 3D 场景是一项对 CPU 性能要求较高的操作:在中高端设备上解压《奥兹国历险记》中的场景 1 大约需要 2 秒。因此,此操作是在“场景设置”时(在场景实际启动之前)使用 Web Workers 技术完成的,以免影响用户体验。
这款便捷工具可以导入大部分 3D 场景:模型、纹理、骨骼动画。您只需创建一个库文件,然后 3D 引擎便可加载该文件。您只需将场景中所需的所有模型放入此库中,然后就可以将它们生成到场景中。
不过,我们遇到了一个问题,那就是我们现在要处理 WebGL:这个新事物。这是一个相当棘手的问题:这为基于浏览器的 3D 体验设定了标准。因此,我们创建了一个临时 JavaScript 层,该层会获取 3D Librarian 压缩的 3D 场景文件,并将其正确转换为 WebGL 可以理解的格式。
教程:风起云涌
“Find Your Way To Oz”中反复出现的主题是风。故事情节的一条主线被设计成风声渐强。
嘉年华的第一个场景相对平静。随着场景的切换,用户会体验到风力逐渐增强,最终在最后一个场景中迎来暴风雨。
因此,提供沉浸式风效非常重要。
为了实现这一效果,我们在 3 个嘉年华场景中放置了柔软的物体,这些物体应该会受到风的影响,例如帐篷、照相亭表面的旗帜以及气球本身。
如今,桌面游戏通常围绕核心物理引擎构建。因此,当需要在 3D 世界中模拟软体对象时,系统会为其运行完整的物理模拟,从而创建可信的软体行为。
在 WebGL / Javascript 中,我们(还)无法运行完整的物理模拟。因此,在《奥兹大帝》中,我们必须找到一种方法来创造风的效果,而不是实际模拟它。
我们将每个对象的“风敏感度”信息嵌入到 3D 模型本身中。3D 模型的每个顶点都有一个“风属性”,用于指定该顶点受风影响的程度。因此,3D 对象的风敏感度是指定的。然后,我们需要创造风本身。
为此,我们生成了一张包含 Perlin 噪声的图片。此图片旨在覆盖特定的“风力区域”。因此,您可以将其想象为一张云状噪声图片,覆盖在 3D 场景的特定矩形区域上。此图片的每个像素(灰度值)都指定了在“周围”3D 区域中某个时刻的风力强度。
为了产生风的效果,图像会随着时间推移以恒定速度向特定方向移动,即风的方向。为了确保“风区”不会影响场景中的所有内容,我们将风图像包裹在边缘周围,并将其限制在效果区域内。
简单的 3D 风教程
现在,我们来在 Three.js 的简单 3D 场景中创建风的效果。
我们将在一个简单的“程序化草地”中创建风。
我们先来创建场景。我们将创建一个简单的、有纹理的平坦地形。然后,每根草都将简单地用一个倒置的 3D 圆锥体来表示。
下面介绍了如何使用 CoffeeScript 在 Three.js 中创建这个简单的场景。
首先,我们将设置 Three.js,并将其与相机、鼠标控制器和一些灯光连接起来:
constructor: ->
@clock = new THREE.Clock()
@container = document.createElement( 'div' );
document.body.appendChild( @container );
@renderer = new THREE.WebGLRenderer();
@renderer.setSize( window.innerWidth, window.innerHeight );
@renderer.setClearColorHex( 0x808080, 1 )
@container.appendChild(@renderer.domElement);
@camera = new THREE.PerspectiveCamera( 50, window.innerWidth / window.innerHeight, 1, 5000 );
@camera.position.x = 5;
@camera.position.y = 10;
@camera.position.z = 40;
@controls = new THREE.OrbitControls( @camera, @renderer.domElement );
@controls.enabled = true
@scene = new THREE.Scene();
@scene.add( new THREE.AmbientLight 0xFFFFFF )
directional = new THREE.DirectionalLight 0xFFFFFF
directional.position.set( 10,10,10)
@scene.add( directional )
# Demo data
@grassTex = THREE.ImageUtils.loadTexture("textures/grass.png");
@initGrass()
@initTerrain()
# Stats
@stats = new Stats();
@stats.domElement.style.position = 'absolute';
@stats.domElement.style.top = '0px';
@container.appendChild( @stats.domElement );
window.addEventListener( 'resize', @onWindowResize, false );
@animate()
initGrass 和 initTerrain 函数调用分别使用草地和地形填充场景:
initGrass:->
mat = new THREE.MeshPhongMaterial( { map: @grassTex } )
NUM = 15
for i in [0..NUM] by 1
for j in [0..NUM] by 1
x = ((i/NUM) - 0.5) * 50 + THREE.Math.randFloat(-1,1)
y = ((j/NUM) - 0.5) * 50 + THREE.Math.randFloat(-1,1)
@scene.add( @instanceGrass( x, 2.5, y, 5.0, mat ) )
instanceGrass:(x,y,z,height,mat)->
geometry = new THREE.CylinderGeometry( 0.9, 0.0, height, 3, 5 )
mesh = new THREE.Mesh( geometry, mat )
mesh.position.set( x, y, z )
return mesh
在这里,我们创建了一个 15x15 的草地网格。我们为每个草的位置添加了一些随机性,这样它们就不会像士兵一样排成一排,否则看起来会很奇怪。
此地形只是一个水平平面,位于草地底部 (y = 2.5)。
initTerrain:->
@plane = new THREE.Mesh( new THREE.PlaneGeometry(60, 60, 2, 2), new THREE.MeshPhongMaterial({ map: @grassTex }))
@plane.rotation.x = -Math.PI/2
@scene.add( @plane )
到目前为止,我们所做的只是创建了一个 Three.js 场景,并添加了一些草(由程序生成的倒锥体组成)和一个简单的地形。
到目前为止,还没有什么特别之处。
现在,可以开始添加风了。首先,我们要将风敏度信息嵌入到草地 3D 模型中。
我们将把这些信息作为自定义属性嵌入到草地 3D 模型的每个顶点中。我们将使用以下规则:草模型底端(圆锥体尖端)的灵敏度为零,因为它附着在地面上。草模型的顶部(圆锥体的底部)对风的敏感度最高,因为它是距离地面最远的部分。
以下是 instanceGrass 函数的重新编码方式,旨在将风敏感度作为草地 3D 模型的自定义属性添加。
instanceGrass:(x,y,z,height)->
geometry = new THREE.CylinderGeometry( 0.9, 0.0, height, 3, 5 )
for i in [0..geometry.vertices.length-1] by 1
v = geometry.vertices[i]
r = (v.y / height) + 0.5
@windMaterial.attributes.windFactor.value[i] = r * r * r
# Create mesh
mesh = new THREE.Mesh( geometry, @windMaterial )
mesh.position.set( x, y, z )
return mesh
我们现在使用自定义材质 windMaterial,而不是之前使用的 MeshPhongMaterial。WindMaterial 封装了我们稍后将看到的 WindMeshShader。
因此,instanceGrass 中的代码会遍历草模型的所有顶点,并为每个顶点添加一个名为 windFactor 的自定义顶点属性。对于草模型的底端(应该接触地形的位置),此 windFactor 设置为 0,对于草模型的顶端,其值为 1。
我们还需要添加另一个元素,那就是为场景添加实际的风。如前所述,我们将使用 Perlin 噪声来实现这一效果。我们将通过程序生成 Perlin 噪声纹理。
为了清晰起见,我们将把此纹理分配给地形本身,以取代其之前的绿色纹理。这样可以更轻松地了解风力情况。
因此,此 Perlin 噪声纹理将在空间上覆盖地形的延伸范围,并且纹理的每个像素都将指定该像素所在地形区域的风力强度。地形矩形将作为我们的“风力区域”。
Perlin 噪声是通过名为 NoiseShader 的着色器以程序化方式生成的。此着色器使用来自以下网址的 3D 单纯形噪声算法:https://github.com/ashima/webgl-noise。此示例的 WebGL 版本直接取自 MrDoob 的一个 Three.js 示例,网址为:http://mrdoob.github.com/three.js/examples/webgl_terrain_dynamic.html。
NoiseShader 接受时间、缩放和偏移参数集作为 uniform,并输出 Perlin 噪声的良好 2D 分布。
class NoiseShader
uniforms:
"fTime" : { type: "f", value: 1 }
"vScale" : { type: "v2", value: new THREE.Vector2(1,1) }
"vOffset" : { type: "v2", value: new THREE.Vector2(1,1) }
...
我们将使用此着色器将 Perlin 噪声渲染到纹理。此操作在 initNoiseShader 函数中完成。
initNoiseShader:->
@noiseMap = new THREE.WebGLRenderTarget( 256, 256, { minFilter: THREE.LinearMipmapLinearFilter, magFilter: THREE.LinearFilter, format: THREE.RGBFormat } );
@noiseShader = new NoiseShader()
@noiseShader.uniforms.vScale.value.set(0.3,0.3)
@noiseScene = new THREE.Scene()
@noiseCameraOrtho = new THREE.OrthographicCamera( window.innerWidth / - 2, window.innerWidth / 2, window.innerHeight / 2, window.innerHeight / - 2, -10000, 10000 );
@noiseCameraOrtho.position.z = 100
@noiseScene.add( @noiseCameraOrtho )
@noiseMaterial = new THREE.ShaderMaterial
fragmentShader: @noiseShader.fragmentShader
vertexShader: @noiseShader.vertexShader
uniforms: @noiseShader.uniforms
lights:false
@noiseQuadTarget = new THREE.Mesh( new THREE.PlaneGeometry(window.innerWidth,window.innerHeight,100,100), @noiseMaterial )
@noiseQuadTarget.position.z = -500
@noiseScene.add( @noiseQuadTarget )
上述代码的作用是将 noiseMap 设置为 Three.js 渲染目标,为其配备 NoiseShader,然后使用正交相机进行渲染,以避免透视失真。
如前所述,我们现在还要将此纹理用作地形的主要渲染纹理。这对于风效本身起作用并不是必需的。但最好还是有,这样我们就能更好地直观了解风力发电的情况。
以下是经过重新设计的 initTerrain 函数,它使用 noiseMap 作为纹理:
initTerrain:->
@plane = new THREE.Mesh( new THREE.PlaneGeometry(60, 60, 2, 2), new THREE.MeshPhongMaterial( { map: @noiseMap, lights: false } ) )
@plane.rotation.x = -Math.PI/2
@scene.add( @plane )
现在,我们已经准备好了风纹理,接下来看看 WindMeshShader,它负责根据风力使草模型变形。
为了创建此着色器,我们从标准 Three.js MeshPhongMaterial 着色器开始,并对其进行了修改。这是一种快速而粗略的方法,可让您开始使用有效的着色器,而无需从头开始。
我们不会在此处复制整个着色器代码(您可以随时在源代码文件中查看),因为其中大部分代码都是 MeshPhongMaterial 着色器的副本。不过,我们先来看看顶点着色器中与风相关的修改部分。
vec4 wpos = modelMatrix * vec4( position, 1.0 );
vec4 wpos = modelMatrix * vec4( position, 1.0 );
wpos.z = -wpos.z;
vec2 totPos = wpos.xz - windMin;
vec2 windUV = totPos / windSize;
vWindForce = texture2D(tWindForce,windUV).x;
float windMod = ((1.0 - vWindForce)* windFactor ) * windScale;
vec4 pos = vec4(position , 1.0);
pos.x += windMod * windDirection.x;
pos.y += windMod * windDirection.y;
pos.z += windMod * windDirection.z;
mvPosition = modelViewMatrix * pos;
因此,此着色器会先根据顶点的 2D xz(水平)位置计算 windUV 纹理查找坐标。此 UV 坐标用于从 Perlin 噪声风纹理中查找风力 vWindForce。
此 vWindForce 值会与上文所述的顶点特定 windFactor 自定义属性组合,以计算顶点需要多少形变。我们还有一个全局 windScale 参数,用于控制风的整体强度,以及一个 windDirection 向量,用于指定风变形需要发生的方向。
这样,草叶就会根据风力产生变形。不过,我们还没有完成。目前,这种变形是静态的,无法传达风力区域的效果。
正如我们之前提到的,我们需要让噪点纹理随时间在风力区域内滑动,这样草才能随风摇曳。
为此,需要随着时间的推移,移动传递给 NoiseShader 的 vOffset uniform。这是一个 vec2 参数,可让我们指定沿特定方向(风向)的噪声偏移。
我们在 render 函数中执行此操作,该函数会在每一帧调用:
render: =>
delta = @clock.getDelta()
if @windDirection
@noiseShader.uniforms[ "fTime" ].value += delta * @noiseSpeed
@noiseShader.uniforms[ "vOffset" ].value.x -= (delta * @noiseOffsetSpeed) * @windDirection.x
@noiseShader.uniforms[ "vOffset" ].value.y += (delta * @noiseOffsetSpeed) * @windDirection.z
...
就是这么简单!我们刚刚创建了一个场景,其中包含受风力影响的“程序化草地”。
添加尘埃
现在,让我们为场景增添一些趣味。我们来添加一些飞扬的尘土,让场景更有趣。
毕竟,灰尘应该会受到风的影响,因此在风场景中让灰尘四处飞扬是完全合理的。
灰尘在 initDust 函数中设置为粒子系统。
initDust:->
for i in [0...5] by 1
shader = new WindParticleShader()
params = {}
params.fragmentShader = shader.fragmentShader
params.vertexShader = shader.vertexShader
params.uniforms = shader.uniforms
params.attributes = { speed: { type: 'f', value: [] } }
mat = new THREE.ShaderMaterial(params)
mat.map = shader.uniforms["map"].value = THREE.ImageUtils.loadCompressedTexture("textures/dust#{i}.dds")
mat.size = shader.uniforms["size"].value = Math.random()
mat.scale = shader.uniforms["scale"].value = 300.0
mat.transparent = true
mat.sizeAttenuation = true
mat.blending = THREE.AdditiveBlending
shader.uniforms["tWindForce"].value = @noiseMap
shader.uniforms[ "windMin" ].value = new THREE.Vector2(-30,-30 )
shader.uniforms[ "windSize" ].value = new THREE.Vector2( 60, 60 )
shader.uniforms[ "windDirection" ].value = @windDirection
geom = new THREE.Geometry()
geom.vertices = []
num = 130
for k in [0...num] by 1
setting = {}
vert = new THREE.Vector3
vert.x = setting.startX = THREE.Math.randFloat(@dustSystemMinX,@dustSystemMaxX)
vert.y = setting.startY = THREE.Math.randFloat(@dustSystemMinY,@dustSystemMaxY)
vert.z = setting.startZ = THREE.Math.randFloat(@dustSystemMinZ,@dustSystemMaxZ)
setting.speed = params.attributes.speed.value[k] = 1 + Math.random() * 10
setting.sinX = Math.random()
setting.sinXR = if Math.random() < 0.5 then 1 else -1
setting.sinY = Math.random()
setting.sinYR = if Math.random() < 0.5 then 1 else -1
setting.sinZ = Math.random()
setting.sinZR = if Math.random() < 0.5 then 1 else -1
setting.rangeX = Math.random() * 5
setting.rangeY = Math.random() * 5
setting.rangeZ = Math.random() * 5
setting.vert = vert
geom.vertices.push vert
@dustSettings.push setting
particlesystem = new THREE.ParticleSystem( geom , mat )
@dustSystems.push particlesystem
@scene.add particlesystem
这里会创建 130 个灰尘粒子。请注意,每个粒子都配备了一个特殊的 WindParticleShader。
现在,在每一帧中,我们将使用 CoffeeScript 让粒子稍微移动一下,不受风的影响。代码如下。
moveDust:(delta)->
for setting in @dustSettings
vert = setting.vert
setting.sinX = setting.sinX + (( 0.002 * setting.speed) * setting.sinXR)
setting.sinY = setting.sinY + (( 0.002 * setting.speed) * setting.sinYR)
setting.sinZ = setting.sinZ + (( 0.002 * setting.speed) * setting.sinZR)
vert.x = setting.startX + ( Math.sin(setting.sinX) * setting.rangeX )
vert.y = setting.startY + ( Math.sin(setting.sinY) * setting.rangeY )
vert.z = setting.startZ + ( Math.sin(setting.sinZ) * setting.rangeZ )
此外,我们还要根据风力来偏移每个粒子的位置。此操作在 WindParticleShader 中完成。具体来说,是在顶点着色器中。
此着色器的代码是 Three.js ParticleMaterial 的修改版本,其核心如下所示:
vec4 mvPosition;
vec4 wpos = modelMatrix * vec4( position, 1.0 );
wpos.z = -wpos.z;
vec2 totPos = wpos.xz - windMin;
vec2 windUV = totPos / windSize;
float vWindForce = texture2D(tWindForce,windUV).x;
float windMod = (1.0 - vWindForce) * windScale;
vec4 pos = vec4(position , 1.0);
pos.x += windMod * windDirection.x;
pos.y += windMod * windDirection.y;
pos.z += windMod * windDirection.z;
mvPosition = modelViewMatrix * pos;
fSpeed = speed;
float fSize = size * (1.0 + sin(time * speed));
#ifdef USE_SIZEATTENUATION
gl_PointSize = fSize * ( scale / length( mvPosition.xyz ) );
#else,
gl_PointSize = fSize;
#endif
gl_Position = projectionMatrix * mvPosition;
此顶点着色器与我们用于草地风力变形的着色器没有太大区别。它将 Perlin 噪声纹理作为输入,并根据灰尘世界位置在噪声纹理中查找 vWindForce 值。然后,它会使用此值来修改尘埃粒子的位置。
Riders On The Storm
在我们的 WebGL 场景中,最惊险刺激的可能就是最后一个场景了。如果您点击热气球,进入龙卷风的风眼,就能到达网站旅程的终点,并观看即将发行的专辑的独家视频。
在创建这个场景时,我们知道需要有一个核心功能来提供具有影响力的体验。旋转的龙卷风将作为核心元素,其他内容层则会塑造这一特征,营造出戏剧性的效果。为此,我们围绕这个奇特的着色器搭建了一个相当于电影摄影棚的场景。
我们采用混合方法来创建逼真的合成图像。有些是视觉技巧,例如通过光线形状营造镜头光晕效果,或让雨滴在您看到的场景上分层呈现动画效果。在其他情况下,我们绘制了看起来在移动的平面,例如根据粒子系统代码移动的低空云层。而围绕龙卷风旋转的碎片则是 3D 场景中的图层,经过排序后在龙卷风的前后移动。
我们之所以必须以这种方式构建场景,主要是为了确保我们有足够的 GPU 来处理龙卷风着色器,同时平衡我们应用的其他效果。最初,我们遇到了严重的 GPU 平衡问题,但后来这个场景得到了优化,变得比主场景更轻量。
教程:风暴着色器
为了创建最终的风暴序列,我们结合使用了许多不同的技术,但这项工作的核心是一个看起来像龙卷风的自定义 GLSL 着色器。我们尝试了许多不同的技术,从使用顶点着色器创建有趣的几何漩涡,到基于粒子的动画,甚至扭曲几何形状的 3D 动画。这些效果要么无法重现龙卷风的感觉,要么需要进行大量处理。
最终,一个完全不同的项目为我们提供了答案。马克斯·普朗克研究所 (brainflight.org) 开展了一个并行项目,该项目涉及通过科学游戏绘制小鼠大脑图谱,并产生了有趣的视觉效果。我们成功使用自定义体积着色器制作了小鼠神经元内部的影片。
我们发现,脑细胞内部看起来有点像龙卷风的漏斗。由于我们使用的是体积技术,因此我们知道可以从空间中的所有方向查看此着色器。我们可以将着色器的渲染设置为与雷暴场景相结合,尤其是在夹在云层和戏剧性背景之间时。
着色器技术涉及一个技巧,该技巧基本上使用单个 GLSL 着色器,通过一种称为“距离场光线步进渲染”的简化渲染算法来渲染整个对象。在这种技术中,系统会创建一个像素着色器,用于估算屏幕上每个点到表面的最近距离。
如需了解该算法,请参阅 iq 的概览:Rendering Worlds With Two Triangles - Iñigo Quilez。此外,您还可以探索 glsl.heroku.com 上的着色器库,其中有许多此类技术的示例可供您进行实验。
着色器的核心从 main 函数开始,它会设置相机转换并进入一个循环,该循环会重复评估到表面的距离。调用 RaytraceFoggy( direction_vector, max_iterations, color, color_multiplier ) 是进行核心光线步进计算的地方。
for(int i=0;i < number_of_steps;i++) // run the ray marching loop
{
old_d=d;
float shape_value=Shape(q); // find out the approximate distance to or density of the tornado cone
float density=-shape_value;
d=max(shape_value*step_scaling,0.0);// The max function clamps values smaller than 0 to 0
float step_dist=d+extra_step; // The point is advanced by larger steps outside the tornado,
// allowing us to skip empty space quicker.
if (density>0.0) { // When density is positive, we are inside the cloud
float brightness=exp(-0.6*density); // Brightness decays exponentially inside the cloud
// This function combines density layers to create a translucent fog
FogStep(step_dist*0.2,clamp(density, 0.0,1.0)*vec3(1,1,1), vec3(1)*brightness, colour, multiplier);
}
if(dist>max_dist || multiplier.x < 0.01) { return; } // if we've gone too far stop, we are done
dist+=step_dist; // add a new step in distance
q=org+dist*dir; // trace its direction according to the ray casted
}
其原理是,随着我们深入到龙卷风的形状中,我们会定期为像素的最终颜色值添加颜色贡献,并为沿光线的透明度添加贡献。这为龙卷风的纹理营造出一种层层叠叠的柔和质感。
龙卷风的下一个核心方面是实际形状本身,它是通过组合多个函数创建的。它最初是一个圆锥体,通过与噪声结合,形成了自然的粗糙边缘,随后沿其主轴扭曲并随时间旋转。
mat2 Spin(float angle){
return mat2(cos(angle),-sin(angle),sin(angle),cos(angle)); // a rotation matrix
}
// This takes noise function and makes ridges at the points where that function crosses zero
float ridged(float f){
return 1.0-2.0*abs(f);
}
// the isosurface shape function, the surface is at o(q)=0
float Shape(vec3 q)
{
float t=time;
if(q.z < 0.0) return length(q);
vec3 spin_pos=vec3(Spin(t-sqrt(q.z))*q.xy,q.z-t*5.0); // spin the coordinates in time
float zcurve=pow(q.z,1.5)*0.03; // a density function dependent on z-depth
// the basic cloud of a cone is perturbed with a distortion that is dependent on its spin
float v=length(q.xy)-1.5-zcurve-clamp(zcurve*0.2,0.1,1.0)*snoise(spin_pos*vec3(0.1,0.1,0.1))*5.0;
// create ridges on the tornado
v=v-ridged(snoise(vec3(Spin(t*1.5+0.1*q.z)*q.xy,q.z-t*4.0)*0.3))*1.2;
return v;
}
创建此类着色器涉及的工作非常棘手。除了与您正在创建的操作的抽象相关的问题之外,还存在严重的优化和跨平台兼容性问题,您需要跟踪并解决这些问题,然后才能在生产环境中使用这些工作。
问题的第一部分:针对我们的场景优化此着色器。为了解决这个问题,我们需要采用一种“安全”的方法,以防着色器过于繁重。为此,我们以不同于场景其余部分的采样分辨率合成了龙卷风着色器。此代码来自 stormTest.coffee 文件(是的,这是一个测试!)。
我们首先创建一个与场景宽度和高度匹配的 renderTarget,这样我们就可以让龙卷风着色器的分辨率独立于场景。然后,我们根据获得的帧速率,动态决定风暴着色器的分辨率降采样。
...
Line 1383
@tornadoRT = new THREE.WebGLRenderTarget( @SCENE_WIDTH, @SCENE_HEIGHT, paramsN )
...
Line 1403
# Change settings based on FPS
if @fpsCount > 0
if @fpsCur < 20
@tornadoSamples = Math.min( @tornadoSamples + 1, @MAX_SAMPLES )
if @fpsCur > 25
@tornadoSamples = Math.max( @tornadoSamples - 1, @MIN_SAMPLES )
@tornadoW = @SCENE_WIDTH / @tornadoSamples // decide tornado resWt
@tornadoH = @SCENE_HEIGHT / @tornadoSamples // decide tornado resHt
最后,我们使用简化的 sal2x 算法(以避免块状外观)将龙卷风渲染到屏幕上,详见 stormTest.coffee 中的第 1107 行。这意味着,在最坏的情况下,我们最终会得到一个更模糊的龙卷风,但至少它能正常运行,而不会剥夺用户的控制权。
下一个优化步骤需要深入研究算法。着色器中的主要计算因素是对每个像素执行的迭代,以尝试近似计算表面函数的距离:光线步进循环的迭代次数。使用较大的步长,我们可以在云层表面之外,通过较少的迭代次数获得龙卷风表面估计值。进入内部后,我们会减小步长以提高精度,并混合不同的值来营造雾气效果。此外,通过创建边界圆柱体来获取投射光线的深度估计值,也大大提高了速度。
问题的下一部分是确保此着色器可在不同的显卡上运行。我们每次都会进行一些测试,并开始对可能遇到的兼容性问题类型形成直觉。我们之所以无法做得比直觉更好,是因为我们无法始终获得有关错误的良好调试信息。典型场景是仅出现 GPU 错误,几乎没有其他信息,甚至系统崩溃!
跨视频板兼容性问题也有类似的解决方案:确保输入的静态常量具有所定义的精确数据类型,例如:float 为 0.0,int 为 0。编写较长的函数时要小心;最好将内容拆分为多个更简单的函数和临时变量,因为编译器似乎无法正确处理某些情况。确保纹理大小均为 2 的幂,不要太大,并且在循环中查找纹理数据时务必“谨慎”。
我们遇到的最大兼容性问题来自风暴的光效。我们使用预制纹理包裹龙卷风,以便为其烟雾上色。这种效果非常棒,可以轻松地将龙卷风融入场景颜色中,但需要花费很长时间才能在其他平台上运行。
移动网站
移动端体验不能直接照搬桌面版,因为技术和处理要求太高。我们必须打造一款专门针对移动用户的新产品。
我们认为,如果能将桌面版 Carnival Photo-Booth 打造为移动 Web 应用,并使用用户的移动摄像头,那将是一件很酷的事情。这是我们之前从未见过的。
为了增加趣味性,我们使用 CSS3 编写了 3D 转换代码。通过将其与陀螺仪和加速度计关联,我们能够为游戏体验增添许多深度。该网站会根据您握持、移动和查看手机的方式做出响应。
在撰写本文时,我们认为有必要为您提供一些提示,帮助您顺利开展移动开发流程。他们出发了!快去看看你能从中获得哪些启发吧!
移动设备提示和技巧
预加载器是必需的,而不是应该避免的。我们知道,有时会出现后一种情况。这主要是因为,随着项目的发展,您需要不断维护预加载的内容列表。更糟糕的是,如果您同时拉取多个不同的资源,则很难计算加载进度。这时,我们自定义的非常通用的抽象类“Task”就派上用场了。其主要思路是允许无限嵌套结构,其中一个任务可以有自己的子任务,子任务也可以有自己的子任务,以此类推。此外,每个任务都会根据其子任务的进度(而不是父任务的进度)计算自己的进度。通过让所有 MainPreloadTask、AssetPreloadTask 和 TemplatePreFetchTask 派生自 Task,我们创建了如下所示的结构:
得益于这种方法和 Task 类,我们可以轻松了解全局进度 (MainPreloadTask)、素材资源进度 (AssetPreloadTask) 或加载模板进度 (TemplatePreFetchTask)。甚至可以查看特定文件的进度。如需了解具体做法,请查看 /m/javascripts/raw/util/Task.js 中的 Task 类以及 /m/javascripts/preloading/task 中的实际任务实现。 例如,以下代码段展示了我们如何设置 /m/javascripts/preloading/task/MainPreloadTask.js 类,这是我们的最终预加载封装容器:
Package('preloading.task', [
Import('util.Task'),
...
Class('public MainPreloadTask extends Task', {
_public: {
MainPreloadTask : function() {
var subtasks = [
new AssetPreloadTask([
{name: 'cutout/cutout-overlay-1', ext: 'png', type: ImagePreloader.TYPE_BACKGROUND, responsive: true},
{name: 'journey/scene1', ext: 'jpg', type: ImagePreloader.TYPE_IMG, responsive: false}, ...
...
]),
new TemplatePreFetchTask([
'page.HomePage',
'page.CutoutPage',
'page.JourneyToOzPage1', ...
...
])
];
this._super(subtasks);
}
}
})
]);
在 /m/javascripts/preloading/task/subtask/AssetPreloadTask.js 类中,除了注意它如何与 MainPreloadTask 通信(通过共享的 Task 实现)之外,还值得注意我们如何加载依赖于平台的资源。基本上,我们有四种类型的图片。移动标准 (.ext,其中 ext 是文件扩展名,通常为 .png 或 .jpg)、移动 Retina (-2x.ext)、平板电脑标准 (-tab.ext) 和平板电脑 Retina (-tab-2x.ext)。我们不使用 MainPreloadTask 进行检测并对四个素材资源数组进行硬编码,而是直接指定要预加载的素材资源的名称和扩展名,以及素材资源是否依赖于平台(responsive = true / false)。然后,AssetPreloadTask 会为我们生成文件名:
resolveAssetUrl : function(assetName, extension, responsive) {
return AssetPreloadTask.ASSETS_ROOT + assetName + (responsive === true ? ((Detection.getInstance().tablet ? '-tab' : '') + (Detection.getInstance().retina ? '-2x' : '')) : '') + '.' + extension;
}
在类链的更深处,执行资源预加载的实际代码如下所示 (/m/javascripts/raw/util/ImagePreloader.js):
loadUrl : function(url, type, completeHandler) {
if(type === ImagePreloader.TYPE_BACKGROUND) {
var $bg = $('<div>').hide().css('background-image', 'url(' + url + ')');
this.$preloadContainer.append($bg);
} else {
var $img= $('<img />').attr('src', url).hide();
this.$preloadContainer.append($img);
}
var image = new Image();
this.cache[this.generateKey(url)] = image;
image.onload = completeHandler;
image.src = url;
}
generateKey : function(url) {
return encodeURIComponent(url);
}
教程:HTML5 照相亭 (iOS6/Android)
在开发 OZ 移动版时,我们发现自己花了很多时间玩大头贴,而不是工作 :D,这纯粹是因为它很有趣。因此,我们制作了一个演示供您体验。
您可以在此处查看实时演示(在 iPhone 或 Android 手机上运行):
http://u9html5rocks.appspot.com/demos/mobile_photo_booth
如需进行设置,您需要一个免费的 Google App Engine 应用实例,以便在其中运行后端。前端代码并不复杂,但有几个可能需要注意的问题。现在,我们来逐一了解一下:
- 允许的图片文件类型
我们希望用户只能上传图片(因为这是照相亭,而不是视频亭)。理论上,您只需在 HTML 中指定过滤器,如下所示:
input id="fileInput" class="fileInput" type="file" name="file" accept="image/*"不过,这似乎仅适用于 iOS,因此我们需要在选择文件后针对正则表达式添加额外的检查:
this.$fileInput.fileupload({
dataType: 'json',
autoUpload : true,
add : function(e, data) {
if(!data.files[0].name.match(/(\.|\/)(gif|jpe?g|png)$/i)) {
return self.onFileTypeNotSupported();
}
}
});
- 取消上传或文件选择 我们在开发过程中注意到的另一个不一致之处是,不同设备在取消文件选择时通知方式不同。iOS 手机和平板电脑不会执行任何操作,根本不会发出通知。因此,我们无需针对这种情况采取任何特殊措施,但无论如何,即使未选择任何文件,Android 手机也会触发 add() 函数。以下是满足这一需求的方法:
add : function(e, data) {
if(data.files.length === 0 || (data.files[0].size === 0 && data.files[0].name === "" && data.files[0].fileName === "")) {
return self.onNoFileSelected();
} else if(data.files.length > 1) {
return self.onMultipleFilesSelected();
}
}
其他功能在各个平台上都运行得相当流畅。祝你使用愉快!
总结
鉴于《Find Your Way To Oz》的庞大规模以及所涉及的各种不同技术,在本文中,我们只能介绍我们所采用的几种方法。
如果您想探索整个项目,请随时访问此链接,查看“Find Your Way To Oz”的完整源代码。
赠金
点击此处可查看完整鸣谢名单
参考
- CoffeeScript - http://coffeescript.org/
- Backbone.js - http://backbonejs.org/
- Three.js - http://mrdoob.github.com/three.js/
- 马克斯·普朗克研究所 (brainflight.org) - http://brainflight.org/