|
|
@@ -0,0 +1,461 @@
|
|
|
+module BABYLON {
|
|
|
+ export class Debug {
|
|
|
+ public static AxesViewer = class AxesViewer {
|
|
|
+ _xline = [Vector3.Zero(), Vector3.Zero()];
|
|
|
+ _yline = [Vector3.Zero(), Vector3.Zero()];
|
|
|
+ _zline = [Vector3.Zero(), Vector3.Zero()];
|
|
|
+
|
|
|
+ _xmesh: Nullable<LinesMesh>;
|
|
|
+ _ymesh: Nullable<LinesMesh>;
|
|
|
+ _zmesh: Nullable<LinesMesh>;
|
|
|
+
|
|
|
+ public scene: Nullable<Scene>;
|
|
|
+ public scaleLines = 1;
|
|
|
+
|
|
|
+ constructor(scene: Scene, scaleLines = 1) {
|
|
|
+
|
|
|
+ this.scaleLines = scaleLines;
|
|
|
+
|
|
|
+ this._xmesh = Mesh.CreateLines("xline", this._xline, scene, true);
|
|
|
+ this._ymesh = Mesh.CreateLines("yline", this._yline, scene, true);
|
|
|
+ this._zmesh = Mesh.CreateLines("zline", this._zline, scene, true);
|
|
|
+
|
|
|
+ this._xmesh.renderingGroupId = 2;
|
|
|
+ this._ymesh.renderingGroupId = 2;
|
|
|
+ this._zmesh.renderingGroupId = 2;
|
|
|
+
|
|
|
+ this._xmesh.material.checkReadyOnlyOnce = true;
|
|
|
+ this._xmesh.color = new Color3(1, 0, 0);
|
|
|
+ this._ymesh.material.checkReadyOnlyOnce = true;
|
|
|
+ this._ymesh.color = new Color3(0, 1, 0);
|
|
|
+ this._zmesh.material.checkReadyOnlyOnce = true;
|
|
|
+ this._zmesh.color = new Color3(0, 0, 1);
|
|
|
+
|
|
|
+ this.scene = scene;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ public update(position: Vector3, xaxis: Vector3, yaxis: Vector3, zaxis: Vector3): void {
|
|
|
+
|
|
|
+ var scaleLines = this.scaleLines;
|
|
|
+
|
|
|
+ if (this._xmesh) {
|
|
|
+ this._xmesh.position.copyFrom(position);
|
|
|
+ }
|
|
|
+ if (this._ymesh) {
|
|
|
+ this._ymesh.position.copyFrom(position);
|
|
|
+ }
|
|
|
+ if (this._zmesh) {
|
|
|
+ this._zmesh.position.copyFrom(position);
|
|
|
+ }
|
|
|
+
|
|
|
+ var point2 = this._xline[1];
|
|
|
+ point2.x = xaxis.x * scaleLines;
|
|
|
+ point2.y = xaxis.y * scaleLines;
|
|
|
+ point2.z = xaxis.z * scaleLines;
|
|
|
+ Mesh.CreateLines("", this._xline, null, false, this._xmesh);
|
|
|
+
|
|
|
+ point2 = this._yline[1];
|
|
|
+ point2.x = yaxis.x * scaleLines;
|
|
|
+ point2.y = yaxis.y * scaleLines;
|
|
|
+ point2.z = yaxis.z * scaleLines;
|
|
|
+ Mesh.CreateLines("", this._yline, null, false, this._ymesh);
|
|
|
+
|
|
|
+ point2 = this._zline[1];
|
|
|
+ point2.x = zaxis.x * scaleLines;
|
|
|
+ point2.y = zaxis.y * scaleLines;
|
|
|
+ point2.z = zaxis.z * scaleLines;
|
|
|
+ Mesh.CreateLines("", this._zline, null, false, this._zmesh);
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ public dispose() {
|
|
|
+
|
|
|
+ if (this._xmesh) {
|
|
|
+ this._xmesh.dispose();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (this._ymesh) {
|
|
|
+ this._ymesh.dispose();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (this._zmesh) {
|
|
|
+ this._zmesh.dispose();
|
|
|
+ }
|
|
|
+
|
|
|
+ this._xmesh = null;
|
|
|
+ this._ymesh = null;
|
|
|
+ this._zmesh = null;
|
|
|
+
|
|
|
+ this.scene = null;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public static BoneAxesViewer = class BoneAxesViewer extends Debug.AxesViewer {
|
|
|
+
|
|
|
+ public mesh: Nullable<Mesh>;
|
|
|
+ public bone: Nullable<Bone>;
|
|
|
+
|
|
|
+ public pos = Vector3.Zero();
|
|
|
+ public xaxis = Vector3.Zero();
|
|
|
+ public yaxis = Vector3.Zero();
|
|
|
+ public zaxis = Vector3.Zero();
|
|
|
+
|
|
|
+ constructor(scene: Scene, bone: Bone, mesh: Mesh, scaleLines = 1) {
|
|
|
+
|
|
|
+ super(scene, scaleLines);
|
|
|
+
|
|
|
+ this.mesh = mesh;
|
|
|
+ this.bone = bone;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ public update(): void {
|
|
|
+
|
|
|
+ if (!this.mesh || !this.bone) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ var bone = this.bone;
|
|
|
+ bone.getAbsolutePositionToRef(this.mesh, this.pos);
|
|
|
+ bone.getDirectionToRef(Axis.X, this.mesh, this.xaxis);
|
|
|
+ bone.getDirectionToRef(Axis.Y, this.mesh, this.yaxis);
|
|
|
+ bone.getDirectionToRef(Axis.Z, this.mesh, this.zaxis);
|
|
|
+
|
|
|
+ super.update(this.pos, this.xaxis, this.yaxis, this.zaxis);
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ public dispose() {
|
|
|
+
|
|
|
+ if (this.mesh) {
|
|
|
+ this.mesh = null;
|
|
|
+ this.bone = null;
|
|
|
+
|
|
|
+ super.dispose();
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ public static PhysicsViewer = class PhysicsViewer {
|
|
|
+
|
|
|
+ _impostors: Array<Nullable<PhysicsImpostor>> = [];
|
|
|
+ _meshes: Array<Nullable<AbstractMesh>> = [];
|
|
|
+ _scene: Nullable<Scene>;
|
|
|
+ _numMeshes = 0;
|
|
|
+ _physicsEnginePlugin: Nullable<IPhysicsEnginePlugin>;
|
|
|
+ _renderFunction: () => void;
|
|
|
+
|
|
|
+ _debugBoxMesh: Mesh;
|
|
|
+ _debugSphereMesh: Mesh;
|
|
|
+ _debugMaterial: StandardMaterial;
|
|
|
+
|
|
|
+ constructor(scene: Scene) {
|
|
|
+ this._scene = scene || Engine.LastCreatedScene;
|
|
|
+ let physicEngine = this._scene.getPhysicsEngine();
|
|
|
+
|
|
|
+ if (physicEngine) {
|
|
|
+ this._physicsEnginePlugin = physicEngine.getPhysicsPlugin();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ _updateDebugMeshes(): void {
|
|
|
+
|
|
|
+ var plugin = this._physicsEnginePlugin;
|
|
|
+
|
|
|
+ for (var i = 0; i < this._numMeshes; i++) {
|
|
|
+ let impostor = this._impostors[i];
|
|
|
+
|
|
|
+ if (!impostor) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (impostor.isDisposed) {
|
|
|
+ this.hideImpostor(this._impostors[i--]);
|
|
|
+ } else {
|
|
|
+ let mesh = this._meshes[i];
|
|
|
+
|
|
|
+ if (mesh && plugin) {
|
|
|
+ plugin.syncMeshWithImpostor(mesh, impostor);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ public showImpostor(impostor: PhysicsImpostor): void {
|
|
|
+
|
|
|
+ if (!this._scene) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (var i = 0; i < this._numMeshes; i++) {
|
|
|
+ if (this._impostors[i] == impostor) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ var debugMesh = this._getDebugMesh(impostor, this._scene);
|
|
|
+
|
|
|
+ if (debugMesh) {
|
|
|
+ this._impostors[this._numMeshes] = impostor;
|
|
|
+ this._meshes[this._numMeshes] = debugMesh;
|
|
|
+
|
|
|
+ if (this._numMeshes === 0) {
|
|
|
+ this._renderFunction = this._updateDebugMeshes.bind(this);
|
|
|
+ this._scene.registerBeforeRender(this._renderFunction);
|
|
|
+ }
|
|
|
+
|
|
|
+ this._numMeshes++;
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ public hideImpostor(impostor: Nullable<PhysicsImpostor>) {
|
|
|
+
|
|
|
+ if (!impostor || !this._scene) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ var removed = false;
|
|
|
+
|
|
|
+ for (var i = 0; i < this._numMeshes; i++) {
|
|
|
+ if (this._impostors[i] == impostor) {
|
|
|
+ let mesh = this._meshes[i];
|
|
|
+
|
|
|
+ if (!mesh) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ this._scene.removeMesh(mesh);
|
|
|
+ mesh.dispose();
|
|
|
+ this._numMeshes--;
|
|
|
+ if (this._numMeshes > 0) {
|
|
|
+ this._meshes[i] = this._meshes[this._numMeshes];
|
|
|
+ this._impostors[i] = this._impostors[this._numMeshes];
|
|
|
+ this._meshes[this._numMeshes] = null;
|
|
|
+ this._impostors[this._numMeshes] = null;
|
|
|
+ } else {
|
|
|
+ this._meshes[0] = null;
|
|
|
+ this._impostors[0] = null;
|
|
|
+ }
|
|
|
+ removed = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (removed && this._numMeshes === 0) {
|
|
|
+ this._scene.unregisterBeforeRender(this._renderFunction);
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ _getDebugMaterial(scene: Scene): Material {
|
|
|
+ if (!this._debugMaterial) {
|
|
|
+ this._debugMaterial = new StandardMaterial('', scene);
|
|
|
+ this._debugMaterial.wireframe = true;
|
|
|
+ }
|
|
|
+
|
|
|
+ return this._debugMaterial;
|
|
|
+ }
|
|
|
+
|
|
|
+ _getDebugBoxMesh(scene: Scene): AbstractMesh {
|
|
|
+ if (!this._debugBoxMesh) {
|
|
|
+ this._debugBoxMesh = MeshBuilder.CreateBox('physicsBodyBoxViewMesh', { size: 1 }, scene);
|
|
|
+ this._debugBoxMesh.renderingGroupId = 1;
|
|
|
+ this._debugBoxMesh.rotationQuaternion = Quaternion.Identity();
|
|
|
+ this._debugBoxMesh.material = this._getDebugMaterial(scene);
|
|
|
+ scene.removeMesh(this._debugBoxMesh);
|
|
|
+ }
|
|
|
+
|
|
|
+ return this._debugBoxMesh.createInstance('physicsBodyBoxViewInstance');
|
|
|
+ }
|
|
|
+
|
|
|
+ _getDebugSphereMesh(scene: Scene): AbstractMesh {
|
|
|
+ if (!this._debugSphereMesh) {
|
|
|
+ this._debugSphereMesh = MeshBuilder.CreateSphere('physicsBodySphereViewMesh', { diameter: 1 }, scene);
|
|
|
+ this._debugSphereMesh.renderingGroupId = 1;
|
|
|
+ this._debugSphereMesh.rotationQuaternion = Quaternion.Identity();
|
|
|
+ this._debugSphereMesh.material = this._getDebugMaterial(scene);
|
|
|
+ scene.removeMesh(this._debugSphereMesh);
|
|
|
+ }
|
|
|
+
|
|
|
+ return this._debugSphereMesh.createInstance('physicsBodyBoxViewInstance');
|
|
|
+ }
|
|
|
+
|
|
|
+ _getDebugMesh(impostor: PhysicsImpostor, scene: Scene): Nullable<AbstractMesh> {
|
|
|
+ var mesh: Nullable<AbstractMesh> = null;
|
|
|
+
|
|
|
+ if (impostor.type == PhysicsImpostor.BoxImpostor) {
|
|
|
+ mesh = this._getDebugBoxMesh(scene);
|
|
|
+ impostor.getBoxSizeToRef(mesh.scaling);
|
|
|
+ } else if (impostor.type == PhysicsImpostor.SphereImpostor) {
|
|
|
+ mesh = this._getDebugSphereMesh(scene);
|
|
|
+ var radius = impostor.getRadius();
|
|
|
+ mesh.scaling.x = radius * 2;
|
|
|
+ mesh.scaling.y = radius * 2;
|
|
|
+ mesh.scaling.z = radius * 2;
|
|
|
+ }
|
|
|
+
|
|
|
+ return mesh;
|
|
|
+ }
|
|
|
+
|
|
|
+ public dispose() {
|
|
|
+
|
|
|
+ for (var i = 0; i < this._numMeshes; i++) {
|
|
|
+ this.hideImpostor(this._impostors[i]);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (this._debugBoxMesh) {
|
|
|
+ this._debugBoxMesh.dispose();
|
|
|
+ }
|
|
|
+ if (this._debugSphereMesh) {
|
|
|
+ this._debugSphereMesh.dispose();
|
|
|
+ }
|
|
|
+ if (this._debugMaterial) {
|
|
|
+ this._debugMaterial.dispose();
|
|
|
+ }
|
|
|
+
|
|
|
+ this._impostors.length = 0;
|
|
|
+ this._scene = null;
|
|
|
+ this._physicsEnginePlugin = null;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ public static SkeletonViewer = class SkeletonViewer {
|
|
|
+ public color: Color3 = Color3.White();
|
|
|
+
|
|
|
+ _scene: Scene;
|
|
|
+ _debugLines = new Array<Array<Vector3>>();
|
|
|
+ _debugMesh: Nullable<LinesMesh>;
|
|
|
+ _isEnabled = false;
|
|
|
+ _renderFunction: () => void;
|
|
|
+
|
|
|
+ constructor(public skeleton: Skeleton, public mesh: AbstractMesh, scene: Scene, public autoUpdateBonesMatrices = true, public renderingGroupId = 1) {
|
|
|
+ this._scene = scene;
|
|
|
+
|
|
|
+ this.update();
|
|
|
+
|
|
|
+ this._renderFunction = this.update.bind(this);
|
|
|
+ }
|
|
|
+
|
|
|
+ public set isEnabled(value: boolean) {
|
|
|
+ if (this._isEnabled === value) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ this._isEnabled = value;
|
|
|
+
|
|
|
+ if (value) {
|
|
|
+ this._scene.registerBeforeRender(this._renderFunction);
|
|
|
+ } else {
|
|
|
+ this._scene.unregisterBeforeRender(this._renderFunction);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public get isEnabled(): boolean {
|
|
|
+ return this._isEnabled;
|
|
|
+ }
|
|
|
+
|
|
|
+ _getBonePosition(position: Vector3, bone: Bone, meshMat: Matrix, x = 0, y = 0, z = 0): void {
|
|
|
+ var tmat = Tmp.Matrix[0];
|
|
|
+ var parentBone = bone.getParent();
|
|
|
+ tmat.copyFrom(bone.getLocalMatrix());
|
|
|
+
|
|
|
+ if (x !== 0 || y !== 0 || z !== 0) {
|
|
|
+ var tmat2 = Tmp.Matrix[1];
|
|
|
+ BABYLON.Matrix.IdentityToRef(tmat2);
|
|
|
+ tmat2.m[12] = x;
|
|
|
+ tmat2.m[13] = y;
|
|
|
+ tmat2.m[14] = z;
|
|
|
+ tmat2.multiplyToRef(tmat, tmat);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (parentBone) {
|
|
|
+ tmat.multiplyToRef(parentBone.getAbsoluteTransform(), tmat);
|
|
|
+ }
|
|
|
+
|
|
|
+ tmat.multiplyToRef(meshMat, tmat);
|
|
|
+
|
|
|
+ position.x = tmat.m[12];
|
|
|
+ position.y = tmat.m[13];
|
|
|
+ position.z = tmat.m[14];
|
|
|
+ }
|
|
|
+
|
|
|
+ _getLinesForBonesWithLength(bones: Bone[], meshMat: Matrix): void {
|
|
|
+ var len = bones.length;
|
|
|
+ var meshPos = this.mesh.position;
|
|
|
+ for (var i = 0; i < len; i++) {
|
|
|
+ var bone = bones[i];
|
|
|
+ var points = this._debugLines[i];
|
|
|
+ if (!points) {
|
|
|
+ points = [Vector3.Zero(), Vector3.Zero()];
|
|
|
+ this._debugLines[i] = points;
|
|
|
+ }
|
|
|
+ this._getBonePosition(points[0], bone, meshMat);
|
|
|
+ this._getBonePosition(points[1], bone, meshMat, 0, bone.length, 0);
|
|
|
+ points[0].subtractInPlace(meshPos);
|
|
|
+ points[1].subtractInPlace(meshPos);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ _getLinesForBonesNoLength(bones: Bone[], meshMat: Matrix): void {
|
|
|
+ var len = bones.length;
|
|
|
+ var boneNum = 0;
|
|
|
+ var meshPos = this.mesh.position;
|
|
|
+ for (var i = len - 1; i >= 0; i--) {
|
|
|
+ var childBone = bones[i];
|
|
|
+ var parentBone = childBone.getParent();
|
|
|
+ if (!parentBone) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ var points = this._debugLines[boneNum];
|
|
|
+ if (!points) {
|
|
|
+ points = [Vector3.Zero(), Vector3.Zero()];
|
|
|
+ this._debugLines[boneNum] = points;
|
|
|
+ }
|
|
|
+ childBone.getAbsolutePositionToRef(this.mesh, points[0]);
|
|
|
+ parentBone.getAbsolutePositionToRef(this.mesh, points[1]);
|
|
|
+ points[0].subtractInPlace(meshPos);
|
|
|
+ points[1].subtractInPlace(meshPos);
|
|
|
+ boneNum++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public update() {
|
|
|
+ if (this.autoUpdateBonesMatrices) {
|
|
|
+ this.skeleton.computeAbsoluteTransforms();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (this.skeleton.bones[0].length === undefined) {
|
|
|
+ this._getLinesForBonesNoLength(this.skeleton.bones, this.mesh.getWorldMatrix());
|
|
|
+ } else {
|
|
|
+ this._getLinesForBonesWithLength(this.skeleton.bones, this.mesh.getWorldMatrix());
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!this._debugMesh) {
|
|
|
+ this._debugMesh = BABYLON.MeshBuilder.CreateLineSystem("", { lines: this._debugLines, updatable: true, instance: null }, this._scene);
|
|
|
+ this._debugMesh.renderingGroupId = this.renderingGroupId;
|
|
|
+ } else {
|
|
|
+ BABYLON.MeshBuilder.CreateLineSystem("", { lines: this._debugLines, updatable: true, instance: this._debugMesh }, this._scene);
|
|
|
+ }
|
|
|
+ this._debugMesh.position.copyFrom(this.mesh.position);
|
|
|
+ this._debugMesh.color = this.color;
|
|
|
+ }
|
|
|
+
|
|
|
+ public dispose() {
|
|
|
+ if (this._debugMesh) {
|
|
|
+ this.isEnabled = false;
|
|
|
+ this._debugMesh.dispose();
|
|
|
+ this._debugMesh = null;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+}
|
David Catuhe