Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
branch: master
Fetching contributors…

Cannot retrieve contributors at this time

599 lines (512 sloc) 19.321 kb
/*{# Copyright (c) 2010-2012 Turbulenz Limited #}*/
/*
* @title: Load model
* @description:
* This sample shows how to load geometry models and how to add instances of them to the scene.
* The sample will first request and load a dinning room model into a Scene object and when finished
* you will then be able to load and remove two additional models to the same scene.
*/
/*{{ javascript("jslib/camera.js") }}*/
/*{{ javascript("jslib/aabbtree.js") }}*/
/*{{ javascript("jslib/effectmanager.js") }}*/
/*{{ javascript("jslib/shadermanager.js") }}*/
/*{{ javascript("jslib/texturemanager.js") }}*/
/*{{ javascript("jslib/geometry.js") }}*/
/*{{ javascript("jslib/material.js") }}*/
/*{{ javascript("jslib/light.js") }}*/
/*{{ javascript("jslib/scenenode.js") }}*/
/*{{ javascript("jslib/scene.js") }}*/
/*{{ javascript("jslib/scenedebugging.js") }}*/
/*{{ javascript("jslib/renderingcommon.js") }}*/
/*{{ javascript("jslib/forwardrendering.js") }}*/
/*{{ javascript("jslib/resourceloader.js") }}*/
/*{{ javascript("jslib/utilities.js") }}*/
/*{{ javascript("jslib/requesthandler.js") }}*/
/*{{ javascript("jslib/observer.js") }}*/
/*{{ javascript("jslib/vertexbuffermanager.js") }}*/
/*{{ javascript("jslib/indexbuffermanager.js") }}*/
/*{{ javascript("jslib/vmath.js") }}*/
/*{{ javascript("jslib/services/turbulenzservices.js") }}*/
/*{{ javascript("jslib/services/turbulenzbridge.js") }}*/
/*{{ javascript("jslib/services/gamesession.js") }}*/
/*{{ javascript("jslib/services/mappingtable.js") }}*/
/*{{ javascript("scripts/sceneloader.js") }}*/
/*{{ javascript("scripts/htmlcontrols.js") }}*/
/*global TurbulenzEngine: true */
/*global TurbulenzServices: false */
/*global RequestHandler: false */
/*global TextureManager: false */
/*global ShaderManager: false */
/*global EffectManager: false */
/*global Scene: false */
/*global SceneNode: false */
/*global SceneLoader: false */
/*global Camera: false */
/*global CameraController: false */
/*global Light: false */
/*global LightInstance: false */
/*global HTMLControls: false */
/*global ForwardRendering: false */
TurbulenzEngine.onload = function onloadFn()
{
var errorCallback = function errorCallback(msg)
{
window.alert(msg);
};
// Create the engine devices objects
var graphicsDeviceParameters = { };
var graphicsDevice = TurbulenzEngine.createGraphicsDevice(graphicsDeviceParameters);
if (!graphicsDevice.shadingLanguageVersion)
{
errorCallback("No shading language support detected.\nPlease check your graphics drivers are up to date.");
graphicsDevice = null;
return;
}
// Clear the background color of the engine window
if (graphicsDevice.beginFrame())
{
graphicsDevice.clear([0.5, 0.5, 0.5, 1.0]);
graphicsDevice.endFrame();
}
var clearColor = [0.0, 0.0, 0.0, 1.0];
var mathDeviceParameters = {};
var mathDevice = TurbulenzEngine.createMathDevice(mathDeviceParameters);
var inputDeviceParameters = { };
var inputDevice = TurbulenzEngine.createInputDevice(inputDeviceParameters);
// Create a camera with a 60 degree FOV
var camera = Camera.create(mathDevice);
var halfFov = Math.tan(30 * Math.PI / 180);
camera.recipViewWindowX = 1.0 / halfFov;
camera.recipViewWindowY = 1.0 / halfFov;
camera.updateProjectionMatrix();
var worldUp = mathDevice.v3BuildYAxis();
camera.lookAt(worldUp, worldUp, mathDevice.v3Build(0.0, 50.0, 200.0));
camera.updateViewMatrix();
var cameraController = CameraController.create(graphicsDevice, inputDevice, camera);
var requestHandlerParameters = {};
var requestHandler = RequestHandler.create(requestHandlerParameters);
var textureManager = TextureManager.create(graphicsDevice, requestHandler, null, errorCallback);
var shaderManager = ShaderManager.create(graphicsDevice, requestHandler, null, errorCallback);
var effectManager = EffectManager.create();
var scene = Scene.create(mathDevice);
var sceneLoader = SceneLoader.create();
var renderer;
var maxSpeed = cameraController.maxSpeed;
var intervalID;
var cube;
var duck;
var sphere;
var loadingDuck = false;
var loadingCube = false;
var loadingSphere = false;
var duckTransform = mathDevice.m43BuildIdentity();
var relPos = mathDevice.v3Build(-4.5, 4.8, -3);
mathDevice.m43Translate(duckTransform, relPos);
var cubeTransform = mathDevice.m43BuildIdentity();
relPos = mathDevice.v3Build(-2, 5.4, 4);
mathDevice.m43Translate(cubeTransform, relPos);
var sphereTransform = mathDevice.m43BuildIdentity();
relPos = mathDevice.v3Build(-6, 5.8, 2);
mathDevice.m43Translate(sphereTransform, relPos);
var buttonLoadDuck;
var buttonRemoveDuck;
var buttonLoadCube;
var buttonRemoveCube;
var buttonLoadSphere;
var buttonRemoveSphere;
var buttonsAvailable;
var loadModelDuck = function loadModelDuckFn()
{
// load in the duck
sceneLoader.load({scene : scene,
append : true,
assetPath : "models/duck.dae",
keepLights : false,
keepCameras : false,
graphicsDevice : graphicsDevice,
mathDevice : mathDevice,
textureManager : textureManager,
shaderManager : shaderManager,
effectManager : effectManager,
requestHandler : requestHandler,
baseMatrix : duckTransform,
disabled : true
});
// we check this flag in the update loop to know when to call sceneLoader.complete()
loadingDuck = true;
if (buttonsAvailable)
{
buttonLoadDuck.disabled = true;
}
};
var removeModelDuck = function removeModelDuckFn()
{
// Remove the duck from the scene
scene.removeRootNode(duck);
// Destroy the duck
// Set references to null
duck.destroy();
duck = null;
if (buttonsAvailable)
{
buttonRemoveDuck.disabled = true;
buttonLoadDuck.disabled = false;
}
};
var loadModelCube = function loadModelCubeFn()
{
// Load in the cube
sceneLoader.load({ scene : scene,
append : true,
assetPath : "models/cube.dae",
keepLights : false,
graphicsDevice : graphicsDevice,
mathDevice : mathDevice,
textureManager : textureManager,
shaderManager : shaderManager,
effectManager : effectManager,
requestHandler : requestHandler,
baseMatrix : cubeTransform,
disabled : true
});
// we check this flag in the update loop to know when to call sceneLoader.complete()
loadingCube = true;
if (buttonsAvailable)
{
buttonLoadCube.disabled = true;
}
};
var removeModelCube = function removeModelCubeFn()
{
// Remove the cube from the scene
scene.removeRootNode(cube);
// Set references to null
cube.destroy();
cube = null;
if (buttonsAvailable)
{
buttonRemoveCube.disabled = true;
buttonLoadCube.disabled = false;
}
};
var loadModelSphere = function loadModelSphereFn()
{
// Load in the sphere
sceneLoader.load({ scene : scene,
append : true,
assetPath : "models/sphere.dae",
keepLights : false,
graphicsDevice : graphicsDevice,
mathDevice : mathDevice,
textureManager : textureManager,
shaderManager : shaderManager,
effectManager : effectManager,
requestHandler : requestHandler,
baseMatrix : sphereTransform,
disabled : true
});
// we check this flag in the update loop to know when to call sceneLoader.complete()
loadingSphere = true;
if (buttonsAvailable)
{
buttonLoadSphere.disabled = true;
}
};
var removeModelSphere = function removeModelSphereFn()
{
// Remove the sphere from the scene
scene.removeRootNode(sphere);
// Set references to null
sphere.destroy();
sphere = null;
if (buttonsAvailable)
{
buttonRemoveSphere.disabled = true;
buttonLoadSphere.disabled = false;
}
};
// Link up with the HTML controls on the page
var htmlControls = HTMLControls.create();
htmlControls.addButtonControl({
id: "buttonLoadDuck",
value: "Load",
fn: loadModelDuck
});
htmlControls.addButtonControl({
id: "buttonRemoveDuck",
value: "Remove",
fn: removeModelDuck
});
htmlControls.addButtonControl({
id: "buttonLoadCube",
value: "Load",
fn: loadModelCube
});
htmlControls.addButtonControl({
id: "buttonRemoveCube",
value: "Remove",
fn: removeModelCube
});
htmlControls.addButtonControl({
id: "buttonLoadSphere",
value: "Load",
fn: loadModelSphere
});
htmlControls.addButtonControl({
id: "buttonRemoveSphere",
value: "Remove",
fn: removeModelSphere
});
buttonLoadDuck = document.getElementById("buttonLoadDuck");
buttonRemoveDuck = document.getElementById("buttonRemoveDuck");
buttonLoadCube = document.getElementById("buttonLoadCube");
buttonRemoveCube = document.getElementById("buttonRemoveCube");
buttonLoadSphere = document.getElementById("buttonLoadSphere");
buttonRemoveSphere = document.getElementById("buttonRemoveSphere");
// check that we can access the buttons
buttonsAvailable = buttonLoadDuck &&
buttonRemoveDuck &&
buttonLoadCube &&
buttonRemoveCube &&
buttonLoadSphere &&
buttonRemoveSphere;
if (buttonsAvailable)
{
buttonLoadDuck.disabled = true;
buttonLoadCube.disabled = true;
buttonLoadSphere.disabled = true;
buttonRemoveDuck.disabled = true;
buttonRemoveCube.disabled = true;
buttonRemoveSphere.disabled = true;
}
htmlControls.register();
// Create a callback for post scene load to update the camera position
var loadCubeFinished = function loadCubeFinishedFn(scene)
{
loadingCube = false;
cube = scene.findNode("cube");
cube.enableHierarchy(true);
buttonRemoveCube.disabled = false;
};
var loadDuckFinished = function loadDuckFinishedFn(scene)
{
loadingDuck = false;
duck = scene.findNode("LOD3sp");
duck.enableHierarchy(true);
buttonRemoveDuck.disabled = false;
};
var loadSphereFinished = function loadSphereFinishedFn(scene)
{
loadingSphere = false;
sphere = scene.findNode("sphere");
sphere.enableHierarchy(true);
buttonRemoveSphere.disabled = false;
};
var v3Build = mathDevice.v3Build;
// Callback for when the scene is loaded to add some lights
function loadSceneFinished(scene)
{
var addPointLight = function addLightFn(lightName, lightMaterial, position, color)
{
var light = Light.create(
{
name : lightName,
color : mathDevice.v3Build(color[0], color[1], color[2]),
point : true,
shadows : true,
halfExtents: v3Build.call(mathDevice, 40, 40, 40),
origin: v3Build.call(mathDevice, 0, 10, 0),
material : lightMaterial
});
scene.addLight(light);
var lightMatrix = mathDevice.m43BuildTranslation(v3Build.apply(mathDevice, position));
var lightNode = SceneNode.create(
{
name: lightName + "-node",
local: lightMatrix
});
lightNode.addLightInstance(LightInstance.create(light));
scene.addRootNode(lightNode);
};
var lightMaterialData = {
effect: "lambert",
parameters : {
lightfalloff: "textures/default_light.png",
lightprojection: "textures/default_light.png"
}
};
scene.loadMaterial(graphicsDevice,
textureManager,
effectManager,
"defaultLightMaterial",
lightMaterialData);
var lightMaterial = scene.getMaterial("defaultLightMaterial");
// Add some lights into the scene
addPointLight("globalLight",
lightMaterial,
[-3.5, 15, -0.5],
[1, 1, 1]);
scene.addLight(Light.create({name : "ambient",
ambient : true,
color : [0.1, 0.1, 0.1]}));
if (buttonsAvailable)
{
buttonLoadDuck.disabled = false;
buttonLoadCube.disabled = false;
buttonLoadSphere.disabled = false;
}
}
var previousFrameTime;
// Create some rendering callbacks to pass to the renderer
function drawExtraDecalsFn()
{
}
function drawExtraTransparentFn()
{
}
function drawDebugFn()
{
}
var update = function updateFn()
{
var currentTime = TurbulenzEngine.time;
var deltaTime = (currentTime - previousFrameTime);
if (deltaTime > 0.1)
{
deltaTime = 0.1;
}
cameraController.maxSpeed = (deltaTime * maxSpeed);
// Update the input device
inputDevice.update();
cameraController.update();
// Update the aspect ratio of the camera in case of window resizes
var deviceWidth = graphicsDevice.width;
var deviceHeight = graphicsDevice.height;
var aspectRatio = (deviceWidth / deviceHeight);
if (aspectRatio !== camera.aspectRatio)
{
camera.aspectRatio = aspectRatio;
camera.updateProjectionMatrix();
}
camera.updateViewProjectionMatrix();
// If the duck is loading then check if it is complete
if (loadingDuck && sceneLoader.complete())
{
loadDuckFinished(scene);
}
else if (loadingCube && sceneLoader.complete())
{
loadCubeFinished(scene);
}
else if (loadingSphere && sceneLoader.complete())
{
loadSphereFinished(scene);
}
scene.update();
renderer.update(graphicsDevice, camera, scene, currentTime);
if (graphicsDevice.beginFrame())
{
renderer.draw(graphicsDevice,
clearColor,
drawExtraDecalsFn,
drawExtraTransparentFn,
drawDebugFn);
graphicsDevice.endFrame();
}
previousFrameTime = currentTime;
};
var loadingLoop = function loadingLoopFn()
{
if (sceneLoader.complete())
{
// Register the mainLoop callback as the new interval
TurbulenzEngine.clearInterval(intervalID);
// Move the camera to look at the scene
camera.lookAt(mathDevice.v3Build(-3.5, 5, -0.5), worldUp, mathDevice.v3Build(-13, 10, 8));
camera.updateViewMatrix();
camera.updateProjectionMatrix();
maxSpeed = 30;
renderer.updateShader(shaderManager);
intervalID = TurbulenzEngine.setInterval(update, 1000 / 60);
}
};
// Start calling the loading loop at 10Hz
intervalID = TurbulenzEngine.setInterval(loadingLoop, 1000 / 10);
previousFrameTime = TurbulenzEngine.time;
var loadAssets = function loadAssetsFn()
{
// Renderer for the scene (requires shader assets).
renderer = ForwardRendering.create(graphicsDevice,
mathDevice,
shaderManager,
effectManager,
{});
// Load the diningroom
sceneLoader.load({ scene : scene,
append : true,
assetPath : "models/diningroom.dae",
keepLights : true,
graphicsDevice : graphicsDevice,
mathDevice : mathDevice,
textureManager : textureManager,
shaderManager : shaderManager,
effectManager : effectManager,
requestHandler: requestHandler,
postSceneLoadFn : loadSceneFinished
});
};
var mappingTableReceived = function mappingTableReceivedFn(mappingTable)
{
textureManager.setPathRemapping(mappingTable.urlMapping, mappingTable.assetPrefix);
shaderManager.setPathRemapping(mappingTable.urlMapping, mappingTable.assetPrefix);
sceneLoader.setPathRemapping(mappingTable.urlMapping, mappingTable.assetPrefix);
loadAssets();
};
var gameSessionCreated = function gameSessionCreatedFn(gameSession)
{
TurbulenzServices.createMappingTable(requestHandler,
gameSession,
mappingTableReceived);
};
var gameSession = TurbulenzServices.createGameSession(requestHandler, gameSessionCreated);
// Create a scene destroy callback to run when the window is closed
TurbulenzEngine.onunload = function destroyScene()
{
TurbulenzEngine.clearInterval(intervalID);
if (gameSession)
{
gameSession.destroy();
gameSession = null;
}
requestHandler = null;
sceneLoader = null;
if (scene)
{
scene.destroy();
scene = null;
}
htmlControls = null;
effectManager = null;
if (textureManager)
{
textureManager.destroy();
textureManager = null;
}
if (shaderManager)
{
shaderManager.destroy();
shaderManager = null;
}
if (renderer)
{
renderer.destroy();
renderer = null;
}
cameraController = null;
camera = null;
TurbulenzEngine.flush();
inputDevice = null;
graphicsDevice = null;
mathDevice = null;
};
};
Jump to Line
Something went wrong with that request. Please try again.