cybafelo
/
r3-legacy
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

merge conflicts

beta.r3js.org
Theunis J. Botha 2016-11-23 10:51:47 +01:00
parent 8e843682a6 6baed2483f
commit 41e834ba9a
16 changed files with 1534 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
gulpfile.js
View File

@ -6,6 +6,7 @@ var plumber = require('gulp-plumber');
var istanbul = require('gulp-istanbul');
var mocha = require('gulp-mocha');
var watch = require('gulp-watch');
var preprocessor = require('gulp-c-preprocessor');
gulp.task(
'build',
@ -58,10 +59,92 @@ gulp.task(
}
);
gulp.task('compileRuntime', ['build'],
function() {
gulp.src(['./build/defines/runtime.js', './build/game-lib.js'])
.pipe(concat('game-lib-runtime.js'))
.pipe(preprocessor(
{
// End of line character
endLine: '\n',
// Escape '//#' & '/*#' comments (see extra/comments)
commentEscape: true,
// Empty lines to add between code and included files
includeSpaces: 0,
// Limit of empty following lines (0 = no limit)
emptyLinesLimit: 0,
// Base path for including files
basePath: './',
// Stop the compiler when an error ocurred ?
stopOnError: true,
// Constants in #enum command must be in hexadecimal ?
enumInHex: true
})
)
.pipe(minify({
ext:{
src:'.js',
min:'-min.js'
}
}))
.pipe(gulp.dest('./build/'));
}
);
gulp.task('compileEditor', ['build'],
function() {
gulp.src(['./build/defines/editor.js', './build/game-lib.js'])
.pipe(concat('game-lib-editor.js'))
.pipe(preprocessor(
{
// End of line character
endLine: '\n',
// Escape '//#' & '/*#' comments (see extra/comments)
commentEscape: true,
// Empty lines to add between code and included files
includeSpaces: 0,
// Limit of empty following lines (0 = no limit)
emptyLinesLimit: 0,
// Base path for including files
basePath: './',
// Stop the compiler when an error ocurred ?
stopOnError: true,
// Constants in #enum command must be in hexadecimal ?
enumInHex: true
})
)
.pipe(minify({
ext:{
src:'.js',
min:'-min.js'
}
}))
.pipe(gulp.dest('./build/'));
}
);
gulp.task(
'default',
[
'build'
'build',
'compileRuntime',
'compileEditor'
],
function() {
return watch([
@ -69,7 +152,9 @@ gulp.task(
],
function() {
gulp.start([
'build'
'build',
'compileRuntime',
'compileEditor'
]);
})
}

13
src/game-lib-a.js
View File

@ -19,9 +19,18 @@ if (typeof Q == 'undefined') {
if (typeof _ == 'undefined') {
if (typeof require == 'undefined') {
console.warn('You need the lowdash library for the GameLib.D3');
throw new Error('You need the lowdash library for the GameLib.D3');
console.warn('You need the lodash library for the GameLib.D3');
throw new Error('You need the lodash library for the GameLib.D3');
}
var _ = require('lodash');
}
//#ifdef RUNTIME__
console.log("Loading runtime library...");
//#endif
//#ifdef EDITOR__
console.log("Loading editor library...");
//#endif

66
src/game-lib-component-colorlerp.js Normal file
View File

@ -0,0 +1,66 @@
GameLib.D3.ComponentColorLerp = function(
id,
name,
startColor,
endColor,
lerpSpeed
) {
this.id = id|| GameLib.D3.Tools.RandomId();
if (typeof name == 'undefined') {
name = this.constructor.name;
}
this.name = name;
this.parentEntity = null;
// Todo: this should be executed somewhere in game-lib-z, so that we don't execute it on every construction of an object.
GameLib.D3.Utils.Extend(GameLib.D3.ComponentColorLerp, GameLib.D3.ComponentInterface);
this.startColor = startColor || new GameLib.D3.Vector3(0, 0, 0);
this.endColor = endColor || new GameLib.D3.Vector3(1, 1, 1);
this.lerpSpeed = lerpSpeed || 1.0;
this.lerpTarget = this.endColor;
};
///////////////////////// Methods to override //////////////////////////
GameLib.D3.ComponentColorLerp.prototype.onUpdate = function(
deltaTime,
parentEntity
) {
var t = deltaTime * this.lerpSpeed;
// t = t * t * t * (t * (6.0 * t - 15.0) + 10.0);
parentEntity.mesh.material.color.r = parentEntity.mesh.material.color.r + (this.endColor.x - parentEntity.mesh.material.color.r) * t;
parentEntity.mesh.material.color.g = parentEntity.mesh.material.color.g + (this.endColor.y - parentEntity.mesh.material.color.g) * t;
parentEntity.mesh.material.color.b = parentEntity.mesh.material.color.b + (this.endColor.z - parentEntity.mesh.material.color.b) * t;
/* if( parentEntity.mesh.material.color.r == this.endColor.x
&& parentEntity.mesh.material.color.g == this.endColor.y
&& parentEntity.mesh.material.color.b == this.endColor.z
) {
console.error("switch target");
//this.lerpTarget = this.startColor;
} /!*else if (parentEntity.mesh.material.color.r == this.startColor.x
&& parentEntity.mesh.material.color.g == this.startColor.y
&& parentEntity.mesh.material.color.b == this.startColor.z) {
this.lerpTarget = this.endColor;
}*!/*/
};
GameLib.D3.ComponentColorLerp.prototype.onSetParentEntity = function(
parentScene,
parentEntity
) {
parentEntity.mesh.material.color = new THREE.Color(
this.startColor.x,
this.startColor.y,
this.startColor.z
);
};

41
src/game-lib-component-fly-controls.js
View File

@ -134,6 +134,47 @@ GameLib.D3.ComponentFlyControls.prototype.onSetParentEntity = function(
document.exitPointerLock = document.exitPointerLock || document.mozExitPointerLock || document.webkitExitPointerLock;
}
// Swipe
document.addEventListener('touchstart', function(evt) {
component.xDown = evt.touches[0].clientX;
component.yDown = evt.touches[0].clientY;
}, false);
document.addEventListener('touchmove', function(evt) {
if ( ! component.xDown || ! component.yDown ) {
return;
}
var xUp = evt.touches[0].clientX;
var yUp = evt.touches[0].clientY;
var xDiff = component.xDown - xUp;
var yDiff = component.yDown - yUp;
if ( Math.abs( xDiff ) > Math.abs( yDiff ) ) {/*most significant*/
if ( xDiff > 0 ) {
/* left swipe */
} else {
/* right swipe */
}
} else {
if ( yDiff > 0 ) {
/* up swipe */
} else {
/* down swipe */
}
}
component.yaw -= xDiff * 0.002;
component.pitch -= yDiff * 0.002;
}, false);
// Mouse move
document.addEventListener('mousemove', function (event) {

4
src/game-lib-component-mesh-permutation.js
View File

@ -31,6 +31,7 @@ GameLib.D3.ComponentMeshPermutation = function ComponentMeshPermutation(
GameLib.D3.Utils.Extend(GameLib.D3.ComponentMeshPermutation, GameLib.D3.ComponentInterface);
};
//#ifdef RUNTIME__
if(typeof THREE != "undefined") {
ComponentMeshPermutation_quaternion = new THREE.Quaternion();
ComponentMeshPermutation_quaternionCopy = new THREE.Quaternion();
@ -67,4 +68,5 @@ GameLib.D3.ComponentMeshPermutation.prototype.onLateUpdate = function(
parentEntity.mesh.quaternion.copy(ComponentMeshPermutation_quaternion);
parentEntity.mesh.scale.copy(ComponentMeshPermutation_scale);
}
};
};
//#endif

130
src/game-lib-component-path-controls.js Normal file
View File

@ -0,0 +1,130 @@
/**
*
* @param id
* @param name
* @constructor
*/
GameLib.D3.ComponentPathControls = function ComponentPathFollowing(
id,
name
) {
this.id = id || GameLib.D3.Tools.RandomId();
if (typeof name == 'undefined') {
name = this.constructor.name;
}
this.name = name;
this.parentEntity = null;
// runtime
this.pathFollowingComponent = null;
this.keyLeftPressed = false;
this.keyRightPressed = false;
this.keyForwardPressed = false;
this.keyBackPressed = false;
this.keyBreakPressed = false;
GameLib.D3.Utils.Extend(GameLib.D3.ComponentPathControls, GameLib.D3.ComponentInterface);
};
///////////////////////// Methods to override //////////////////////////
GameLib.D3.ComponentPathControls.prototype.onUpdate = function(
deltaTime,
parentEntity
) {
if (this.keyForwardPressed) { // Forward [i]
this.pathFollowingComponent.direction = 1;
} else if (this.keyBackPressed){
this.pathFollowingComponent.direction = -1;
} else {
this.pathFollowingComponent.direction = 0;
}
// left right
if (this.keyLeftPressed) { // Left [j]
this.pathFollowingComponent.offset.x = 0;
this.pathFollowingComponent.offset.y = 0;
this.pathFollowingComponent.offset.z = 1;
// also: set offset scale
} else if (this.keyRightPressed) { // Right [l]
this.pathFollowingComponent.offset.x = 0;
this.pathFollowingComponent.offset.y = 0;
this.pathFollowingComponent.offset.z = -1;
// also: set offset scale
}
};
GameLib.D3.ComponentPathControls.prototype.onSetParentEntity = function(
parentScene,
parentEntity
) {
this.pathFollowingComponent = parentEntity.getComponent(GameLib.D3.ComponentPathFollowing);
if(!this.pathFollowingComponent) {
console.error("ComponentPathControls. NO PATH FOLLOWING COMPONENT");
}
var component = this;
document.addEventListener('keydown', function(event) {
if (event.keyCode == 73) { // Forward [i]
component.keyForwardPressed = true;
} else if (event.keyCode == 75) { // Back [k]
component.keyBackPressed = true;
}
if (event.keyCode == 74) { // Left [j]
component.keyLeftPressed = true;
} else if (event.keyCode == 76) { // Right [l]
component.keyRightPressed = true;
}
if (event.keyCode == 66) {
component.keyBreakPressed = true;
}
}, false);
document.addEventListener('keyup', function(event) {
if (event.keyCode == 73) { // Forward [i]
component.keyForwardPressed = false;
} else if (event.keyCode == 75) { // Back [k]
component.keyBackPressed = false;
}
if (event.keyCode == 74) { // Left [j]
component.keyLeftPressed = false;
} else if (event.keyCode == 76) { // Right [l]
component.keyRightPressed = false;
}
if (event.keyCode == 66) {
component.keyBreakPressed = false;
}
}, false);
};

109
src/game-lib-component-path-following.js Normal file
View File

@ -0,0 +1,109 @@
/**
*
* @param id
* @param name
* @param splineCurve3
* @param accel
* @param maxSpeed
* @param baseOffset
* @constructor
*/
GameLib.D3.ComponentPathFollowing = function ComponentPathFollowing(
id,
name,
splineCurve3,
accel,
maxSpeed,
baseOffset
) {
this.id = id || GameLib.D3.Tools.RandomId();
if (typeof name == 'undefined') {
name = this.constructor.name;
}
this.name = name;
this.parentEntity = null;
this.splineCurve3 = splineCurve3;
this.maxSpeed = maxSpeed || 10.0;
this.accel = accel || 2.0;
this.baseOffset = baseOffset || new GameLib.D3.Vector3();
// runtime code
this.currentPathValue = 0.0;
this.offset = new GameLib.D3.Vector3();
this.currentSpeed = 0.0;
this.direction = 0;
GameLib.D3.Utils.Extend(GameLib.D3.ComponentPathFollowing, GameLib.D3.ComponentInterface);
};
///////////////////////// Methods to override //////////////////////////
GameLib.D3.ComponentPathFollowing.prototype.onUpdate = function(
deltaTime,
parentEntity
) {
if(this.splineCurve3) {
if(this.currentPathValue >= 1 || this.currentPathValue < 0) {
this.currentPathValue = 0;
}
//To maintain a constant speed, you use .getPointAt( t ) instead of .getPoint( t ).
//http://stackoverflow.com/questions/18400667/three-js-object-following-a-spline-path-rotation-tanget-issues-constant-sp
var position = this.splineCurve3.getPointAt(this.currentPathValue);
var rotation = this.splineCurve3.getTangentAt(this.currentPathValue).normalize();
var up = new THREE.Vector3(-1, 0, 0);
var axis = new THREE.Vector3();
axis.crossVectors(up, rotation).normalize();
var radians = Math.acos(up.dot(rotation));
var quaternion = new THREE.Quaternion().setFromAxisAngle( axis, radians );
// move the entity
var t = deltaTime * this.accel;
t = t * t * t * (t * (6.0 * t - 15.0) + 10.0);
this.currentSpeed = this.currentSpeed + (this.maxSpeed * this.direction - this.currentSpeed) * t;
var transformedOffset = new THREE.Vector3(
this.baseOffset.x + this.offset.x,
this.baseOffset.y + this.offset.y,
this.baseOffset.z + this.offset.z
).applyQuaternion(quaternion);
// apply to parent rigidbody instead of direclty to the mesh.
parentEntity.position.x = position.x + transformedOffset.x;
parentEntity.position.y = position.y + transformedOffset.y;
parentEntity.position.z = position.z + transformedOffset.z;
parentEntity.quaternion.x = quaternion.x;
parentEntity.quaternion.y = quaternion.y;
parentEntity.quaternion.z = quaternion.z;
parentEntity.quaternion.w = quaternion.w;
console.log("this.currentSpeed", this.currentSpeed);
this.currentPathValue += (this.currentSpeed);
if(this.currentSpeed >= this.maxSpeed) {
this.currentSpeed = this.maxSpeed;
} else if (this.currentSpeed <= 0) {
this.currentSpeed = 0.0;
}
}
};
GameLib.D3.ComponentPathFollowing.prototype.onSetParentEntity = function(
parentScene,
parentEntity
) {
if(!this.splineCurve3) {
console.error("NO PATH GIVEN");
}
};

6
src/game-lib-component-trigger-box-box.js
View File

@ -31,10 +31,12 @@ GameLib.D3.ComponentTriggerBoxBox = function ComponentTriggerBoxBox(
this.onLeave = onLeave || null;
this.onSetParent = onSetParent || null;
// runtime code
// defines code
this.entitiesInside = [];
};
//#ifdef RUNTIME__
if(typeof THREE != "undefined") {
ComponentTriggerBoxBox_BB = new THREE.Box3();
ComponentTriggerBoxBox_BBEntity = new THREE.Box3();
@ -89,6 +91,8 @@ GameLib.D3.ComponentTriggerBoxBox.prototype.onUpdate = function(
}
}
};
//#endif
GameLib.D3.ComponentTriggerBoxBox.prototype.onSetParentEntity = function(
parentScene,

5
src/game-lib-component-trigger-box-sphere.js
View File

@ -29,10 +29,11 @@ GameLib.D3.ComponentTriggerBoxSphere = function ComponentTriggerBoxSphere(
this.onLeave = onLeave || null;
this.onSetParent = onSetParent || null;
// runtime code
// defines code
this.entitiesInside = [];
};
//#ifdef RUNTIME__
if(typeof THREE != "undefined") {
ComponentTriggerBoxSphere_TargetPosition_Vec3 = new THREE.Vector3();
ComponentTriggerBoxSphere_TargetRadius = 0.0;
@ -115,6 +116,8 @@ GameLib.D3.ComponentTriggerBoxSphere.prototype.onUpdate = function(
}
};
//#endif
GameLib.D3.ComponentTriggerBoxSphere.prototype.onSetParentEntity = function(
parentScene,
parentEntity

5
src/game-lib-component-trigger-sphere-sphere.js
View File

@ -41,10 +41,11 @@ GameLib.D3.ComponentTriggerSphereSphere = function ComponentTriggerSphereSphere(
this.onLeave = onLeave || null;
this.onSetParent = onSetParent || null;
// runtime code
// defines code
this.entitiesInside = [];
};
//#ifdef RUNTIME__
if(typeof THREE != "undefined") {
ComponentTriggerSphereSphere_spherePosition_Vector3 = new THREE.Vector3();
ComponentTriggerSphereSphere_targetBoundingSpherePosition_Vector3 = new THREE.Vector3();
@ -126,6 +127,8 @@ GameLib.D3.ComponentTriggerSphereSphere.prototype.onUpdate = function(
}
};
//#endif
GameLib.D3.ComponentTriggerSphereSphere.prototype.onSetParentEntity = function(
parentScene,
parentEntity

570
src/game-lib-component-vehicle-ai-object-avoidance.js Normal file
View File

@ -0,0 +1,570 @@
/**
*
* @param id
* @param name
* @param physicsWorld
* @constructor
*/
GameLib.D3.ComponentVehicleAIObjectAvoidance = function(
id,
name,
physicsWorld
) {
this.id = id|| GameLib.D3.Tools.RandomId();
if (typeof name == 'undefined') {
name = this.constructor.name;
}
this.name = name;
this.parentEntity = null;
GameLib.D3.Utils.Extend(GameLib.D3.ComponentVehicleAIObjectAvoidance, GameLib.D3.ComponentInterface);
this.raycastVehicleComponent = null;
this.physicsWorld = physicsWorld || null;
this.sensors = [];
// debug
this.debugArrows = {};
console.log("constructor for : ComponentVehicleAIObjectAvoidance");
};
//#ifdef RUNTIME__
/////////////////////////////////////////////////////////////////////////
///////////////////////// Methods to override ///////////////////////////
/////////////////////////////////////////////////////////////////////////
GameLib.D3.ComponentVehicleAIObjectAvoidance.prototype.onSetParentEntity = function(
parentScene,
parentEntity
) {
this.parentEntity = parentEntity;
this.raycastVehicleComponent = parentEntity.getComponent(GameLib.D3.RaycastVehicle);
console.log("onSetParentEntity for : ComponentVehicleAIObjectAvoidance");
if(!this.raycastVehicleComponent) {
console.warn("NO RAYCAST VEHICLE FOUND!");
}
// create sensors
var boundingBox = this.parentEntity.mesh.geometry.boundingBox;
// this is taken from the main.js.
// this should be configurable inside the editor
var carBoxScaleModifier = { x : 3 / 4, y : 1 / 2, z : 0.90 };
var sensorLength = 7.0;
var sensorColor = new THREE.Color(0, 0, 1);
// . . . . . . . . . . FRONT . . . . . . . . . .
// right
this.sensors.push(
{
sensorLength : sensorLength,
sensorColor : sensorColor,
sensorDirection : new THREE.Vector3(
1,
0,
0
).normalize(),
sensorPositionOffset : new THREE.Vector3(
boundingBox.max.x * this.parentEntity.mesh.scale.x * carBoxScaleModifier.x,
boundingBox.max.z * this.parentEntity.mesh.scale.z * carBoxScaleModifier.z,
0//boundingBox.max.y * this.parentEntity.mesh.scale.y * carBoxScaleModifier.y // this is still swapped with y, because cannon.
)
}
);
// left
this.sensors.push(
{
sensorLength : sensorLength,
sensorColor : sensorColor,
sensorDirection : new THREE.Vector3(
1,
0,
0
).normalize(),
sensorPositionOffset : new THREE.Vector3(
boundingBox.max.x * this.parentEntity.mesh.scale.x * carBoxScaleModifier.x,
-boundingBox.max.z * this.parentEntity.mesh.scale.z * carBoxScaleModifier.z,
0//boundingBox.max.y * this.parentEntity.mesh.scale.y * carBoxScaleModifier.y // this is still swapped with y, because cannon.
)
}
);
// center
this.sensors.push(
{
sensorLength : sensorLength,
sensorColor : sensorColor,
sensorDirection : new THREE.Vector3(
1,
0,
0
).normalize(),
sensorPositionOffset : new THREE.Vector3(
boundingBox.max.x * this.parentEntity.mesh.scale.x * carBoxScaleModifier.x,
0,
0
)
}
);
// . . . . . . DIAGONAL FRONT . . . . . . . .
// right
this.sensors.push(
{
sensorLength : sensorLength,
sensorColor : sensorColor,
sensorDirection : new THREE.Vector3(
0,
1,
0
).normalize(),
sensorPositionOffset : new THREE.Vector3(
boundingBox.max.x * this.parentEntity.mesh.scale.x * carBoxScaleModifier.x,
boundingBox.max.z * this.parentEntity.mesh.scale.z * carBoxScaleModifier.z,
0//boundingBox.max.y * this.parentEntity.mesh.scale.y * carBoxScaleModifier.y // this is still swapped with y, because cannon.
)
}
);
// left
this.sensors.push(
{
sensorLength : sensorLength,
sensorColor : sensorColor,
sensorDirection : new THREE.Vector3(
0,
-1,
0
).normalize(),
sensorPositionOffset : new THREE.Vector3(
boundingBox.max.x * this.parentEntity.mesh.scale.x * carBoxScaleModifier.x,
-boundingBox.max.z * this.parentEntity.mesh.scale.z * carBoxScaleModifier.z,
0//boundingBox.max.y * this.parentEntity.mesh.scale.y * carBoxScaleModifier.y // this is still swapped with y, because cannon.
)
}
);
// right
this.sensors.push(
{
sensorLength : sensorLength,
sensorColor : sensorColor,
sensorDirection : new THREE.Vector3(
0.5,
0.5,
0
).normalize(),
sensorPositionOffset : new THREE.Vector3(
boundingBox.max.x * this.parentEntity.mesh.scale.x * carBoxScaleModifier.x,
boundingBox.max.z * this.parentEntity.mesh.scale.z * carBoxScaleModifier.z,
0//boundingBox.max.y * this.parentEntity.mesh.scale.y * carBoxScaleModifier.y // this is still swapped with y, because cannon.
)
}
);
// left
this.sensors.push(
{
sensorLength : sensorLength,
sensorColor : sensorColor,
sensorDirection : new THREE.Vector3(
0.5,
-0.5,
0
).normalize(),
sensorPositionOffset : new THREE.Vector3(
boundingBox.max.x * this.parentEntity.mesh.scale.x * carBoxScaleModifier.x,
-boundingBox.max.z * this.parentEntity.mesh.scale.z * carBoxScaleModifier.z,
0//boundingBox.max.y * this.parentEntity.mesh.scale.y * carBoxScaleModifier.y // this is still swapped with y, because cannon.
)
}
);
// right
this.sensors.push(
{
sensorLength : sensorLength,
sensorColor : sensorColor,
sensorDirection : new THREE.Vector3(
0.75,
0.25,
0
).normalize(),
sensorPositionOffset : new THREE.Vector3(
boundingBox.max.x * this.parentEntity.mesh.scale.x * carBoxScaleModifier.x,
boundingBox.max.z * this.parentEntity.mesh.scale.z * carBoxScaleModifier.z,
0//boundingBox.max.y * this.parentEntity.mesh.scale.y * carBoxScaleModifier.y // this is still swapped with y, because cannon.
)
}
);
// left
this.sensors.push(
{
sensorLength : sensorLength,
sensorColor : sensorColor,
sensorDirection : new THREE.Vector3(
0.75,
-0.25,
0
).normalize(),
sensorPositionOffset : new THREE.Vector3(
boundingBox.max.x * this.parentEntity.mesh.scale.x * carBoxScaleModifier.x,
-boundingBox.max.z * this.parentEntity.mesh.scale.z * carBoxScaleModifier.z,
0//boundingBox.max.y * this.parentEntity.mesh.scale.y * carBoxScaleModifier.y // this is still swapped with y, because cannon.
)
}
);
console.log("pushed sensors", this.sensors.length);
};
GameLib.D3.ComponentVehicleAIObjectAvoidance.prototype.onUpdate = function(
deltaTime,
parentEntity
) {
if(this.raycastVehicleComponent && this.physicsWorld) {
// debug
this.debugArrows.avgDirection = this.debugArrows.avgDirection || {};
this.debugArrows.sensors = this.debugArrows.sensors || [];
var vehicleVelocity = this.parentEntity.getComponent(GameLib.D3.RigidBody).instance.velocity;
var vehicleVelocityLength = 12;
// shoot rays for each sensor & check collisions.
var world = this.physicsWorld.instance;
var result = new CANNON.RaycastResult();
this.debugArrows.avgDirection.vector = new THREE.Vector3();
for(var s = 0, l = this.sensors.length; s < l; ++s) {
// debug
if(!this.debugArrows.sensors[s]) {
this.debugArrows.sensors[s] = {};
}
var sensor = this.sensors[s];
var from = new THREE.Vector3(
this.parentEntity.position.x,
this.parentEntity.position.y,
this.parentEntity.position.z
).add(new THREE.Vector3(
sensor.sensorPositionOffset.x,
sensor.sensorPositionOffset.y,
sensor.sensorPositionOffset.z
).applyQuaternion(new THREE.Quaternion(
this.parentEntity.quaternion.x,
this.parentEntity.quaternion.y,
this.parentEntity.quaternion.z,
this.parentEntity.quaternion.w
)));
var fromC = new CANNON.Vec3(
from.x,
from.y,
from.z
);
var to = new THREE.Vector3(
sensor.sensorDirection.x,
sensor.sensorDirection.y,
sensor.sensorDirection.z
).applyQuaternion(new THREE.Quaternion(
this.parentEntity.quaternion.x,
this.parentEntity.quaternion.y,
this.parentEntity.quaternion.z,
this.parentEntity.quaternion.w
)).normalize().multiplyScalar(sensor.sensorLength);
var toC = new CANNON.Vec3(
from.x + to.x,
from.y + to.y,
from.z + to.z
);
world.raycastClosest(
fromC,
toC,
{
collisionFilterMask : 2 // check only group 2 (track)
},
result
);
if(result.hasHit) {
sensor.sensorColor = new THREE.Color(1, 0, 0);
var direction = new THREE.Vector3(
sensor.sensorDirection.x,
sensor.sensorDirection.y,
sensor.sensorDirection.z
).applyQuaternion(new THREE.Quaternion(
this.parentEntity.quaternion.x,
this.parentEntity.quaternion.y,
this.parentEntity.quaternion.z,
this.parentEntity.quaternion.w
)).normalize();
/*var reflection = direction.reflect(
new THREE.Vector3(
result.hitNormalWorld.x,
result.hitNormalWorld.y,
result.hitNormalWorld.z
)
).normalize();*/
var reflection = direction.reflect(
new THREE.Vector3(
result.hitPointWorld.x,
result.hitPointWorld.y,
result.hitPointWorld.z
).normalize().cross(direction)
).normalize().negate();
var origin = new THREE.Vector3(
this.parentEntity.position.x,
this.parentEntity.position.y,
this.parentEntity.position.z
).add(new THREE.Vector3(
sensor.sensorPositionOffset.x,
sensor.sensorPositionOffset.y,
sensor.sensorPositionOffset.z
).applyQuaternion(new THREE.Quaternion(
this.parentEntity.quaternion.x,
this.parentEntity.quaternion.y,
this.parentEntity.quaternion.z,
this.parentEntity.quaternion.w
)));
var moveDirection = direction.add(reflection).setY(0).normalize();
this.debugArrows.avgDirection.vector = this.debugArrows.avgDirection.vector.add(moveDirection);
if(this.debugArrows.sensors[s].intersectionArrow && this.debugArrows.sensors[s].mesh) {
this.debugArrows.sensors[s].mesh.remove(this.debugArrows.sensors[s].intersectionArrow);
}
if(this.debugArrows.sensors[s].mesh){
var arrow = new THREE.ArrowHelper(
moveDirection,
origin,
22,
new THREE.Color(1, 1, 0)
);
this.debugArrows.sensors[s].intersectionArrow = arrow;
this.debugArrows.sensors[s].mesh.add(this.debugArrows.sensors[s].intersectionArrow);
}
} else {
sensor.sensorColor = new THREE.Color(0, 0, 1);
if(this.debugArrows.sensors[s].intersectionArrow && this.debugArrows.sensors[s].mesh) {
this.debugArrows.sensors[s].mesh.remove(this.debugArrows.sensors[s].intersectionArrow);
}
}
}
this.debugArrows.avgDirection.vector = this.debugArrows.avgDirection.vector.normalize();
// draw the avg move direction
/*if(!this.debugArrows.avgDirection.mesh) {
this.debugArrows.avgDirection.mesh = new THREE.Mesh(
new THREE.Geometry(),
new THREE.MeshBasicMaterial(
{
color : 0x00ffff,
wireframe : true
}
)
);
sys.game.scenes["MainScene"].instance.add(this.debugArrows.avgDirection.mesh);
}
if(this.debugArrows.avgDirection.arrow && this.debugArrows.avgDirection.mesh) {
this.debugArrows.avgDirection.mesh.remove(this.debugArrows.avgDirection.arrow);
}*/
/*this.debugArrows.avgDirection.arrow = new THREE.ArrowHelper(
this.debugArrows.avgDirection.vector,
new THREE.Vector3(
this.parentEntity.position.x,
this.parentEntity.position.y,
this.parentEntity.position.z
),
12,
this.debugArrows.avgDirection.mesh.material.color
);*/
//this.debugArrows.avgDirection.mesh.add(this.debugArrows.avgDirection.arrow);
// draw sensors
/*{
for(var s = 0, l = this.sensors.length; s < l; ++s) {
if(!this.debugArrows.sensors[s].mesh) {
var geometry = new THREE.Geometry();
var mesh = new THREE.Mesh(
geometry,
new THREE.MeshBasicMaterial(
{
color : 0x000000,
wireframe : true
}
)
);
this.debugArrows.sensors[s].mesh = mesh;
sys.game.scenes["MainScene"].instance.add(this.debugArrows.sensors[s].mesh);
}
// remove old arrow, if we have one
if(this.debugArrows.sensors[s].arrow) {
this.debugArrows.sensors[s].mesh.remove(this.debugArrows.sensors[s].arrow);
}
var sensor = this.sensors[s];
var sensorLength = sensor.sensorLength; // should get this from the sensor itself
this.debugArrows.sensors[s].arrow = new THREE.ArrowHelper(
new THREE.Vector3(
sensor.sensorDirection.x,
sensor.sensorDirection.y,
sensor.sensorDirection.z
).applyQuaternion(new THREE.Quaternion(
this.parentEntity.quaternion.x,
this.parentEntity.quaternion.y,
this.parentEntity.quaternion.z,
this.parentEntity.quaternion.w
)).normalize(),
new THREE.Vector3(
this.parentEntity.position.x,
this.parentEntity.position.y,
this.parentEntity.position.z
).add(new THREE.Vector3(
sensor.sensorPositionOffset.x,
sensor.sensorPositionOffset.y,
sensor.sensorPositionOffset.z
).applyQuaternion(new THREE.Quaternion(
this.parentEntity.quaternion.x,
this.parentEntity.quaternion.y,
this.parentEntity.quaternion.z,
this.parentEntity.quaternion.w
))),
sensorLength,
sensor.sensorColor
);
this.debugArrows.sensors[s].mesh.add(this.debugArrows.sensors[s].arrow);
}
}*/
// . . . . . . . . . . . . correct the path . . . . . . . . . . . . . .
if( this.debugArrows.avgDirection.vector.x != 0
|| this.debugArrows.avgDirection.vector.y != 0
|| this.debugArrows.avgDirection.vector.z != 0
) {
// get forward direction OR better the velocity angle of the car
var avgMoveVector = this.debugArrows.avgDirection.vector;
var forward = new THREE.Vector3(
1,
0,
0
).applyQuaternion(new THREE.Quaternion(
this.parentEntity.quaternion.x,
this.parentEntity.quaternion.y,
this.parentEntity.quaternion.z,
this.parentEntity.quaternion.w
)).setY(0).normalize();
// get angle and steer.
var cos = avgMoveVector.dot(forward);
var angleRadians = Math.acos(cos);
var steerAngleModifier = GameLib.D3.Vector3.AngleDirection(
forward,
avgMoveVector,
new GameLib.D3.Vector3(
0,
1,
0
)
);
var steerAngle = Math.min(angleRadians, 0.5) * steerAngleModifier;
this.raycastVehicleComponent.instance.setSteeringValue(steerAngle, 0);
this.raycastVehicleComponent.instance.setSteeringValue(steerAngle, 1);
}
}
};
//#endif

244
src/game-lib-component-vehicle-ai-path-steering.js Normal file
View File

@ -0,0 +1,244 @@
/**
*
* @param id
* @param name
* @param targetEntity GameLib.D3.Entity
* @param steeringSpeed
* @param maxSteerAngle
* @constructor
*/
GameLib.D3.ComponentVehicleAIPathSteering = function(
id,
name,
targetEntity,
steeringSpeed,
maxSteerAngle
) {
this.id = id|| GameLib.D3.Tools.RandomId();
if (typeof name == 'undefined') {
name = this.constructor.name;
}
this.name = name;
this.parentEntity = null;
// Todo: this should be executed somewhere in game-lib-z, so that we don't execute it on every construction of an object.
GameLib.D3.Utils.Extend(GameLib.D3.ComponentVehicleAIPathSteering, GameLib.D3.ComponentInterface);
//
this.targetEntity = targetEntity;
this.steeringSpeed = steeringSpeed || 2.5;
this.maxSteerAngle = maxSteerAngle || 0.5;
this.raycastVehicleComponent = null;
this.debugArrows = {};
};
///////////////////////// Methods to override //////////////////////////
GameLib.D3.ComponentVehicleAIPathSteering.prototype.onSetParentEntity = function(
parentScene,
parentEntity
) {
this.raycastVehicleComponent = parentEntity.getComponent(GameLib.D3.RaycastVehicle);
this.parentEntity = parentEntity;
if(!this.raycastVehicleComponent) {
console.warn("NO RAYCAST VEHICLE FOUND!");
}
};
//#ifdef RUNTIME__
GameLib.D3.ComponentVehicleAIPathSteering.prototype.onUpdate = function(
deltaTime,
parentEntity
) {
if(this.targetEntity && this.raycastVehicleComponent) {
var v1 = new THREE.Vector3(
this.parentEntity.position.x,
this.parentEntity.position.y,
this.parentEntity.position.z
);
var v2 = new THREE.Vector3(
this.targetEntity.position.x,
this.targetEntity.position.y,
this.targetEntity.position.z
);
// get forward vector of the car.
var v3 = new THREE.Vector3(
1,
0,
0
);
var q1 = new THREE.Quaternion(
this.parentEntity.quaternion.x,
this.parentEntity.quaternion.y,
this.parentEntity.quaternion.z,
this.parentEntity.quaternion.w
);
var q2 = new THREE.Quaternion(
this.targetEntity.quaternion.x,
this.targetEntity.quaternion.y,
this.targetEntity.quaternion.z,
this.targetEntity.quaternion.w
);
var v1ToV2 = v2.sub(v1);
var forward = v3.applyQuaternion(q1).normalize();
var v1v2cpy = new THREE.Vector3(
v1ToV2.x,
v1ToV2.y,
v1ToV2.z
).applyQuaternion(q2).normalize();
v1v2cpy.y = 0;
v1v2cpy = v1v2cpy.normalize();
var forwardcpy = new THREE.Vector3(
forward.x,
0,
forward.z
).normalize();
var cos = v1v2cpy.dot(forwardcpy);
var angleRadians = Math.acos(cos);
var steerAngleModifier = GameLib.D3.Vector3.AngleDirection(
forwardcpy,
v1v2cpy,
new GameLib.D3.Vector3(
0,
1,
0
)
);
var steerAngle = Math.min(angleRadians, this.maxSteerAngle) * steerAngleModifier;
if(isNaN(steerAngle)) {
console.log("NOT A NUMBER", steerAngle);
}
// check if forward & movedirection are pointing in two different directions
/* if(cos < 0) {
console.log("movedirection & forward are pointing in different directions");
}*/
//if(steerAngle > 0.002 || steerAngle < -0.002) {
this.raycastVehicleComponent.instance.setSteeringValue(steerAngle, 0);
this.raycastVehicleComponent.instance.setSteeringValue(steerAngle, 1);
//}
/*// - - - - - - - - - - - DEBUG ARROW 1 - - - - - - - - -
{
if(!this.debugArrows.v1) {
this.debugArrows.v1 = this.debugArrows.v1 || {};
}
if(!this.debugArrows.v1.mesh) {
var geometryTHREE = new THREE.Geometry();
var wireframeMesh = new THREE.Mesh(
geometryTHREE,
new THREE.MeshBasicMaterial(
{
color: 0xff0000,
wireframe: true,
opacity: 1
}
)
);
this.debugArrows.v1.mesh = wireframeMesh;
sys.game.scenes["MainScene"].instance.add(this.debugArrows.v1.mesh);
}
if(this.debugArrows.v1.arrow) {
this.debugArrows.v1.mesh.remove(this.debugArrows.v1.arrow);
}
var len = v1ToV2.length();
this.debugArrows.v1.arrow = new THREE.ArrowHelper(
v1ToV2.normalize(),
new THREE.Vector3(
this.parentEntity.position.x,
this.parentEntity.position.y,
this.parentEntity.position.z
),
len || 100,
new THREE.Color(
0,
1,
0
)
);
this.debugArrows.v1.mesh.add( this.debugArrows.v1.arrow );
}
// - - - - - - - - - - - DEBUG ARROW 2 - - - - - - - - -
{
if(!this.debugArrows.v2) {
this.debugArrows.v2 = this.debugArrows.v2 || {};
}
if(!this.debugArrows.v2.mesh) {
var geometryTHREE = new THREE.Geometry();
var wireframeMesh = new THREE.Mesh(
geometryTHREE,
new THREE.MeshBasicMaterial(
{
color: 0xff0000,
wireframe: true,
opacity: 1
}
)
);
this.debugArrows.v2.mesh = wireframeMesh;
sys.game.scenes["MainScene"].instance.add(this.debugArrows.v2.mesh);
}
if(this.debugArrows.v2.arrow) {
this.debugArrows.v2.mesh.remove(this.debugArrows.v2.arrow);
}
this.debugArrows.v2.arrow = new THREE.ArrowHelper(
forward,
new THREE.Vector3(
this.parentEntity.position.x,
this.parentEntity.position.y,
this.parentEntity.position.z
),
12,
new THREE.Color(
1.0,
0.0,
0.0
)
);
this.debugArrows.v2.mesh.add( this.debugArrows.v2.arrow );
}*/
}
this.raycastVehicleComponent.instance.applyEngineForce(-3500, 2);
this.raycastVehicleComponent.instance.applyEngineForce(-3500, 3);
};
//#endif

5
src/game-lib-game.js
View File

@ -26,8 +26,7 @@ GameLib.D3.Game.prototype.processPhysics = function (
GameLib.D3.Game.prototype.render = function(
dt,
renderer,
camera
renderer
) {
for(var s in this.scenes) {
var scene = this.scenes[s];
@ -45,7 +44,7 @@ GameLib.D3.Game.prototype.update = function(
for(var w in scene.worlds) {
var world = scene.worlds[w];
// NOTE: We are calling the step function with a variable timestep!
world.step(dt);
world.step(fixedDt, dt);
}
scene.update(dt);

105
src/game-lib-vector-2.js
View File

@ -1,15 +1,6 @@
GameLib.D3.Vector2 = function Vector2(x, y) {
this.x = 0;
this.y = 0;
if (x) {
this.x = x;
}
if (y) {
this.y = y;
}
this.x = x || 0;
this.y = y || 0;
};
GameLib.D3.Vector2.prototype.copy = function() {
@ -25,3 +16,95 @@ GameLib.D3.Vector2.prototype.equals = function(v) {
((this.y == v.x) &&
(this.x == v.y)));
};
GameLib.D3.Vector2.prototype.add = function(v) {
return new GameLib.D3.Vector2(
this.x + v.x,
this.y + v.y
);
};
GameLib.D3.Vector2.prototype.subtract = function(v) {
return new GameLib.D3.Vector2(
this.x - v.x,
this.y - v.y
);
};
GameLib.D3.Vector2.prototype.multiply = function(v) {
if (v instanceof GameLib.D3.Vector2) {
return new GameLib.D3.Vector2(
this.x * v.x,
this.y * v.y
);
} else if (isNumber(v)) {
return new GameLib.D3.Vector2(
this.x * v,
this.y * v
);
}
};
GameLib.D3.Vector2.prototype.divide = function(v) {
if (v instanceof GameLib.D3.Vector2) {
return new GameLib.D3.Vector2(
this.x * (1.0 / v.x),
this.y * (1.0 / v.y)
);
} else if (isNumber(v)) {
var invS = 1.0 / v;
return new GameLib.D3.Vector2(
this.x * invS,
this.y * invS
);
}
};
GameLib.D3.Vector2.prototype.clone = function() {
return new GameLib.D3.Vector2(
this.x,
this.y
);
};
GameLib.D3.Vector2.prototype.copy = function(v) {
this.x = v.x;
this.y = v.y;
};
GameLib.D3.Vector2.prototype.set = function(x, y) {
this.x = x;
this.y = y;
};
GameLib.D3.Vector2.prototype.clamp = function(min, max) {
return new GameLib.D3.Vector2(
Math.max(min.x, Math.min(max.x, this.x)),
Math.max(min.y, Math.min(max.y, this.y))
);
};
GameLib.D3.Vector2.prototype.length = function() {
return Math.sqrt(this.x * this.x + this.y * this.y);
};
GameLib.D3.Vector2.prototype.dot = function(v) {
return this.x * v.x + this.y * v.y;
};
GameLib.D3.Vector2.prototype.normalize = function() {
return this.multiply(1.0 / this.length());
};
GameLib.D3.Vector2.prototype.angle = function() {
var angle = Math.atan2(this.y, this.x);
if ( angle < 0 ) angle += 2 * Math.PI;
return angle;
};
GameLib.D3.Vector2.prototype.lerp = function ( v, alpha ) {
return new GameLib.D3.Vector2(
this.x + ( v.x - this.x ) * alpha,
this.y + ( v.y - this.y ) * alpha
);
};

203
src/game-lib-vector-3.js
View File

@ -1,35 +1,23 @@
GameLib.D3.Vector3 = function Vector3(x, y, z) {
this.x = 0;
this.y = 0;
this.z = 0;
if (x) {
this.x = x;
}
if (y) {
this.y = y;
}
if (z) {
this.z = z;
}
this.x = x || 0;
this.y = y || 0;
this.z = z || 0;
};
GameLib.D3.Vector3.prototype.subtract = function (v) {
return new GameLib.D3.Vector3(
this.x - v.x,
this.y - v.y,
this.z - v.z
);
};
if (v instanceof GameLib.D3.Vector3) {
this.x -= v.x;
this.y -= v.y;
this.z -= v.z;
}
if (v instanceof GameLib.D3.Vector4) {
console.warn("trying to subtract vector of bigger length (4 vs 3))");
}
return this;
GameLib.D3.Vector3.prototype.sub = function (v) {
return new GameLib.D3.Vector3(
this.x - v.x,
this.y - v.y,
this.z - v.z
);
};
GameLib.D3.Vector3.prototype.cross = function (v) {
@ -40,21 +28,11 @@ GameLib.D3.Vector3.prototype.cross = function (v) {
);
};
GameLib.D3.Vector3.prototype.negative = function () {
this.x *= -1;
this.y *= -1;
this.z *= -1;
return this;
};
GameLib.D3.Vector3.clockwise = function (u, v, w, viewPoint) {
var normal = GameLib.D3.Vector3.normal(u, v, w);
var uv = u.copy();
var winding = normal.dot(uv.subtract(viewPoint));
return (winding > 0);
};
@ -65,10 +43,8 @@ GameLib.D3.Vector3.normal = function (u, v, w) {
};
GameLib.D3.Vector3.prototype.lookAt = function (at, up) {
var lookAtMatrix = GameLib.D3.Matrix4.lookAt(this, at, up);
this.multiply(lookAtMatrix);
return this.multiply(lookAtMatrix);
};
GameLib.D3.Vector3.prototype.translate = function (v) {
@ -78,6 +54,14 @@ GameLib.D3.Vector3.prototype.translate = function (v) {
return this;
};
GameLib.D3.Vector3.prototype.add = function (v) {
return new GameLib.D3.Vector3(
this.x + v.x,
this.y + v.y,
this.z + v.z
);
};
GameLib.D3.Vector3.prototype.squared = function () {
return this.x * this.x + this.y * this.y + this.z * this.z;
};
@ -90,6 +74,12 @@ GameLib.D3.Vector3.prototype.copy = function () {
);
};
GameLib.D3.Vector3.prototype.set = function (x, y, z) {
this.x = x;
this.y = y;
this.z = z;
};
GameLib.D3.Vector3.prototype.lerp = function ( v, alpha ) {
return new GameLib.D3.Vector3(
this.x + ( v.x - this.x ) * alpha,
@ -98,23 +88,77 @@ GameLib.D3.Vector3.prototype.lerp = function ( v, alpha ) {
);
};
GameLib.D3.Vector3.prototype.distanceTo = function(v) {
var dx = this.x - v.x,
dy = this.y - v.y,
dz = this.z - v.z;
return Math.sqrt(dx * dx + dy * dy + dz * dz);
};
/**
* @return {number}
*/
GameLib.D3.Vector3.AngleDirection = function(forward, directionToCheck, up) {
var perp = forward.cross(directionToCheck);
var dir = perp.dot(up);
if (dir > 0.0) {
return 1.0;
} else if (dir < 0.0) {
return -1.0;
} else {
return 0.0;
}
};
GameLib.D3.Vector3.prototype.multiply = function (s) {
if (s instanceof GameLib.D3.Vector3) {
this.x *= s.x;
this.y *= s.y;
this.z *= s.z;
return new GameLib.D3.Vector3(
this.x * s.x,
this.y * s.y,
this.z * s.z
)
} else if (s instanceof GameLib.D3.Matrix4) {
var x = s.rows[0].x * this.x + s.rows[0].y * this.y + s.rows[0].z * this.z + s.rows[0].w;
var y = s.rows[1].x * this.x + s.rows[1].y * this.y + s.rows[1].z * this.z + s.rows[1].w;
var z = s.rows[2].x * this.x + s.rows[2].y * this.y + s.rows[2].z * this.z + s.rows[2].w;
return new GameLib.D3.Vector3(
x,
y,
z
);
} else if (s instanceof GameLib.D3.Matrix3) {
var x = s.rows[0].x * this.x + s.rows[0].y * this.y + s.rows[0].z * this.z;
var y = s.rows[1].x * this.x + s.rows[1].y * this.y + s.rows[1].z * this.z;
var z = s.rows[2].x * this.x + s.rows[2].y * this.y + s.rows[2].z * this.z;
this.x = x;
this.y = y;
this.z = z;
return new GameLib.D3.Vector3(
x,
y,
z
);
} else if(!isNaN(parseFloat(s)) && isFinite(s)) {
return new GameLib.D3.Vector3(
this.x * s,
this.y * s,
this.z * s
);
} else {
console.log("functionality not implemented - please do this");
throw new Error("not implemented");
return this;
}
return this;
};
@ -123,20 +167,73 @@ GameLib.D3.Vector3.prototype.dot = function (v) {
};
GameLib.D3.Vector3.prototype.normalize = function () {
var EPSILON = 0.000001;
var v2 = this.squared();
if (v2 < EPSILON) {
return this; //do nothing for zero vector
}
var invLength = 1 / Math.sqrt(v2);
var invLength = 1.0 / Math.sqrt(v2);
return new GameLib.D3.Vector3(
this.x * invLength,
this.y * invLength,
this.z * invLength
);
};
this.x *= invLength;
this.y *= invLength;
this.z *= invLength;
GameLib.D3.Vector3.prototype.clone = function () {
return new GameLib.D3.Vector3(
this.x,
this.y,
this.z
);
};
GameLib.D3.Vector3.prototype.applyQuaternion = function(q) {
var x = this.x, y = this.y, z = this.z;
var qx = q.x, qy = q.y, qz = q.z, qw = q.w;
// calculate quat * vector
var ix = qw * x + qy * z - qz * y;
var iy = qw * y + qz * x - qx * z;
var iz = qw * z + qx * y - qy * x;
var iw = - qx * x - qy * y - qz * z;
// calculate result * inverse quat
return new GameLib.D3.Vector3(
ix * qw + iw * - qx + iy * - qz - iz * - qy,
iy * qw + iw * - qy + iz * - qx - ix * - qz,
iz * qw + iw * - qz + ix * - qy - iy * - qx
);
};
GameLib.D3.Vector3.prototype.clamp = function(min, max) {
this.x = Math.max( min.x, Math.min( max.x, this.x ) );
this.y = Math.max( min.y, Math.min( max.y, this.y ) );
this.z = Math.max( min.z, Math.min( max.z, this.z ) );
return this;
};
GameLib.D3.Vector3.prototype.negate = function() {
this.x = -this.x;
this.y = -this.y;
this.z = -this.z;
return this;
};
GameLib.D3.Vector3.prototype.length = function() {
return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z );
};
GameLib.D3.Vector3.prototype.reflect = function(normal) {
return this.sub( v1.copy( normal ).multiply( 2 * this.dot( normal ) ) );
};
GameLib.D3.Vector3.prototype.angleTo = function (v) {
var theta = this.dot( v ) / ( Math.sqrt( this.lengthSq() * v.lengthSq() ) );
return Math.acos( exports.Math.clamp( theta, - 1, 1 ) );
};

25
src/game-lib-world.js
View File

@ -103,25 +103,24 @@ GameLib.D3.World.prototype.addVehicle = function(
};
GameLib.D3.World.prototype.step = function(
timeStep
fixedStep,
dtStep
) {
// todo: figure out, why this call to internal step is more stable for trimesh collisions.....
//this.instance.internalStep(timeStep);
//return;
//console.log("this should not be called.");
this.instance.step(fixedStep, dtStep, 3);
return;
//var now = Date.now() / 1000;
var now = null;
var now = Date.now() / 1000.0;
//var now = null;
if(!this.lastCallTime){
// last call time not saved, cant guess elapsed time. Take a simple step.
this.instance.step(timeStep);
this.instance.step(fixedStep);
this.lastCallTime = now;
return;
}
var timeSinceLastCall = now - this.lastCallTime;
var timeSinceLastCall = (now - this.lastCallTime);
this.instance.step(timeStep, timeSinceLastCall);
this.instance.step(fixedStep, timeSinceLastCall, 4);
this.lastCallTime = now;
};
@ -837,7 +836,7 @@ GameLib.D3.World.prototype.fixupTriangleMeshShape = function(
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Decide if we want to create new rigid bodies, or create a compound mesh
// Decide if we want to create new rigiwyd bodies, or create a compound mesh
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
for(var e in bFaceIndexed) {
@ -850,6 +849,10 @@ GameLib.D3.World.prototype.fixupTriangleMeshShape = function(
} else {
var body = new GameLib.D3.RigidBody(this.engine, 0, 12);
//TODO: this is just a hack.
body.instance.collisionFilterGroup = 1 | 2; // puts this body in two groups.
body.addShape(shape);
this.addRigidBody(body);
}