diff --git a/bin/AlternativaEditor.swf b/bin/AlternativaEditor.swf index b34ffcf..f2c0c0d 100644 Binary files a/bin/AlternativaEditor.swf and b/bin/AlternativaEditor.swf differ diff --git a/libs/Alternativa3D.swc b/libs/Alternativa3D.swc deleted file mode 100644 index 61378b1..0000000 Binary files a/libs/Alternativa3D.swc and /dev/null differ diff --git a/src/AlternativaEditor.mxml b/src/AlternativaEditor.mxml index 94cba36..90eacda 100644 --- a/src/AlternativaEditor.mxml +++ b/src/AlternativaEditor.mxml @@ -793,19 +793,19 @@ width="130"/> - + - - - + + + - - + + diff --git a/src/alternativa/Alternativa3D.as b/src/alternativa/Alternativa3D.as new file mode 100644 index 0000000..b43a76d --- /dev/null +++ b/src/alternativa/Alternativa3D.as @@ -0,0 +1,14 @@ +package alternativa +{ + public class Alternativa3D + { + + public static const version:String = "7.11.mod"; + + + public function Alternativa3D() + { + super(); + } + } +} diff --git a/src/alternativa/editor/FunctionalProps.as b/src/alternativa/editor/FunctionalProps.as index b9510a3..c89cc8b 100644 --- a/src/alternativa/editor/FunctionalProps.as +++ b/src/alternativa/editor/FunctionalProps.as @@ -6,7 +6,7 @@ package alternativa.editor import alternativa.editor.propslib.PropGroup; import alternativa.editor.propslib.PropLibObject; import alternativa.editor.propslib.PropsLibrary; - import alternativa.engine3d.core.Mesh; + import alternativa.engine3d.objects.Mesh; import alternativa.engine3d.core.Object3D; import alternativa.engine3d.core.Vertex; import alternativa.engine3d.loaders.Parser3DS; @@ -16,6 +16,7 @@ package alternativa.editor import flash.geom.Point; import flash.utils.ByteArray; import flash.utils.Dictionary; + import alternativa.engine3d.primitives.Box; public class FunctionalProps { @@ -163,14 +164,14 @@ package alternativa.editor private static function getColoredPropObject(param1:String, param2:ByteArray, param3:uint) : PropLibObject { var loc4:Mesh = parse3DS(param2); - loc4.cloneMaterialToAllSurfaces(new TextureMaterial(getMonochromeTexture(param3))); + loc4.setMaterialToAllFaces(new TextureMaterial(getMonochromeTexture(param3))); return new PropLibObject(param1,loc4); } private static function getTexturedPropObject(param1:String, param2:ByteArray, param3:BitmapData) : PropLibObject { var loc4:Mesh = parse3DS(param2); - loc4.cloneMaterialToAllSurfaces(new TextureMaterial(new Texture(param3))); + loc4.setMaterialToAllFaces(new TextureMaterial(param3)); return new PropLibObject(param1,loc4); } @@ -178,19 +179,19 @@ package alternativa.editor { var loc2:Parser3DS = new Parser3DS(); loc2.parse(param1); - var loc3:Mesh = loc2.content.children.peek() as Mesh; + var loc3:Mesh = loc2.objects[0] as Mesh; loc3.x = 0; loc3.y = 0; loc3.z = 0; return loc3; } - private static function getMonochromeTexture(param1:uint) : Texture + private static function getMonochromeTexture(param1:uint) : BitmapData { - var loc2:Texture = textures[param1]; + var loc2:BitmapData = textures[param1]; if(loc2 == null) { - loc2 = new Texture(new BitmapData(1,1,false,param1)); + loc2 = new BitmapData(1,1,false,param1); textures[param1] = loc2; } return loc2; @@ -208,7 +209,7 @@ package alternativa.editor private static function createDominationPoint() : Object3D { - var loc1:Mesh = new Mesh(); + /*var loc1:Mesh = new Mesh(); var loc4:Vertex = loc1.createVertex(-50,-50,0); var loc5:Vertex = loc1.createVertex(50,-50,0); var loc6:Vertex = loc1.createVertex(50,50,0); @@ -223,8 +224,9 @@ package alternativa.editor loc1.setUVsToFace(new Point(0,0),new Point(1,0),new Point(1,1),loc1.createFace([loc5,loc6,loc10,loc9])); loc1.setUVsToFace(new Point(0,0),new Point(1,0),new Point(1,1),loc1.createFace([loc6,loc7,loc11,loc10])); loc1.setUVsToFace(new Point(0,0),new Point(1,0),new Point(1,1),loc1.createFace([loc4,loc8,loc11,loc7])); - loc1.moveAllFacesToSurface(); - loc1.cloneMaterialToAllSurfaces(new TextureMaterial(getMonochromeTexture(16711935))); + loc1.moveAllFacesToSurface();*/ + var loc1:Box = new Box(100,100,400); + loc1.setMaterialToAllFaces(new TextureMaterial(getMonochromeTexture(16711935))); return loc1; } diff --git a/src/alternativa/editor/LibraryManager.as b/src/alternativa/editor/LibraryManager.as index 7dd2c34..e62c54f 100644 --- a/src/alternativa/editor/LibraryManager.as +++ b/src/alternativa/editor/LibraryManager.as @@ -14,9 +14,9 @@ package alternativa.editor import alternativa.editor.propslib.PropLibObject; import alternativa.editor.propslib.PropsLibrary; import alternativa.editor.propslib.events.PropLibProgressEvent; - import alternativa.engine3d.core.Mesh; + import alternativa.engine3d.objects.Mesh; import alternativa.engine3d.core.Object3D; - import alternativa.engine3d.core.Sprite3D; + import alternativa.engine3d.objects.Sprite3D; import alternativa.types.Map; import alternativa.types.Point3D; import flash.events.ErrorEvent; @@ -59,7 +59,7 @@ package alternativa.editor private static function createFunctionalProp(param1:PropLibObject, param2:String) : Prop { - var loc3:Object3D = param1.object3d; + var loc3:Object3D = param1.mainObject; switch(param2) { case FunctionalProps.GRP_SPAWN_POINTS: @@ -86,9 +86,9 @@ package alternativa.editor case FunctionalProps.DOMINATION_BLUE_SPAWN: case FunctionalProps.DOMINATION_RED_SPAWN: case FunctionalProps.DOMINATION_SPAWN: - return new SpawnPoint(param2.object3d,param2.name,FunctionalProps.LIBRARY_NAME,param1); + return new SpawnPoint(param2.mainObject,param2.name,FunctionalProps.LIBRARY_NAME,param1); case FunctionalProps.DOMINATION_POINT: - return new ControlPoint(param2.object3d,param2.name,FunctionalProps.LIBRARY_NAME,param1); + return new ControlPoint(param2.mainObject,param2.name,FunctionalProps.LIBRARY_NAME,param1); default: throw new Error("Unsupported prop type: " + param2.name); } @@ -98,11 +98,11 @@ package alternativa.editor { var loc5:MeshProp = null; var loc6:String = null; - var loc4:Object3D = param1.object3d; - loc4.coords = new Point3D(); + var loc4:Object3D = param1.mainObject; + loc4.setPositionXYZ(0,0,0); if(loc4 is Mesh) { - loc5 = new MeshProp(loc4,param1.name,param2,param3); + loc5 = new MeshProp(loc4,param1.objects,param1.name,param2,param3); loc5.bitmaps = (param1 as PropLibMesh).bitmaps; if(loc5.bitmaps != null) { diff --git a/src/alternativa/editor/Preview.as b/src/alternativa/editor/Preview.as index 9482227..b394025 100644 --- a/src/alternativa/editor/Preview.as +++ b/src/alternativa/editor/Preview.as @@ -4,9 +4,9 @@ package alternativa.editor import alternativa.editor.prop.Sprite3DProp; import alternativa.engine3d.core.Camera3D; import alternativa.engine3d.core.Object3D; - import alternativa.engine3d.core.Scene3D; + import alternativa.editor.engine3d.Scene3D; import alternativa.engine3d.core.Vertex; - import alternativa.engine3d.display.View; + import alternativa.engine3d.core.View; import alternativa.types.Map; import alternativa.types.Point3D; import alternativa.utils.MathUtils; @@ -16,6 +16,7 @@ package alternativa.editor import flash.geom.Matrix; import flash.geom.Point; import mx.core.UIComponent; + import alternativa.engine3d.core.Object3DContainer; public class Preview extends UIComponent { @@ -27,7 +28,7 @@ package alternativa.editor private var camera:Camera3D; - private var cameraContainer:Object3D; + private var cameraContainer:Object3DContainer; private var propDistance:Map; @@ -50,14 +51,15 @@ package alternativa.editor private function initScene() : void { this.scene = new Scene3D(); - this.scene.root = new Object3D(); - this.camera = new Camera3D(); + this.scene.root = new Object3DContainer(); + this.camera = this.scene.camera = new Camera3D(); this.camera.rotationX = -MathUtils.DEG90 - MathUtils.DEG30; - this.cameraContainer = new Object3D(); + this.cameraContainer = new Object3DContainer(); this.cameraContainer.addChild(this.camera); - this.camera.coords = new Point3D(0,-100,40); + this.camera.setPositionXYZ(0,-100,40); this.scene.root.addChild(this.cameraContainer); - this.view = new View(this.camera); + this.view = new View(100,100); + this.camera.view = this.view; addChild(this.view); this.view.graphics.beginFill(16777215); this.view.graphics.drawRect(0,0,1,1); @@ -73,10 +75,10 @@ package alternativa.editor private function calculateOptimalCameraPosition(param1:Prop) : void { var loc7:BitmapData = null; - var loc8:Array = null; + var loc8:Vector. = null; var loc9:int = 0; var loc10:int = 0; - var loc11:Point3D = null; + var loc11:Point3D = new Point3D(); var loc12:Number = NaN; var loc13:Number = NaN; var loc14:Number = NaN; @@ -94,12 +96,12 @@ package alternativa.editor } else { - loc8 = param1.vertices.toArray(true); + loc8 = param1.vertices; loc9 = int(loc8.length); loc10 = 0; while(loc10 < loc9) { - loc11 = Vertex(loc8[loc10]).coords; + loc11.copyFromVertex(loc8[loc10]); loc12 = loc11.x - param1.x; loc13 = loc11.y - param1.y; loc14 = loc11.z - param1.z; @@ -151,9 +153,9 @@ package alternativa.editor private function clearScene() : void { - var loc1:* = undefined; + var loc1:Object3D; var loc2:Prop = null; - for(loc1 in this.scene.root.children) + for each(loc1 in this.scene.root.children) { loc2 = loc1 as Prop; if(loc2 != null) diff --git a/src/alternativa/editor/SceneContainer.as b/src/alternativa/editor/SceneContainer.as index 709a184..6172381 100644 --- a/src/alternativa/editor/SceneContainer.as +++ b/src/alternativa/editor/SceneContainer.as @@ -9,10 +9,10 @@ package alternativa.editor import alternativa.editor.scene.MainScene; import alternativa.editor.scene.OccupyMap; import alternativa.engine3d.alternativa3d; - import alternativa.engine3d.core.Mesh; + import alternativa.engine3d.objects.Mesh; import alternativa.engine3d.core.Vertex; - import alternativa.engine3d.events.MouseEvent3D; - import alternativa.types.Matrix3D; + import alternativa.engine3d.core.MouseEvent3D; + import alternativa.types.Matrix4; import alternativa.types.Point3D; import alternativa.types.Set; import alternativa.utils.KeyboardUtils; @@ -27,6 +27,8 @@ package alternativa.editor import mx.controls.Alert; import mx.core.UIComponent; import mx.events.CloseEvent; + import alternativa.engine3d.core.Object3D; + import flash.geom.Vector3D; use namespace alternativa3d; @@ -50,7 +52,7 @@ package alternativa.editor private var eventJournal:EventJournal; - private var cameraTransformation:Matrix3D; + private var cameraTransformation:Matrix4; private var _snapMode:Boolean; @@ -111,13 +113,13 @@ package alternativa.editor private static function getMeshBounds(param1:Mesh, param2:Point3D, param3:Point3D) : void { - var loc4:Vertex = null; + /*var loc4:Vertex = null; var loc5:Point3D = null; param2.reset(10000000000,10000000000,10000000000); param3.reset(-10000000000,-10000000000,-10000000000); - for each(loc4 in param1.alternativa3d::_vertices) + for each(loc4 in param1.vertices) { - loc5 = loc4.alternativa3d::globalCoords; + loc5 = loc4.globalCoords; if(loc5.x < param2.x) { param2.x = loc5.x; @@ -142,7 +144,10 @@ package alternativa.editor { param3.z = loc5.z; } - } + }*/ + param1.calculateBounds(); + param2.reset(param1.boundMaxX,param1.boundMaxY,param1.boundMaxZ); + param3.reset(param1.boundMinX,param1.boundMinY,param1.boundMinZ); } private static function fillBBPoints(param1:Point3D, param2:Point3D, param3:Array) : void @@ -196,7 +201,7 @@ package alternativa.editor { removeEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage); this.keyMapper.startListening(stage); - this.cursorScene = new CursorScene(stage); + this.cursorScene = new CursorScene(stage,this); this.mainScene = new MainScene(); this.cursorScene.occupyMap = this.mainScene.occupyMap; addChild(this.mainScene.view); @@ -209,7 +214,7 @@ package alternativa.editor addChild(this.selectionRectOverlay); this.initListeners(); this.eventJournal = new EventJournal(); - var loc2:Point3D = this.cursorScene.camera.coords; + var loc2:Object3D = this.cursorScene.camera; this.cameraDistance = Math.sqrt(loc2.x * loc2.x + loc2.y * loc2.y + loc2.z * loc2.z); } @@ -240,7 +245,7 @@ package alternativa.editor { if(this.mainScene.selectedProp != null) { - this.startSelectionCoords = this.mainScene.selectedProp.coords; + this.startSelectionCoords = new Point3D().copyFromObject3D(this.mainScene.selectedProp); this.cursorScene.visible = false; } } @@ -268,9 +273,9 @@ package alternativa.editor { this.eventJournal.addEvent(EventJournal.COPY,loc3.clone()); } - else if(!this.startSelectionCoords.equals(loc2.coords)) + else if(!this.startSelectionCoords.equalsXYZ(loc2.x,loc2.y,loc2.z)) { - loc5 = loc2.coords; + loc5 = new Point3D().copyFromObject3D(loc2); loc5.difference(loc5,this.startSelectionCoords); this.eventJournal.addEvent(EventJournal.MOVE,loc3.clone(),loc5); loc4 = true; @@ -367,7 +372,7 @@ package alternativa.editor var loc6:Set = null; var loc7:Point3D = null; var loc8:Prop = null; - var loc9:Matrix3D = null; + var loc9:Matrix4 = null; var loc10:Point3D = null; var loc11:Point3D = null; var loc12:Point3D = null; @@ -385,9 +390,9 @@ package alternativa.editor { if(param1.shiftKey && !this.copy) { - if(!this.startSelectionCoords.equals(loc4.coords)) + if(!this.startSelectionCoords.equalsXYZ(loc4.x,loc4.y,loc4.z)) { - loc7 = loc4.coords; + loc7 = new Point3D().copyFromObject3D(loc4); loc7.difference(loc7,this.startSelectionCoords); this.eventJournal.addEvent(EventJournal.MOVE,loc5.clone(),loc7); } @@ -395,7 +400,7 @@ package alternativa.editor for(loc2 in loc5) { loc3 = loc2 as Prop; - loc8 = this.mainScene.addProp(loc3,loc3.coords,loc3.rotationZ); + loc8 = this.mainScene.addProp(loc3,new Point3D().copyFromObject3D(loc3),loc3.rotationZ); if(loc3 == loc4) { loc4 = loc8; @@ -404,7 +409,7 @@ package alternativa.editor } this.mainScene.selectProps(loc6); this.mainScene.selectedProp = loc4; - this.startSelectionCoords = loc4.coords; + this.startSelectionCoords = new Point3D().copyFromObject3D(loc4); this.copy = true; } this.mainScene.moveSelectedPropsByMouse(this.verticalMoving); @@ -419,7 +424,7 @@ package alternativa.editor loc12 = new Point3D(loc9.d,loc9.h,loc9.l); loc12.add(loc10); loc12.add(loc11); - this.cursorScene.cameraController.coords = this.cursorScene.container.globalToLocal(loc12); + this.cursorScene.cameraController.setObjectPos(this.cursorScene.container.globalToLocal(loc12.toVector3D())); } else if(this.mouseDown) { @@ -490,18 +495,23 @@ package alternativa.editor private function zoom(param1:int) : void { - var loc2:Point3D = !!this.mainScene.selectedProp ? this.mainScene.selectedProp.coords : this.cursorScene.camera.localToGlobal(cameraPoint); - var loc3:Point3D = this.cursorScene.container.localToGlobal(this.cursorScene.cameraController.coords); + var loc2:Point3D = new Point3D(); + var cameraPointV3:Vector3D = cameraPoint.toVector3D(); + if(this.mainScene.selectedProp) + loc2.copyFromObject3D(this.mainScene.selectedProp) + else + loc2.copyFromVector3D(this.cursorScene.camera.localToGlobal(cameraPointV3)); + var loc3:Point3D = new Point3D().copyFromVector3D(this.cursorScene.container.localToGlobal(this.cursorScene.cameraController.coords3D)); var loc4:Point3D = loc3.clone(); var loc5:Point3D = Point3D.difference(loc2,loc3); if(loc5.length < 500) { - loc5 = Point3D.difference(this.cursorScene.camera.localToGlobal(cameraPoint),loc3); + loc5 = Point3D.difference(new Point3D().copyFromVector3D(this.cursorScene.camera.localToGlobal(cameraPointV3)),loc3); } loc5.normalize(); loc5.multiply(param1 * 100); loc3.add(loc5); - this.cursorScene.cameraController.coords = this.cursorScene.container.globalToLocal(loc3); + this.cursorScene.cameraController.setObjectPos(this.cursorScene.container.globalToLocal(loc3.toVector3D())); } private function onMouseOut(param1:MouseEvent) : void @@ -543,13 +553,13 @@ package alternativa.editor } else { - loc2 = this.cursorScene.camera.localToGlobal(new Point3D(0,0,this.cameraDistance)); + loc2 = new Point3D().copyFromVector3D(this.cursorScene.camera.localToGlobal(new Vector3D(0,0,this.cameraDistance))); } loc4 = this.cursorScene.containerController.coords.clone(); loc4.subtract(loc2); - loc5 = this.cursorScene.container.localToGlobal(this.cursorScene.cameraController.coords); + loc5 = new Point3D().copyFromVector3D(this.cursorScene.container.localToGlobal(this.cursorScene.cameraController.coords3D)); loc5.add(loc4); - this.cursorScene.cameraController.coords = this.cursorScene.container.globalToLocal(loc5); + this.cursorScene.cameraController.setObjectPos(this.cursorScene.container.globalToLocal(loc5.toVector3D())); this.cursorScene.containerController.coords = loc2; this.cursorScene.containerController.setMouseLook(true); } @@ -596,16 +606,17 @@ package alternativa.editor private function drawBoundBoxes() : void { - var loc1:* = undefined; var loc2:MeshProp = null; this.boundBoxesOverlay.graphics.clear(); - for(loc1 in this.mainScene.root.alternativa3d::_children) + var loc1:Object3D = this.mainScene.root.childrenList; + while(loc1 != null) { loc2 = loc1 as MeshProp; if(loc2 != null && !loc2.hidden) { this.drawPropBoundBox(loc2); } + loc1 = loc1.next; } } @@ -684,7 +695,7 @@ package alternativa.editor var loc2:Prop = null; var loc3:Point3D = null; var loc4:Point3D = null; - var loc5:Point3D = null; + var loc5:Object3D = null; var loc6:Prop = null; var loc7:Set = null; switch(param1.keyCode) @@ -694,7 +705,7 @@ package alternativa.editor { this.cursorScene.camera.rotationX = this.cursorScene.camera.rotationX = this.cursorScene.camera.rotationX = -2.0943951023931953; this.cursorScene.cameraController.coords = new Point3D(250,-7800,4670); - loc5 = this.cursorScene.camera.coords; + loc5 = this.cursorScene.camera; this.cameraDistance = Math.sqrt(loc5.x * loc5.x + loc5.y * loc5.y + loc5.z * loc5.z); } break; @@ -708,9 +719,9 @@ package alternativa.editor break; } loc2 = this.mainScene.selectedProp; - loc4 = loc2.coords; + loc4 = new Point3D().copyFromObject3D(loc2); this.mainScene.moveByArrows(param1.keyCode); - loc3 = loc2.coords; + loc3 = new Point3D().copyFromObject3D(loc2); loc3.difference(loc3,loc4); this.eventJournal.addEvent(EventJournal.MOVE,this.mainScene.selectedProps,loc3); break; @@ -727,9 +738,9 @@ package alternativa.editor loc2 = this.mainScene.selectedProp; if(loc2) { - loc4 = loc2.coords; + loc4 = new Point3D().copyFromObject3D(loc2); this.mainScene.verticalMove(false); - loc3 = loc2.coords; + loc3 = new Point3D().copyFromObject3D(loc2); loc3.difference(loc3,loc4); this.eventJournal.addEvent(EventJournal.MOVE,this.mainScene.selectedProps,loc3); } @@ -746,9 +757,9 @@ package alternativa.editor loc2 = this.mainScene.selectedProp; if(loc2) { - loc4 = loc2.coords; + loc4 = new Point3D().copyFromObject3D(loc2); this.mainScene.verticalMove(true); - loc3 = loc2.coords; + loc3 = new Point3D().copyFromObject3D(loc2); loc3.difference(loc3,loc4); this.eventJournal.addEvent(EventJournal.MOVE,this.mainScene.selectedProps,loc3); } @@ -762,7 +773,7 @@ package alternativa.editor loc6 = this.cursorScene.object; if(loc6) { - loc6.coords = loc2.coords; + loc6.setPositionXYZ(loc2.x,loc2.y,loc2.z); if(this.snapMode) { loc6.snapToGrid(); @@ -799,7 +810,7 @@ package alternativa.editor { if(this.cursorScene.object) { - this.cursorScene.object.coords = loc2.coords; + this.cursorScene.object.setPositionXYZ(loc2.x,loc2.y,loc2.z); this.cursorScene.object.snapToGrid(); } this.mainScene.deselectProps(); @@ -872,7 +883,7 @@ package alternativa.editor public function addProp(param1:Prop) : void { - var loc2:Prop = this.mainScene.addProp(param1,this.cursorScene.object.coords,this.cursorScene.object.rotationZ); + var loc2:Prop = this.mainScene.addProp(param1,new Point3D().copyFromObject3D(this.cursorScene.object),this.cursorScene.object.rotationZ); var loc3:Set = new Set(); loc3.add(loc2); this.eventJournal.addEvent(EventJournal.ADD,loc3); @@ -886,7 +897,7 @@ package alternativa.editor private function onPropMouseDown(param1:MouseEvent3D) : void { - this.clickZ = param1.object.z; + this.clickZ = param1.relatedObject.z; this.propDown = true; } diff --git a/src/alternativa/editor/engine3d/Scene3D.as b/src/alternativa/editor/engine3d/Scene3D.as new file mode 100644 index 0000000..9e84773 --- /dev/null +++ b/src/alternativa/editor/engine3d/Scene3D.as @@ -0,0 +1,44 @@ +package alternativa.editor.engine3d +{ + import alternativa.engine3d.core.Object3DContainer; + import alternativa.engine3d.core.Camera3D; + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.alternativa3d; + import alternativa.editor.prop.Prop; + + use namespace alternativa3d; + + public class Scene3D + { + public var camera:Camera3D; + + private var _root:Object3DContainer; + + + public function get root() : Object3DContainer + { + return _root; + } + public function set root(container:Object3DContainer) : void + { + _root = container; + } + + + public function calculate() : void + { + var child:Object3D = _root.childrenList; + while(child != null) + { + if(child is Prop) + { + (child as Prop).calculate(); + } + + child = child.next; + } + + this.camera.render(); + } + } +} \ No newline at end of file diff --git a/src/alternativa/editor/engine3d/controllers/ObjectController.as b/src/alternativa/editor/engine3d/controllers/ObjectController.as new file mode 100644 index 0000000..b578c89 --- /dev/null +++ b/src/alternativa/editor/engine3d/controllers/ObjectController.as @@ -0,0 +1,581 @@ +package alternativa.editor.engine3d.controllers +{ + import alternativa.engine3d.*; + import alternativa.engine3d.core.Object3D; + import alternativa.types.Map; + import alternativa.types.Point3D; + import alternativa.utils.ObjectUtils; + import flash.display.DisplayObject; + import flash.events.KeyboardEvent; + import flash.events.MouseEvent; + import flash.utils.getTimer; + import alternativa.engine3d.core.EllipsoidCollider; + import flash.geom.Vector3D; + + use namespace alternativa3d; + + public class ObjectController + { + public static const ACTION_FORWARD:String = "ACTION_FORWARD"; + + public static const ACTION_BACK:String = "ACTION_BACK"; + + public static const ACTION_LEFT:String = "ACTION_LEFT"; + + public static const ACTION_RIGHT:String = "ACTION_RIGHT"; + + public static const ACTION_UP:String = "ACTION_UP"; + + public static const ACTION_DOWN:String = "ACTION_DOWN"; + + public static const ACTION_PITCH_UP:String = "ACTION_PITCH_UP"; + + public static const ACTION_PITCH_DOWN:String = "ACTION_PITCH_DOWN"; + + public static const ACTION_YAW_LEFT:String = "ACTION_YAW_LEFT"; + + public static const ACTION_YAW_RIGHT:String = "ACTION_YAW_RIGHT"; + + public static const ACTION_ACCELERATE:String = "ACTION_ACCELERATE"; + + public static const ACTION_MOUSE_LOOK:String = "ACTION_MOUSE_LOOK"; + + protected var _enabled:Boolean = true; + + protected var keyBindings:Map; + + protected var _mouseSensitivity:Number = 1; + + protected var _keyboardEnabled:Boolean; + + protected var _right:Boolean; + + protected var _speedMultiplier:Number = 2; + + //public var onStopMoving:Function; + + protected var _up:Boolean; + + protected var _coords:Point3D; + + protected var _speed:Number = 100; + + protected var _yawRight:Boolean; + + protected var _collider:EllipsoidCollider; + + protected var _object:Object3D; + + protected var _mouseSensitivityX:Number; + + protected var _mouseSensitivityY:Number; + + protected var startMouseCoords:Point3D; + + protected var _eventsSource:DisplayObject; + + protected var _yawSpeed:Number = 1; + + protected var _accelerate:Boolean; + + protected var _down:Boolean; + + protected var _pitchDown:Boolean; + + protected var _forward:Boolean; + + protected var _mouseCoefficientX:Number; + + protected var _mouseCoefficientY:Number; + + protected var _pitchSpeed:Number = 1; + + //protected var _isMoving:Boolean; + + public var checkCollisions:Boolean; + + protected var _mouseEnabled:Boolean; + + protected var _pitchUp:Boolean; + + protected var _back:Boolean; + + protected var _mouseLookActive:Boolean; + + protected var _yawLeft:Boolean; + + protected var actionBindings:Map; + + protected var _left:Boolean; + + protected var lastFrameTime:uint; + + //public var onStartMoving:Function; + + private var _displacement:Point3D; + + public function ObjectController(eventsSourceObject:DisplayObject) + { + startMouseCoords = new Point3D(); + keyBindings = new Map(); + actionBindings = new Map(); + _mouseSensitivityY = Math.PI / 360; + _mouseSensitivityX = Math.PI / 360; + _mouseCoefficientY = _mouseSensitivity * _mouseSensitivityY; + _mouseCoefficientX = _mouseSensitivity * _mouseSensitivityX; + _coords = new Point3D(); + _collider = new EllipsoidCollider(50,50,50); + _displacement = new Point3D(); + super(); + if(eventsSourceObject == null) + { + throw new ArgumentError(ObjectUtils.getClassName(this) + ": eventsSourceObject is null"); + } + _eventsSource = eventsSourceObject; + actionBindings[ACTION_FORWARD] = moveForward; + actionBindings[ACTION_BACK] = moveBack; + actionBindings[ACTION_LEFT] = moveLeft; + actionBindings[ACTION_RIGHT] = moveRight; + actionBindings[ACTION_UP] = moveUp; + actionBindings[ACTION_DOWN] = moveDown; + actionBindings[ACTION_PITCH_UP] = pitchUp; + actionBindings[ACTION_PITCH_DOWN] = pitchDown; + actionBindings[ACTION_YAW_LEFT] = yawLeft; + actionBindings[ACTION_YAW_RIGHT] = yawRight; + actionBindings[ACTION_ACCELERATE] = accelerate; + actionBindings[ACTION_MOUSE_LOOK] = setMouseLook; + keyboardEnabled = true; + mouseEnabled = true; + } + + public function pitchDown(value:Boolean) : void + { + _pitchDown = value; + } + + public function moveDown(value:Boolean) : void + { + _down = value; + } + + public function yawLeft(value:Boolean) : void + { + _yawLeft = value; + } + + public function get yawSpeed() : Number + { + return _yawSpeed; + } + + public function get coords() : Point3D + { + return _coords.clone(); + } + public function get coords3D() : Vector3D + { + return _coords.toVector3D(); + } + + public function get accelerated() : Boolean + { + return _accelerate; + } + + public function setDefaultBindings() : void + { + } + + public function set yawSpeed(spd:Number) : void + { + _yawSpeed = spd; + } + + public function unbindKey(keyCode:uint) : void + { + keyBindings.remove(keyCode); + } + + protected function stopMouseLook() : void + { + } + + public function set coords(value:Point3D) : void + { + _coords.copy(value); + setObjectCoords(); + } + + public function setObjectPos(pos:Vector3D) : void + { + _coords.copyFromVector3D(pos); + setObjectCoords(); + } + + public function get object() : Object3D + { + return _object; + } + + protected function unregisterKeyboardListeners() : void + { + clearCommandFlags(); + _eventsSource.removeEventListener(KeyboardEvent.KEY_DOWN,onKeyboardEvent); + _eventsSource.removeEventListener(KeyboardEvent.KEY_UP,onKeyboardEvent); + } + + public function get speed() : Number + { + return _speed; + } + + public function get enabled() : Boolean + { + return _enabled; + } + + public function readCoords(point:Point3D) : void + { + point.copy(_coords); + } + + public function moveBack(value:Boolean) : void + { + _back = value; + } + + public function get keyboardEnabled() : Boolean + { + return _keyboardEnabled; + } + + public function moveUp(value:Boolean) : void + { + _up = value; + } + + private function onKeyboardEvent(e:KeyboardEvent) : void + { + var method:Function = keyBindings[e.keyCode]; + if(method != null) + { + method.call(this,e.type == KeyboardEvent.KEY_DOWN); + } + } + + public function get speedMultiplier() : Number + { + return _speedMultiplier; + } + + public function unbindAll() : void + { + keyBindings.clear(); + } + + private function onMouseUp(e:MouseEvent) : void + { + setMouseLook(false); + _eventsSource.stage.removeEventListener(MouseEvent.MOUSE_UP,onMouseUp); + } + + public function moveLeft(value:Boolean) : void + { + _left = value; + } + + public function set mouseSensitivity(sensitivity:Number) : void + { + _mouseSensitivity = sensitivity; + _mouseCoefficientY = _mouseSensitivity * _mouseSensitivityY; + _mouseCoefficientX = _mouseSensitivity * _mouseSensitivityX; + } + + protected function unregisterMouseListeners() : void + { + _eventsSource.removeEventListener(MouseEvent.MOUSE_DOWN,onMouseDown); + _eventsSource.stage.removeEventListener(MouseEvent.MOUSE_UP,onMouseUp); + } + + public function set object(value:Object3D) : void + { + _object = value; + //_collider.scene = _object == null ? null : _object.scene; + setObjectCoords(); + } + + public function set enabled(value:Boolean) : void + { + _enabled = value; + if(_enabled) + { + if(_mouseEnabled) + { + registerMouseListeners(); + } + if(_keyboardEnabled) + { + registerKeyboardListeners(); + } + } + else + { + if(_mouseEnabled) + { + unregisterMouseListeners(); + setMouseLook(false); + } + if(_keyboardEnabled) + { + unregisterKeyboardListeners(); + } + } + } + + public function set speed(value:Number) : void + { + _speed = value < 0 ? -value : value; + } + + protected function rotateObject(frameTime:Number) : void + { + } + + protected function getDisplacement(frameTime:Number, displacement:Point3D) : void + { + } + + public function processInput() : void + { + if(!_enabled || _object == null) + { + return; + } + var frameTime:Number = getTimer() - lastFrameTime; + if(frameTime == 0) + { + return; + } + lastFrameTime += frameTime; + if(frameTime > 100) + { + frameTime = 100; + } + frameTime /= 1000; + rotateObject(frameTime); + getDisplacement(frameTime,_displacement); + applyDisplacement(frameTime,_displacement); + /*if(Boolean(_object.changeRotationOrScaleOperation.queued) || Boolean(_object.changeCoordsOperation.queued)) + { + if(!_isMoving) + { + _isMoving = true; + if(onStartMoving != null) + { + onStartMoving.call(this); + } + } + } + else if(_isMoving) + { + _isMoving = false; + if(onStopMoving != null) + { + onStopMoving.call(this); + } + }*/ + } + + protected function registerMouseListeners() : void + { + _eventsSource.addEventListener(MouseEvent.MOUSE_DOWN,onMouseDown); + } + + public function setMouseLook(value:Boolean) : void + { + if(_mouseLookActive != value) + { + _mouseLookActive = value; + if(_mouseLookActive) + { + startMouseLook(); + } + else + { + stopMouseLook(); + } + } + } + + protected function applyDisplacement(frameTime:Number, displacement:Point3D) : void + { + } + + protected function startMouseLook() : void + { + startMouseCoords.x = _eventsSource.stage.mouseX; + startMouseCoords.y = _eventsSource.stage.mouseY; + } + + public function moveForward(value:Boolean) : void + { + _forward = value; + } + + protected function registerKeyboardListeners() : void + { + _eventsSource.addEventListener(KeyboardEvent.KEY_DOWN,onKeyboardEvent); + _eventsSource.addEventListener(KeyboardEvent.KEY_UP,onKeyboardEvent); + } + + public function set mouseEnabled(value:Boolean) : void + { + if(_mouseEnabled != value) + { + _mouseEnabled = value; + if(_mouseEnabled) + { + if(_enabled) + { + registerMouseListeners(); + } + } + else + { + unregisterMouseListeners(); + } + } + } + + public function get mouseSensitivity() : Number + { + return _mouseSensitivity; + } + + protected function setObjectCoords() : void + { + if(_object != null) + { + _object.setPositionXYZ(_coords.x,_coords.y,_coords.z); + } + } + + public function set mouseSensitivityY(value:Number) : void + { + _mouseSensitivityY = value; + _mouseCoefficientY = _mouseSensitivity * _mouseSensitivityY; + } + + public function set pitchSpeed(spd:Number) : void + { + _pitchSpeed = spd; + } + + public function set speedMultiplier(value:Number) : void + { + _speedMultiplier = value; + } + + public function moveRight(value:Boolean) : void + { + _right = value; + } + + public function set mouseSensitivityX(value:Number) : void + { + _mouseSensitivityX = value; + _mouseCoefficientX = _mouseSensitivity * _mouseSensitivityX; + } + + public function set keyboardEnabled(value:Boolean) : void + { + if(_keyboardEnabled != value) + { + _keyboardEnabled = value; + if(_keyboardEnabled) + { + if(_enabled) + { + registerKeyboardListeners(); + } + } + else + { + unregisterKeyboardListeners(); + } + } + } + + public function get mouseEnabled() : Boolean + { + return _mouseEnabled; + } + + public function accelerate(value:Boolean) : void + { + _accelerate = value; + } + + public function get mouseSensitivityX() : Number + { + return _mouseSensitivityX; + } + + public function get mouseSensitivityY() : Number + { + return _mouseSensitivityY; + } + + private function onMouseDown(e:MouseEvent) : void + { + setMouseLook(true); + _eventsSource.stage.addEventListener(MouseEvent.MOUSE_UP,onMouseUp); + } + + public function get pitchSpeed() : Number + { + return _pitchSpeed; + } + + public function bindKey(keyCode:uint, action:String) : void + { + var method:Function = actionBindings[action]; + if(method != null) + { + keyBindings[keyCode] = method; + } + } + + public function yawRight(value:Boolean) : void + { + _yawRight = value; + } + + protected function clearCommandFlags() : void + { + _forward = false; + _back = false; + _left = false; + _right = false; + _up = false; + _down = false; + _pitchUp = false; + _pitchDown = false; + _yawLeft = false; + _yawRight = false; + _accelerate = false; + _mouseLookActive = false; + } + + public function get collider() : EllipsoidCollider + { + return _collider; + } + + public function pitchUp(value:Boolean) : void + { + _pitchUp = value; + } + } +} + diff --git a/src/alternativa/editor/engine3d/controllers/WalkController.as b/src/alternativa/editor/engine3d/controllers/WalkController.as new file mode 100644 index 0000000..aec76ba --- /dev/null +++ b/src/alternativa/editor/engine3d/controllers/WalkController.as @@ -0,0 +1,477 @@ +package alternativa.editor.engine3d.controllers +{ + import alternativa.engine3d.alternativa3d; + import alternativa.engine3d.core.Camera3D; + import alternativa.types.Matrix4; + import alternativa.types.Point3D; + import alternativa.utils.KeyboardUtils; + import alternativa.utils.MathUtils; + import flash.display.DisplayObject; + import flash.geom.Vector3D; + + use namespace alternativa3d; + + public class WalkController extends ObjectController + { + private var _airControlCoefficient:Number = 1; + + private var _objectZPosition:Number = 0.5; + + private var destination:Point3D; + + private var tmpVelocity:Point3D; + + private var _onGround:Boolean; + + private var _currentSpeed:Number = 0; + + public var jumpSpeed:Number = 0; + + //private var _groundMesh:Mesh; + + private const collisionPos:Vector3D = new Vector3D(); + private const collisionNormal:Vector3D = new Vector3D(); + + public var gravity:Number = 0; + + private var minGroundCos:Number; + + private var controlsActive:Boolean; + + private var velocity:Point3D; + + private var startRotX:Number; + + public var speedThreshold:Number = 1; + + private var startRotZ:Number; + + private var currentMouseCoords:Point3D; + + private var prevMouseCoords:Point3D; + + private var inJump:Boolean; + + private var _flyMode:Boolean; + + private var _jumpLocked:Boolean; + + public function WalkController(eventSourceObject:DisplayObject) + { + minGroundCos = Math.cos(MathUtils.toRadian(70)); + destination = new Point3D(); + //collision = new Collision(); + velocity = new Point3D(); + tmpVelocity = new Point3D(); + prevMouseCoords = new Point3D(); + currentMouseCoords = new Point3D(); + super(eventSourceObject); + } + + public function get airControlCoefficient() : Number + { + return _airControlCoefficient; + } + + public function set airControlCoefficient(value:Number) : void + { + _airControlCoefficient = value > 0 ? value : -value; + } + + public function get maxGroundAngle() : Number + { + return Math.acos(minGroundCos); + } + + override public function set enabled(value:Boolean) : void + { + super.enabled = value; + if(!value) + { + velocity.reset(); + _currentSpeed = 0; + } + } + + override protected function getDisplacement(frameTime:Number, displacement:Point3D) : void + { + var len:Number = NaN; + var x:Number = NaN; + var y:Number = NaN; + var z:Number = NaN; + var matrix:Matrix4 = null; + var heading:Number = NaN; + var headingCos:Number = NaN; + var headingSin:Number = NaN; + var spd:Number = NaN; + var cos:Number = 0; + if(checkCollisions && !_flyMode) + { + displacement.x = 0; + displacement.y = 0; + displacement.z = -0.5 * gravity * frameTime * frameTime; + if(_collider.getCollision(_coords.toVector3D(),displacement.toVector3D(), collisionPos,collisionNormal, _object)) + { + cos = collisionNormal.z; + //_groundMesh = collision.face.alternativa3d::_mesh; + } + else + { + //_groundMesh = null; + } + } + _onGround = cos > minGroundCos; + if(_onGround && inJump) + { + inJump = false; + if(!_up) + { + _jumpLocked = false; + } + } + controlsActive = _forward || _back || _right || _left; + if(flyMode || gravity == 0) + { + controlsActive = controlsActive || (_up || _down); + } + if(controlsActive) + { + if(_flyMode) + { + tmpVelocity.x = 0; + tmpVelocity.y = 0; + tmpVelocity.z = 0; + if(_forward) + { + tmpVelocity.y = 1; + } + else if(_back) + { + tmpVelocity.y = -1; + } + if(_right) + { + tmpVelocity.x = 1; + } + else if(_left) + { + tmpVelocity.x = -1; + } + if(_up) + { + tmpVelocity.z = 1; + } + else if(_down) + { + tmpVelocity.z = -1; + } + matrix = _object.transformation; + x = tmpVelocity.x; + if(_object is Camera3D) + { + y = -tmpVelocity.z; + z = tmpVelocity.y; + } + else + { + y = tmpVelocity.y; + z = tmpVelocity.z; + } + velocity.x += (x * matrix.a + y * matrix.b + z * matrix.c) * _speed; + velocity.y += (x * matrix.e + y * matrix.f + z * matrix.g) * _speed; + velocity.z += (x * matrix.i + y * matrix.j + z * matrix.k) * _speed; + } + else + { + heading = _object.rotationZ; + headingCos = Math.cos(heading); + headingSin = Math.sin(heading); + spd = _speed; + if(gravity != 0 && !_onGround) + { + spd *= _airControlCoefficient; + } + if(_forward) + { + velocity.x -= spd * headingSin; + velocity.y += spd * headingCos; + } + else if(_back) + { + velocity.x += spd * headingSin; + velocity.y -= spd * headingCos; + } + if(_right) + { + velocity.x += spd * headingCos; + velocity.y += spd * headingSin; + } + else if(_left) + { + velocity.x -= spd * headingCos; + velocity.y -= spd * headingSin; + } + if(gravity == 0) + { + if(_up) + { + velocity.z += _speed; + } + else if(_down) + { + velocity.z -= _speed; + } + } + } + } + else + { + len = 1 / Math.pow(3,frameTime * 10); + if(_flyMode || gravity == 0) + { + velocity.x *= len; + velocity.y *= len; + velocity.z *= len; + } + else if(_onGround) + { + velocity.x *= len; + velocity.y *= len; + if(velocity.z < 0) + { + velocity.z *= len; + } + } + else if(cos > 0 && velocity.z > 0) + { + velocity.z = 0; + } + } + if(_onGround && _up && !inJump && !_jumpLocked) + { + velocity.z = jumpSpeed; + inJump = true; + _onGround = false; + _jumpLocked = true; + cos = 0; + } + if(!(_flyMode || _onGround)) + { + velocity.z -= gravity * frameTime; + } + var max:Number = _accelerate ? _speed * _speedMultiplier : _speed; + if(_flyMode || gravity == 0) + { + len = velocity.length; + if(len > max) + { + velocity.length = max; + } + } + else + { + len = Math.sqrt(velocity.x * velocity.x + velocity.y * velocity.y); + if(len > max) + { + velocity.x *= max / len; + velocity.y *= max / len; + } + if(cos > 0 && velocity.z > 0) + { + velocity.z = 0; + } + } + displacement.x = velocity.x * frameTime; + displacement.y = velocity.y * frameTime; + displacement.z = velocity.z * frameTime; + } + + public function set objectZPosition(value:Number) : void + { + _objectZPosition = value; + setObjectCoords(); + } + + public function set maxGroundAngle(value:Number) : void + { + minGroundCos = Math.cos(value); + } + + /*public function get groundMesh() : Mesh + { + return _groundMesh; + }*/ + + override protected function startMouseLook() : void + { + super.startMouseLook(); + startRotX = _object is Camera3D ? _object.rotationX + MathUtils.DEG90 : _object.rotationX; + startRotZ = _object.rotationZ; + } + + override protected function applyDisplacement(frameTime:Number, displacement:Point3D) : void + { + if(checkCollisions) + { + var destination3D:Vector3D = _collider.calculateDestination(_coords.toVector3D(),displacement.toVector3D(),_object); + destination.copyFromVector3D(destination3D); + displacement.x = destination.x - _coords.x; + displacement.y = destination.y - _coords.y; + displacement.z = destination.z - _coords.z; + } + else + { + destination.x = _coords.x + displacement.x; + destination.y = _coords.y + displacement.y; + destination.z = _coords.z + displacement.z; + } + velocity.x = displacement.x / frameTime; + velocity.y = displacement.y / frameTime; + velocity.z = displacement.z / frameTime; + _coords.x = destination.x; + _coords.y = destination.y; + _coords.z = destination.z; + setObjectCoords(); + var len:Number = Math.sqrt(velocity.x * velocity.x + velocity.y * velocity.y + velocity.z * velocity.z); + if(len < speedThreshold) + { + velocity.x = 0; + velocity.y = 0; + velocity.z = 0; + _currentSpeed = 0; + } + else + { + _currentSpeed = len; + } + } + + public function lookAt(point:Point3D) : void + { + if(_object == null) + { + return; + } + var dx:Number = point.x - _object.x; + var dy:Number = point.y - _object.y; + var dz:Number = point.z - _object.z; + _object.rotationX = Math.atan2(dz,Math.sqrt(dx * dx + dy * dy)) - (_object is Camera3D ? MathUtils.DEG90 : 0); + _object.rotationY = 0; + _object.rotationZ = -Math.atan2(dx,dy); + } + + override public function setDefaultBindings() : void + { + unbindAll(); + bindKey(KeyboardUtils.W,ACTION_FORWARD); + bindKey(KeyboardUtils.S,ACTION_BACK); + bindKey(KeyboardUtils.A,ACTION_LEFT); + bindKey(KeyboardUtils.D,ACTION_RIGHT); + bindKey(KeyboardUtils.SPACE,ACTION_UP); + bindKey(KeyboardUtils.Z,ACTION_DOWN); + bindKey(KeyboardUtils.UP,ACTION_PITCH_UP); + bindKey(KeyboardUtils.DOWN,ACTION_PITCH_DOWN); + bindKey(KeyboardUtils.LEFT,ACTION_YAW_LEFT); + bindKey(KeyboardUtils.RIGHT,ACTION_YAW_RIGHT); + bindKey(KeyboardUtils.SHIFT,ACTION_ACCELERATE); + bindKey(KeyboardUtils.M,ACTION_MOUSE_LOOK); + } + + public function get flyMode() : Boolean + { + return _flyMode; + } + + override protected function setObjectCoords() : void + { + if(_object != null) + { + _object.x = _coords.x; + _object.y = _coords.y; + _object.z = _coords.z + (2 * _objectZPosition - 1) * _collider.radiusZ; + } + } + + public function get objectZPosition() : Number + { + return _objectZPosition; + } + + override public function moveUp(value:Boolean) : void + { + super.moveUp(value); + if(!inJump && !value) + { + _jumpLocked = false; + } + } + + public function get onGround() : Boolean + { + return _onGround; + } + + public function set flyMode(value:Boolean) : void + { + _flyMode = value; + } + + override protected function rotateObject(frameTime:Number) : void + { + var rotX:Number = NaN; + if(_mouseLookActive) + { + prevMouseCoords.copy(currentMouseCoords); + currentMouseCoords.x = _eventsSource.stage.mouseX; + currentMouseCoords.y = _eventsSource.stage.mouseY; + if(!prevMouseCoords.equals(currentMouseCoords)) + { + _object.rotationZ = startRotZ + (startMouseCoords.x - currentMouseCoords.x) * _mouseCoefficientX; + rotX = startRotX + (startMouseCoords.y - currentMouseCoords.y) * _mouseCoefficientY; + if(_object is Camera3D) + { + _object.rotationX = rotX > MathUtils.DEG90 ? 0 : (rotX < -MathUtils.DEG90 ? -Math.PI : rotX - MathUtils.DEG90); + } + else + { + _object.rotationX = rotX > MathUtils.DEG90 ? MathUtils.DEG90 : (rotX < -MathUtils.DEG90 ? -MathUtils.DEG90 : rotX); + } + } + } + if(_yawLeft) + { + _object.rotationZ += _yawSpeed * frameTime; + } + else if(_yawRight) + { + _object.rotationZ -= _yawSpeed * frameTime; + } + rotX = NaN; + if(_pitchUp) + { + rotX = _object.rotationX + _pitchSpeed * frameTime; + } + else if(_pitchDown) + { + rotX = _object.rotationX - _pitchSpeed * frameTime; + } + if(!isNaN(rotX)) + { + if(_object is Camera3D) + { + _object.rotationX = rotX > 0 ? 0 : (rotX < -Math.PI ? -Math.PI : rotX); + } + else + { + _object.rotationX = rotX > MathUtils.DEG90 ? MathUtils.DEG90 : (rotX < -MathUtils.DEG90 ? -MathUtils.DEG90 : rotX); + } + } + } + + public function get currentSpeed() : Number + { + return _currentSpeed; + } + } +} + diff --git a/src/alternativa/editor/engine3d/loaders/LoaderEvent.as b/src/alternativa/editor/engine3d/loaders/LoaderEvent.as new file mode 100644 index 0000000..1f2c217 --- /dev/null +++ b/src/alternativa/editor/engine3d/loaders/LoaderEvent.as @@ -0,0 +1,35 @@ +package alternativa.editor.engine3d.loaders +{ + import flash.events.Event; + + public class LoaderEvent extends Event + { + public static const LOADING_START:String = "loadingStart"; + + public static const LOADING_COMPLETE:String = "loadingComplete"; + + private var _loadingStage:int; + + public function LoaderEvent(type:String, loadingStage:int) + { + super(type); + this._loadingStage = loadingStage; + } + + public function get loadingStage() : int + { + return this._loadingStage; + } + + override public function clone() : Event + { + return new LoaderEvent(type,this._loadingStage); + } + + override public function toString() : String + { + return "[LoaderEvent type=\"" + type + "\", loadingStage=" + this._loadingStage + "]"; + } + } +} + diff --git a/src/alternativa/editor/engine3d/loaders/LoaderProgressEvent.as b/src/alternativa/editor/engine3d/loaders/LoaderProgressEvent.as new file mode 100644 index 0000000..13ed4ae --- /dev/null +++ b/src/alternativa/editor/engine3d/loaders/LoaderProgressEvent.as @@ -0,0 +1,50 @@ +package alternativa.editor.engine3d.loaders +{ + import flash.events.Event; + import flash.events.ProgressEvent; + + public class LoaderProgressEvent extends ProgressEvent + { + public static const LOADING_PROGRESS:String = "loadingProgress"; + + private var _loadingStage:int; + + private var _totalItems:int; + + private var _currentItem:int; + + public function LoaderProgressEvent(type:String, loadingStage:int, totalItems:int, currentItem:int, bytesLoaded:uint = 0, bytesTotal:uint = 0) + { + super(type,false,false,bytesLoaded,bytesTotal); + this._loadingStage = loadingStage; + this._totalItems = totalItems; + this._currentItem = currentItem; + } + + public function get currentItem() : int + { + return this._currentItem; + } + + override public function clone() : Event + { + return new LoaderProgressEvent(type,this._loadingStage,this._totalItems,this._currentItem,bytesLoaded,bytesTotal); + } + + public function get loadingStage() : int + { + return this._loadingStage; + } + + public function get totalItems() : int + { + return this._totalItems; + } + + override public function toString() : String + { + return "[LoaderProgressEvent type=\"" + type + "\", loadingStage=" + this._loadingStage + ", totalItems=" + this._totalItems + ", currentItem=" + this._currentItem + ", bytesTotal=" + bytesTotal + ", bytesLoaded=" + bytesLoaded + "]"; + } + } +} + diff --git a/src/alternativa/editor/engine3d/loaders/LoadingStage.as b/src/alternativa/editor/engine3d/loaders/LoadingStage.as new file mode 100644 index 0000000..ddb0de7 --- /dev/null +++ b/src/alternativa/editor/engine3d/loaders/LoadingStage.as @@ -0,0 +1,17 @@ +package alternativa.editor.engine3d.loaders +{ + public final class LoadingStage + { + public static const MAIN_FILE:int = 0; + + public static const TEXTURE:int = 1; + + public static const MATERIAL_LIBRARY:int = 2; + + public function LoadingStage() + { + super(); + } + } +} + diff --git a/src/alternativa/editor/engine3d/loaders/TextureMapsBatchLoader.as b/src/alternativa/editor/engine3d/loaders/TextureMapsBatchLoader.as new file mode 100644 index 0000000..518fd01 --- /dev/null +++ b/src/alternativa/editor/engine3d/loaders/TextureMapsBatchLoader.as @@ -0,0 +1,167 @@ +package alternativa.editor.engine3d.loaders +{ + import alternativa.types.Map; + import flash.display.BitmapData; + import flash.events.Event; + import flash.events.EventDispatcher; + import flash.events.IOErrorEvent; + import flash.events.ProgressEvent; + import flash.system.LoaderContext; + + [Event(name="ioError",type="flash.events.IOErrorEvent")] + [Event(name="complete",type="flash.events.Event")] + [Event(name="loadingComplete",type="alternativa.engine3d.loaders.events.LoaderEvent")] + [Event(name="loadingProgress",type="alternativa.engine3d.loaders.events.LoaderProgressEvent")] + [Event(name="loadingStart",type="alternativa.engine3d.loaders.events.LoaderEvent")] + public class TextureMapsBatchLoader extends EventDispatcher + { + public static var stubBitmapData:BitmapData; + + private var loader:TextureMapsLoader; + + private var _textures:Map; + + private var totalFiles:int; + + private var loaderContext:LoaderContext; + + private var baseUrl:String; + + private var materialNames:Array; + + private var materialIndex:int; + + private var batch:Map; + + private var currentFileNumber:int; + + public function TextureMapsBatchLoader() + { + super(); + } + + private function loadNextTextureFile() : void + { + var info:TextureMapsInfo = this.batch[this.materialNames[this.materialIndex]]; + this.loader.load(this.baseUrl + info.diffuseMapFileName,info.opacityMapFileName == null ? null : this.baseUrl + info.opacityMapFileName,this.loaderContext); + } + + private function clean() : void + { + this.loaderContext = null; + this.batch = null; + this.materialNames = null; + } + + public function get textures() : Map + { + return this._textures; + } + + private function onTextureLoadingStart(e:Event) : void + { + dispatchEvent(e); + } + + private function onProgress(e:ProgressEvent) : void + { + dispatchEvent(new LoaderProgressEvent(LoaderProgressEvent.LOADING_PROGRESS,LoadingStage.TEXTURE,this.totalFiles,this.currentFileNumber,e.bytesLoaded,e.bytesTotal)); + } + + public function load(baseURL:String, batch:Map, loaderContext:LoaderContext) : void + { + var materialName:String = null; + var info:TextureMapsInfo = null; + this.baseUrl = baseURL; + this.batch = batch; + this.loaderContext = loaderContext; + if(this.loader == null) + { + this.loader = new TextureMapsLoader(); + this.loader.addEventListener(LoaderEvent.LOADING_START,this.onTextureLoadingStart); + this.loader.addEventListener(LoaderEvent.LOADING_COMPLETE,this.onTextureLoadingComplete); + this.loader.addEventListener(ProgressEvent.PROGRESS,this.onProgress); + this.loader.addEventListener(Event.COMPLETE,this.onMaterialTexturesLoadingComplete); + this.loader.addEventListener(IOErrorEvent.IO_ERROR,this.onMaterialTexturesLoadingComplete); + } + else + { + this.close(); + } + this.totalFiles = 0; + this.materialNames = new Array(); + for(materialName in batch) + { + this.materialNames.push(materialName); + info = batch[materialName]; + this.totalFiles += info.opacityMapFileName == null ? 1 : 2; + } + this.currentFileNumber = 1; + this.materialIndex = 0; + this._textures = new Map(); + this.loadNextTextureFile(); + } + + private function onMaterialTexturesLoadingComplete(e:Event) : void + { + if(e is IOErrorEvent) + { + this._textures.add(this.materialNames[this.materialIndex],this.getStubBitmapData()); + dispatchEvent(e); + } + else + { + this._textures.add(this.materialNames[this.materialIndex],this.loader.bitmapData); + } + if(++this.materialIndex == this.materialNames.length) + { + this.clean(); + dispatchEvent(new Event(Event.COMPLETE)); + } + else + { + this.loadNextTextureFile(); + } + } + + public function close() : void + { + if(this.loader != null) + { + this.loader.close(); + } + } + + private function onTextureLoadingComplete(e:Event) : void + { + dispatchEvent(e); + ++this.currentFileNumber; + } + + private function getStubBitmapData() : BitmapData + { + var size:uint = 0; + var i:uint = 0; + var j:uint = 0; + if(stubBitmapData == null) + { + size = 20; + stubBitmapData = new BitmapData(size,size,false,0); + for(i = 0; i < size; i++) + { + for(j = 0; j < size; j += 2) + { + stubBitmapData.setPixel(Boolean(i % 2) ? int(j) : j + 1,i,16711935); + } + } + } + return stubBitmapData; + } + + public function unload() : void + { + this._textures = null; + } + } +} + diff --git a/src/alternativa/editor/engine3d/loaders/TextureMapsInfo.as b/src/alternativa/editor/engine3d/loaders/TextureMapsInfo.as new file mode 100644 index 0000000..58fb897 --- /dev/null +++ b/src/alternativa/editor/engine3d/loaders/TextureMapsInfo.as @@ -0,0 +1,17 @@ +package alternativa.editor.engine3d.loaders +{ + public class TextureMapsInfo + { + public var opacityMapFileName:String; + + public var diffuseMapFileName:String; + + public function TextureMapsInfo(diffuseMapFileName:String = null, opacityMapFileName:String = null) + { + super(); + this.diffuseMapFileName = diffuseMapFileName; + this.opacityMapFileName = opacityMapFileName; + } + } +} + diff --git a/src/alternativa/editor/engine3d/loaders/TextureMapsLoader.as b/src/alternativa/editor/engine3d/loaders/TextureMapsLoader.as new file mode 100644 index 0000000..26b9269 --- /dev/null +++ b/src/alternativa/editor/engine3d/loaders/TextureMapsLoader.as @@ -0,0 +1,187 @@ +package alternativa.editor.engine3d.loaders +{ + import flash.display.Bitmap; + import flash.display.BitmapData; + import flash.display.BitmapDataChannel; + import flash.display.BlendMode; + import flash.display.Loader; + import flash.events.Event; + import flash.events.EventDispatcher; + import flash.events.IOErrorEvent; + import flash.events.ProgressEvent; + import flash.geom.Matrix; + import flash.geom.Point; + import flash.net.URLRequest; + import flash.system.LoaderContext; + import mx.controls.Alert; + import flash.filesystem.File; + + [Event(name="progress",type="flash.events.ProgressEvent")] + [Event(name="ioError",type="flash.events.IOErrorEvent")] + [Event(name="complete",type="flash.events.Event")] + [Event(name="loadingComplete",type="alternativa.engine3d.loaders.events.LoaderEvent")] + [Event(name="loadingStart",type="alternativa.engine3d.loaders.events.LoaderEvent")] + public class TextureMapsLoader extends EventDispatcher + { + private static const STATE_IDLE:int = 0; + + private static const STATE_LOADING_DIFFUSE_MAP:int = 1; + + private static const STATE_LOADING_ALPHA_MAP:int = 2; + + private var bitmapLoader:Loader; + + private var loaderContext:LoaderContext; + + private var alphaTextureUrl:String; + + private var _bitmapData:BitmapData; + + private var loaderState:int = 0; + + private var _triedPNG:Boolean = false; + private var _triedUnderscore:Boolean = false; + private var _originalUrl:String; + + public function TextureMapsLoader(diffuseTextureUrl:String = null, alphaTextureUrl:String = null, loaderContext:LoaderContext = null) + { + super(); + if(diffuseTextureUrl != null) + { + this.load(diffuseTextureUrl,alphaTextureUrl,loaderContext); + } + } + + public function get bitmapData() : BitmapData + { + return this._bitmapData; + } + + public function close() : void + { + if(this.loaderState != STATE_IDLE) + { + this.loaderState = STATE_IDLE; + this.bitmapLoader.close(); + } + this.unload(); + } + + public function load(diffuseTextureUrl:String, alphaTextureUrl:String = null, loaderContext:LoaderContext = null) : void + { + this.alphaTextureUrl = alphaTextureUrl; + this.loaderContext = loaderContext; + if(this.bitmapLoader == null) + { + this.bitmapLoader = new Loader(); + this.bitmapLoader.contentLoaderInfo.addEventListener(Event.OPEN,this.onOpen); + this.bitmapLoader.contentLoaderInfo.addEventListener(Event.COMPLETE,this.onComplete); + this.bitmapLoader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS,this.onProgress); + this.bitmapLoader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,this.onLoadError); + } + else + { + this.close(); + } + _originalUrl = diffuseTextureUrl; + this.startLoading(STATE_LOADING_DIFFUSE_MAP,diffuseTextureUrl); + } + + private function onComplete(e:Event) : void + { + var tmpBmp:BitmapData = null; + var alpha:BitmapData = null; + dispatchEvent(new LoaderEvent(LoaderEvent.LOADING_COMPLETE,LoadingStage.TEXTURE)); + switch(this.loaderState) + { + case STATE_LOADING_DIFFUSE_MAP: + this._bitmapData = Bitmap(this.bitmapLoader.content).bitmapData; + if(this.alphaTextureUrl != null) + { + _originalUrl = this.alphaTextureUrl; + this.startLoading(STATE_LOADING_ALPHA_MAP,this.alphaTextureUrl); + } + else + { + this.complete(); + } + break; + case STATE_LOADING_ALPHA_MAP: + tmpBmp = this._bitmapData; + this._bitmapData = new BitmapData(this._bitmapData.width,this._bitmapData.height,true,0); + this._bitmapData.copyPixels(tmpBmp,tmpBmp.rect,new Point()); + alpha = Bitmap(this.bitmapLoader.content).bitmapData; + if(this._bitmapData.width != alpha.width || this._bitmapData.height != alpha.height) + { + tmpBmp.draw(alpha,new Matrix(this._bitmapData.width / alpha.width,0,0,this._bitmapData.height / alpha.height),null,BlendMode.NORMAL,null,true); + alpha.dispose(); + alpha = tmpBmp; + } + this._bitmapData.copyChannel(alpha,alpha.rect,new Point(),BitmapDataChannel.RED,BitmapDataChannel.ALPHA); + alpha.dispose(); + this.complete(); + } + } + + private function onOpen(e:Event) : void + { + dispatchEvent(new LoaderEvent(LoaderEvent.LOADING_START,LoadingStage.TEXTURE)); + } + + private function onLoadError(e:IOErrorEvent) : void + { + var split:Array = _originalUrl.split(File.separator); + var lastPart:String = split[split.length-1]; + if(!_triedUnderscore && lastPart.indexOf("_") != -1) + { + _triedUnderscore = true; + var underscoreIndex:int = _originalUrl.lastIndexOf("_"); + this.bitmapLoader.load(new URLRequest(_originalUrl.slice(0,underscoreIndex)+_originalUrl.slice(underscoreIndex,_originalUrl.length-underscoreIndex)),this.loaderContext); + return; + } + if(!_triedPNG && _originalUrl.indexOf(".jpg") != -1) + { + _triedPNG = true; + this.bitmapLoader.load(new URLRequest(_originalUrl.replace(".jpg",".png")),this.loaderContext); + return; + } + this.loaderState = STATE_IDLE; + //dispatchEvent(e); + + this._bitmapData = new BitmapData(1,1,false,0xff00ff); + dispatchEvent(new Event(Event.COMPLETE)); + } + + private function onProgress(e:Event) : void + { + dispatchEvent(e); + } + + public function unload() : void + { + if(this.loaderState == STATE_IDLE) + { + if(this.bitmapLoader != null) + { + this.bitmapLoader.unload(); + } + this.loaderContext = null; + this._bitmapData = null; + } + } + + private function complete() : void + { + this.loaderState = STATE_IDLE; + this.bitmapLoader.unload(); + dispatchEvent(new Event(Event.COMPLETE)); + } + + private function startLoading(state:int, url:String) : void + { + this.loaderState = state; + this.bitmapLoader.load(new URLRequest(url),this.loaderContext); + } + } +} + diff --git a/src/alternativa/editor/engine3d/materials/WireMaterial.as b/src/alternativa/editor/engine3d/materials/WireMaterial.as new file mode 100644 index 0000000..662553a --- /dev/null +++ b/src/alternativa/editor/engine3d/materials/WireMaterial.as @@ -0,0 +1,74 @@ +package alternativa.editor.engine3d.materials +{ + import alternativa.engine3d.materials.TextureMaterial; + import flash.display.BitmapData; + import alternativa.engine3d.alternativa3d; + import alternativa.engine3d.materials.Material; + import flash.display.Shape; + import flash.display.Graphics; + + use namespace alternativa3d; + + public class WireMaterial extends TextureMaterial + { + private static const shape:Shape = new Shape(); + + private var _color:uint; + private var _thickness:int; + private var _width:int; + private var _height:int; + private var _segments:int; + + public function WireMaterial(thickness:int, width:int, height:int, segments:int = 5, color:uint = 0x0) + { + _color = color; + _thickness = thickness; + _width = width; + _height = height; + _segments = segments; + + _hardwareMipMaps = true; + _mipMapping = 1; + super(createWireTexture()); + } + + override public function clone():Material + { + var _local_1:WireMaterial = new WireMaterial(_color, _thickness, _width, _height, _segments); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + private function createWireTexture() : BitmapData + { + var ctx:Graphics = shape.graphics; + ctx.clear(); + shape.width = _width; + shape.height = _height; + + var offsetPerNumX:Number = _width / _segments; + var offsetPerNumY:Number = _height / _segments; + + ctx.lineStyle(_thickness, _color); + + var num:int; + var pos:Number; + for(num = 0; num < _segments; num++) + { + pos = num * offsetPerNumX; + ctx.moveTo(pos, 0); + ctx.lineTo(pos, _height); + } + for(num = 0; num < _segments; num++) + { + pos = num * offsetPerNumY; + ctx.moveTo(0, pos); + ctx.lineTo(_width, pos); + } + + var bitmap:BitmapData = new BitmapData(_width, _height, true, 0x00000000); + bitmap.draw(shape); + return bitmap; + } + } +} \ No newline at end of file diff --git a/src/alternativa/editor/mapexport/CollisionBox.as b/src/alternativa/editor/mapexport/CollisionBox.as index 85b0358..4cfc012 100644 --- a/src/alternativa/editor/mapexport/CollisionBox.as +++ b/src/alternativa/editor/mapexport/CollisionBox.as @@ -1,9 +1,9 @@ package alternativa.editor.mapexport { import alternativa.engine3d.alternativa3d; - import alternativa.engine3d.core.Mesh; + import alternativa.engine3d.objects.Mesh; import alternativa.engine3d.core.Vertex; - import alternativa.types.Matrix3D; + import alternativa.types.Matrix4; import alternativa.types.Point3D; public class CollisionBox extends CollisionPrimitive @@ -68,9 +68,9 @@ package alternativa.editor.mapexport transform.l = loc9.z; } - override public function getXml(param1:Matrix3D) : XML + override public function getXml(param1:Matrix4) : XML { - var loc2:Matrix3D = null; + var loc2:Matrix4 = null; if(param1 == null) { loc2 = transform; diff --git a/src/alternativa/editor/mapexport/CollisionPrimitive.as b/src/alternativa/editor/mapexport/CollisionPrimitive.as index 462e985..a49cd7a 100644 --- a/src/alternativa/editor/mapexport/CollisionPrimitive.as +++ b/src/alternativa/editor/mapexport/CollisionPrimitive.as @@ -1,7 +1,7 @@ package alternativa.editor.mapexport { - import alternativa.engine3d.core.Mesh; - import alternativa.types.Matrix3D; + import alternativa.engine3d.objects.Mesh; + import alternativa.types.Matrix4; public class CollisionPrimitive { @@ -11,11 +11,11 @@ package alternativa.editor.mapexport public var id:int; - public var transform:Matrix3D; + public var transform:Matrix4; public function CollisionPrimitive(param1:int, param2:Mesh = null) { - this.transform = new Matrix3D(); + this.transform = new Matrix4(); super(); this.id = param1; if(param2 != null) @@ -28,7 +28,7 @@ package alternativa.editor.mapexport { } - public function getXml(param1:Matrix3D) : XML + public function getXml(param1:Matrix4) : XML { return new XML(); } diff --git a/src/alternativa/editor/mapexport/CollisionRect.as b/src/alternativa/editor/mapexport/CollisionRect.as index d991b88..cb50c09 100644 --- a/src/alternativa/editor/mapexport/CollisionRect.as +++ b/src/alternativa/editor/mapexport/CollisionRect.as @@ -2,8 +2,8 @@ package alternativa.editor.mapexport { import alternativa.engine3d.alternativa3d; import alternativa.engine3d.core.Face; - import alternativa.engine3d.core.Mesh; - import alternativa.types.Matrix3D; + import alternativa.engine3d.objects.Mesh; + import alternativa.types.Matrix4; import alternativa.types.Point3D; public class CollisionRect extends CollisionPrimitive @@ -59,9 +59,9 @@ package alternativa.editor.mapexport transform.translate(param1.alternativa3d::_coords.x,param1.alternativa3d::_coords.y,param1.alternativa3d::_coords.z); } - override public function getXml(param1:Matrix3D) : XML + override public function getXml(param1:Matrix4) : XML { - var loc2:Matrix3D = null; + var loc2:Matrix4 = null; if(param1 == null) { loc2 = transform; diff --git a/src/alternativa/editor/mapexport/CollisionTriangle.as b/src/alternativa/editor/mapexport/CollisionTriangle.as index 86d6671..8ee3e09 100644 --- a/src/alternativa/editor/mapexport/CollisionTriangle.as +++ b/src/alternativa/editor/mapexport/CollisionTriangle.as @@ -2,9 +2,9 @@ package alternativa.editor.mapexport { import alternativa.engine3d.alternativa3d; import alternativa.engine3d.core.Face; - import alternativa.engine3d.core.Mesh; + import alternativa.engine3d.objects.Mesh; import alternativa.engine3d.core.Vertex; - import alternativa.types.Matrix3D; + import alternativa.types.Matrix4; import alternativa.types.Point3D; public class CollisionTriangle extends CollisionPrimitive @@ -25,10 +25,10 @@ package alternativa.editor.mapexport override public function parse(param1:Mesh) : void { - var loc2:Array = Face(param1.alternativa3d::_faces.peek()).vertices; - this.v0.copy(Vertex(loc2[0]).alternativa3d::_coords); - this.v1.copy(Vertex(loc2[1]).alternativa3d::_coords); - this.v2.copy(Vertex(loc2[2]).alternativa3d::_coords); + var loc2:Vector. = param1.faceList.vertices; + this.v0.copy((loc2[0]).alternativa3d::_coords); + this.v1.copy((loc2[1]).alternativa3d::_coords); + this.v2.copy((loc2[2]).alternativa3d::_coords); var loc3:Point3D = new Point3D(); loc3.x = (this.v0.x + this.v1.x + this.v2.x) / 3; loc3.y = (this.v0.y + this.v1.y + this.v2.y) / 3; @@ -59,9 +59,9 @@ package alternativa.editor.mapexport this.v2.y -= loc7; } - override public function getXml(param1:Matrix3D) : XML + override public function getXml(param1:Matrix4) : XML { - var loc2:Matrix3D = null; + var loc2:Matrix4 = null; if(param1 == null) { loc2 = transform; diff --git a/src/alternativa/editor/mapexport/FileExporter.as b/src/alternativa/editor/mapexport/FileExporter.as index ed22dd9..404941d 100644 --- a/src/alternativa/editor/mapexport/FileExporter.as +++ b/src/alternativa/editor/mapexport/FileExporter.as @@ -1,13 +1,13 @@ package alternativa.editor.mapexport { - import alternativa.engine3d.core.Object3D; import flash.filesystem.FileStream; + import alternativa.engine3d.core.Object3DContainer; public class FileExporter { - public var sceneRoot:Object3D; + public var sceneRoot:Object3DContainer; - public function FileExporter(param1:Object3D) + public function FileExporter(param1:Object3DContainer) { super(); this.sceneRoot = param1; diff --git a/src/alternativa/editor/mapexport/TanksXmlExporterV1Full.as b/src/alternativa/editor/mapexport/TanksXmlExporterV1Full.as index b75e97c..c35519d 100644 --- a/src/alternativa/editor/mapexport/TanksXmlExporterV1Full.as +++ b/src/alternativa/editor/mapexport/TanksXmlExporterV1Full.as @@ -10,10 +10,11 @@ package alternativa.editor.mapexport import alternativa.editor.prop.SpawnPoint; import alternativa.engine3d.core.Object3D; import flash.filesystem.FileStream; + import alternativa.engine3d.core.Object3DContainer; public class TanksXmlExporterV1Full extends TanksXmlExporterV1Lite { - public function TanksXmlExporterV1Full(param1:Object3D) + public function TanksXmlExporterV1Full(param1:Object3DContainer) { super(param1); } @@ -41,7 +42,6 @@ package alternativa.editor.mapexport override public function exportToFileStream(param1:FileStream) : void { - var loc8:* = undefined; var loc9:Prop = null; var loc10:MeshProp = null; var loc2:XML = new XML("\r\n\t\t\t\t\t\t\r\n\t\t\t\t\t\t\r\n\t\t\t\t\t\t\r\n\t\t\t\t\t\t\r\n\t\t\t\t\t\t\r\n\t\t\t\t\t\t\r\n\t\t\t\t\t\t\r\n\t\t\t\t\t\t\r\n\t\t\t\t\t\t" + ("<" + FunctionalProps.KILL_GEOMETRY + "/>") + "\r\n\t\t\t\t\t"); @@ -50,7 +50,7 @@ package alternativa.editor.mapexport var loc5:XML = loc2.child("bonus-regions")[0]; var loc6:XML = loc2.child("spawn-points")[0]; var loc7:XML = loc2.child(FunctionalProps.KILL_GEOMETRY)[0]; - for(loc8 in sceneRoot.children) + for each(var loc8:Object3D in sceneRoot.children) { loc9 = loc8 as Prop; if(!loc9) diff --git a/src/alternativa/editor/mapexport/TanksXmlExporterV1Lite.as b/src/alternativa/editor/mapexport/TanksXmlExporterV1Lite.as index c7b7381..f959004 100644 --- a/src/alternativa/editor/mapexport/TanksXmlExporterV1Lite.as +++ b/src/alternativa/editor/mapexport/TanksXmlExporterV1Lite.as @@ -8,9 +8,10 @@ package alternativa.editor.mapexport import alternativa.editor.prop.Prop; import alternativa.editor.prop.SpawnPoint; import alternativa.engine3d.alternativa3d; - import alternativa.engine3d.core.Mesh; + import alternativa.engine3d.objects.Mesh; import alternativa.engine3d.core.Object3D; import flash.filesystem.FileStream; + import alternativa.engine3d.core.Object3DContainer; public class TanksXmlExporterV1Lite extends FileExporter { @@ -18,7 +19,7 @@ package alternativa.editor.mapexport private var collPrimCache:CollisionPrimitivesCache; - public function TanksXmlExporterV1Lite(param1:Object3D) + public function TanksXmlExporterV1Lite(param1:Object3DContainer) { super(param1); this.collPrimCache = new CollisionPrimitivesCache(); @@ -183,7 +184,6 @@ package alternativa.editor.mapexport override public function exportToFileStream(param1:FileStream) : void { - var loc7:* = undefined; var loc8:Prop = null; var loc9:MeshProp = null; var loc2:XML = @@ -200,7 +200,7 @@ package alternativa.editor.mapexport var loc4:XML = loc2.child("collision-geometry")[0]; var loc5:XML = loc2.child("bonus-regions")[0]; var loc6:XML = loc2.child("spawn-points")[0]; - for(loc7 in sceneRoot.children) + for each(var loc7:Object3D in sceneRoot.children) { loc8 = loc7 as Prop; if(!loc8) diff --git a/src/alternativa/editor/mapexport/TanksXmlExporterV3.as b/src/alternativa/editor/mapexport/TanksXmlExporterV3.as index 68e38b4..d2fcbd0 100644 --- a/src/alternativa/editor/mapexport/TanksXmlExporterV3.as +++ b/src/alternativa/editor/mapexport/TanksXmlExporterV3.as @@ -7,9 +7,10 @@ package alternativa.editor.mapexport import alternativa.editor.prop.SpawnPoint; import alternativa.editor.prop.Sprite3DProp; import alternativa.engine3d.alternativa3d; - import alternativa.engine3d.core.Mesh; + import alternativa.engine3d.objects.Mesh; import alternativa.engine3d.core.Object3D; import flash.filesystem.FileStream; + import alternativa.engine3d.core.Object3DContainer; use namespace alternativa3d; @@ -39,14 +40,13 @@ package alternativa.editor.mapexport private var spritesXML:XML; - public function TanksXmlExporterV3(param1:Object3D) + public function TanksXmlExporterV3(param1:Object3DContainer) { super(param1); } override public function exportToFileStream(param1:FileStream) : void { - var loc6:* = undefined; var loc7:XML = null; var loc8:PropRegistryData = null; var loc9:Prop = null; @@ -63,7 +63,7 @@ package alternativa.editor.mapexport var loc3:XML = ; var loc4:XML = ; var loc5:XML = ; - for(loc6 in sceneRoot.children) + for each(var loc6:Object3D in sceneRoot.children) { loc9 = loc6 as Prop; if(!loc9) diff --git a/src/alternativa/editor/prop/BonusRegion.as b/src/alternativa/editor/prop/BonusRegion.as index e961d81..787beb3 100644 --- a/src/alternativa/editor/prop/BonusRegion.as +++ b/src/alternativa/editor/prop/BonusRegion.as @@ -1,6 +1,6 @@ package alternativa.editor.prop { - import alternativa.engine3d.core.Mesh; + import alternativa.engine3d.objects.Mesh; import alternativa.engine3d.core.Object3D; import alternativa.engine3d.materials.TextureMaterial; import alternativa.types.Set; @@ -37,7 +37,7 @@ package alternativa.editor.prop { var loc2:BonusRegion = null; var loc1:Mesh = _object.clone() as Mesh; - loc1.cloneMaterialToAllSurfaces(_material as TextureMaterial); + loc1.setMaterialToAllFaces(_material as TextureMaterial); loc2 = new BonusRegion(loc1,name,_libraryName,_groupName,false); loc2.distancesX = distancesX.clone(); loc2.distancesY = distancesY.clone(); diff --git a/src/alternativa/editor/prop/CTFFlagBase.as b/src/alternativa/editor/prop/CTFFlagBase.as index cd970f7..1a9a75b 100644 --- a/src/alternativa/editor/prop/CTFFlagBase.as +++ b/src/alternativa/editor/prop/CTFFlagBase.as @@ -1,7 +1,7 @@ package alternativa.editor.prop { import alternativa.editor.scene.EditorScene; - import alternativa.engine3d.core.Mesh; + import alternativa.engine3d.objects.Mesh; import alternativa.engine3d.core.Object3D; import alternativa.engine3d.materials.TextureMaterial; import flash.geom.Point; @@ -25,7 +25,7 @@ package alternativa.editor.prop override public function clone() : Object3D { var loc1:Mesh = _object.clone() as Mesh; - loc1.cloneMaterialToAllSurfaces(_material as TextureMaterial); + loc1.setMaterialToAllFaces(_material as TextureMaterial); var loc2:CTFFlagBase = new CTFFlagBase(loc1,name,_libraryName,_groupName,false); loc2.distancesX = distancesX.clone(); loc2.distancesY = distancesY.clone(); diff --git a/src/alternativa/editor/prop/ControlPoint.as b/src/alternativa/editor/prop/ControlPoint.as index 3c06c07..10bd3fe 100644 --- a/src/alternativa/editor/prop/ControlPoint.as +++ b/src/alternativa/editor/prop/ControlPoint.as @@ -2,9 +2,9 @@ package alternativa.editor.prop { import alternativa.editor.events.DominationSpawnLinkEndEvent; import alternativa.editor.scene.EditorScene; - import alternativa.engine3d.core.Mesh; + import alternativa.engine3d.objects.Mesh; import alternativa.engine3d.core.Object3D; - import alternativa.engine3d.events.MouseEvent3D; + import alternativa.engine3d.core.MouseEvent3D; import alternativa.engine3d.materials.TextureMaterial; import flash.geom.Point; import flash.utils.Dictionary; @@ -68,7 +68,7 @@ package alternativa.editor.prop override public function clone() : Object3D { var loc1:Mesh = _object.clone() as Mesh; - loc1.cloneMaterialToAllSurfaces(_material as TextureMaterial); + loc1.setMaterialToAllFaces(_material as TextureMaterial); var loc2:ControlPoint = new ControlPoint(loc1,name,_libraryName,_groupName,false); loc2.distancesX = distancesX.clone(); loc2.distancesY = distancesY.clone(); diff --git a/src/alternativa/editor/prop/CustomFillMaterial.as b/src/alternativa/editor/prop/CustomFillMaterial.as index 7e12f94..98d34ce 100644 --- a/src/alternativa/editor/prop/CustomFillMaterial.as +++ b/src/alternativa/editor/prop/CustomFillMaterial.as @@ -2,8 +2,6 @@ package alternativa.editor.prop { import alternativa.engine3d.alternativa3d; import alternativa.engine3d.core.Camera3D; - import alternativa.engine3d.core.PolyPrimitive; - import alternativa.engine3d.display.Skin; import alternativa.engine3d.materials.FillMaterial; import alternativa.engine3d.materials.Material; import alternativa.types.Point3D; @@ -18,17 +16,21 @@ package alternativa.editor.prop private var lightPoint:Point3D; private var normal:Point3D; + + private var blendMode:String; public function CustomFillMaterial(param1:Point3D, param2:uint, param3:Number = 1, param4:String = "normal", param5:Number = -1, param6:uint = 0) { this.center = new Point3D(); this.lightPoint = new Point3D(); this.normal = new Point3D(); - super(param2,param3,param4,param5,param6); + //super(param2,param3,param4,param5,param6); + super(param2, param3, param5, param6); this.lightPoint.copy(param1); + this.blendMode = param4; } - override alternativa3d function draw(param1:Camera3D, param2:Skin, param3:uint, param4:Array) : void + /*override alternativa3d function draw(param1:Camera3D, param2:Skin, param3:uint, param4:Array) : void { var loc5:PolyPrimitive = param2.alternativa3d::primitive; this.center.reset(); @@ -46,11 +48,11 @@ package alternativa.editor.prop alternativa3d::_color = ColorUtils.multiply(alternativa3d::_color,loc8); super.alternativa3d::draw(param1,param2,param3,param4); alternativa3d::_color = loc7; - } + }*/ override public function clone() : Material { - return new CustomFillMaterial(this.lightPoint,color,alpha,blendMode,wireThickness,wireColor); + return new CustomFillMaterial(this.lightPoint,color,alpha,blendMode,lineThickness,lineColor); } } } diff --git a/src/alternativa/editor/prop/FreeBonusRegion.as b/src/alternativa/editor/prop/FreeBonusRegion.as index e7103b3..bb17a0d 100644 --- a/src/alternativa/editor/prop/FreeBonusRegion.as +++ b/src/alternativa/editor/prop/FreeBonusRegion.as @@ -1,28 +1,29 @@ package alternativa.editor.prop { import alternativa.editor.scene.MainScene; - import alternativa.engine3d.core.Mesh; + import alternativa.engine3d.objects.Mesh; import alternativa.engine3d.core.Object3D; import alternativa.engine3d.materials.Material; - import alternativa.engine3d.materials.SurfaceMaterial; import alternativa.engine3d.materials.TextureMaterial; import alternativa.engine3d.primitives.Box; import alternativa.engine3d.primitives.Plane; import alternativa.types.Point3D; import alternativa.types.Set; - import alternativa.types.Texture; import flash.display.BitmapData; import flash.display.BlendMode; + import flash.geom.Vector3D; public class FreeBonusRegion extends Prop { + private static const tmpVec:Vector3D = new Vector3D(); + private static const BASE_WIDTH:Number = 500; private static const BASE_LENGTH:Number = 500; private static const BASE_HEIGHT:Number = 300; - private static const texture:Texture = new Texture(new BitmapData(1,1,false,16756224)); + private static const texture:BitmapData = new BitmapData(1,1,false,16756224); private var _typeNames:Set; @@ -47,8 +48,9 @@ package alternativa.editor.prop loc5.x = BASE_WIDTH / 2; loc5.y = BASE_LENGTH / 2; loc5.z = BASE_HEIGHT / 2; - _material = new TextureMaterial(texture,0.5,true,false,BlendMode.MULTIPLY); - loc5.cloneMaterialToAllSurfaces(SurfaceMaterial(_material)); + //_material = new TextureMaterial(texture,0.5,true,false,BlendMode.MULTIPLY); + _material = new TextureMaterial(texture); + loc5.setMaterialToAllFaces(_material); _object = loc5; super(object,param1,param2,param3,param4); type = Prop.BONUS; @@ -68,7 +70,7 @@ package alternativa.editor.prop override public function clone() : Object3D { var loc1:Mesh = _object.clone() as Mesh; - loc1.cloneMaterialToAllSurfaces(_material as TextureMaterial); + loc1.setMaterialToAllFaces(_material as TextureMaterial); var loc2:FreeBonusRegion = new FreeBonusRegion(name,_libraryName,_groupName,false); loc2.scaleX = scaleX; loc2.scaleY = scaleY; @@ -86,19 +88,20 @@ package alternativa.editor.prop public function showDestinationArea() : void { - if(Boolean(this.shadow) && children.has(this.shadow)) + if(Boolean(this.shadow) && contains(this.shadow)) { removeChild(this.shadow); } - var loc1:Point3D = MainScene.getProjectedPoint(new Point3D(x + scaleX * BASE_WIDTH / 2,y + scaleY * BASE_LENGTH / 2,z - 50)); - globalToLocal(loc1,loc1); + var loc1:Vector3D = MainScene.getProjectedPoint(new Vector3D(x + scaleX * BASE_WIDTH / 2,y + scaleY * BASE_LENGTH / 2,z - 50)); + loc1 = globalToLocal(loc1); var loc2:Number = BASE_WIDTH * scaleX + this.BOX_SIZE; var loc3:Number = BASE_LENGTH * scaleY + this.BOX_SIZE; this.shadow = new Plane(loc2,loc3); this.shadow.mouseEnabled = false; var loc4:TextureMaterial = new TextureMaterial(texture); - loc4.alpha = 0.5; - this.shadow.cloneMaterialToAllSurfaces(loc4); + //loc4.alpha = 0.5; + this.shadow.alpha = 0.5; + this.shadow.setMaterialToAllFaces(loc4); this.shadow.scaleX /= scaleX; this.shadow.scaleY /= scaleY; this.shadow.x = BASE_WIDTH / 2; @@ -109,9 +112,10 @@ package alternativa.editor.prop override public function setMaterial(param1:Material) : void { - var loc2:SurfaceMaterial = param1 as SurfaceMaterial; - (_object as Mesh).cloneMaterialToAllSurfaces(loc2); - (this.shadow as Mesh).cloneMaterialToAllSurfaces(loc2); + //var loc2:SurfaceMaterial = param1 as SurfaceMaterial; + var loc2:Material = param1; //TODO check maybe FillMaterial is not Surface + (_object as Mesh).setMaterialToAllFaces(loc2); + (this.shadow as Mesh).setMaterialToAllFaces(loc2); } override public function get rotationX() : Number diff --git a/src/alternativa/editor/prop/KillBox.as b/src/alternativa/editor/prop/KillBox.as index bd05427..c3f2618 100644 --- a/src/alternativa/editor/prop/KillBox.as +++ b/src/alternativa/editor/prop/KillBox.as @@ -1,10 +1,9 @@ package alternativa.editor.prop { - import alternativa.engine3d.core.Mesh; + import alternativa.engine3d.objects.Mesh; import alternativa.engine3d.core.Object3D; import alternativa.engine3d.materials.TextureMaterial; import alternativa.engine3d.primitives.Box; - import alternativa.types.Texture; import flash.display.BitmapData; import mx.collections.ArrayCollection; @@ -22,7 +21,7 @@ package alternativa.editor.prop private static const BASE_HEIGHT:Number = 300; - private static const texture:Texture = new Texture(new BitmapData(1,1,false,15732981)); + private static const texture:BitmapData = new BitmapData(1,1,false,15732981); public static const typesProvider:ArrayCollection = new ArrayCollection([KICK,KILL,BLOCK]); @@ -36,8 +35,9 @@ package alternativa.editor.prop loc5.z = BASE_HEIGHT / 2; _object = loc5; var loc6:TextureMaterial = new TextureMaterial(texture); - loc6.alpha = 0.5; - loc5.cloneMaterialToAllSurfaces(loc6); + //loc6.alpha = 0.5; + loc5.alpha = 0.5; + loc5.setMaterialToAllFaces(loc6); super(object,param1,param2,param3,param4); type = Prop.KILL_GEOMETRY; } @@ -45,7 +45,7 @@ package alternativa.editor.prop override public function clone() : Object3D { var loc1:Mesh = _object.clone() as Mesh; - loc1.cloneMaterialToAllSurfaces(_material as TextureMaterial); + loc1.setMaterialToAllFaces(_material as TextureMaterial); var loc2:KillBox = new KillBox(name,_libraryName,_groupName,false); loc2.action = this.action; loc2.scaleX = scaleX; diff --git a/src/alternativa/editor/prop/MeshProp.as b/src/alternativa/editor/prop/MeshProp.as index f4e9341..3779033 100644 --- a/src/alternativa/editor/prop/MeshProp.as +++ b/src/alternativa/editor/prop/MeshProp.as @@ -2,19 +2,19 @@ package alternativa.editor.prop { import alternativa.editor.InvisibleTexture; import alternativa.engine3d.alternativa3d; - import alternativa.engine3d.core.Mesh; + import alternativa.engine3d.objects.Mesh; import alternativa.engine3d.core.Object3D; - import alternativa.engine3d.core.Surface; import alternativa.engine3d.materials.TextureMaterial; - import alternativa.engine3d.materials.WireMaterial; import alternativa.types.Map; - import alternativa.types.Matrix3D; + import alternativa.types.Matrix4; import alternativa.types.Point3D; import alternativa.types.Set; - import alternativa.types.Texture; import flash.display.BitmapData; import flash.geom.Matrix; import mx.controls.Alert; + import alternativa.engine3d.core.Face; + import alternativa.editor.engine3d.materials.WireMaterial; + import alternativa.engine3d.core.Vertex; use namespace alternativa3d; @@ -31,12 +31,15 @@ package alternativa.editor.prop private var collisionBoxes:Set; private var bound:Mesh; + + private var _objects:Vector.; - public function MeshProp(param1:Object3D, param2:String, param3:String, param4:String, param5:Boolean = true) + public function MeshProp(mainObject:Object3D, objects:Vector., param2:String, param3:String, param4:String, param5:Boolean = true) { - super(param1,param2,param3,param4,param5); + super(mainObject,param2,param3,param4,param5); + _objects = objects; type = Prop.TILE; - this.parseCollisionData(param1); + this.parseCollisionData(mainObject, objects); } private static function getMirrorBitmapData(param1:BitmapData) : BitmapData @@ -46,17 +49,17 @@ package alternativa.editor.prop return loc2; } - private function parseCollisionData(param1:Object3D) : void + private function parseCollisionData(mainObject:Object3D, objects:Vector.) : void { - var loc2:* = undefined; + var loc2:Object3D; var loc3:Mesh = null; this.collisionBoxes = new Set(); - for(loc2 in param1.children) + for each(loc2 in objects) { loc3 = loc2 as Mesh; if(loc3) { - loc3.cloneMaterialToAllSurfaces(null); + loc3.setMaterialToAllFaces(null); if(loc3.name.substr(0,3) != "occ") { this.collisionBoxes.add(loc3); @@ -64,7 +67,7 @@ package alternativa.editor.prop } else { - Alert.show(param1.name + " include invalid collision mesh " + Object3D(loc2).name); + Alert.show(mainObject.name + " include invalid collision mesh " + Object3D(loc2).name); } } this.collisionMaterial = new CustomFillMaterial(new Point3D(-10000000000,-7000000000,4000000000),16744319); @@ -77,7 +80,7 @@ package alternativa.editor.prop for(loc1 in this.collisionBoxes) { loc2 = loc1 as Mesh; - loc2.cloneMaterialToAllSurfaces(this.collisionMaterial); + loc2.setMaterialToAllFaces(this.collisionMaterial); } setMaterial(null); } @@ -89,7 +92,7 @@ package alternativa.editor.prop for(loc1 in this.collisionBoxes) { loc2 = loc1 as Mesh; - loc2.cloneMaterialToAllSurfaces(null); + loc2.setMaterialToAllFaces(null); } setMaterial(_material); } @@ -115,7 +118,7 @@ package alternativa.editor.prop { bitmapData = this._isMirror ? getMirrorBitmapData(this.bitmaps[param1]) : this.bitmaps[param1]; } - _material = new TextureMaterial(new Texture(bitmapData)); + _material = new TextureMaterial(bitmapData); if(_selected) { _selectBitmapData.dispose(); @@ -135,7 +138,7 @@ package alternativa.editor.prop { this._isMirror = !this._isMirror; bitmapData = getMirrorBitmapData(bitmapData); - (_material as TextureMaterial).texture = new Texture(bitmapData); + (_material as TextureMaterial).texture = bitmapData; if(selected) { _selectBitmapData.dispose(); @@ -150,8 +153,15 @@ package alternativa.editor.prop override public function clone() : Object3D { var loc1:Mesh = _object.clone() as Mesh; - loc1.cloneMaterialToAllSurfaces(_material as TextureMaterial); - var loc2:MeshProp = new MeshProp(loc1,name,_libraryName,_groupName,false); + loc1.setMaterialToAllFaces(_material as TextureMaterial); + + var objectsCopy:Vector. = new Vector.(); + for each(var obj:Object3D in _objects) + { + objectsCopy.push(obj.clone()); + } + + var loc2:MeshProp = new MeshProp(loc1,objectsCopy,name,_libraryName,_groupName,false); loc2.distancesX = distancesX.clone(); loc2.distancesY = distancesY.clone(); loc2.distancesZ = distancesZ.clone(); @@ -165,12 +175,12 @@ package alternativa.editor.prop public function showBound() : void { - var loc1:Matrix3D = null; + var loc1:Matrix4 = null; var loc2:Point3D = null; var loc3:Point3D = null; var loc4:Point3D = null; var loc5:Point3D = null; - var loc6:Surface = null; + var loc6:Face = null; if(!this.bound) { this.bound = new Mesh(); @@ -184,12 +194,13 @@ package alternativa.editor.prop loc4.transform(loc1); loc3.transform(loc1); loc2.transform(loc1); - this.bound.createFace([this.bound.createVertex(loc2.x,loc2.y,loc2.z,3),this.bound.createVertex(loc3.x,loc3.y,loc3.z,2),this.bound.createVertex(loc4.x,loc4.y,loc4.z,1),this.bound.createVertex(loc5.x,loc5.y,loc5.z,0)],0); - loc6 = this.bound.createSurface([0],0); - loc6.material = new WireMaterial(4,255); + this.bound.addFace(Vector.([this.bound.addVertex(loc2.x,loc2.y,loc2.z,3),this.bound.addVertex(loc3.x,loc3.y,loc3.z,2),this.bound.addVertex(loc4.x,loc4.y,loc4.z,1),this.bound.addVertex(loc5.x,loc5.y,loc5.z,0)])); + //loc6 = this.bound.createSurface([0],0); + //loc6.material = new WireMaterial(4,255); + this.bound.setMaterialToAllFaces(new WireMaterial(4,128,128,5,255)); addChild(this.bound); this.bound.z = 0.1; - this.bound.mobility = -100; + //this.bound.mobility = -100; this.bound.mouseEnabled = false; } } diff --git a/src/alternativa/editor/prop/Prop.as b/src/alternativa/editor/prop/Prop.as index ed9764b..c91d81f 100644 --- a/src/alternativa/editor/prop/Prop.as +++ b/src/alternativa/editor/prop/Prop.as @@ -1,23 +1,22 @@ package alternativa.editor.prop { import alternativa.editor.scene.EditorScene; - import alternativa.engine3d.core.Mesh; + import alternativa.engine3d.objects.Mesh; import alternativa.engine3d.core.Object3D; - import alternativa.engine3d.events.MouseEvent3D; + import alternativa.engine3d.core.MouseEvent3D; import alternativa.engine3d.materials.Material; - import alternativa.engine3d.materials.SurfaceMaterial; import alternativa.engine3d.materials.TextureMaterial; - import alternativa.types.Map; - import alternativa.types.Point3D; - import alternativa.types.Texture; import alternativa.utils.MathUtils; import flash.display.Bitmap; import flash.display.BitmapData; import flash.display.BlendMode; import flash.geom.Matrix; import flash.geom.Point; + import alternativa.engine3d.core.Object3DContainer; + import alternativa.engine3d.core.Vertex; + import flash.geom.Vector3D; - public class Prop extends Object3D + public class Prop extends Object3DContainer { public static const TILE:int = 1; @@ -31,11 +30,14 @@ package alternativa.editor.prop public static const KILL_GEOMETRY:int = 6; - private static const matrix:Matrix = new Matrix(); + private static const _matrix:Matrix = new Matrix(); private static var redClass:Class = Prop_redClass; private static const redBmp:BitmapData = new redClass().bitmapData; + + private static const v1:Vector3D = new Vector3D(); + private static const v2:Vector3D = new Vector3D(); public var type:int = 3; @@ -73,7 +75,8 @@ package alternativa.editor.prop public function Prop(param1:Object3D, param2:String, param3:String, param4:String, param5:Boolean = true) { - super(param2); + super(); + this.name = param2; addChild(param1); this._object = param1; this._object.addEventListener(MouseEvent3D.MOUSE_DOWN,this.onMouseDown); @@ -144,30 +147,30 @@ package alternativa.editor.prop private function onMouseDown(param1:MouseEvent3D) : void { - param1.object = this; + param1.relatedObject = this; } protected function initBitmapData() : void { - this._material = Mesh(this._object).surfaces.peek().material; + this._material = Mesh(this._object).faceList.material; if(_material is TextureMaterial) { - this.bitmapData = TextureMaterial(this._material).texture.bitmapData; + this.bitmapData = TextureMaterial(this._material).texture; } } public function calculate() : void { - var loc13:Point3D = null; + var loc13:Vector3D = null; var loc14:int = 0; - var loc15:Point3D = null; + var loc15:Vector3D = null; var loc16:Number = NaN; var loc17:Number = NaN; var loc18:Number = NaN; var loc19:Number = NaN; var loc20:Number = NaN; var loc21:Number = NaN; - var loc1:Array = (this._object as Mesh).vertices.toArray(true); + var loc1:Vector. = (this._object as Mesh).vertices; var loc2:Number = 0; var loc3:Number = 0; var loc4:Number = 0; @@ -181,16 +184,16 @@ package alternativa.editor.prop var loc12:int = 0; while(loc12 < loc11) { - loc13 = loc1[loc12].coords; - if(scene) + loc13 = loc1[loc12].copyToVector3D(v1); + if(parent) { loc13 = localToGlobal(loc13); } loc14 = loc12 + 1; while(loc14 < loc11) { - loc15 = loc1[loc14].coords; - if(scene) + loc15 = loc1[loc14].copyToVector3D(v2); + if(parent) { loc15 = localToGlobal(loc15); } @@ -230,7 +233,7 @@ package alternativa.editor.prop { this._multi = true; } - if(!scene) + if(!parent) { if(this._multi) { @@ -278,9 +281,9 @@ package alternativa.editor.prop public function select() : void { this._selectBitmapData = this.bitmapData.clone(); - matrix.a = this.bitmapData.width / redBmp.width; - matrix.d = matrix.a; - this._selectBitmapData.draw(redBmp,matrix,null,BlendMode.MULTIPLY); + _matrix.a = this.bitmapData.width / redBmp.width; + _matrix.d = _matrix.a; + this._selectBitmapData.draw(redBmp,_matrix,null,BlendMode.MULTIPLY); this.setMaterial(this.newSelectedMaterial); this._selected = true; } @@ -301,13 +304,14 @@ package alternativa.editor.prop protected function get newSelectedMaterial() : Material { - return new TextureMaterial(new Texture(this._selectBitmapData)); + return new TextureMaterial(this._selectBitmapData); } public function setMaterial(param1:Material) : void { - var loc2:SurfaceMaterial = param1 as SurfaceMaterial; - (this._object as Mesh).cloneMaterialToAllSurfaces(loc2); + //var loc2:SurfaceMaterial = param1 as SurfaceMaterial; + var loc2:Material = param1; //TODO + (this._object as Mesh).setMaterialToAllFaces(loc2); } public function hide() : void @@ -347,7 +351,7 @@ package alternativa.editor.prop return this._groupName; } - public function get vertices() : Map + public function get vertices() : Vector. { return (this._object as Mesh).vertices; } diff --git a/src/alternativa/editor/prop/SpawnPoint.as b/src/alternativa/editor/prop/SpawnPoint.as index 60bab98..08dba23 100644 --- a/src/alternativa/editor/prop/SpawnPoint.as +++ b/src/alternativa/editor/prop/SpawnPoint.as @@ -3,9 +3,9 @@ package alternativa.editor.prop import alternativa.editor.FunctionalProps; import alternativa.editor.events.DominationSpawnLinkStartEvent; import alternativa.editor.scene.EditorScene; - import alternativa.engine3d.core.Mesh; + import alternativa.engine3d.objects.Mesh; import alternativa.engine3d.core.Object3D; - import alternativa.engine3d.events.MouseEvent3D; + import alternativa.engine3d.core.MouseEvent3D; import alternativa.engine3d.materials.TextureMaterial; import alternativa.utils.MathUtils; import flash.geom.Point; @@ -40,7 +40,7 @@ package alternativa.editor.prop { var loc2:SpawnPoint = null; var loc1:Mesh = _object.clone() as Mesh; - loc1.cloneMaterialToAllSurfaces(_material as TextureMaterial); + loc1.setMaterialToAllFaces(_material as TextureMaterial); loc2 = new SpawnPoint(loc1,name,_libraryName,_groupName,false); loc2.distancesX = distancesX.clone(); loc2.distancesY = distancesY.clone(); diff --git a/src/alternativa/editor/prop/Sprite3DProp.as b/src/alternativa/editor/prop/Sprite3DProp.as index 2d4b20a..f8391bb 100644 --- a/src/alternativa/editor/prop/Sprite3DProp.as +++ b/src/alternativa/editor/prop/Sprite3DProp.as @@ -1,21 +1,21 @@ package alternativa.editor.prop { import alternativa.engine3d.core.Object3D; - import alternativa.engine3d.core.Sprite3D; + import alternativa.engine3d.objects.Sprite3D; import alternativa.engine3d.core.Vertex; import alternativa.engine3d.materials.Material; - import alternativa.engine3d.materials.SpriteTextureMaterial; - import alternativa.types.Map; - import alternativa.types.Texture; import flash.geom.Point; + import alternativa.engine3d.materials.TextureMaterial; public class Sprite3DProp extends MeshProp { - private var spriteTextureMaterial:SpriteTextureMaterial; + private static const EMPTY_OBJECTS:Vector. = new Vector.(); + + private var spriteTextureMaterial:TextureMaterial; public function Sprite3DProp(param1:Sprite3D, param2:String, param3:String, param4:String, param5:Boolean = true) { - super(param1,param2,param3,param4,param5); + super(param1,EMPTY_OBJECTS,param2,param3,param4,param5); } public function get scale() : Number @@ -34,11 +34,11 @@ package alternativa.editor.prop override public function setMaterial(param1:Material) : void { - var loc2:SpriteTextureMaterial = param1 as SpriteTextureMaterial; + var loc2:TextureMaterial = param1 as TextureMaterial; if(loc2) { - loc2.originX = this.spriteTextureMaterial.originX; - loc2.originY = this.spriteTextureMaterial.originY; + //loc2.originX = this.spriteTextureMaterial.originX; + //loc2.originY = this.spriteTextureMaterial.originY; } (_object as Sprite3D).material = loc2; } @@ -46,27 +46,28 @@ package alternativa.editor.prop override protected function initBitmapData() : void { _material = (_object as Sprite3D).material; - this.spriteTextureMaterial = _material as SpriteTextureMaterial; - bitmapData = this.spriteTextureMaterial.texture.bitmapData; + this.spriteTextureMaterial = _material as TextureMaterial; + bitmapData = this.spriteTextureMaterial.texture; } - override public function get vertices() : Map + override public function get vertices() : Vector. { - var loc1:Vertex = new Vertex(0,0,0); + /*var loc1:Vertex = new Vertex(0,0,0); var loc2:Map = new Map(); loc2.add("1",loc1); - return loc2; + return loc2;*/ + return Vector.([new Vertex()]); } override protected function get newSelectedMaterial() : Material { - return new SpriteTextureMaterial(new Texture(_selectBitmapData)); + return new TextureMaterial(_selectBitmapData); } override public function clone() : Object3D { var loc1:Sprite3D = _object.clone() as Sprite3D; - loc1.material = _material.clone() as SpriteTextureMaterial; + loc1.material = _material.clone() as TextureMaterial; var loc2:Sprite3DProp = new Sprite3DProp(loc1,name,_libraryName,_groupName,false); loc2.distancesX = distancesX.clone(); loc2.distancesY = distancesY.clone(); diff --git a/src/alternativa/editor/propslib/PropLibMesh.as b/src/alternativa/editor/propslib/PropLibMesh.as index 18763b7..577010c 100644 --- a/src/alternativa/editor/propslib/PropLibMesh.as +++ b/src/alternativa/editor/propslib/PropLibMesh.as @@ -15,7 +15,7 @@ package alternativa.editor.propslib public function toString() : String { - return "[PropMesh object3d=" + object3d + ", bitmaps=" + this.bitmaps + "]"; + return "[PropMesh object3d=" + mainObject + ", bitmaps=" + this.bitmaps + (objects != null ? ", objectsLen="+objects.length : "") + "]"; } } } diff --git a/src/alternativa/editor/propslib/PropLibObject.as b/src/alternativa/editor/propslib/PropLibObject.as index c7144c5..f50e851 100644 --- a/src/alternativa/editor/propslib/PropLibObject.as +++ b/src/alternativa/editor/propslib/PropLibObject.as @@ -6,13 +6,16 @@ package alternativa.editor.propslib { public var name:String; - public var object3d:Object3D; + public var mainObject:Object3D; + + public var objects:Vector.; - public function PropLibObject(param1:String, param2:Object3D = null) + public function PropLibObject(param1:String, param2:Object3D = null, objects:Vector. = null) { super(); this.name = param1; - this.object3d = param2; + this.mainObject = param2; + this.objects = objects; } } } diff --git a/src/alternativa/editor/propslib/PropsLibrary.as b/src/alternativa/editor/propslib/PropsLibrary.as index 21bb9c3..858fb2d 100644 --- a/src/alternativa/editor/propslib/PropsLibrary.as +++ b/src/alternativa/editor/propslib/PropsLibrary.as @@ -3,7 +3,7 @@ package alternativa.editor.propslib import alternativa.editor.propslib.events.PropLibProgressEvent; import alternativa.editor.propslib.loaders.MeshLoader; import alternativa.editor.propslib.loaders.SpriteLoader; - import alternativa.engine3d.loaders.TextureMapsInfo; + import alternativa.editor.engine3d.loaders.TextureMapsInfo; import alternativa.types.Map; import flash.events.ErrorEvent; import flash.events.Event; @@ -117,12 +117,13 @@ package alternativa.editor.propslib { loc2 = this.currLoader.propObject as PropLibMesh; loc3 = this.currLoader.loader as MeshLoader; - loc2.object3d = loc3.object; + loc2.mainObject = loc3.object; loc2.bitmaps = loc3.bitmaps; + loc2.objects = loc3.objects; } else { - this.currLoader.propObject.object3d = (this.currLoader.loader as SpriteLoader).sprite; + this.currLoader.propObject.mainObject = (this.currLoader.loader as SpriteLoader).sprite; } ++this.propsLoaded; if(hasEventListener(PropLibProgressEvent.PROGRESS)) diff --git a/src/alternativa/editor/propslib/loaders/MeshLoader.as b/src/alternativa/editor/propslib/loaders/MeshLoader.as index 707fbb9..6bc4c06 100644 --- a/src/alternativa/editor/propslib/loaders/MeshLoader.as +++ b/src/alternativa/editor/propslib/loaders/MeshLoader.as @@ -1,19 +1,24 @@ package alternativa.editor.propslib.loaders { - import alternativa.engine3d.core.Mesh; - import alternativa.engine3d.core.Surface; - import alternativa.engine3d.loaders.Loader3DS; - import alternativa.engine3d.loaders.TextureMapsBatchLoader; + import alternativa.engine3d.objects.Mesh; import alternativa.engine3d.materials.TextureMaterial; import alternativa.types.Map; import flash.events.Event; import flash.events.IOErrorEvent; import flash.events.SecurityErrorEvent; import flash.system.LoaderContext; + import flash.net.URLLoader; + import alternativa.engine3d.loaders.Parser3DS; + import flash.net.URLRequest; + import flash.net.URLLoaderDataFormat; + import alternativa.engine3d.core.Face; + import alternativa.editor.engine3d.loaders.TextureMapsBatchLoader; + import alternativa.engine3d.core.Object3D; public class MeshLoader extends ObjectLoader { public var object:Mesh; + public var objects:Vector.; public var bitmaps:Map; @@ -23,7 +28,8 @@ package alternativa.editor.propslib.loaders private var textures:Map; - private var loader3DS:Loader3DS; + private var loader3DS:URLLoader; + private const parser3DS:Parser3DS = new Parser3DS(); private var texturesLoader:TextureMapsBatchLoader; @@ -40,25 +46,33 @@ package alternativa.editor.propslib.loaders override public function load(param1:LoaderContext) : void { this.loaderContext = param1; - this.loader3DS = new Loader3DS(); + this.loader3DS = new URLLoader(); + this.loader3DS.dataFormat = URLLoaderDataFormat.BINARY; this.loader3DS.addEventListener(Event.COMPLETE,this.on3DSLoadingComplete); this.loader3DS.addEventListener(IOErrorEvent.IO_ERROR,onErrorEvent); this.loader3DS.addEventListener(SecurityErrorEvent.SECURITY_ERROR,onErrorEvent); - this.loader3DS.smooth = true; - this.loader3DS.repeat = false; - this.loader3DS.load(this.url,param1); + //this.loader3DS.smooth = true; + //this.loader3DS.repeat = false; + //this.loader3DS.load(this.url,param1); + this.loader3DS.load(new URLRequest(this.url)); } private function on3DSLoadingComplete(param1:Event) : void { + this.parser3DS.parse(this.loader3DS.data); if(this.objectName != null) { - this.object = this.loader3DS.content.getChildByName(this.objectName,true) as Mesh; + this.object = this.parser3DS.getObjectByName(this.objectName) as Mesh; } else { - this.object = this.loader3DS.content.children.peek() as Mesh; + this.object = this.parser3DS.objects[0] as Mesh; } + + //'child' objects for old engine + this.objects = this.parser3DS.objects.concat(); + this.objects.removeAt(this.objects.indexOf(this.object)); + this.loader3DS.removeEventListener(Event.COMPLETE,this.on3DSLoadingComplete); this.loader3DS.removeEventListener(IOErrorEvent.IO_ERROR,onErrorEvent); this.loader3DS.removeEventListener(SecurityErrorEvent.SECURITY_ERROR,onErrorEvent); @@ -80,12 +94,12 @@ package alternativa.editor.propslib.loaders private function initDefaultTexture() : void { var loc1:Mesh = Mesh(this.object); - var loc2:Surface = loc1.surfaces.peek(); + var loc2:Face = loc1.faceList; var loc3:TextureMaterial = loc2.material as TextureMaterial; if(loc3 != null) { this.bitmaps = new Map(); - this.bitmaps.add("DEFAULT",loc3.texture.bitmapData); + this.bitmaps.add("DEFAULT",loc3.texture); } } diff --git a/src/alternativa/editor/propslib/loaders/SpriteLoader.as b/src/alternativa/editor/propslib/loaders/SpriteLoader.as index b5eda3f..c91e2e7 100644 --- a/src/alternativa/editor/propslib/loaders/SpriteLoader.as +++ b/src/alternativa/editor/propslib/loaders/SpriteLoader.as @@ -1,13 +1,13 @@ package alternativa.editor.propslib.loaders { - import alternativa.engine3d.core.Sprite3D; - import alternativa.engine3d.loaders.TextureMapsLoader; - import alternativa.engine3d.materials.SpriteTextureMaterial; + import alternativa.engine3d.objects.Sprite3D; + import alternativa.editor.engine3d.loaders.TextureMapsLoader; import alternativa.types.Texture; import flash.display.BlendMode; import flash.events.Event; import flash.events.IOErrorEvent; import flash.system.LoaderContext; + import alternativa.engine3d.materials.TextureMaterial; public class SpriteLoader extends ObjectLoader { @@ -44,8 +44,12 @@ package alternativa.editor.propslib.loaders private function onLoadingComplete(param1:Event) : void { - this.sprite = new Sprite3D(); - this.sprite.material = new SpriteTextureMaterial(new Texture(this.loader.bitmapData),1,true,BlendMode.NORMAL,this.originX,this.originY); + this.sprite = new Sprite3D(100,150); + //this.sprite.material = new SpriteTextureMaterial(new Texture(this.loader.bitmapData),1,true,BlendMode.NORMAL,this.originX,this.originY); + this.sprite.material = new TextureMaterial(this.loader.bitmapData); + this.sprite.originX = this.originX; + this.sprite.originY = this.originY; + this.sprite.scaleX = this.scale; this.sprite.scaleY = this.scale; this.sprite.scaleZ = this.scale; diff --git a/src/alternativa/editor/scene/CursorScene.as b/src/alternativa/editor/scene/CursorScene.as index 8984441..0a3faa5 100644 --- a/src/alternativa/editor/scene/CursorScene.as +++ b/src/alternativa/editor/scene/CursorScene.as @@ -4,13 +4,12 @@ package alternativa.editor.scene import alternativa.editor.prop.MeshProp; import alternativa.editor.prop.Prop; import alternativa.editor.prop.Sprite3DProp; - import alternativa.engine3d.controllers.WalkController; + import alternativa.editor.engine3d.controllers.WalkController; import alternativa.engine3d.core.Camera3D; import alternativa.engine3d.core.Object3D; - import alternativa.engine3d.display.View; + import alternativa.engine3d.core.View; import alternativa.engine3d.materials.Material; - import alternativa.engine3d.materials.SpriteTextureMaterial; - import alternativa.types.Matrix3D; + import alternativa.types.Matrix4; import alternativa.types.Point3D; import alternativa.types.Set; import alternativa.types.Texture; @@ -22,6 +21,10 @@ package alternativa.editor.scene import flash.display.Shape; import flash.geom.Matrix; import flash.geom.Point; + import alternativa.engine3d.core.Object3DContainer; + import flash.geom.Vector3D; + import alternativa.engine3d.materials.TextureMaterial; + import flash.display.Sprite; public class CursorScene extends EditorScene { @@ -47,7 +50,7 @@ package alternativa.editor.scene public var containerController:WalkController; - public var container:Object3D; + public var container:Object3DContainer; private var eventSourceObject:DisplayObject; @@ -59,12 +62,12 @@ package alternativa.editor.scene private var _visible:Boolean = false; - public function CursorScene(param1:DisplayObject) + public function CursorScene(param1:DisplayObject, container:Sprite) { super(); this.eventSourceObject = param1; this.initControllers(); - view.addChild(this.axisIndicatorOverlay = new Shape()); + container.addChild(this.axisIndicatorOverlay = new Shape()); } private function initControllers() : void @@ -75,7 +78,7 @@ package alternativa.editor.scene this.cameraController.speedThreshold = 1; this.cameraController.mouseEnabled = false; this.cameraController.coords = new Point3D(250,-7800,4670); - this.container = new Object3D(); + this.container = new Object3DContainer(); root.addChild(this.container); this.containerController = new WalkController(this.eventSourceObject); this.containerController.object = this.container; @@ -85,10 +88,10 @@ package alternativa.editor.scene public function set object(param1:Prop) : void { - var loc2:Point3D = null; + var loc2:Vector3D = null; if(this._object) { - loc2 = this._object.coords; + loc2 = new Vector3D(this._object.x,this._object.y,this._object.z); if(this._visible) { root.removeChild(this._object); @@ -96,10 +99,11 @@ package alternativa.editor.scene } this._object = param1; this.material = this._object.material.clone(); - this.material.alpha = 0.5; + //this.material.alpha = 0.5; + this._object.alpha = 0.5; if(loc2) { - this._object.coords = loc2; + this._object.setPositionFromVector3(loc2); } if(this._visible) { @@ -150,24 +154,25 @@ package alternativa.editor.scene loc2.draw(greenBmp,loc3,null,BlendMode.HARDLIGHT); if(this._object is Sprite3DProp) { - this.greenMaterial = new SpriteTextureMaterial(new Texture(loc2)); - this.redMaterial = new SpriteTextureMaterial(new Texture(loc1)); + this.greenMaterial = new TextureMaterial(loc2); + this.redMaterial = new TextureMaterial(loc1); } else { this.greenMaterial = new CustomFillMaterial(new Point3D(-10000000000,-7000000000,4000000000),65280); this.redMaterial = new CustomFillMaterial(new Point3D(-10000000000,-7000000000,4000000000),16711680); } - this.greenMaterial.alpha = 0.8; - this.redMaterial.alpha = 0.8; + //this.greenMaterial.alpha = 0.8; + //this.redMaterial.alpha = 0.8; + this._object.alpha = 0.8; } public function moveCursorByMouse() : void { - var loc1:Point3D = null; + var loc1:Vector3D = null; if(this._object) { - loc1 = view.projectViewPointToPlane(new Point(view.mouseX,view.mouseY),znormal,this._object.z); + loc1 = camera.projectGlobal(new Vector3D(view.mouseX,view.mouseY,this._object.z)); this._object.x = loc1.x; this._object.y = loc1.y; if(this._snapMode || this._object is MeshProp && !(this._object is Sprite3DProp)) @@ -185,11 +190,12 @@ package alternativa.editor.scene override protected function initScene() : void { - root = new Object3D(); + root = new Object3DContainer(); camera = new Camera3D(); camera.rotationX = -MathUtils.DEG90 - MathUtils.DEG30; - view = new View(camera); - view.interactive = false; + view = new View(100,100); + camera.view = view; + //view.interactive = false; view.mouseEnabled = false; view.mouseChildren = false; view.graphics.beginFill(16777215); @@ -234,7 +240,7 @@ package alternativa.editor.scene } } - public function drawAxis(param1:Matrix3D) : void + public function drawAxis(param1:Matrix4) : void { var loc2:Graphics = this.axisIndicatorOverlay.graphics; var loc3:Number = this.axisIndicatorSize; diff --git a/src/alternativa/editor/scene/EditorScene.as b/src/alternativa/editor/scene/EditorScene.as index 073143f..ce5aa10 100644 --- a/src/alternativa/editor/scene/EditorScene.as +++ b/src/alternativa/editor/scene/EditorScene.as @@ -3,14 +3,15 @@ package alternativa.editor.scene import alternativa.editor.prop.Prop; import alternativa.engine3d.core.Camera3D; import alternativa.engine3d.core.Object3D; - import alternativa.engine3d.core.Scene3D; - import alternativa.engine3d.display.View; - import alternativa.types.Matrix3D; + import alternativa.editor.engine3d.Scene3D; + import alternativa.engine3d.core.View; + import alternativa.types.Matrix4; import alternativa.types.Point3D; import alternativa.types.Set; import alternativa.utils.KeyboardUtils; import alternativa.utils.MathUtils; import flash.geom.Point; + import alternativa.engine3d.core.Object3DContainer; public class EditorScene extends Scene3D { @@ -30,8 +31,6 @@ package alternativa.editor.scene public static var vBase:Number = 300; - public var camera:Camera3D; - public var view:View; public var occupyMap:OccupyMap; @@ -65,13 +64,14 @@ package alternativa.editor.scene protected function initScene() : void { - root = new Object3D(); + root = new Object3DContainer(); this.camera = new Camera3D(); this.camera.rotationX = -MathUtils.DEG90 - MathUtils.DEG30; - this.camera.coords = new Point3D(250,-7800,4670); + this.camera.setPositionXYZ(250,-7800,4670); root.addChild(this.camera); - this.view = new View(this.camera); - this.view.interactive = true; + this.view = new View(100,100); + this.camera.view = view; + //this.view.interactive = true; this.view.buttonMode = true; this.view.useHandCursor = false; this.view.graphics.beginFill(16777215); @@ -81,7 +81,7 @@ package alternativa.editor.scene protected function getCameraFacing() : CameraFacing { - var loc1:Matrix3D = this.camera.transformation; + var loc1:Matrix4 = this.camera.transformation; if(loc1.a > 1 / Math.SQRT2) { return CameraFacing.Y; diff --git a/src/alternativa/editor/scene/MainScene.as b/src/alternativa/editor/scene/MainScene.as index b4658e1..1f036b9 100644 --- a/src/alternativa/editor/scene/MainScene.as +++ b/src/alternativa/editor/scene/MainScene.as @@ -26,9 +26,8 @@ package alternativa.editor.scene import alternativa.editor.prop.SpawnPoint; import alternativa.editor.prop.Sprite3DProp; import alternativa.engine3d.core.Object3D; - import alternativa.engine3d.events.MouseEvent3D; - import alternativa.engine3d.materials.WireMaterial; - import alternativa.engine3d.physics.EllipsoidCollider; + import alternativa.engine3d.core.MouseEvent3D; + import alternativa.editor.engine3d.materials.WireMaterial; import alternativa.engine3d.primitives.Plane; import alternativa.types.Map; import alternativa.types.Point3D; @@ -41,10 +40,14 @@ package alternativa.editor.scene import flash.utils.getQualifiedClassName; import gui.events.PropListEvent; import mx.containers.Panel; + import alternativa.engine3d.core.EllipsoidCollider; + import flash.geom.Vector3D; + import alternativa.engine3d.core.Object3DContainer; public class MainScene extends EditorScene { public static var collider:EllipsoidCollider; + private static var __root:Object3DContainer; public var selectedProp:Prop; @@ -97,7 +100,7 @@ package alternativa.editor.scene this.selectablePropTypes = AlternativaEditor.DEFAULT_SELECTABLE_TYPES; var loc2:Number = 15 * hBase2; this.grid = new Plane(loc2,loc2,15,15); - this.grid.cloneMaterialToAllSurfaces(new WireMaterial(1,9474192)); + this.grid.setMaterialToAllFaces(new WireMaterial(1,loc2,loc2,15,9474192)); root.addChild(this.grid); this.grid.x = hBase; this.grid.y = hBase; @@ -106,18 +109,17 @@ package alternativa.editor.scene this.exporters[FileType.MAP_XML_VERSION_1_FULL] = new TanksXmlExporterV1Full(root); this.exporters[FileType.MAP_XML_VERSION_3] = new TanksXmlExporterV3(root); this.createControlPointNameTextField(); - collider = new EllipsoidCollider(this,30,30,30); + collider = new EllipsoidCollider(30,30,30); + __root = root; GlobalEventDispatcher.addListener(LayerVisibilityChangeEvent.VISIBILITY_CHANGED,this.onLayerVisibilityChange); GlobalEventDispatcher.addListener(LayerContentChangeEvent.LAYER_CONTENT_CHANGED,this.onLayerContentChange); GlobalEventDispatcher.addListener(DominationSpawnLinkStartEvent.DOMINATION_SPAWN_LINK_START,this.onDominationLinkStart); GlobalEventDispatcher.addListener(DominationSpawnLinkEndEvent.DOMINATION_SPAWN_LINK_END,this.onDominationLinkEnd); } - public static function getProjectedPoint(param1:Point3D) : Point3D + public static function getProjectedPoint(param1:Vector3D) : Vector3D { - var loc2:Point3D = new Point3D(); - collider.calculateDestination(param1,new Point3D(0,0,-10000),loc2); - return loc2; + return collider.calculateDestination(param1,new Vector3D(0,0,-10000),__root); } private static function snapPropsToGrid(param1:Set) : void @@ -163,7 +165,7 @@ package alternativa.editor.scene } } - override public function set root(param1:Object3D) : void + override public function set root(param1:Object3DContainer) : void { var loc2:FileExporter = null; super.root = param1; @@ -216,7 +218,7 @@ package alternativa.editor.scene { loc4 = loc3; loc4.deselect(); - this.addProp(loc4,loc4.coords,loc4.rotationZ,false); + this.addProp(loc4,new Point3D(loc4.x,loc4.y,loc4.z),loc4.rotationZ,false); } break; case EventJournal.MOVE: @@ -247,13 +249,13 @@ package alternativa.editor.scene { case EventJournal.ADD: loc3 = loc2.peek(); - this.addProp(loc3,loc3.coords,loc3.rotationZ,false); + this.addProp(loc3,new Point3D(loc3.x,loc3.y,loc3.z),loc3.rotationZ,false); break; case EventJournal.COPY: for(loc4 in loc2) { loc3 = loc4; - this.addProp(loc3,loc3.coords,loc3.rotationZ,false); + this.addProp(loc3,new Point3D(loc3.x,loc3.y,loc3.z),loc3.rotationZ,false); } break; case EventJournal.DELETE: @@ -280,7 +282,7 @@ package alternativa.editor.scene public function setCameraPosition(param1:Point3D, param2:Number, param3:Number, param4:Number) : void { - camera.coords = param1; + camera.setPositionXYZ(param1.x,param1.y,param1.z); camera.rotationX = param2; camera.rotationY = param3; camera.rotationZ = param4; @@ -288,9 +290,9 @@ package alternativa.editor.scene public function showCollisionBoxes() : void { - var loc1:* = undefined; + var loc1:Object3D; var loc2:MeshProp = null; - for(loc1 in root.children) + for each(loc1 in root.children) { loc2 = loc1 as MeshProp; if(loc2) @@ -302,9 +304,9 @@ package alternativa.editor.scene public function hideCollisionBoxes() : void { - var loc1:* = undefined; + var loc1:Object3D; var loc2:MeshProp = null; - for(loc1 in root.children) + for each(loc1 in root.children) { loc2 = loc1 as MeshProp; if(loc2) @@ -326,9 +328,9 @@ package alternativa.editor.scene public function showPlaneBounds() : void { - var loc1:* = undefined; + var loc1:Object3D; var loc2:MeshProp = null; - for(loc1 in root.children) + for each(loc1 in root.children) { loc2 = loc1 as MeshProp; if(Boolean(loc2) && loc2.height == 0) @@ -340,9 +342,9 @@ package alternativa.editor.scene public function hidePlaneBounds() : void { - var loc1:* = undefined; + var loc1:Object3D; var loc2:MeshProp = null; - for(loc1 in root.children) + for each(loc1 in root.children) { loc2 = loc1 as MeshProp; if(Boolean(loc2) && loc2.height == 0) @@ -354,9 +356,9 @@ package alternativa.editor.scene public function set selectablePropTypes(param1:Array) : void { - var loc4:* = undefined; + var loc4:Object3D; var loc5:Prop = null; - var loc6:* = undefined; + var loc6:Object3D; var loc7:Object3D = null; this._selectablePropTypes.clear(); var loc2:int = int(param1.length); @@ -366,13 +368,13 @@ package alternativa.editor.scene this._selectablePropTypes.add(getQualifiedClassName(param1[loc3])); loc3++; } - for(loc4 in root.children) + for each(loc4 in root.children) { loc5 = loc4 as Prop; if(loc5) { loc5.mouseEnabled = this.isSelectableProp(loc5); - for(loc6 in loc5.children) + for each(loc6 in loc5.children) { loc7 = loc6 as Object3D; loc7.mouseEnabled = loc5.mouseEnabled; @@ -406,7 +408,7 @@ package alternativa.editor.scene public function moveSelectedPropsByMouse(param1:Boolean) : void { var loc2:Point = null; - var loc3:Point3D = null; + var loc3:Vector3D = null; var loc4:* = undefined; var loc5:Number = NaN; var loc6:Number = NaN; @@ -428,13 +430,13 @@ package alternativa.editor.scene loc8 = getCameraFacing(); if(loc8 == CameraFacing.Y || loc8 == CameraFacing.NEGATIVE_Y) { - loc3 = view.projectViewPointToPlane(loc2,ynormal,this.selectedProp.y); + loc3 = camera.projectGlobal(new Vector3D(loc2.x,loc2.y,this.selectedProp.y)); loc5 = loc3.x - this.selectedProp.x; this.selectedProp.x = loc3.x; } else { - loc3 = view.projectViewPointToPlane(loc2,xnormal,this.selectedProp.x); + loc3 = camera.projectGlobal(new Vector3D(loc2.x,loc2.y,this.selectedProp.x)); loc6 = loc3.y - this.selectedProp.y; this.selectedProp.y = loc3.y; } @@ -443,7 +445,7 @@ package alternativa.editor.scene } else { - loc3 = view.projectViewPointToPlane(loc2,znormal,this.selectedProp.z); + loc3 = camera.projectGlobal(new Vector3D(loc2.x,loc2.y,this.selectedProp.z)); loc5 = loc3.x - this.selectedProp.x; loc6 = loc3.y - this.selectedProp.y; this.selectedProp.x = loc3.x; @@ -510,7 +512,7 @@ package alternativa.editor.scene var loc3:Boolean = false; if(!param1.ctrlKey) { - loc2 = param1.object as Prop; + loc2 = param1.relatedObject as Prop; if(this.isSelectableProp(loc2)) { loc3 = loc2.selected; @@ -621,16 +623,16 @@ package alternativa.editor.scene public function getPropsUnderRect(param1:Point, param2:Number, param3:Number, param4:Boolean) : Set { - var loc6:* = undefined; + var loc6:Object3D; var loc7:Prop = null; - var loc8:Point3D = null; + var loc8:Vector3D = null; var loc5:Set = new Set(); - for(loc6 in root.children) + for each(loc6 in root.children) { loc7 = loc6 as Prop; if((Boolean(loc7)) && this.isSelectableProp(loc7)) { - loc8 = view.projectPoint(loc7.coords); + loc8 = camera.projectGlobal(new Vector3D(loc7.x,loc7.y,loc7.z)); if(loc8.x >= param1.x && loc8.x <= param1.x + param2 && loc8.y >= param1.y && loc8.y <= param1.y + param3) { if(param4) @@ -654,7 +656,7 @@ package alternativa.editor.scene public function addProp(param1:Prop, param2:Point3D, param3:Number, param4:Boolean = true, param5:Boolean = true) : Prop { var loc6:Prop = null; - var loc7:* = undefined; + var loc7:Object3D; var loc8:Object3D = null; if(param4) { @@ -687,7 +689,7 @@ package alternativa.editor.scene occupyMap.occupy(loc6); } loc6.mouseEnabled = this.isSelectableProp(loc6); - for(loc7 in loc6.children) + for each(loc7 in loc6.children) { loc8 = loc7 as Object3D; loc8.mouseEnabled = loc6.mouseEnabled; @@ -821,9 +823,9 @@ package alternativa.editor.scene public function clear() : void { - var loc1:* = undefined; + var loc1:Object3D; var loc2:Prop = null; - for(loc1 in root.children) + for each(loc1 in root.children) { loc2 = loc1 as Prop; if(loc2) @@ -835,7 +837,7 @@ package alternativa.editor.scene this.selectedProps.clear(); occupyMap.clear(); this.layers.clear(); - view.interactive = true; + //view.interactive = true; this.dominationPoints = new Dictionary(); } @@ -1108,12 +1110,12 @@ package alternativa.editor.scene private function drawDominationPointLinks(param1:Graphics, param2:ControlPoint) : void { var loc4:SpawnPoint = null; - var loc5:Point3D = null; + var loc5:Point3D = new Point3D(); param1.lineStyle(0,65280); - var loc3:Point3D = view.projectPoint(param2.coords); + var loc3:Point3D = new Point3D().copyFromVector3D(camera.projectGlobal(new Vector3D(param2.x,param2.y,param2.z))); for each(loc4 in param2.getSpawnPoints()) { - loc5 = view.projectPoint(loc4.coords); + loc5.copyFromVector3D(camera.projectGlobal(new Vector3D(loc4.x,loc4.y,loc4.z))); GraphicUtils.drawLine(param1,loc3,loc5); } } diff --git a/src/alternativa/engine3d/alternativa3d.as b/src/alternativa/engine3d/alternativa3d.as new file mode 100644 index 0000000..bf7839c --- /dev/null +++ b/src/alternativa/engine3d/alternativa3d.as @@ -0,0 +1,4 @@ +package alternativa.engine3d +{ + public namespace alternativa3d = "http://alternativaplatform.com/en/alternativa3d"; +} diff --git a/src/alternativa/engine3d/animation/AnimationClip.as b/src/alternativa/engine3d/animation/AnimationClip.as new file mode 100644 index 0000000..22f243e --- /dev/null +++ b/src/alternativa/engine3d/animation/AnimationClip.as @@ -0,0 +1,424 @@ +package alternativa.engine3d.animation +{ + import __AS3__.vec.Vector; + import alternativa.engine3d.animation.keys.Track; + import alternativa.engine3d.objects.Joint; + import alternativa.engine3d.core.Object3DContainer; + import alternativa.engine3d.objects.Skin; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class AnimationClip extends AnimationNode + { + + alternativa3d var _objects:Array; + public var name:String; + public var loop:Boolean = true; + public var length:Number = 0; + public var animated:Boolean = true; + private var _time:Number = 0; + private var _numTracks:int = 0; + private var _tracks:Vector. = new Vector.(); + private var _notifiersList:AnimationNotify; + + public function AnimationClip(_arg_1:String=null) + { + this.name = _arg_1; + } + + public function get objects():Array + { + return ((this._objects == null) ? null : [].concat(this._objects)); + } + + public function set objects(_arg_1:Array):void + { + this.updateObjects(this._objects, controller, _arg_1, controller); + this._objects = ((_arg_1 == null) ? null : [].concat(_arg_1)); + } + + override alternativa3d function setController(_arg_1:AnimationController):void + { + this.updateObjects(this._objects, controller, this._objects, _arg_1); + this.controller = _arg_1; + } + + private function addObject(_arg_1:Object):void + { + if (this._objects == null) + { + this._objects = [_arg_1]; + } else + { + this._objects.push(_arg_1); + }; + if (controller != null) + { + controller.addObject(_arg_1); + }; + } + + private function updateObjects(_arg_1:Array, _arg_2:AnimationController, _arg_3:Array, _arg_4:AnimationController):void + { + var _local_5:int; + var _local_6:int; + if (((!(_arg_2 == null)) && (!(_arg_1 == null)))) + { + _local_5 = 0; + _local_6 = this._objects.length; + while (_local_5 < _local_6) + { + _arg_2.removeObject(_arg_1[_local_5]); + _local_5++; + }; + }; + if (((!(_arg_4 == null)) && (!(_arg_3 == null)))) + { + _local_5 = 0; + _local_6 = _arg_3.length; + while (_local_5 < _local_6) + { + _arg_4.addObject(_arg_3[_local_5]); + _local_5++; + }; + }; + } + + public function updateLength():void + { + var _local_2:Track; + var _local_3:Number; + var _local_1:int; + while (_local_1 < this._numTracks) + { + _local_2 = this._tracks[_local_1]; + _local_3 = _local_2.length; + if (_local_3 > this.length) + { + this.length = _local_3; + }; + _local_1++; + }; + } + + public function addTrack(_arg_1:Track):Track + { + if (_arg_1 == null) + { + throw (new Error("Track can not be null")); + }; + var _local_2:* = this._numTracks++; + this._tracks[_local_2] = _arg_1; + if (_arg_1.length > this.length) + { + this.length = _arg_1.length; + }; + return (_arg_1); + } + + public function removeTrack(_arg_1:Track):Track + { + var _local_5:Track; + var _local_2:int = this._tracks.indexOf(_arg_1); + if (_local_2 < 0) + { + throw (new ArgumentError("Track not found")); + }; + this._numTracks--; + var _local_3:int = (_local_2 + 1); + while (_local_2 < this._numTracks) + { + this._tracks[_local_2] = this._tracks[_local_3]; + _local_2++; + _local_3++; + }; + this._tracks.length = this._numTracks; + this.length = 0; + var _local_4:int; + while (_local_4 < this._numTracks) + { + _local_5 = this._tracks[_local_4]; + if (_local_5.length > this.length) + { + this.length = _local_5.length; + }; + _local_4++; + }; + return (_arg_1); + } + + public function getTrackAt(_arg_1:int):Track + { + return (this._tracks[_arg_1]); + } + + public function get numTracks():int + { + return (this._numTracks); + } + + override alternativa3d function update(_arg_1:Number, _arg_2:Number):void + { + var _local_4:int; + var _local_5:Track; + var _local_6:AnimationState; + var _local_3:Number = this._time; + if (this.animated) + { + this._time = (this._time + (_arg_1 * speed)); + if (this.loop) + { + if (this._time < 0) + { + this._time = 0; + } else + { + if (this._time >= this.length) + { + this.collectNotifiers(_local_3, this.length); + this._time = ((this.length <= 0) ? 0 : (this._time % this.length)); + this.collectNotifiers(0, this._time); + } else + { + this.collectNotifiers(_local_3, this._time); + }; + }; + } else + { + if (this._time < 0) + { + this._time = 0; + } else + { + if (this._time >= this.length) + { + this._time = this.length; + }; + }; + this.collectNotifiers(_local_3, this._time); + }; + }; + if (_arg_2 > 0) + { + _local_4 = 0; + while (_local_4 < this._numTracks) + { + _local_5 = this._tracks[_local_4]; + if (_local_5.object != null) + { + _local_6 = controller.getState(_local_5.object); + if (_local_6 != null) + { + _local_5.blend(this._time, _arg_2, _local_6); + }; + }; + _local_4++; + }; + }; + } + + public function get time():Number + { + return (this._time); + } + + public function set time(_arg_1:Number):void + { + this._time = _arg_1; + } + + public function get normalizedTime():Number + { + return ((this.length == 0) ? 0 : (this._time / this.length)); + } + + public function set normalizedTime(_arg_1:Number):void + { + this._time = (_arg_1 * this.length); + } + + private function getNumChildren(_arg_1:Object):int + { + if ((_arg_1 is Joint)) + { + return (Joint(_arg_1).numChildren); + }; + if ((_arg_1 is Object3DContainer)) + { + return (Object3DContainer(_arg_1).numChildren); + }; + if ((_arg_1 is Skin)) + { + return (Skin(_arg_1).numJoints); + }; + return (0); + } + + private function getChildAt(_arg_1:Object, _arg_2:int):Object + { + if ((_arg_1 is Joint)) + { + return (Joint(_arg_1).getChildAt(_arg_2)); + }; + if ((_arg_1 is Object3DContainer)) + { + return (Object3DContainer(_arg_1).getChildAt(_arg_2)); + }; + if ((_arg_1 is Skin)) + { + return (Skin(_arg_1).getJointAt(_arg_2)); + }; + return (null); + } + + private function addChildren(_arg_1:Object):void + { + var _local_4:Object; + var _local_2:int; + var _local_3:int = this.getNumChildren(_arg_1); + while (_local_2 < _local_3) + { + _local_4 = this.getChildAt(_arg_1, _local_2); + this.addObject(_local_4); + this.addChildren(_local_4); + _local_2++; + }; + } + + public function attach(_arg_1:Object, _arg_2:Boolean):void + { + this.updateObjects(this._objects, controller, null, controller); + this._objects = null; + this.addObject(_arg_1); + if (_arg_2) + { + this.addChildren(_arg_1); + }; + } + + alternativa3d function collectNotifiers(_arg_1:Number, _arg_2:Number):void + { + var _local_3:AnimationNotify = this._notifiersList; + while (_local_3 != null) + { + if (_local_3._time > _arg_1) + { + if (_local_3._time > _arg_2) + { + return; + }; + _local_3.processNext = controller.nearestNotifyers; + controller.nearestNotifyers = _local_3; + }; + _local_3 = _local_3.next; + }; + } + + public function addNotify(_arg_1:Number, _arg_2:String=null):AnimationNotify + { + var _local_4:AnimationNotify; + _arg_1 = ((_arg_1 <= 0) ? 0 : ((_arg_1 >= this.length) ? this.length : _arg_1)); + var _local_3:AnimationNotify = new AnimationNotify(_arg_2); + _local_3._time = _arg_1; + if (this._notifiersList == null) + { + this._notifiersList = _local_3; + return (_local_3); + }; + if (this._notifiersList._time > _arg_1) + { + _local_3.next = this._notifiersList; + this._notifiersList = _local_3; + return (_local_3); + }; + _local_4 = this._notifiersList; + while (((!(_local_4.next == null)) && (_local_4.next._time <= _arg_1))) + { + _local_4 = _local_4.next; + }; + if (_local_4.next == null) + { + _local_4.next = _local_3; + } else + { + _local_3.next = _local_4.next; + _local_4.next = _local_3; + }; + return (_local_3); + } + + public function addNotifyAtEnd(_arg_1:Number=0, _arg_2:String=null):AnimationNotify + { + return (this.addNotify((this.length - _arg_1), _arg_2)); + } + + public function removeNotify(_arg_1:AnimationNotify):AnimationNotify + { + var _local_2:AnimationNotify; + if (this._notifiersList != null) + { + if (this._notifiersList == _arg_1) + { + this._notifiersList = this._notifiersList.next; + return (_arg_1); + }; + _local_2 = this._notifiersList; + while (((!(_local_2.next == null)) && (!(_local_2.next == _arg_1)))) + { + _local_2 = _local_2.next; + }; + if (_local_2.next == _arg_1) + { + _local_2.next = _arg_1.next; + return (_arg_1); + }; + }; + throw (new Error("Notify not found")); + } + + public function get notifiers():Vector. + { + var _local_1:Vector. = new Vector.(); + var _local_2:int; + var _local_3:AnimationNotify = this._notifiersList; + while (_local_3 != null) + { + _local_1[_local_2] = _local_3; + _local_2++; + _local_3 = _local_3.next; + }; + return (_local_1); + } + + public function slice(_arg_1:Number, _arg_2:Number=1.79769313486232E308):AnimationClip + { + var _local_3:AnimationClip = new AnimationClip(this.name); + _local_3._objects = ((this._objects == null) ? null : [].concat(this._objects)); + var _local_4:int; + while (_local_4 < this._numTracks) + { + _local_3.addTrack(this._tracks[_local_4].slice(_arg_1, _arg_2)); + _local_4++; + }; + return (_local_3); + } + + public function clone():AnimationClip + { + var _local_1:AnimationClip = new AnimationClip(this.name); + _local_1._objects = ((this._objects == null) ? null : [].concat(this._objects)); + var _local_2:int; + while (_local_2 < this._numTracks) + { + _local_1.addTrack(this._tracks[_local_2]); + _local_2++; + }; + _local_1.length = this.length; + return (_local_1); + } + + + } +}//package alternativa.engine3d.animation \ No newline at end of file diff --git a/src/alternativa/engine3d/animation/AnimationController.as b/src/alternativa/engine3d/animation/AnimationController.as new file mode 100644 index 0000000..93a3a07 --- /dev/null +++ b/src/alternativa/engine3d/animation/AnimationController.as @@ -0,0 +1,176 @@ +package alternativa.engine3d.animation +{ + import __AS3__.vec.Vector; + import alternativa.engine3d.core.Object3D; + import flash.utils.Dictionary; + import flash.utils.getTimer; + import alternativa.engine3d.animation.events.NotifyEvent; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class AnimationController + { + + private var _root:AnimationNode; + private var _objects:Vector.; + private var _object3ds:Vector. = new Vector.(); + private var objectsUsedCount:Dictionary = new Dictionary(); + private var states:Object = new Object(); + private var lastTime:int = -1; + alternativa3d var nearestNotifyers:AnimationNotify; + + + public function get root():AnimationNode + { + return (this._root); + } + + public function set root(_arg_1:AnimationNode):void + { + if (this._root != _arg_1) + { + if (this._root != null) + { + this._root.setController(null); + this._root._isActive = false; + }; + if (_arg_1 != null) + { + _arg_1.setController(this); + _arg_1._isActive = true; + }; + this._root = _arg_1; + }; + } + + public function update():void + { + var _local_1:Number; + var _local_2:AnimationState; + var _local_3:int; + var _local_4:int; + var _local_6:int; + var _local_7:Object3D; + if (this.lastTime < 0) + { + this.lastTime = getTimer(); + _local_1 = 0; + } else + { + _local_6 = getTimer(); + _local_1 = (0.001 * (_local_6 - this.lastTime)); + this.lastTime = _local_6; + }; + if (this._root == null) + { + return; + }; + for each (_local_2 in this.states) + { + _local_2.reset(); + }; + this._root.update(_local_1, 1); + _local_3 = 0; + _local_4 = this._object3ds.length; + while (_local_3 < _local_4) + { + _local_7 = this._object3ds[_local_3]; + _local_2 = this.states[_local_7.name]; + if (_local_2 != null) + { + _local_2.apply(_local_7); + }; + _local_3++; + }; + var _local_5:AnimationNotify = this.nearestNotifyers; + while (_local_5 != null) + { + if (_local_5.willTrigger(NotifyEvent.NOTIFY)) + { + _local_5.dispatchEvent(new NotifyEvent(_local_5)); + }; + _local_5 = _local_5.processNext; + }; + this.nearestNotifyers = null; + } + + alternativa3d function addObject(_arg_1:Object):void + { + if ((_arg_1 in this.objectsUsedCount)) + { + this.objectsUsedCount[_arg_1]++; + } else + { + if ((_arg_1 is Object3D)) + { + this._object3ds.push(_arg_1); + } else + { + this._objects.push(_arg_1); + }; + this.objectsUsedCount[_arg_1] = 1; + }; + } + + alternativa3d function removeObject(_arg_1:Object):void + { + var _local_3:int; + var _local_4:int; + var _local_5:int; + var _local_2:int = this.objectsUsedCount[_arg_1]; + _local_2--; + if (_local_2 <= 0) + { + if ((_arg_1 is Object3D)) + { + _local_3 = this._object3ds.indexOf(_arg_1); + _local_5 = (this._object3ds.length - 1); + _local_4 = (_local_3 + 1); + while (_local_3 < _local_5) + { + this._object3ds[_local_3] = this._object3ds[_local_4]; + _local_3++; + _local_4++; + }; + this._object3ds.length = _local_5; + } else + { + _local_3 = this._objects.indexOf(_arg_1); + _local_5 = (this._objects.length - 1); + _local_4 = (_local_3 + 1); + while (_local_3 < _local_5) + { + this._objects[_local_3] = this._objects[_local_4]; + _local_3++; + _local_4++; + }; + this._objects.length = _local_5; + }; + delete this.objectsUsedCount[_arg_1]; + } else + { + this.objectsUsedCount[_arg_1] = _local_2; + }; + } + + alternativa3d function getState(_arg_1:String):AnimationState + { + var _local_2:AnimationState = this.states[_arg_1]; + if (_local_2 == null) + { + _local_2 = new AnimationState(); + this.states[_arg_1] = _local_2; + }; + return (_local_2); + } + + public function freeze():void + { + this.lastTime = -1; + } + + + } +}//package alternativa.engine3d.animation \ No newline at end of file diff --git a/src/alternativa/engine3d/animation/AnimationCouple.as b/src/alternativa/engine3d/animation/AnimationCouple.as new file mode 100644 index 0000000..99a5e3c --- /dev/null +++ b/src/alternativa/engine3d/animation/AnimationCouple.as @@ -0,0 +1,117 @@ +package alternativa.engine3d.animation +{ + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class AnimationCouple extends AnimationNode + { + + private var _left:AnimationNode; + private var _right:AnimationNode; + public var balance:Number = 0.5; + + + override alternativa3d function update(_arg_1:Number, _arg_2:Number):void + { + var _local_3:Number = ((this.balance <= 0) ? 0 : ((this.balance >= 1) ? 1 : this.balance)); + if (this._left == null) + { + this._right.update((_arg_1 * speed), _arg_2); + } else + { + if (this._right == null) + { + this._left.update((_arg_1 * speed), _arg_2); + } else + { + this._left.update((_arg_1 * speed), ((1 - _local_3) * _arg_2)); + this._right.update((_arg_1 * speed), (_local_3 * _arg_2)); + }; + }; + } + + override alternativa3d function setController(_arg_1:AnimationController):void + { + this.controller = _arg_1; + if (this._left != null) + { + this._left.setController(_arg_1); + }; + if (this._right != null) + { + this._right.setController(_arg_1); + }; + } + + override alternativa3d function addNode(_arg_1:AnimationNode):void + { + super.addNode(_arg_1); + _arg_1._isActive = true; + } + + override alternativa3d function removeNode(_arg_1:AnimationNode):void + { + if (this._left == _arg_1) + { + this._left = null; + } else + { + this._right = null; + }; + super.removeNode(_arg_1); + } + + public function get left():AnimationNode + { + return (this._left); + } + + public function set left(_arg_1:AnimationNode):void + { + if (_arg_1 != this._left) + { + if (_arg_1._parent == this) + { + throw (new Error("Animation already exist in blender")); + }; + if (this._left != null) + { + this.removeNode(this._left); + }; + this._left = _arg_1; + if (_arg_1 != null) + { + this.addNode(_arg_1); + }; + }; + } + + public function get right():AnimationNode + { + return (this._right); + } + + public function set right(_arg_1:AnimationNode):void + { + if (_arg_1 != this._right) + { + if (_arg_1._parent == this) + { + throw (new Error("Animation already exist in blender")); + }; + if (this._right != null) + { + this.removeNode(this._right); + }; + this._right = _arg_1; + if (_arg_1 != null) + { + this.addNode(_arg_1); + }; + }; + } + + + } +}//package alternativa.engine3d.animation \ No newline at end of file diff --git a/src/alternativa/engine3d/animation/AnimationNode.as b/src/alternativa/engine3d/animation/AnimationNode.as new file mode 100644 index 0000000..133e554 --- /dev/null +++ b/src/alternativa/engine3d/animation/AnimationNode.as @@ -0,0 +1,54 @@ +package alternativa.engine3d.animation +{ + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class AnimationNode + { + + alternativa3d var _isActive:Boolean = false; + alternativa3d var _parent:AnimationNode; + alternativa3d var controller:AnimationController; + public var speed:Number = 1; + + + public function get isActive():Boolean + { + return ((this._isActive) && (!(this.controller == null))); + } + + public function get parent():AnimationNode + { + return (this._parent); + } + + alternativa3d function update(_arg_1:Number, _arg_2:Number):void + { + } + + alternativa3d function setController(_arg_1:AnimationController):void + { + this.controller = _arg_1; + } + + alternativa3d function addNode(_arg_1:AnimationNode):void + { + if (_arg_1._parent != null) + { + _arg_1._parent.removeNode(_arg_1); + }; + _arg_1._parent = this; + _arg_1.setController(this.controller); + } + + alternativa3d function removeNode(_arg_1:AnimationNode):void + { + _arg_1.setController(null); + _arg_1._isActive = false; + _arg_1._parent = null; + } + + + } +}//package alternativa.engine3d.animation \ No newline at end of file diff --git a/src/alternativa/engine3d/animation/AnimationNotify.as b/src/alternativa/engine3d/animation/AnimationNotify.as new file mode 100644 index 0000000..366d40d --- /dev/null +++ b/src/alternativa/engine3d/animation/AnimationNotify.as @@ -0,0 +1,29 @@ +package alternativa.engine3d.animation +{ + import flash.events.EventDispatcher; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class AnimationNotify extends EventDispatcher + { + + public var name:String; + alternativa3d var _time:Number = 0; + alternativa3d var next:AnimationNotify; + alternativa3d var updateTime:Number; + alternativa3d var processNext:AnimationNotify; + + public function AnimationNotify(_arg_1:String) + { + this.name = _arg_1; + } + + public function get time():Number + { + return (this._time); + } + + + } +}//package alternativa.engine3d.animation \ No newline at end of file diff --git a/src/alternativa/engine3d/animation/AnimationState.as b/src/alternativa/engine3d/animation/AnimationState.as new file mode 100644 index 0000000..ace0cc5 --- /dev/null +++ b/src/alternativa/engine3d/animation/AnimationState.as @@ -0,0 +1,261 @@ +package alternativa.engine3d.animation +{ + import alternativa.engine3d.animation.keys.TransformKey; + import alternativa.engine3d.core.Object3D; + import flash.geom.Vector3D; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class AnimationState + { + + public var useCount:int = 0; + public var transform:TransformKey = new TransformKey(); + public var transformWeightSum:Number = 0; + public var numbers:Object = new Object(); + public var numberWeightSums:Object = new Object(); + + + public function reset():void + { + var _local_1:String; + this.transformWeightSum = 0; + for (_local_1 in this.numbers) + { + delete this.numbers[_local_1]; + delete this.numberWeightSums[_local_1]; + }; + } + + public function addWeightedTransform(_arg_1:TransformKey, _arg_2:Number):void + { + this.transformWeightSum = (this.transformWeightSum + _arg_2); + this.transform.interpolate(this.transform, _arg_1, (_arg_2 / this.transformWeightSum)); + } + + public function addWeightedNumber(_arg_1:String, _arg_2:Number, _arg_3:Number):void + { + var _local_5:Number; + var _local_4:Number = this.numberWeightSums[_arg_1]; + if (_local_4 == _local_4) + { + _local_4 = (_local_4 + _arg_3); + _arg_3 = (_arg_3 / _local_4); + _local_5 = this.numbers[_arg_1]; + this.numbers[_arg_1] = (((1 - _arg_3) * _local_5) + (_arg_3 * _arg_2)); + this.numberWeightSums[_arg_1] = _local_4; + } else + { + this.numbers[_arg_1] = _arg_2; + this.numberWeightSums[_arg_1] = _arg_3; + }; + } + + public function apply(_arg_1:Object3D):void + { + var _local_2:Number; + var _local_3:Number; + var _local_4:String; + if (this.transformWeightSum > 0) + { + _arg_1.x = this.transform.x; + _arg_1.y = this.transform.y; + _arg_1.z = this.transform.z; + this.setEulerAngles(this.transform.rotation, _arg_1); + _arg_1.scaleX = this.transform.scaleX; + _arg_1.scaleY = this.transform.scaleY; + _arg_1.scaleZ = this.transform.scaleZ; + }; + for (_local_4 in this.numbers) + { + switch (_local_4) + { + case "x": + _local_2 = this.numberWeightSums["x"]; + _local_3 = (_local_2 / (_local_2 + this.transformWeightSum)); + _arg_1.x = (((1 - _local_3) * _arg_1.x) + (_local_3 * this.numbers["x"])); + break; + case "y": + _local_2 = this.numberWeightSums["y"]; + _local_3 = (_local_2 / (_local_2 + this.transformWeightSum)); + _arg_1.y = (((1 - _local_3) * _arg_1.y) + (_local_3 * this.numbers["y"])); + break; + case "z": + _local_2 = this.numberWeightSums["z"]; + _local_3 = (_local_2 / (_local_2 + this.transformWeightSum)); + _arg_1.z = (((1 - _local_3) * _arg_1.z) + (_local_3 * this.numbers["z"])); + break; + case "rotationX": + _local_2 = this.numberWeightSums["rotationX"]; + _local_3 = (_local_2 / (_local_2 + this.transformWeightSum)); + _arg_1.rotationX = (((1 - _local_3) * _arg_1.rotationX) + (_local_3 * this.numbers["rotationX"])); + break; + case "rotationY": + _local_2 = this.numberWeightSums["rotationY"]; + _local_3 = (_local_2 / (_local_2 + this.transformWeightSum)); + _arg_1.rotationY = (((1 - _local_3) * _arg_1.rotationY) + (_local_3 * this.numbers["rotationY"])); + break; + case "rotationZ": + _local_2 = this.numberWeightSums["rotationZ"]; + _local_3 = (_local_2 / (_local_2 + this.transformWeightSum)); + _arg_1.rotationZ = (((1 - _local_3) * _arg_1.rotationZ) + (_local_3 * this.numbers["rotationZ"])); + break; + case "scaleX": + _local_2 = this.numberWeightSums["scaleX"]; + _local_3 = (_local_2 / (_local_2 + this.transformWeightSum)); + _arg_1.scaleX = (((1 - _local_3) * _arg_1.scaleX) + (_local_3 * this.numbers["scaleX"])); + break; + case "scaleY": + _local_2 = this.numberWeightSums["scaleY"]; + _local_3 = (_local_2 / (_local_2 + this.transformWeightSum)); + _arg_1.scaleY = (((1 - _local_3) * _arg_1.scaleY) + (_local_3 * this.numbers["scaleY"])); + break; + case "scaleZ": + _local_2 = this.numberWeightSums["scaleZ"]; + _local_3 = (_local_2 / (_local_2 + this.transformWeightSum)); + _arg_1.scaleZ = (((1 - _local_3) * _arg_1.scaleZ) + (_local_3 * this.numbers["scaleZ"])); + break; + default: + _arg_1[_local_4] = this.numbers[_local_4]; + }; + }; + } + + public function applyObject(_arg_1:Object):void + { + var _local_2:Number; + var _local_3:Number; + var _local_4:String; + if (this.transformWeightSum > 0) + { + _arg_1.x = this.transform.x; + _arg_1.y = this.transform.y; + _arg_1.z = this.transform.z; + this.setEulerAnglesObject(this.transform.rotation, _arg_1); + _arg_1.scaleX = this.transform.scaleX; + _arg_1.scaleY = this.transform.scaleY; + _arg_1.scaleZ = this.transform.scaleZ; + }; + for (_local_4 in this.numbers) + { + switch (_local_4) + { + case "x": + _local_2 = this.numberWeightSums["x"]; + _local_3 = (_local_2 / (_local_2 + this.transformWeightSum)); + _arg_1.x = (((1 - _local_3) * _arg_1.x) + (_local_3 * this.numbers["x"])); + break; + case "y": + _local_2 = this.numberWeightSums["y"]; + _local_3 = (_local_2 / (_local_2 + this.transformWeightSum)); + _arg_1.y = (((1 - _local_3) * _arg_1.y) + (_local_3 * this.numbers["y"])); + break; + case "z": + _local_2 = this.numberWeightSums["z"]; + _local_3 = (_local_2 / (_local_2 + this.transformWeightSum)); + _arg_1.z = (((1 - _local_3) * _arg_1.z) + (_local_3 * this.numbers["z"])); + break; + case "rotationX": + _local_2 = this.numberWeightSums["rotationX"]; + _local_3 = (_local_2 / (_local_2 + this.transformWeightSum)); + _arg_1.rotationX = (((1 - _local_3) * _arg_1.rotationX) + (_local_3 * this.numbers["rotationX"])); + break; + case "rotationY": + _local_2 = this.numberWeightSums["rotationY"]; + _local_3 = (_local_2 / (_local_2 + this.transformWeightSum)); + _arg_1.rotationY = (((1 - _local_3) * _arg_1.rotationY) + (_local_3 * this.numbers["rotationY"])); + break; + case "rotationZ": + _local_2 = this.numberWeightSums["rotationZ"]; + _local_3 = (_local_2 / (_local_2 + this.transformWeightSum)); + _arg_1.rotationZ = (((1 - _local_3) * _arg_1.rotationZ) + (_local_3 * this.numbers["rotationZ"])); + break; + case "scaleX": + _local_2 = this.numberWeightSums["scaleX"]; + _local_3 = (_local_2 / (_local_2 + this.transformWeightSum)); + _arg_1.scaleX = (((1 - _local_3) * _arg_1.scaleX) + (_local_3 * this.numbers["scaleX"])); + break; + case "scaleY": + _local_2 = this.numberWeightSums["scaleY"]; + _local_3 = (_local_2 / (_local_2 + this.transformWeightSum)); + _arg_1.scaleY = (((1 - _local_3) * _arg_1.scaleY) + (_local_3 * this.numbers["scaleY"])); + break; + case "scaleZ": + _local_2 = this.numberWeightSums["scaleZ"]; + _local_3 = (_local_2 / (_local_2 + this.transformWeightSum)); + _arg_1.scaleZ = (((1 - _local_3) * _arg_1.scaleZ) + (_local_3 * this.numbers["scaleZ"])); + break; + default: + _arg_1[_local_4] = this.numbers[_local_4]; + }; + }; + } + + private function setEulerAngles(_arg_1:Vector3D, _arg_2:Object3D):void + { + var _local_3:Number = ((2 * _arg_1.x) * _arg_1.x); + var _local_4:Number = ((2 * _arg_1.y) * _arg_1.y); + var _local_5:Number = ((2 * _arg_1.z) * _arg_1.z); + var _local_6:Number = ((2 * _arg_1.x) * _arg_1.y); + var _local_7:Number = ((2 * _arg_1.y) * _arg_1.z); + var _local_8:Number = ((2 * _arg_1.z) * _arg_1.x); + var _local_9:Number = ((2 * _arg_1.w) * _arg_1.x); + var _local_10:Number = ((2 * _arg_1.w) * _arg_1.y); + var _local_11:Number = ((2 * _arg_1.w) * _arg_1.z); + var _local_12:Number = ((1 - _local_4) - _local_5); + var _local_13:Number = (_local_6 - _local_11); + var _local_14:Number = (_local_6 + _local_11); + var _local_15:Number = ((1 - _local_3) - _local_5); + var _local_16:Number = (_local_8 - _local_10); + var _local_17:Number = (_local_7 + _local_9); + var _local_18:Number = ((1 - _local_3) - _local_4); + if (((-1 < _local_16) && (_local_16 < 1))) + { + _arg_2.rotationX = Math.atan2(_local_17, _local_18); + _arg_2.rotationY = -(Math.asin(_local_16)); + _arg_2.rotationZ = Math.atan2(_local_14, _local_12); + } else + { + _arg_2.rotationX = 0; + _arg_2.rotationY = ((_local_16 <= -1) ? Math.PI : -(Math.PI)); + _arg_2.rotationY = (_arg_2.rotationY * 0.5); + _arg_2.rotationZ = Math.atan2(-(_local_13), _local_15); + }; + } + + private function setEulerAnglesObject(_arg_1:Vector3D, _arg_2:Object):void + { + var _local_3:Number = ((2 * _arg_1.x) * _arg_1.x); + var _local_4:Number = ((2 * _arg_1.y) * _arg_1.y); + var _local_5:Number = ((2 * _arg_1.z) * _arg_1.z); + var _local_6:Number = ((2 * _arg_1.x) * _arg_1.y); + var _local_7:Number = ((2 * _arg_1.y) * _arg_1.z); + var _local_8:Number = ((2 * _arg_1.z) * _arg_1.x); + var _local_9:Number = ((2 * _arg_1.w) * _arg_1.x); + var _local_10:Number = ((2 * _arg_1.w) * _arg_1.y); + var _local_11:Number = ((2 * _arg_1.w) * _arg_1.z); + var _local_12:Number = ((1 - _local_4) - _local_5); + var _local_13:Number = (_local_6 - _local_11); + var _local_14:Number = (_local_6 + _local_11); + var _local_15:Number = ((1 - _local_3) - _local_5); + var _local_16:Number = (_local_8 - _local_10); + var _local_17:Number = (_local_7 + _local_9); + var _local_18:Number = ((1 - _local_3) - _local_4); + if (((-1 < _local_16) && (_local_16 < 1))) + { + _arg_2.rotationX = Math.atan2(_local_17, _local_18); + _arg_2.rotationY = -(Math.asin(_local_16)); + _arg_2.rotationZ = Math.atan2(_local_14, _local_12); + } else + { + _arg_2.rotationX = 0; + _arg_2.rotationY = ((_local_16 <= -1) ? Math.PI : -(Math.PI)); + _arg_2.rotationY = (_arg_2.rotationY * 0.5); + _arg_2.rotationZ = Math.atan2(-(_local_13), _local_15); + }; + } + + + } +}//package alternativa.engine3d.animation \ No newline at end of file diff --git a/src/alternativa/engine3d/animation/AnimationSwitcher.as b/src/alternativa/engine3d/animation/AnimationSwitcher.as new file mode 100644 index 0000000..7d92ba9 --- /dev/null +++ b/src/alternativa/engine3d/animation/AnimationSwitcher.as @@ -0,0 +1,176 @@ +package alternativa.engine3d.animation +{ + import __AS3__.vec.Vector; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class AnimationSwitcher extends AnimationNode + { + + private var _numAnimations:int = 0; + private var _animations:Vector. = new Vector.(); + private var _weights:Vector. = new Vector.(); + private var _active:AnimationNode; + private var fadingSpeed:Number = 0; + + + override alternativa3d function update(_arg_1:Number, _arg_2:Number):void + { + var _local_6:AnimationNode; + var _local_7:Number; + var _local_3:Number = (speed * _arg_1); + var _local_4:Number = (this.fadingSpeed * _local_3); + var _local_5:int; + while (_local_5 < this._numAnimations) + { + _local_6 = this._animations[_local_5]; + _local_7 = this._weights[_local_5]; + if (_local_6 == this._active) + { + _local_7 = (_local_7 + _local_4); + _local_7 = ((_local_7 >= 1) ? 1 : _local_7); + _local_6.update(_local_3, (_arg_2 * _local_7)); + this._weights[_local_5] = _local_7; + } else + { + _local_7 = (_local_7 - _local_4); + if (_local_7 > 0) + { + _local_6.update(_local_3, (_arg_2 * _local_7)); + this._weights[_local_5] = _local_7; + } else + { + _local_6._isActive = false; + this._weights[_local_5] = 0; + }; + }; + _local_5++; + }; + } + + public function get active():AnimationNode + { + return (this._active); + } + + public function activate(_arg_1:AnimationNode, _arg_2:Number=0):void + { + var _local_3:int; + if (_arg_1._parent != this) + { + throw (new Error("Animation is not child of this blender")); + }; + this._active = _arg_1; + _arg_1._isActive = true; + if (_arg_2 <= 0) + { + _local_3 = 0; + while (_local_3 < this._numAnimations) + { + if (this._animations[_local_3] == _arg_1) + { + this._weights[_local_3] = 1; + } else + { + this._weights[_local_3] = 0; + this._animations[_local_3]._isActive = false; + }; + _local_3++; + }; + this.fadingSpeed = 0; + } else + { + this.fadingSpeed = (1 / _arg_2); + }; + } + + override alternativa3d function setController(_arg_1:AnimationController):void + { + var _local_3:AnimationNode; + this.controller = _arg_1; + var _local_2:int; + while (_local_2 < this._numAnimations) + { + _local_3 = this._animations[_local_2]; + _local_3.setController(controller); + _local_2++; + }; + } + + override alternativa3d function removeNode(_arg_1:AnimationNode):void + { + this.removeAnimation(_arg_1); + } + + public function addAnimation(_arg_1:AnimationNode):AnimationNode + { + if (_arg_1 == null) + { + throw (new Error("Animation cannot be null")); + }; + if (_arg_1._parent == this) + { + throw (new Error("Animation already exist in blender")); + }; + this._animations[this._numAnimations] = _arg_1; + if (this._numAnimations == 0) + { + this._active = _arg_1; + _arg_1._isActive = true; + this._weights[this._numAnimations] = 1; + } else + { + this._weights[this._numAnimations] = 0; + }; + this._numAnimations++; + addNode(_arg_1); + return (_arg_1); + } + + public function removeAnimation(_arg_1:AnimationNode):AnimationNode + { + var _local_2:int = this._animations.indexOf(_arg_1); + if (_local_2 < 0) + { + throw (new ArgumentError("Animation not found")); + }; + this._numAnimations--; + var _local_3:int = (_local_2 + 1); + while (_local_2 < this._numAnimations) + { + this._animations[_local_2] = this._animations[_local_3]; + _local_2++; + _local_3++; + }; + this._animations.length = this._numAnimations; + this._weights.length = this._numAnimations; + if (this._active == _arg_1) + { + if (this._numAnimations > 0) + { + this._active = this._animations[int((this._numAnimations - 1))]; + this._weights[int((this._numAnimations - 1))] = 1; + } else + { + this._active = null; + }; + }; + super.removeNode(_arg_1); + return (_arg_1); + } + + public function getAnimationAt(_arg_1:int):AnimationNode + { + return (this._animations[_arg_1]); + } + + public function numAnimations():int + { + return (this._numAnimations); + } + + + } +}//package alternativa.engine3d.animation \ No newline at end of file diff --git a/src/alternativa/engine3d/animation/events/NotifyEvent.as b/src/alternativa/engine3d/animation/events/NotifyEvent.as new file mode 100644 index 0000000..8519b39 --- /dev/null +++ b/src/alternativa/engine3d/animation/events/NotifyEvent.as @@ -0,0 +1,23 @@ +package alternativa.engine3d.animation.events +{ + import flash.events.Event; + import alternativa.engine3d.animation.AnimationNotify; + + public class NotifyEvent extends Event + { + + public static const NOTIFY:String = "notify"; + + public function NotifyEvent(_arg_1:AnimationNotify) + { + super(NOTIFY); + } + + public function get notify():AnimationNotify + { + return (AnimationNotify(target)); + } + + + } +}//package alternativa.engine3d.animation.events \ No newline at end of file diff --git a/src/alternativa/engine3d/animation/keys/Keyframe.as b/src/alternativa/engine3d/animation/keys/Keyframe.as new file mode 100644 index 0000000..9843b86 --- /dev/null +++ b/src/alternativa/engine3d/animation/keys/Keyframe.as @@ -0,0 +1,43 @@ +package alternativa.engine3d.animation.keys +{ + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class Keyframe + { + + alternativa3d var _time:Number = 0; + + + public function get time():Number + { + return (this._time); + } + + public function get value():Object + { + return (null); + } + + public function set value(_arg_1:Object):void + { + } + + alternativa3d function get nextKeyFrame():Keyframe + { + return (null); + } + + alternativa3d function set nextKeyFrame(_arg_1:Keyframe):void + { + } + + public function toString():String + { + return (((("[Keyframe time = " + this._time.toFixed(2)) + " value = ") + this.value) + "]"); + } + + + } +}//package alternativa.engine3d.animation.keys \ No newline at end of file diff --git a/src/alternativa/engine3d/animation/keys/NumberKey.as b/src/alternativa/engine3d/animation/keys/NumberKey.as new file mode 100644 index 0000000..b9d9364 --- /dev/null +++ b/src/alternativa/engine3d/animation/keys/NumberKey.as @@ -0,0 +1,41 @@ +package alternativa.engine3d.animation.keys +{ + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class NumberKey extends Keyframe + { + + alternativa3d var _value:Number = 0; + alternativa3d var next:NumberKey; + + + public function interpolate(_arg_1:NumberKey, _arg_2:NumberKey, _arg_3:Number):void + { + this._value = (((1 - _arg_3) * _arg_1._value) + (_arg_3 * _arg_2._value)); + } + + override public function get value():Object + { + return (this._value); + } + + override public function set value(_arg_1:Object):void + { + this._value = Number(_arg_1); + } + + override alternativa3d function get nextKeyFrame():Keyframe + { + return (this.next); + } + + override alternativa3d function set nextKeyFrame(_arg_1:Keyframe):void + { + this.next = NumberKey(_arg_1); + } + + + } +}//package alternativa.engine3d.animation.keys \ No newline at end of file diff --git a/src/alternativa/engine3d/animation/keys/NumberTrack.as b/src/alternativa/engine3d/animation/keys/NumberTrack.as new file mode 100644 index 0000000..4d17d71 --- /dev/null +++ b/src/alternativa/engine3d/animation/keys/NumberTrack.as @@ -0,0 +1,92 @@ +package alternativa.engine3d.animation.keys +{ + import alternativa.engine3d.animation.AnimationState; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class NumberTrack extends Track + { + + private static var temp:NumberKey = new NumberKey(); + + alternativa3d var keyList:NumberKey; + public var property:String; + + public function NumberTrack(_arg_1:String, _arg_2:String) + { + this.property = _arg_2; + this.object = _arg_1; + } + + override alternativa3d function get keyFramesList():Keyframe + { + return (this.keyList); + } + + override alternativa3d function set keyFramesList(_arg_1:Keyframe):void + { + this.keyList = NumberKey(_arg_1); + } + + public function addKey(_arg_1:Number, _arg_2:Number=0):Keyframe + { + var _local_3:NumberKey = new NumberKey(); + _local_3._time = _arg_1; + _local_3.value = _arg_2; + addKeyToList(_local_3); + return (_local_3); + } + + override alternativa3d function blend(_arg_1:Number, _arg_2:Number, _arg_3:AnimationState):void + { + var _local_4:NumberKey; + if (this.property == null) + { + return; + }; + var _local_5:NumberKey = this.keyList; + while (((!(_local_5 == null)) && (_local_5._time < _arg_1))) + { + _local_4 = _local_5; + _local_5 = _local_5.next; + }; + if (_local_4 != null) + { + if (_local_5 != null) + { + temp.interpolate(_local_4, _local_5, ((_arg_1 - _local_4._time) / (_local_5._time - _local_4._time))); + _arg_3.addWeightedNumber(this.property, temp._value, _arg_2); + } else + { + _arg_3.addWeightedNumber(this.property, _local_4._value, _arg_2); + }; + } else + { + if (_local_5 != null) + { + _arg_3.addWeightedNumber(this.property, _local_5._value, _arg_2); + }; + }; + } + + override alternativa3d function createKeyFrame():Keyframe + { + return (new NumberKey()); + } + + override alternativa3d function interpolateKeyFrame(_arg_1:Keyframe, _arg_2:Keyframe, _arg_3:Keyframe, _arg_4:Number):void + { + NumberKey(_arg_1).interpolate(NumberKey(_arg_2), NumberKey(_arg_3), _arg_4); + } + + override public function slice(_arg_1:Number, _arg_2:Number=1.79769313486232E308):Track + { + var _local_3:NumberTrack = new NumberTrack(object, this.property); + sliceImplementation(_local_3, _arg_1, _arg_2); + return (_local_3); + } + + + } +}//package alternativa.engine3d.animation.keys \ No newline at end of file diff --git a/src/alternativa/engine3d/animation/keys/Track.as b/src/alternativa/engine3d/animation/keys/Track.as new file mode 100644 index 0000000..056ea52 --- /dev/null +++ b/src/alternativa/engine3d/animation/keys/Track.as @@ -0,0 +1,193 @@ +package alternativa.engine3d.animation.keys +{ + import __AS3__.vec.Vector; + import alternativa.engine3d.animation.AnimationState; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class Track + { + + public var object:String; + alternativa3d var _length:Number = 0; + + + public function get length():Number + { + return (this._length); + } + + alternativa3d function get keyFramesList():Keyframe + { + return (null); + } + + alternativa3d function set keyFramesList(_arg_1:Keyframe):void + { + } + + alternativa3d function addKeyToList(_arg_1:Keyframe):void + { + var _local_3:Keyframe; + var _local_2:Number = _arg_1._time; + if (this.keyFramesList == null) + { + this.keyFramesList = _arg_1; + this._length = ((_local_2 <= 0) ? 0 : _local_2); + return; + }; + if (this.keyFramesList._time > _local_2) + { + _arg_1.nextKeyFrame = this.keyFramesList; + this.keyFramesList = _arg_1; + return; + }; + _local_3 = this.keyFramesList; + while (((!(_local_3.nextKeyFrame == null)) && (_local_3.nextKeyFrame._time <= _local_2))) + { + _local_3 = _local_3.nextKeyFrame; + }; + if (_local_3.nextKeyFrame == null) + { + _local_3.nextKeyFrame = _arg_1; + this._length = ((_local_2 <= 0) ? 0 : _local_2); + } else + { + _arg_1.nextKeyFrame = _local_3.nextKeyFrame; + _local_3.nextKeyFrame = _arg_1; + }; + } + + public function removeKey(_arg_1:Keyframe):Keyframe + { + var _local_2:Keyframe; + if (this.keyFramesList != null) + { + if (this.keyFramesList == _arg_1) + { + this.keyFramesList = this.keyFramesList.nextKeyFrame; + if (this.keyFramesList == null) + { + this._length = 0; + }; + return (_arg_1); + }; + _local_2 = this.keyFramesList; + while (((!(_local_2.nextKeyFrame == null)) && (!(_local_2.nextKeyFrame == _arg_1)))) + { + _local_2 = _local_2.nextKeyFrame; + }; + if (_local_2.nextKeyFrame == _arg_1) + { + if (_arg_1.nextKeyFrame == null) + { + this._length = ((_local_2._time <= 0) ? 0 : _local_2._time); + }; + _local_2.nextKeyFrame = _arg_1.nextKeyFrame; + return (_arg_1); + }; + }; + throw (new Error("Key not found")); + } + + public function get keys():Vector. + { + var _local_1:Vector. = new Vector.(); + var _local_2:int; + var _local_3:Keyframe = this.keyFramesList; + while (_local_3 != null) + { + _local_1[_local_2] = _local_3; + _local_2++; + _local_3 = _local_3.nextKeyFrame; + }; + return (_local_1); + } + + alternativa3d function blend(_arg_1:Number, _arg_2:Number, _arg_3:AnimationState):void + { + } + + public function slice(_arg_1:Number, _arg_2:Number=1.79769313486232E308):Track + { + return (null); + } + + alternativa3d function createKeyFrame():Keyframe + { + return (null); + } + + alternativa3d function interpolateKeyFrame(_arg_1:Keyframe, _arg_2:Keyframe, _arg_3:Keyframe, _arg_4:Number):void + { + } + + alternativa3d function sliceImplementation(_arg_1:Track, _arg_2:Number, _arg_3:Number):void + { + var _local_5:Keyframe; + var _local_8:Keyframe; + var _local_4:Number = ((_arg_2 > 0) ? _arg_2 : 0); + var _local_6:Keyframe = this.keyFramesList; + var _local_7:Keyframe = this.createKeyFrame(); + while (((!(_local_6 == null)) && (_local_6._time <= _arg_2))) + { + _local_5 = _local_6; + _local_6 = _local_6.nextKeyFrame; + }; + if (_local_5 != null) + { + if (_local_6 != null) + { + this.interpolateKeyFrame(_local_7, _local_5, _local_6, ((_arg_2 - _local_5._time) / (_local_6._time - _local_5._time))); + _local_7._time = (_arg_2 - _local_4); + } else + { + this.interpolateKeyFrame(_local_7, _local_7, _local_5, 1); + }; + } else + { + if (_local_6 != null) + { + this.interpolateKeyFrame(_local_7, _local_7, _local_6, 1); + _local_7._time = (_local_6._time - _local_4); + _local_5 = _local_6; + _local_6 = _local_6.nextKeyFrame; + } else + { + return; + }; + }; + _arg_1.keyFramesList = _local_7; + if (((_local_6 == null) || (_arg_3 <= _arg_2))) + { + _arg_1._length = ((_local_7._time <= 0) ? 0 : _local_7._time); + return; + }; + while (((!(_local_6 == null)) && (_local_6._time <= _arg_3))) + { + _local_8 = this.createKeyFrame(); + this.interpolateKeyFrame(_local_8, _local_8, _local_6, 1); + _local_8._time = (_local_6._time - _local_4); + _local_7.nextKeyFrame = _local_8; + _local_7 = _local_8; + _local_5 = _local_6; + _local_6 = _local_6.nextKeyFrame; + }; + if (_local_6 != null) + { + _local_8 = this.createKeyFrame(); + this.interpolateKeyFrame(_local_8, _local_5, _local_6, ((_arg_3 - _local_5._time) / (_local_6._time - _local_5._time))); + _local_8._time = (_arg_3 - _local_4); + _local_7.nextKeyFrame = _local_8; + }; + if (_local_8 != null) + { + _arg_1._length = ((_local_8._time <= 0) ? 0 : _local_8._time); + }; + } + + + } +}//package alternativa.engine3d.animation.keys \ No newline at end of file diff --git a/src/alternativa/engine3d/animation/keys/TransformKey.as b/src/alternativa/engine3d/animation/keys/TransformKey.as new file mode 100644 index 0000000..bfd082e --- /dev/null +++ b/src/alternativa/engine3d/animation/keys/TransformKey.as @@ -0,0 +1,114 @@ +package alternativa.engine3d.animation.keys +{ + import flash.geom.Vector3D; + import flash.geom.Matrix3D; + import flash.geom.Orientation3D; + import __AS3__.vec.Vector; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class TransformKey extends Keyframe + { + + alternativa3d var x:Number = 0; + alternativa3d var y:Number = 0; + alternativa3d var z:Number = 0; + alternativa3d var rotation:Vector3D = new Vector3D(0, 0, 0, 1); + alternativa3d var scaleX:Number = 1; + alternativa3d var scaleY:Number = 1; + alternativa3d var scaleZ:Number = 1; + alternativa3d var next:TransformKey; + + + override public function get value():Object + { + var _local_1:Matrix3D = new Matrix3D(); + _local_1.recompose(Vector.([new Vector3D(this.x, this.y, this.z), this.rotation, new Vector3D(this.scaleX, this.scaleY, this.scaleZ)]), Orientation3D.QUATERNION); + return (_local_1); + } + + override public function set value(_arg_1:Object):void + { + var _local_2:Matrix3D = Matrix3D(_arg_1); + var _local_3:Vector. = _local_2.decompose(Orientation3D.QUATERNION); + this.x = _local_3[0].x; + this.y = _local_3[0].y; + this.z = _local_3[0].z; + this.rotation = _local_3[1]; + this.scaleX = _local_3[2].x; + this.scaleY = _local_3[2].y; + this.scaleZ = _local_3[2].z; + } + + public function interpolate(_arg_1:TransformKey, _arg_2:TransformKey, _arg_3:Number):void + { + var _local_4:Number = (1 - _arg_3); + this.x = ((_local_4 * _arg_1.x) + (_arg_3 * _arg_2.x)); + this.y = ((_local_4 * _arg_1.y) + (_arg_3 * _arg_2.y)); + this.z = ((_local_4 * _arg_1.z) + (_arg_3 * _arg_2.z)); + this.slerp(_arg_1.rotation, _arg_2.rotation, _arg_3, this.rotation); + this.scaleX = ((_local_4 * _arg_1.scaleX) + (_arg_3 * _arg_2.scaleX)); + this.scaleY = ((_local_4 * _arg_1.scaleY) + (_arg_3 * _arg_2.scaleY)); + this.scaleZ = ((_local_4 * _arg_1.scaleZ) + (_arg_3 * _arg_2.scaleZ)); + } + + private function slerp(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Number, _arg_4:Vector3D):void + { + var _local_7:Number; + var _local_8:Number; + var _local_9:Number; + var _local_10:Number; + var _local_11:Number; + var _local_12:Number; + var _local_13:Number; + var _local_5:Number = 1; + var _local_6:Number = ((((_arg_1.w * _arg_2.w) + (_arg_1.x * _arg_2.x)) + (_arg_1.y * _arg_2.y)) + (_arg_1.z * _arg_2.z)); + if (_local_6 < 0) + { + _local_6 = -(_local_6); + _local_5 = -1; + }; + if ((1 - _local_6) < 0.001) + { + _local_7 = (1 - _arg_3); + _local_8 = (_arg_3 * _local_5); + _arg_4.w = ((_arg_1.w * _local_7) + (_arg_2.w * _local_8)); + _arg_4.x = ((_arg_1.x * _local_7) + (_arg_2.x * _local_8)); + _arg_4.y = ((_arg_1.y * _local_7) + (_arg_2.y * _local_8)); + _arg_4.z = ((_arg_1.z * _local_7) + (_arg_2.z * _local_8)); + _local_9 = ((((_arg_4.w * _arg_4.w) + (_arg_4.x * _arg_4.x)) + (_arg_4.y * _arg_4.y)) + (_arg_4.z * _arg_4.z)); + if (_local_9 == 0) + { + _arg_4.w = 1; + } else + { + _arg_4.scaleBy((1 / Math.sqrt(_local_9))); + }; + } else + { + _local_10 = Math.acos(_local_6); + _local_11 = Math.sin(_local_10); + _local_12 = (Math.sin(((1 - _arg_3) * _local_10)) / _local_11); + _local_13 = ((Math.sin((_arg_3 * _local_10)) / _local_11) * _local_5); + _arg_4.w = ((_arg_1.w * _local_12) + (_arg_2.w * _local_13)); + _arg_4.x = ((_arg_1.x * _local_12) + (_arg_2.x * _local_13)); + _arg_4.y = ((_arg_1.y * _local_12) + (_arg_2.y * _local_13)); + _arg_4.z = ((_arg_1.z * _local_12) + (_arg_2.z * _local_13)); + }; + } + + override alternativa3d function get nextKeyFrame():Keyframe + { + return (this.next); + } + + override alternativa3d function set nextKeyFrame(_arg_1:Keyframe):void + { + this.next = TransformKey(_arg_1); + } + + + } +}//package alternativa.engine3d.animation.keys \ No newline at end of file diff --git a/src/alternativa/engine3d/animation/keys/TransformTrack.as b/src/alternativa/engine3d/animation/keys/TransformTrack.as new file mode 100644 index 0000000..f50477e --- /dev/null +++ b/src/alternativa/engine3d/animation/keys/TransformTrack.as @@ -0,0 +1,164 @@ +package alternativa.engine3d.animation.keys +{ + import flash.geom.Vector3D; + import flash.geom.Orientation3D; + import __AS3__.vec.Vector; + import flash.geom.Matrix3D; + import alternativa.engine3d.animation.AnimationState; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class TransformTrack extends Track + { + + private static var tempQuat:Vector3D = new Vector3D(); + private static var temp:TransformKey = new TransformKey(); + + private var keyList:TransformKey; + + public function TransformTrack(_arg_1:String) + { + this.object = _arg_1; + } + + override alternativa3d function get keyFramesList():Keyframe + { + return (this.keyList); + } + + override alternativa3d function set keyFramesList(_arg_1:Keyframe):void + { + this.keyList = TransformKey(_arg_1); + } + + public function addKey(_arg_1:Number, _arg_2:Matrix3D):TransformKey + { + var _local_3:TransformKey; + _local_3 = new TransformKey(); + _local_3._time = _arg_1; + var _local_4:Vector. = _arg_2.decompose(Orientation3D.QUATERNION); + _local_3.x = _local_4[0].x; + _local_3.y = _local_4[0].y; + _local_3.z = _local_4[0].z; + _local_3.rotation = _local_4[1]; + _local_3.scaleX = _local_4[2].x; + _local_3.scaleY = _local_4[2].y; + _local_3.scaleZ = _local_4[2].z; + addKeyToList(_local_3); + return (_local_3); + } + + public function addKeyComponents(_arg_1:Number, _arg_2:Number=0, _arg_3:Number=0, _arg_4:Number=0, _arg_5:Number=0, _arg_6:Number=0, _arg_7:Number=0, _arg_8:Number=1, _arg_9:Number=1, _arg_10:Number=1):TransformKey + { + var _local_11:TransformKey = new TransformKey(); + _local_11._time = _arg_1; + _local_11.x = _arg_2; + _local_11.y = _arg_3; + _local_11.z = _arg_4; + _local_11.rotation = this.createQuatFromEuler(_arg_5, _arg_6, _arg_7); + _local_11.scaleX = _arg_8; + _local_11.scaleY = _arg_9; + _local_11.scaleZ = _arg_10; + addKeyToList(_local_11); + return (_local_11); + } + + private function appendQuat(_arg_1:Vector3D, _arg_2:Vector3D):void + { + var _local_3:Number = ((((_arg_2.w * _arg_1.w) - (_arg_2.x * _arg_1.x)) - (_arg_2.y * _arg_1.y)) - (_arg_2.z * _arg_1.z)); + var _local_4:Number = ((((_arg_2.w * _arg_1.x) + (_arg_2.x * _arg_1.w)) + (_arg_2.y * _arg_1.z)) - (_arg_2.z * _arg_1.y)); + var _local_5:Number = ((((_arg_2.w * _arg_1.y) + (_arg_2.y * _arg_1.w)) + (_arg_2.z * _arg_1.x)) - (_arg_2.x * _arg_1.z)); + var _local_6:Number = ((((_arg_2.w * _arg_1.z) + (_arg_2.z * _arg_1.w)) + (_arg_2.x * _arg_1.y)) - (_arg_2.y * _arg_1.x)); + _arg_1.w = _local_3; + _arg_1.x = _local_4; + _arg_1.y = _local_5; + _arg_1.z = _local_6; + } + + private function normalizeQuat(_arg_1:Vector3D):void + { + var _local_2:Number = ((((_arg_1.w * _arg_1.w) + (_arg_1.x * _arg_1.x)) + (_arg_1.y * _arg_1.y)) + (_arg_1.z * _arg_1.z)); + if (_local_2 == 0) + { + _arg_1.w = 1; + } else + { + _local_2 = (1 / Math.sqrt(_local_2)); + _arg_1.w = (_arg_1.w * _local_2); + _arg_1.x = (_arg_1.x * _local_2); + _arg_1.y = (_arg_1.y * _local_2); + _arg_1.z = (_arg_1.z * _local_2); + }; + } + + private function setQuatFromAxisAngle(_arg_1:Vector3D, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number):void + { + _arg_1.w = Math.cos((0.5 * _arg_5)); + var _local_6:Number = (Math.sin((0.5 * _arg_5)) / Math.sqrt((((_arg_2 * _arg_2) + (_arg_3 * _arg_3)) + (_arg_4 * _arg_4)))); + _arg_1.x = (_arg_2 * _local_6); + _arg_1.y = (_arg_3 * _local_6); + _arg_1.z = (_arg_4 * _local_6); + } + + private function createQuatFromEuler(_arg_1:Number, _arg_2:Number, _arg_3:Number):Vector3D + { + var _local_4:Vector3D = new Vector3D(); + this.setQuatFromAxisAngle(_local_4, 1, 0, 0, _arg_1); + this.setQuatFromAxisAngle(tempQuat, 0, 1, 0, _arg_2); + this.appendQuat(_local_4, tempQuat); + this.normalizeQuat(_local_4); + this.setQuatFromAxisAngle(tempQuat, 0, 0, 1, _arg_3); + this.appendQuat(_local_4, tempQuat); + this.normalizeQuat(_local_4); + return (_local_4); + } + + override alternativa3d function blend(_arg_1:Number, _arg_2:Number, _arg_3:AnimationState):void + { + var _local_4:TransformKey; + var _local_5:TransformKey = this.keyList; + while (((!(_local_5 == null)) && (_local_5._time < _arg_1))) + { + _local_4 = _local_5; + _local_5 = _local_5.next; + }; + if (_local_4 != null) + { + if (_local_5 != null) + { + temp.interpolate(_local_4, _local_5, ((_arg_1 - _local_4._time) / (_local_5._time - _local_4._time))); + _arg_3.addWeightedTransform(temp, _arg_2); + } else + { + _arg_3.addWeightedTransform(_local_4, _arg_2); + }; + } else + { + if (_local_5 != null) + { + _arg_3.addWeightedTransform(_local_5, _arg_2); + }; + }; + } + + override alternativa3d function createKeyFrame():Keyframe + { + return (new TransformKey()); + } + + override alternativa3d function interpolateKeyFrame(_arg_1:Keyframe, _arg_2:Keyframe, _arg_3:Keyframe, _arg_4:Number):void + { + TransformKey(_arg_1).interpolate(TransformKey(_arg_2), TransformKey(_arg_3), _arg_4); + } + + override public function slice(_arg_1:Number, _arg_2:Number=1.79769313486232E308):Track + { + var _local_3:TransformTrack = new TransformTrack(object); + sliceImplementation(_local_3, _arg_1, _arg_2); + return (_local_3); + } + + + } +}//package alternativa.engine3d.animation.keys \ No newline at end of file diff --git a/src/alternativa/engine3d/containers/BSPContainer.as b/src/alternativa/engine3d/containers/BSPContainer.as new file mode 100644 index 0000000..a380517 --- /dev/null +++ b/src/alternativa/engine3d/containers/BSPContainer.as @@ -0,0 +1,3429 @@ +package alternativa.engine3d.containers +{ + import flash.geom.Vector3D; + import alternativa.engine3d.core.Vertex; + import alternativa.engine3d.core.Face; + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.objects.Mesh; + import __AS3__.vec.Vector; + import alternativa.engine3d.core.RayIntersectionData; + import flash.utils.Dictionary; + import alternativa.engine3d.core.Camera3D; + import alternativa.engine3d.core.Wrapper; + import alternativa.engine3d.core.Object3DContainer; + import alternativa.engine3d.core.VG; + import alternativa.engine3d.core.Debug; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class BSPContainer extends ConflictContainer + { + + private static const treeSphere:Vector3D = new Vector3D(); + + public var clipping:int = 2; + public var debugAlphaFade:Number = 0.8; + alternativa3d var root:BSPNode; + alternativa3d var vertexList:Vertex; + private var nearPlaneX:Number; + private var nearPlaneY:Number; + private var nearPlaneZ:Number; + private var nearPlaneOffset:Number; + private var farPlaneX:Number; + private var farPlaneY:Number; + private var farPlaneZ:Number; + private var farPlaneOffset:Number; + private var leftPlaneX:Number; + private var leftPlaneY:Number; + private var leftPlaneZ:Number; + private var leftPlaneOffset:Number; + private var rightPlaneX:Number; + private var rightPlaneY:Number; + private var rightPlaneZ:Number; + private var rightPlaneOffset:Number; + private var topPlaneX:Number; + private var topPlaneY:Number; + private var topPlaneZ:Number; + private var topPlaneOffset:Number; + private var bottomPlaneX:Number; + private var bottomPlaneY:Number; + private var bottomPlaneZ:Number; + private var bottomPlaneOffset:Number; + private var directionX:Number; + private var directionY:Number; + private var directionZ:Number; + private var viewAngle:Number; + + + public function createTree(_arg_1:Vector., _arg_2:Vector.=null, _arg_3:Boolean=false, _arg_4:Vector.=null):void + { + var _local_5:int; + var _local_6:int; + var _local_7:Face; + var _local_8:Face; + var _local_9:Object3D; + var _local_10:Object3D; + var _local_11:Object3D; + var _local_12:Object3D; + this.destroyTree(); + if (_arg_2 != null) + { + _local_6 = _arg_2.length; + _local_5 = (_local_6 - 1); + while (_local_5 >= 0) + { + _local_7 = this.calculateFaceList(((_arg_3) ? _arg_2[_local_5] : Mesh(_arg_2[_local_5].clone())), false, _local_7); + _local_5--; + }; + }; + _local_6 = _arg_1.length; + _local_5 = (_local_6 - 1); + while (_local_5 >= 0) + { + _local_8 = this.calculateFaceList(((_arg_3) ? _arg_1[_local_5] : Mesh(_arg_1[_local_5].clone())), true, _local_8); + _local_5--; + }; + if (_arg_4 != null) + { + _local_6 = _arg_4.length; + _local_5 = 0; + while (_local_5 < _local_6) + { + _local_11 = _arg_4[_local_5]; + _local_11 = _local_11.clone(); + _local_11.setParent(this); + this.calculateObjectBounds(_local_11); + _local_12 = this.createObjectBounds(_local_11); + if (_local_12.boundMinX <= _local_12.boundMaxX) + { + _local_11.next = _local_9; + _local_9 = _local_11; + _local_12.next = _local_10; + _local_10 = _local_12; + }; + _local_5++; + }; + }; + if ((((!(_local_8 == null)) || (!(_local_9 == null))) || (!(_local_7 == null)))) + { + this.root = this.createNode(_local_7, _local_8, _local_9, _local_10, new Vector.(3), new Vector.(4)); + }; + } + + public function destroyTree():void + { + if (this.root != null) + { + this.vertexList = null; + this.destroyNode(this.root); + this.root = null; + }; + } + + override public function intersectRay(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Dictionary=null, _arg_4:Camera3D=null):RayIntersectionData + { + var _local_6:RayIntersectionData; + if (((!(_arg_3 == null)) && (_arg_3[this]))) + { + return (null); + }; + if ((!(boundIntersectRay(_arg_1, _arg_2, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ)))) + { + return (null); + }; + var _local_5:RayIntersectionData = super.intersectRay(_arg_1, _arg_2, _arg_3, _arg_4); + if (((!(this.root == null)) && (boundIntersectRay(_arg_1, _arg_2, this.root.boundMinX, this.root.boundMinY, this.root.boundMinZ, this.root.boundMaxX, this.root.boundMaxY, this.root.boundMaxZ)))) + { + _local_6 = this.intersectRayNode(this.root, _arg_1, _arg_2, _arg_3, _arg_4); + if (((!(_local_6 == null)) && ((_local_5 == null) || (_local_6.time < _local_5.time)))) + { + _local_5 = _local_6; + }; + }; + return (_local_5); + } + + private function intersectRayNode(_arg_1:BSPNode, _arg_2:Vector3D, _arg_3:Vector3D, _arg_4:Dictionary, _arg_5:Camera3D):RayIntersectionData + { + var _local_6:RayIntersectionData; + var _local_7:Number; + var _local_8:Number; + var _local_9:Number; + var _local_10:Number; + var _local_11:Number; + var _local_12:Number; + var _local_13:Number; + var _local_14:Number; + var _local_15:Number; + var _local_16:Face; + var _local_17:Wrapper; + var _local_18:Vertex; + var _local_19:Vertex; + var _local_20:Number; + var _local_21:Number; + var _local_22:Number; + var _local_23:Number; + var _local_24:Number; + var _local_25:Number; + var _local_26:Vector3D; + var _local_27:Vector3D; + var _local_28:Number; + var _local_29:RayIntersectionData; + var _local_30:Object3D; + if (_arg_1.objectList == null) + { + _local_7 = _arg_1.normalX; + _local_8 = _arg_1.normalY; + _local_9 = _arg_1.normalZ; + _local_10 = ((((_local_7 * _arg_2.x) + (_local_8 * _arg_2.y)) + (_local_9 * _arg_2.z)) - _arg_1.offset); + if (_local_10 > 0) + { + if (((!(_arg_1.positive == null)) && (boundIntersectRay(_arg_2, _arg_3, _arg_1.positive.boundMinX, _arg_1.positive.boundMinY, _arg_1.positive.boundMinZ, _arg_1.positive.boundMaxX, _arg_1.positive.boundMaxY, _arg_1.positive.boundMaxZ)))) + { + _local_6 = this.intersectRayNode(_arg_1.positive, _arg_2, _arg_3, _arg_4, _arg_5); + if (_local_6 != null) + { + return (_local_6); + }; + }; + _local_11 = (((_arg_3.x * _local_7) + (_arg_3.y * _local_8)) + (_arg_3.z * _local_9)); + if (_local_11 < 0) + { + _local_12 = (-(_local_10) / _local_11); + _local_13 = (_arg_2.x + (_arg_3.x * _local_12)); + _local_14 = (_arg_2.y + (_arg_3.y * _local_12)); + _local_15 = (_arg_2.z + (_arg_3.z * _local_12)); + _local_16 = _arg_1.faceList; + while (_local_16 != null) + { + _local_17 = _local_16.wrapper; + while (_local_17 != null) + { + _local_18 = _local_17.vertex; + _local_19 = ((_local_17.next != null) ? _local_17.next.vertex : _local_16.wrapper.vertex); + _local_20 = (_local_19.x - _local_18.x); + _local_21 = (_local_19.y - _local_18.y); + _local_22 = (_local_19.z - _local_18.z); + _local_23 = (_local_13 - _local_18.x); + _local_24 = (_local_14 - _local_18.y); + _local_25 = (_local_15 - _local_18.z); + if ((((((_local_25 * _local_21) - (_local_24 * _local_22)) * _local_7) + (((_local_23 * _local_22) - (_local_25 * _local_20)) * _local_8)) + (((_local_24 * _local_20) - (_local_23 * _local_21)) * _local_9)) < 0) break; + _local_17 = _local_17.next; + }; + if (_local_17 == null) + { + _local_6 = new RayIntersectionData(); + _local_6.object = this; + _local_6.face = _local_16; + _local_6.point = new Vector3D(_local_13, _local_14, _local_15); + _local_6.uv = _local_16.getUV(_local_6.point); + _local_6.time = _local_12; + return (_local_6); + }; + _local_16 = _local_16.next; + }; + if (((!(_arg_1.negative == null)) && (boundIntersectRay(_arg_2, _arg_3, _arg_1.negative.boundMinX, _arg_1.negative.boundMinY, _arg_1.negative.boundMinZ, _arg_1.negative.boundMaxX, _arg_1.negative.boundMaxY, _arg_1.negative.boundMaxZ)))) + { + return (this.intersectRayNode(_arg_1.negative, _arg_2, _arg_3, _arg_4, _arg_5)); + }; + }; + } else + { + if (((!(_arg_1.negative == null)) && (boundIntersectRay(_arg_2, _arg_3, _arg_1.negative.boundMinX, _arg_1.negative.boundMinY, _arg_1.negative.boundMinZ, _arg_1.negative.boundMaxX, _arg_1.negative.boundMaxY, _arg_1.negative.boundMaxZ)))) + { + _local_6 = this.intersectRayNode(_arg_1.negative, _arg_2, _arg_3, _arg_4, _arg_5); + if (_local_6 != null) + { + return (_local_6); + }; + }; + if ((((!(_arg_1.positive == null)) && ((((_arg_3.x * _local_7) + (_arg_3.y * _local_8)) + (_arg_3.z * _local_9)) > 0)) && (boundIntersectRay(_arg_2, _arg_3, _arg_1.positive.boundMinX, _arg_1.positive.boundMinY, _arg_1.positive.boundMinZ, _arg_1.positive.boundMaxX, _arg_1.positive.boundMaxY, _arg_1.positive.boundMaxZ)))) + { + return (this.intersectRayNode(_arg_1.positive, _arg_2, _arg_3, _arg_4, _arg_5)); + }; + }; + } else + { + _local_28 = 1E22; + _local_30 = _arg_1.objectList; + while (_local_30 != null) + { + _local_30.composeMatrix(); + _local_30.invertMatrix(); + if (_local_26 == null) + { + _local_26 = new Vector3D(); + _local_27 = new Vector3D(); + }; + _local_26.x = ((((_local_30.ma * _arg_2.x) + (_local_30.mb * _arg_2.y)) + (_local_30.mc * _arg_2.z)) + _local_30.md); + _local_26.y = ((((_local_30.me * _arg_2.x) + (_local_30.mf * _arg_2.y)) + (_local_30.mg * _arg_2.z)) + _local_30.mh); + _local_26.z = ((((_local_30.mi * _arg_2.x) + (_local_30.mj * _arg_2.y)) + (_local_30.mk * _arg_2.z)) + _local_30.ml); + _local_27.x = (((_local_30.ma * _arg_3.x) + (_local_30.mb * _arg_3.y)) + (_local_30.mc * _arg_3.z)); + _local_27.y = (((_local_30.me * _arg_3.x) + (_local_30.mf * _arg_3.y)) + (_local_30.mg * _arg_3.z)); + _local_27.z = (((_local_30.mi * _arg_3.x) + (_local_30.mj * _arg_3.y)) + (_local_30.mk * _arg_3.z)); + _local_6 = _local_30.intersectRay(_local_26, _local_27, _arg_4, _arg_5); + if (((!(_local_6 == null)) && (_local_6.time < _local_28))) + { + _local_28 = _local_6.time; + _local_29 = _local_6; + }; + _local_30 = _local_30.next; + }; + return (_local_29); + }; + return (null); + } + + override alternativa3d function checkIntersection(_arg_1:Number, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Dictionary):Boolean + { + if (super.checkIntersection(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8)) + { + return (true); + }; + if (((!(this.root == null)) && (boundCheckIntersection(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, this.root.boundMinX, this.root.boundMinY, this.root.boundMinZ, this.root.boundMaxX, this.root.boundMaxY, this.root.boundMaxZ)))) + { + return (this.checkIntersectionNode(this.root, _arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8)); + }; + return (false); + } + + private function checkIntersectionNode(_arg_1:BSPNode, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Number, _arg_9:Dictionary):Boolean + { + var _local_10:Number; + var _local_11:Number; + var _local_12:Number; + var _local_13:Number; + var _local_14:Number; + var _local_15:Number; + var _local_16:Number; + var _local_17:Number; + var _local_18:Number; + var _local_19:Face; + var _local_20:Wrapper; + var _local_21:Vertex; + var _local_22:Vertex; + var _local_23:Number; + var _local_24:Number; + var _local_25:Number; + var _local_26:Number; + var _local_27:Number; + var _local_28:Number; + var _local_29:Object3D; + var _local_30:Number; + var _local_31:Number; + var _local_32:Number; + var _local_33:Number; + var _local_34:Number; + var _local_35:Number; + if (_arg_1.objectList == null) + { + _local_11 = _arg_1.normalX; + _local_12 = _arg_1.normalY; + _local_13 = _arg_1.normalZ; + _local_14 = ((((_local_11 * _arg_2) + (_local_12 * _arg_3)) + (_local_13 * _arg_4)) - _arg_1.offset); + if (_local_14 > 0) + { + _local_10 = (((_arg_5 * _local_11) + (_arg_6 * _local_12)) + (_arg_7 * _local_13)); + if (_local_10 < 0) + { + _local_15 = (-(_local_14) / _local_10); + if (_local_15 < _arg_8) + { + _local_16 = (_arg_2 + (_arg_5 * _local_15)); + _local_17 = (_arg_3 + (_arg_6 * _local_15)); + _local_18 = (_arg_4 + (_arg_7 * _local_15)); + _local_19 = _arg_1.faceList; + while (_local_19 != null) + { + _local_20 = _local_19.wrapper; + while (_local_20 != null) + { + _local_21 = _local_20.vertex; + _local_22 = ((_local_20.next != null) ? _local_20.next.vertex : _local_19.wrapper.vertex); + _local_23 = (_local_22.x - _local_21.x); + _local_24 = (_local_22.y - _local_21.y); + _local_25 = (_local_22.z - _local_21.z); + _local_26 = (_local_16 - _local_21.x); + _local_27 = (_local_17 - _local_21.y); + _local_28 = (_local_18 - _local_21.z); + if ((((((_local_28 * _local_24) - (_local_27 * _local_25)) * _local_11) + (((_local_26 * _local_25) - (_local_28 * _local_23)) * _local_12)) + (((_local_27 * _local_23) - (_local_26 * _local_24)) * _local_13)) < 0) break; + _local_20 = _local_20.next; + }; + if (_local_20 == null) + { + return (true); + }; + _local_19 = _local_19.next; + }; + if ((((!(_arg_1.negative == null)) && (boundCheckIntersection(_arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_1.negative.boundMinX, _arg_1.negative.boundMinY, _arg_1.negative.boundMinZ, _arg_1.negative.boundMaxX, _arg_1.negative.boundMaxY, _arg_1.negative.boundMaxZ))) && (this.checkIntersectionNode(_arg_1.negative, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9)))) + { + return (true); + }; + }; + }; + return (((!(_arg_1.positive == null)) && (boundCheckIntersection(_arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_1.positive.boundMinX, _arg_1.positive.boundMinY, _arg_1.positive.boundMinZ, _arg_1.positive.boundMaxX, _arg_1.positive.boundMaxY, _arg_1.positive.boundMaxZ))) && (this.checkIntersectionNode(_arg_1.positive, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9))); + }; + if ((((!(_arg_1.negative == null)) && (boundCheckIntersection(_arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_1.negative.boundMinX, _arg_1.negative.boundMinY, _arg_1.negative.boundMinZ, _arg_1.negative.boundMaxX, _arg_1.negative.boundMaxY, _arg_1.negative.boundMaxZ))) && (this.checkIntersectionNode(_arg_1.negative, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9)))) + { + return (true); + }; + if (_arg_1.positive != null) + { + _local_10 = (((_arg_5 * _local_11) + (_arg_6 * _local_12)) + (_arg_7 * _local_13)); + return ((((_local_10 > 0) && ((-(_local_14) / _local_10) < _arg_8)) && (boundCheckIntersection(_arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_1.positive.boundMinX, _arg_1.positive.boundMinY, _arg_1.positive.boundMinZ, _arg_1.positive.boundMaxX, _arg_1.positive.boundMaxY, _arg_1.positive.boundMaxZ))) && (this.checkIntersectionNode(_arg_1.positive, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9))); + }; + } else + { + _local_29 = _arg_1.objectList; + while (_local_29 != null) + { + _local_29.composeMatrix(); + _local_29.invertMatrix(); + _local_30 = ((((_local_29.ma * _arg_2) + (_local_29.mb * _arg_3)) + (_local_29.mc * _arg_4)) + _local_29.md); + _local_31 = ((((_local_29.me * _arg_2) + (_local_29.mf * _arg_3)) + (_local_29.mg * _arg_4)) + _local_29.mh); + _local_32 = ((((_local_29.mi * _arg_2) + (_local_29.mj * _arg_3)) + (_local_29.mk * _arg_4)) + _local_29.ml); + _local_33 = (((_local_29.ma * _arg_5) + (_local_29.mb * _arg_6)) + (_local_29.mc * _arg_7)); + _local_34 = (((_local_29.me * _arg_5) + (_local_29.mf * _arg_6)) + (_local_29.mg * _arg_7)); + _local_35 = (((_local_29.mi * _arg_5) + (_local_29.mj * _arg_6)) + (_local_29.mk * _arg_7)); + if (_local_29.checkIntersection(_local_30, _local_31, _local_32, _local_33, _local_34, _local_35, _arg_8, _arg_9)) + { + return (true); + }; + _local_29 = _local_29.next; + }; + }; + return (false); + } + + override alternativa3d function collectPlanes(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Vector3D, _arg_4:Vector3D, _arg_5:Vector3D, _arg_6:Vector., _arg_7:Dictionary=null):void + { + var _local_10:Vertex; + if (((!(_arg_7 == null)) && (_arg_7[this]))) + { + return; + }; + var _local_8:Vector3D = calculateSphere(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5, treeSphere); + if ((!(boundIntersectSphere(_local_8, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ)))) + { + return; + }; + if (transformId > 0x1DCD6500) + { + transformId = 0; + _local_10 = this.vertexList; + while (_local_10 != null) + { + _local_10.transformId = 0; + _local_10 = _local_10.next; + }; + }; + transformId++; + var _local_9:Object3D = childrenList; + while (_local_9 != null) + { + _local_9.composeAndAppend(this); + _local_9.collectPlanes(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7); + _local_9 = _local_9.next; + }; + if (((!(this.root == null)) && (boundIntersectSphere(_local_8, this.root.boundMinX, this.root.boundMinY, this.root.boundMinZ, this.root.boundMaxX, this.root.boundMaxY, this.root.boundMaxZ)))) + { + this.collectPlanesNode(this.root, _local_8, _arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7); + }; + } + + private function collectPlanesNode(_arg_1:BSPNode, _arg_2:Vector3D, _arg_3:Vector3D, _arg_4:Vector3D, _arg_5:Vector3D, _arg_6:Vector3D, _arg_7:Vector3D, _arg_8:Vector., _arg_9:Dictionary=null):void + { + var _local_10:Number; + var _local_11:Face; + var _local_12:Wrapper; + var _local_13:Vertex; + var _local_14:Object3D; + if (_arg_1.objectList == null) + { + _local_10 = ((((_arg_1.normalX * _arg_2.x) + (_arg_1.normalY * _arg_2.y)) + (_arg_1.normalZ * _arg_2.z)) - _arg_1.offset); + if (_local_10 >= _arg_2.w) + { + if (((!(_arg_1.positive == null)) && (boundIntersectSphere(_arg_2, _arg_1.positive.boundMinX, _arg_1.positive.boundMinY, _arg_1.positive.boundMinZ, _arg_1.positive.boundMaxX, _arg_1.positive.boundMaxY, _arg_1.positive.boundMaxZ)))) + { + this.collectPlanesNode(_arg_1.positive, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9); + }; + } else + { + if (_local_10 <= -(_arg_2.w)) + { + if (((!(_arg_1.negative == null)) && (boundIntersectSphere(_arg_2, _arg_1.negative.boundMinX, _arg_1.negative.boundMinY, _arg_1.negative.boundMinZ, _arg_1.negative.boundMaxX, _arg_1.negative.boundMaxY, _arg_1.negative.boundMaxZ)))) + { + this.collectPlanesNode(_arg_1.negative, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9); + }; + } else + { + _local_11 = _arg_1.faceList; + while (_local_11 != null) + { + _local_12 = _local_11.wrapper; + while (_local_12 != null) + { + _local_13 = _local_12.vertex; + if (_local_13.transformId != transformId) + { + _local_13.cameraX = ((((ma * _local_13.x) + (mb * _local_13.y)) + (mc * _local_13.z)) + md); + _local_13.cameraY = ((((me * _local_13.x) + (mf * _local_13.y)) + (mg * _local_13.z)) + mh); + _local_13.cameraZ = ((((mi * _local_13.x) + (mj * _local_13.y)) + (mk * _local_13.z)) + ml); + _local_13.transformId = transformId; + }; + _local_12 = _local_12.next; + }; + _arg_8.push(_local_11); + _local_11 = _local_11.next; + }; + if (((!(_arg_1.positive == null)) && (boundIntersectSphere(_arg_2, _arg_1.positive.boundMinX, _arg_1.positive.boundMinY, _arg_1.positive.boundMinZ, _arg_1.positive.boundMaxX, _arg_1.positive.boundMaxY, _arg_1.positive.boundMaxZ)))) + { + this.collectPlanesNode(_arg_1.positive, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9); + }; + if (((!(_arg_1.negative == null)) && (boundIntersectSphere(_arg_2, _arg_1.negative.boundMinX, _arg_1.negative.boundMinY, _arg_1.negative.boundMinZ, _arg_1.negative.boundMaxX, _arg_1.negative.boundMaxY, _arg_1.negative.boundMaxZ)))) + { + this.collectPlanesNode(_arg_1.negative, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9); + }; + }; + }; + } else + { + _local_14 = _arg_1.objectList; + while (_local_14 != null) + { + _local_14.composeAndAppend(this); + _local_14.collectPlanes(_arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9); + _local_14 = _local_14.next; + }; + }; + } + + override public function clone():Object3D + { + var _local_1:BSPContainer = new BSPContainer(); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + override protected function clonePropertiesFrom(_arg_1:Object3D):void + { + var _local_3:Vertex; + var _local_4:Vertex; + var _local_5:Vertex; + super.clonePropertiesFrom(_arg_1); + var _local_2:BSPContainer = (_arg_1 as BSPContainer); + this.clipping = _local_2.clipping; + this.debugAlphaFade = _local_2.debugAlphaFade; + _local_3 = _local_2.vertexList; + while (_local_3 != null) + { + _local_5 = new Vertex(); + _local_5.x = _local_3.x; + _local_5.y = _local_3.y; + _local_5.z = _local_3.z; + _local_5.u = _local_3.u; + _local_5.v = _local_3.v; + _local_5.normalX = _local_3.normalX; + _local_5.normalY = _local_3.normalY; + _local_5.normalZ = _local_3.normalZ; + _local_3.value = _local_5; + if (_local_4 != null) + { + _local_4.next = _local_5; + } else + { + this.vertexList = _local_5; + }; + _local_4 = _local_5; + _local_3 = _local_3.next; + }; + if (_local_2.root != null) + { + this.root = _local_2.cloneNode(_local_2.root, this); + }; + _local_3 = _local_2.vertexList; + while (_local_3 != null) + { + _local_3.value = null; + _local_3 = _local_3.next; + }; + } + + private function cloneNode(_arg_1:BSPNode, _arg_2:Object3DContainer):BSPNode + { + var _local_4:Face; + var _local_6:Object3D; + var _local_7:Object3D; + var _local_8:Object3D; + var _local_9:Face; + var _local_10:Wrapper; + var _local_11:Wrapper; + var _local_12:Wrapper; + var _local_3:BSPNode = new BSPNode(); + _local_3.normalX = _arg_1.normalX; + _local_3.normalY = _arg_1.normalY; + _local_3.normalZ = _arg_1.normalZ; + _local_3.offset = _arg_1.offset; + _local_3.boundMinX = _arg_1.boundMinX; + _local_3.boundMinY = _arg_1.boundMinY; + _local_3.boundMinZ = _arg_1.boundMinZ; + _local_3.boundMaxX = _arg_1.boundMaxX; + _local_3.boundMaxY = _arg_1.boundMaxY; + _local_3.boundMaxZ = _arg_1.boundMaxZ; + var _local_5:Face = _arg_1.faceList; + while (_local_5 != null) + { + _local_9 = new Face(); + _local_9.material = _local_5.material; + _local_9.normalX = _local_5.normalX; + _local_9.normalY = _local_5.normalY; + _local_9.normalZ = _local_5.normalZ; + _local_9.offset = _local_5.offset; + _local_10 = null; + _local_11 = _local_5.wrapper; + while (_local_11 != null) + { + _local_12 = new Wrapper(); + _local_12.vertex = _local_11.vertex.value; + if (_local_10 != null) + { + _local_10.next = _local_12; + } else + { + _local_9.wrapper = _local_12; + }; + _local_10 = _local_12; + _local_11 = _local_11.next; + }; + if (_local_3.faceList != null) + { + _local_4.next = _local_9; + } else + { + _local_3.faceList = _local_9; + }; + _local_4 = _local_9; + _local_5 = _local_5.next; + }; + _local_6 = _arg_1.objectList; + _local_7 = null; + while (_local_6 != null) + { + _local_8 = _local_6.clone(); + if (_local_3.objectList != null) + { + _local_7.next = _local_8; + } else + { + _local_3.objectList = _local_8; + }; + _local_7 = _local_8; + _local_8.setParent(_arg_2); + _local_6 = _local_6.next; + }; + _local_6 = _arg_1.boundList; + _local_7 = null; + while (_local_6 != null) + { + _local_8 = _local_6.clone(); + if (_local_3.boundList != null) + { + _local_7.next = _local_8; + } else + { + _local_3.boundList = _local_8; + }; + _local_7 = _local_8; + _local_6 = _local_6.next; + }; + if (_arg_1.negative != null) + { + _local_3.negative = this.cloneNode(_arg_1.negative, _arg_2); + }; + if (_arg_1.positive != null) + { + _local_3.positive = this.cloneNode(_arg_1.positive, _arg_2); + }; + return (_local_3); + } + + override alternativa3d function draw(_arg_1:Camera3D):void + { + var _local_2:int; + var _local_3:int; + var _local_4:Vertex; + var _local_5:VG; + var _local_6:VG; + var _local_7:Face; + if (this.root != null) + { + if (transformId > 0x1DCD6500) + { + transformId = 0; + _local_4 = this.vertexList; + while (_local_4 != null) + { + _local_4.transformId = 0; + _local_4 = _local_4.next; + }; + }; + transformId++; + calculateInverseMatrix(); + this.calculateCameraPlanes(_arg_1.nearClipping, _arg_1.farClipping); + _local_3 = this.cullingInContainer(culling, this.root.boundMinX, this.root.boundMinY, this.root.boundMinZ, this.root.boundMaxX, this.root.boundMaxY, this.root.boundMaxZ); + if (_local_3 >= 0) + { + if (((_arg_1.debug) && ((_local_2 = _arg_1.checkInDebug(this)) > 0))) + { + if ((_local_2 & Debug.NODES)) + { + this.debugNode(this.root, _local_3, _arg_1, 1); + }; + if ((_local_2 & Debug.BOUNDS)) + { + Debug.drawBounds(_arg_1, this, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ); + }; + }; + _local_5 = super.getVG(_arg_1); + _local_6 = _local_5; + while (_local_6 != null) + { + _local_6.calculateAABB(ima, imb, imc, imd, ime, imf, img, imh, imi, imj, imk, iml); + _local_6 = _local_6.next; + }; + _local_7 = this.drawNode(this.root, _local_3, _arg_1, _local_5); + if (_local_7 != null) + { + this.drawFaces(_arg_1, _local_7); + }; + } else + { + super.draw(_arg_1); + }; + } else + { + super.draw(_arg_1); + }; + } + + override alternativa3d function getVG(_arg_1:Camera3D):VG + { + var _local_3:int; + var _local_4:Vertex; + var _local_2:VG = super.getVG(_arg_1); + if (this.root != null) + { + if (transformId > 0x1DCD6500) + { + transformId = 0; + _local_4 = this.vertexList; + while (_local_4 != null) + { + _local_4.transformId = 0; + _local_4 = _local_4.next; + }; + }; + transformId++; + calculateInverseMatrix(); + this.calculateCameraPlanes(_arg_1.nearClipping, _arg_1.farClipping); + _local_3 = this.cullingInContainer(culling, this.root.boundMinX, this.root.boundMinY, this.root.boundMinZ, this.root.boundMaxX, this.root.boundMaxY, this.root.boundMaxZ); + if (_local_3 >= 0) + { + _local_2 = this.collectVGNode(this.root, _local_3, _arg_1, _local_2); + }; + }; + return (_local_2); + } + + private function collectVGNode(_arg_1:BSPNode, _arg_2:int, _arg_3:Camera3D, _arg_4:VG=null):VG + { + var _local_5:VG; + var _local_6:VG; + var _local_9:VG; + var _local_10:int; + var _local_11:int; + var _local_7:Object3D = _arg_1.objectList; + var _local_8:Object3D = _arg_1.boundList; + while (_local_7 != null) + { + if (((_local_7.visible) && (((_local_7.culling = _arg_2) == 0) || ((_local_7.culling = this.cullingInContainer(_arg_2, _local_8.boundMinX, _local_8.boundMinY, _local_8.boundMinZ, _local_8.boundMaxX, _local_8.boundMaxY, _local_8.boundMaxZ)) >= 0)))) + { + _local_7.composeAndAppend(this); + _local_7.concat(this); + _local_9 = _local_7.getVG(_arg_3); + if (_local_9 != null) + { + if (_local_5 != null) + { + _local_6.next = _local_9; + } else + { + _local_5 = _local_9; + _local_6 = _local_9; + }; + while (_local_6.next != null) + { + _local_6 = _local_6.next; + }; + }; + }; + _local_7 = _local_7.next; + _local_8 = _local_8.next; + }; + if (_local_5 != null) + { + _local_6.next = _arg_4; + _arg_4 = _local_5; + }; + if (_arg_1.negative != null) + { + _local_10 = ((_arg_2 > 0) ? this.cullingInContainer(_arg_2, _arg_1.negative.boundMinX, _arg_1.negative.boundMinY, _arg_1.negative.boundMinZ, _arg_1.negative.boundMaxX, _arg_1.negative.boundMaxY, _arg_1.negative.boundMaxZ) : 0); + if (_local_10 >= 0) + { + _arg_4 = this.collectVGNode(_arg_1.negative, _local_10, _arg_3, _arg_4); + }; + }; + if (_arg_1.positive != null) + { + _local_11 = ((_arg_2 > 0) ? this.cullingInContainer(_arg_2, _arg_1.positive.boundMinX, _arg_1.positive.boundMinY, _arg_1.positive.boundMinZ, _arg_1.positive.boundMaxX, _arg_1.positive.boundMaxY, _arg_1.positive.boundMaxZ) : 0); + if (_local_11 >= 0) + { + _arg_4 = this.collectVGNode(_arg_1.positive, _local_11, _arg_3, _arg_4); + }; + }; + return (_arg_4); + } + + override alternativa3d function updateBounds(_arg_1:Object3D, _arg_2:Object3D=null):void + { + super.updateBounds(_arg_1, _arg_2); + var _local_3:Vertex = this.vertexList; + while (_local_3 != null) + { + if (_arg_2 != null) + { + _local_3.cameraX = ((((_arg_2.ma * _local_3.x) + (_arg_2.mb * _local_3.y)) + (_arg_2.mc * _local_3.z)) + _arg_2.md); + _local_3.cameraY = ((((_arg_2.me * _local_3.x) + (_arg_2.mf * _local_3.y)) + (_arg_2.mg * _local_3.z)) + _arg_2.mh); + _local_3.cameraZ = ((((_arg_2.mi * _local_3.x) + (_arg_2.mj * _local_3.y)) + (_arg_2.mk * _local_3.z)) + _arg_2.ml); + } else + { + _local_3.cameraX = _local_3.x; + _local_3.cameraY = _local_3.y; + _local_3.cameraZ = _local_3.z; + }; + if (_local_3.cameraX < _arg_1.boundMinX) + { + _arg_1.boundMinX = _local_3.cameraX; + }; + if (_local_3.cameraX > _arg_1.boundMaxX) + { + _arg_1.boundMaxX = _local_3.cameraX; + }; + if (_local_3.cameraY < _arg_1.boundMinY) + { + _arg_1.boundMinY = _local_3.cameraY; + }; + if (_local_3.cameraY > _arg_1.boundMaxY) + { + _arg_1.boundMaxY = _local_3.cameraY; + }; + if (_local_3.cameraZ < _arg_1.boundMinZ) + { + _arg_1.boundMinZ = _local_3.cameraZ; + }; + if (_local_3.cameraZ > _arg_1.boundMaxZ) + { + _arg_1.boundMaxZ = _local_3.cameraZ; + }; + _local_3 = _local_3.next; + }; + if (this.root != null) + { + this.updateBoundsNode(this.root, _arg_1, _arg_2); + }; + } + + private function updateBoundsNode(_arg_1:BSPNode, _arg_2:Object3D, _arg_3:Object3D):void + { + var _local_4:Object3D; + if (_arg_1.objectList == null) + { + if (_arg_1.negative != null) + { + this.updateBoundsNode(_arg_1.negative, _arg_2, _arg_3); + }; + if (_arg_1.positive != null) + { + this.updateBoundsNode(_arg_1.positive, _arg_2, _arg_3); + }; + } else + { + _local_4 = _arg_1.objectList; + while (_local_4 != null) + { + if (_arg_3 != null) + { + _local_4.composeAndAppend(_arg_3); + } else + { + _local_4.composeMatrix(); + }; + _local_4.updateBounds(_arg_2, _local_4); + _local_4 = _local_4.next; + }; + }; + } + + private function debugNode(_arg_1:BSPNode, _arg_2:int, _arg_3:Camera3D, _arg_4:Number):void + { + var _local_5:int; + var _local_6:int; + if (_arg_1 != null) + { + _local_5 = -1; + _local_6 = -1; + if (_arg_1.negative != null) + { + _local_5 = ((_arg_2 > 0) ? this.cullingInContainer(_arg_2, _arg_1.negative.boundMinX, _arg_1.negative.boundMinY, _arg_1.negative.boundMinZ, _arg_1.negative.boundMaxX, _arg_1.negative.boundMaxY, _arg_1.negative.boundMaxZ) : 0); + }; + if (_arg_1.positive != null) + { + _local_6 = ((_arg_2 > 0) ? this.cullingInContainer(_arg_2, _arg_1.positive.boundMinX, _arg_1.positive.boundMinY, _arg_1.positive.boundMinZ, _arg_1.positive.boundMaxX, _arg_1.positive.boundMaxY, _arg_1.positive.boundMaxZ) : 0); + }; + if (_local_5 >= 0) + { + this.debugNode(_arg_1.negative, _local_5, _arg_3, (_arg_4 * this.debugAlphaFade)); + }; + Debug.drawBounds(_arg_3, this, _arg_1.boundMinX, _arg_1.boundMinY, _arg_1.boundMinZ, _arg_1.boundMaxX, _arg_1.boundMaxY, _arg_1.boundMaxZ, 14496733, _arg_4); + if (_local_6 >= 0) + { + this.debugNode(_arg_1.positive, _local_6, _arg_3, (_arg_4 * this.debugAlphaFade)); + }; + }; + } + + private function drawNode(_arg_1:BSPNode, _arg_2:int, _arg_3:Camera3D, _arg_4:VG, _arg_5:Face=null):Face + { + var _local_6:VG; + var _local_7:VG; + var _local_8:VG; + var _local_9:int; + var _local_10:int; + var _local_11:int; + var _local_12:Number; + var _local_13:Number; + var _local_14:Number; + var _local_15:Number; + var _local_16:Face; + var _local_17:Face; + var _local_18:Wrapper; + var _local_19:Vertex; + var _local_20:Number; + var _local_21:Number; + var _local_22:Number; + var _local_23:Object3D; + var _local_24:Object3D; + var _local_25:VG; + if (_arg_1.objectList == null) + { + _local_10 = -1; + _local_11 = -1; + _local_12 = _arg_1.normalX; + _local_13 = _arg_1.normalY; + _local_14 = _arg_1.normalZ; + _local_15 = _arg_1.offset; + if ((((imd * _local_12) + (imh * _local_13)) + (iml * _local_14)) > _local_15) + { + if ((((this.directionX * _local_12) + (this.directionY * _local_13)) + (this.directionZ * _local_14)) < this.viewAngle) + { + while (_arg_4 != null) + { + _local_6 = _arg_4.next; + _local_9 = this.checkBounds(_local_12, _local_13, _local_14, _local_15, _arg_4.boundMinX, _arg_4.boundMinY, _arg_4.boundMinZ, _arg_4.boundMaxX, _arg_4.boundMaxY, _arg_4.boundMaxZ, true); + if (_local_9 < 0) + { + _arg_4.next = _local_7; + _local_7 = _arg_4; + } else + { + if (_local_9 > 0) + { + _arg_4.next = _local_8; + _local_8 = _arg_4; + } else + { + _arg_4.split(_arg_3, _local_12, _local_13, _local_14, _local_15, threshold); + if (_arg_4.next != null) + { + _arg_4.next.next = _local_7; + _local_7 = _arg_4.next; + }; + if (_arg_4.faceStruct != null) + { + _arg_4.next = _local_8; + _local_8 = _arg_4; + } else + { + _arg_4.destroy(); + }; + }; + }; + _arg_4 = _local_6; + }; + if (_arg_1.positive != null) + { + _local_11 = ((_arg_2 > 0) ? this.cullingInContainer(_arg_2, _arg_1.positive.boundMinX, _arg_1.positive.boundMinY, _arg_1.positive.boundMinZ, _arg_1.positive.boundMaxX, _arg_1.positive.boundMaxY, _arg_1.positive.boundMaxZ) : 0); + }; + if (_local_11 >= 0) + { + _arg_5 = this.drawNode(_arg_1.positive, _local_11, _arg_3, _local_8, _arg_5); + } else + { + if (_local_8 != null) + { + if (_arg_5 != null) + { + this.drawFaces(_arg_3, _arg_5); + _arg_5 = null; + }; + if (_local_8.next != null) + { + if (resolveByAABB) + { + drawAABBGeometry(_arg_3, _local_8); + } else + { + if (resolveByOOBB) + { + _arg_4 = _local_8; + while (_arg_4 != null) + { + _arg_4.calculateOOBB(this); + _arg_4 = _arg_4.next; + }; + drawOOBBGeometry(_arg_3, _local_8); + } else + { + drawConflictGeometry(_arg_3, _local_8); + }; + }; + } else + { + _local_8.draw(_arg_3, threshold, this); + _local_8.destroy(); + }; + }; + }; + _local_17 = _arg_1.faceList; + while (_local_17 != null) + { + _local_18 = _local_17.wrapper; + while (_local_18 != null) + { + _local_19 = _local_18.vertex; + if (_local_19.transformId != transformId) + { + _local_20 = _local_19.x; + _local_21 = _local_19.y; + _local_22 = _local_19.z; + _local_19.cameraX = ((((ma * _local_20) + (mb * _local_21)) + (mc * _local_22)) + md); + _local_19.cameraY = ((((me * _local_20) + (mf * _local_21)) + (mg * _local_22)) + mh); + _local_19.cameraZ = ((((mi * _local_20) + (mj * _local_21)) + (mk * _local_22)) + ml); + _local_19.transformId = transformId; + _local_19.drawId = 0; + }; + _local_18 = _local_18.next; + }; + _local_17.processNext = _local_16; + _local_16 = _local_17; + _local_17 = _local_17.next; + }; + if (_local_16 != null) + { + if (_arg_2 > 0) + { + if (this.clipping == 2) + { + _local_16 = _arg_3.clip(_local_16, _arg_2); + } else + { + _local_16 = _arg_3.cull(_local_16, _arg_2); + }; + if (_local_16 != null) + { + _local_17 = _local_16; + while (_local_17.processNext != null) + { + _local_17 = _local_17.processNext; + }; + _local_17.processNext = _arg_5; + _arg_5 = _local_16; + }; + } else + { + _local_17 = _local_16; + while (_local_17.processNext != null) + { + _local_17 = _local_17.processNext; + }; + _local_17.processNext = _arg_5; + _arg_5 = _local_16; + }; + }; + if (_arg_1.negative != null) + { + _local_10 = ((_arg_2 > 0) ? this.cullingInContainer(_arg_2, _arg_1.negative.boundMinX, _arg_1.negative.boundMinY, _arg_1.negative.boundMinZ, _arg_1.negative.boundMaxX, _arg_1.negative.boundMaxY, _arg_1.negative.boundMaxZ) : 0); + }; + if (_local_10 >= 0) + { + _arg_5 = this.drawNode(_arg_1.negative, _local_10, _arg_3, _local_7, _arg_5); + } else + { + if (_local_7 != null) + { + if (_arg_5 != null) + { + this.drawFaces(_arg_3, _arg_5); + _arg_5 = null; + }; + if (_local_7.next != null) + { + if (resolveByAABB) + { + drawAABBGeometry(_arg_3, _local_7); + } else + { + if (resolveByOOBB) + { + _arg_4 = _local_7; + while (_arg_4 != null) + { + _arg_4.calculateOOBB(this); + _arg_4 = _arg_4.next; + }; + drawOOBBGeometry(_arg_3, _local_7); + } else + { + drawConflictGeometry(_arg_3, _local_7); + }; + }; + } else + { + _local_7.draw(_arg_3, threshold, this); + _local_7.destroy(); + }; + }; + }; + } else + { + while (_arg_4 != null) + { + _local_6 = _arg_4.next; + _local_9 = this.checkBounds(_local_12, _local_13, _local_14, _local_15, _arg_4.boundMinX, _arg_4.boundMinY, _arg_4.boundMinZ, _arg_4.boundMaxX, _arg_4.boundMaxY, _arg_4.boundMaxZ, true); + if (_local_9 < 0) + { + _arg_4.destroy(); + } else + { + if (_local_9 > 0) + { + _arg_4.next = _local_8; + _local_8 = _arg_4; + } else + { + _arg_4.crop(_arg_3, _local_12, _local_13, _local_14, _local_15, threshold); + if (_arg_4.faceStruct != null) + { + _arg_4.next = _local_8; + _local_8 = _arg_4; + } else + { + _arg_4.destroy(); + }; + }; + }; + _arg_4 = _local_6; + }; + if (_arg_1.positive != null) + { + _local_11 = ((_arg_2 > 0) ? this.cullingInContainer(_arg_2, _arg_1.positive.boundMinX, _arg_1.positive.boundMinY, _arg_1.positive.boundMinZ, _arg_1.positive.boundMaxX, _arg_1.positive.boundMaxY, _arg_1.positive.boundMaxZ) : 0); + }; + if (_local_11 >= 0) + { + _arg_5 = this.drawNode(_arg_1.positive, _local_11, _arg_3, _local_8, _arg_5); + } else + { + if (_local_8 != null) + { + if (_arg_5 != null) + { + this.drawFaces(_arg_3, _arg_5); + _arg_5 = null; + }; + if (_local_8.next != null) + { + if (resolveByAABB) + { + drawAABBGeometry(_arg_3, _local_8); + } else + { + if (resolveByOOBB) + { + _arg_4 = _local_8; + while (_arg_4 != null) + { + _arg_4.calculateOOBB(this); + _arg_4 = _arg_4.next; + }; + drawOOBBGeometry(_arg_3, _local_8); + } else + { + drawConflictGeometry(_arg_3, _local_8); + }; + }; + } else + { + _local_8.draw(_arg_3, threshold, this); + _local_8.destroy(); + }; + }; + }; + }; + } else + { + if ((((this.directionX * _local_12) + (this.directionY * _local_13)) + (this.directionZ * _local_14)) > -(this.viewAngle)) + { + while (_arg_4 != null) + { + _local_6 = _arg_4.next; + _local_9 = this.checkBounds(_local_12, _local_13, _local_14, _local_15, _arg_4.boundMinX, _arg_4.boundMinY, _arg_4.boundMinZ, _arg_4.boundMaxX, _arg_4.boundMaxY, _arg_4.boundMaxZ, false); + if (_local_9 < 0) + { + _arg_4.next = _local_7; + _local_7 = _arg_4; + } else + { + if (_local_9 > 0) + { + _arg_4.next = _local_8; + _local_8 = _arg_4; + } else + { + _arg_4.split(_arg_3, _local_12, _local_13, _local_14, _local_15, threshold); + if (_arg_4.next != null) + { + _arg_4.next.next = _local_7; + _local_7 = _arg_4.next; + }; + if (_arg_4.faceStruct != null) + { + _arg_4.next = _local_8; + _local_8 = _arg_4; + } else + { + _arg_4.destroy(); + }; + }; + }; + _arg_4 = _local_6; + }; + if (_arg_1.negative != null) + { + _local_10 = ((_arg_2 > 0) ? this.cullingInContainer(_arg_2, _arg_1.negative.boundMinX, _arg_1.negative.boundMinY, _arg_1.negative.boundMinZ, _arg_1.negative.boundMaxX, _arg_1.negative.boundMaxY, _arg_1.negative.boundMaxZ) : 0); + }; + if (_local_10 >= 0) + { + _arg_5 = this.drawNode(_arg_1.negative, _local_10, _arg_3, _local_7, _arg_5); + } else + { + if (_local_7 != null) + { + if (_arg_5 != null) + { + this.drawFaces(_arg_3, _arg_5); + _arg_5 = null; + }; + if (_local_7.next != null) + { + if (resolveByAABB) + { + drawAABBGeometry(_arg_3, _local_7); + } else + { + if (resolveByOOBB) + { + _arg_4 = _local_7; + while (_arg_4 != null) + { + _arg_4.calculateOOBB(this); + _arg_4 = _arg_4.next; + }; + drawOOBBGeometry(_arg_3, _local_7); + } else + { + drawConflictGeometry(_arg_3, _local_7); + }; + }; + } else + { + _local_7.draw(_arg_3, threshold, this); + _local_7.destroy(); + }; + }; + }; + if (_arg_1.positive != null) + { + _local_11 = ((_arg_2 > 0) ? this.cullingInContainer(_arg_2, _arg_1.positive.boundMinX, _arg_1.positive.boundMinY, _arg_1.positive.boundMinZ, _arg_1.positive.boundMaxX, _arg_1.positive.boundMaxY, _arg_1.positive.boundMaxZ) : 0); + }; + if (_local_11 >= 0) + { + _arg_5 = this.drawNode(_arg_1.positive, _local_11, _arg_3, _local_8, _arg_5); + } else + { + if (_local_8 != null) + { + if (_arg_5 != null) + { + this.drawFaces(_arg_3, _arg_5); + _arg_5 = null; + }; + if (_local_8.next != null) + { + if (resolveByAABB) + { + drawAABBGeometry(_arg_3, _local_8); + } else + { + if (resolveByOOBB) + { + _arg_4 = _local_8; + while (_arg_4 != null) + { + _arg_4.calculateOOBB(this); + _arg_4 = _arg_4.next; + }; + drawOOBBGeometry(_arg_3, _local_8); + } else + { + drawConflictGeometry(_arg_3, _local_8); + }; + }; + } else + { + _local_8.draw(_arg_3, threshold, this); + _local_8.destroy(); + }; + }; + }; + } else + { + while (_arg_4 != null) + { + _local_6 = _arg_4.next; + _local_9 = this.checkBounds(_local_12, _local_13, _local_14, _local_15, _arg_4.boundMinX, _arg_4.boundMinY, _arg_4.boundMinZ, _arg_4.boundMaxX, _arg_4.boundMaxY, _arg_4.boundMaxZ, false); + if (_local_9 < 0) + { + _arg_4.next = _local_7; + _local_7 = _arg_4; + } else + { + if (_local_9 > 0) + { + _arg_4.destroy(); + } else + { + _arg_4.crop(_arg_3, -(_local_12), -(_local_13), -(_local_14), -(_local_15), threshold); + if (_arg_4.faceStruct != null) + { + _arg_4.next = _local_7; + _local_7 = _arg_4; + } else + { + _arg_4.destroy(); + }; + }; + }; + _arg_4 = _local_6; + }; + if (_arg_1.negative != null) + { + _local_10 = ((_arg_2 > 0) ? this.cullingInContainer(_arg_2, _arg_1.negative.boundMinX, _arg_1.negative.boundMinY, _arg_1.negative.boundMinZ, _arg_1.negative.boundMaxX, _arg_1.negative.boundMaxY, _arg_1.negative.boundMaxZ) : 0); + }; + if (_local_10 >= 0) + { + _arg_5 = this.drawNode(_arg_1.negative, _local_10, _arg_3, _local_7, _arg_5); + } else + { + if (_local_7 != null) + { + if (_arg_5 != null) + { + this.drawFaces(_arg_3, _arg_5); + _arg_5 = null; + }; + if (_local_7.next != null) + { + if (resolveByAABB) + { + drawAABBGeometry(_arg_3, _local_7); + } else + { + if (resolveByOOBB) + { + _arg_4 = _local_7; + while (_arg_4 != null) + { + _arg_4.calculateOOBB(this); + _arg_4 = _arg_4.next; + }; + drawOOBBGeometry(_arg_3, _local_7); + } else + { + drawConflictGeometry(_arg_3, _local_7); + }; + }; + } else + { + _local_7.draw(_arg_3, threshold, this); + _local_7.destroy(); + }; + }; + }; + }; + }; + } else + { + if (_arg_5 != null) + { + this.drawFaces(_arg_3, _arg_5); + _arg_5 = null; + }; + if (((!(_arg_1.objectList.next == null)) || (!(_arg_4 == null)))) + { + _local_23 = _arg_1.objectList; + _local_24 = _arg_1.boundList; + while (_local_23 != null) + { + if (((_local_23.visible) && (((_local_23.culling = _arg_2) == 0) || ((_local_23.culling = this.cullingInContainer(_arg_2, _local_24.boundMinX, _local_24.boundMinY, _local_24.boundMinZ, _local_24.boundMaxX, _local_24.boundMaxY, _local_24.boundMaxZ)) >= 0)))) + { + _local_23.composeAndAppend(this); + _local_23.concat(this); + _local_25 = _local_23.getVG(_arg_3); + while (_local_25 != null) + { + _local_6 = _local_25.next; + _local_25.next = _arg_4; + _arg_4 = _local_25; + if (resolveByAABB) + { + _local_25.calculateAABB(ima, imb, imc, imd, ime, imf, img, imh, imi, imj, imk, iml); + }; + _local_25 = _local_6; + }; + }; + _local_23 = _local_23.next; + _local_24 = _local_24.next; + }; + if (_arg_4 != null) + { + if (_arg_4.next != null) + { + drawConflictGeometry(_arg_3, _arg_4); + } else + { + _arg_4.draw(_arg_3, threshold, this); + _arg_4.destroy(); + }; + }; + } else + { + _local_23 = _arg_1.objectList; + if (_local_23.visible) + { + _local_23.composeAndAppend(this); + _local_23.culling = _arg_2; + _local_23.concat(this); + _local_23.draw(_arg_3); + }; + }; + }; + return (_arg_5); + } + + private function drawFaces(_arg_1:Camera3D, _arg_2:Face):void + { + var _local_4:Face; + if (((_arg_1.debug) && (_arg_1.checkInDebug(this) & Debug.EDGES))) + { + Debug.drawEdges(_arg_1, _arg_2, 0xFFFFFF); + }; + var _local_3:Face = _arg_2; + while (_local_3 != null) + { + _local_4 = _local_3.processNext; + if (((_local_4 == null) || (!(_local_4.material == _arg_2.material)))) + { + _local_3.processNext = null; + if (_arg_2.material == null) + { + while (_arg_2 != null) + { + _local_3 = _arg_2.processNext; + _arg_2.processNext = null; + _arg_2 = _local_3; + }; + }; + _arg_2 = _local_4; + }; + _local_3 = _local_4; + }; + } + + private function checkBounds(_arg_1:Number, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Number, _arg_9:Number, _arg_10:Number, _arg_11:Boolean):int + { + if (_arg_11) + { + if (_arg_1 >= 0) + { + if (_arg_2 >= 0) + { + if (_arg_3 >= 0) + { + if ((((_arg_5 * _arg_1) + (_arg_6 * _arg_2)) + (_arg_7 * _arg_3)) >= (_arg_4 - threshold)) + { + return (1); + }; + if ((((_arg_8 * _arg_1) + (_arg_9 * _arg_2)) + (_arg_10 * _arg_3)) <= (_arg_4 + threshold)) + { + return (-1); + }; + } else + { + if ((((_arg_5 * _arg_1) + (_arg_6 * _arg_2)) + (_arg_10 * _arg_3)) >= (_arg_4 - threshold)) + { + return (1); + }; + if ((((_arg_8 * _arg_1) + (_arg_9 * _arg_2)) + (_arg_7 * _arg_3)) <= (_arg_4 + threshold)) + { + return (-1); + }; + }; + } else + { + if (_arg_3 >= 0) + { + if ((((_arg_5 * _arg_1) + (_arg_9 * _arg_2)) + (_arg_7 * _arg_3)) >= (_arg_4 - threshold)) + { + return (1); + }; + if ((((_arg_8 * _arg_1) + (_arg_6 * _arg_2)) + (_arg_10 * _arg_3)) <= (_arg_4 + threshold)) + { + return (-1); + }; + } else + { + if ((((_arg_5 * _arg_1) + (_arg_9 * _arg_2)) + (_arg_10 * _arg_3)) >= (_arg_4 - threshold)) + { + return (1); + }; + if ((((_arg_8 * _arg_1) + (_arg_6 * _arg_2)) + (_arg_7 * _arg_3)) <= (_arg_4 + threshold)) + { + return (-1); + }; + }; + }; + } else + { + if (_arg_2 >= 0) + { + if (_arg_3 >= 0) + { + if ((((_arg_8 * _arg_1) + (_arg_6 * _arg_2)) + (_arg_7 * _arg_3)) >= (_arg_4 - threshold)) + { + return (1); + }; + if ((((_arg_5 * _arg_1) + (_arg_9 * _arg_2)) + (_arg_10 * _arg_3)) <= (_arg_4 + threshold)) + { + return (-1); + }; + } else + { + if ((((_arg_8 * _arg_1) + (_arg_6 * _arg_2)) + (_arg_10 * _arg_3)) >= (_arg_4 - threshold)) + { + return (1); + }; + if ((((_arg_5 * _arg_1) + (_arg_9 * _arg_2)) + (_arg_7 * _arg_3)) <= (_arg_4 + threshold)) + { + return (-1); + }; + }; + } else + { + if (_arg_3 >= 0) + { + if ((((_arg_8 * _arg_1) + (_arg_9 * _arg_2)) + (_arg_7 * _arg_3)) >= (_arg_4 - threshold)) + { + return (1); + }; + if ((((_arg_5 * _arg_1) + (_arg_6 * _arg_2)) + (_arg_10 * _arg_3)) <= (_arg_4 + threshold)) + { + return (-1); + }; + } else + { + if ((((_arg_8 * _arg_1) + (_arg_9 * _arg_2)) + (_arg_10 * _arg_3)) >= (_arg_4 - threshold)) + { + return (1); + }; + if ((((_arg_5 * _arg_1) + (_arg_6 * _arg_2)) + (_arg_7 * _arg_3)) <= (_arg_4 + threshold)) + { + return (-1); + }; + }; + }; + }; + } else + { + if (_arg_1 >= 0) + { + if (_arg_2 >= 0) + { + if (_arg_3 >= 0) + { + if ((((_arg_8 * _arg_1) + (_arg_9 * _arg_2)) + (_arg_10 * _arg_3)) <= (_arg_4 + threshold)) + { + return (-1); + }; + if ((((_arg_5 * _arg_1) + (_arg_6 * _arg_2)) + (_arg_7 * _arg_3)) >= (_arg_4 - threshold)) + { + return (1); + }; + } else + { + if ((((_arg_8 * _arg_1) + (_arg_9 * _arg_2)) + (_arg_7 * _arg_3)) <= (_arg_4 + threshold)) + { + return (-1); + }; + if ((((_arg_5 * _arg_1) + (_arg_6 * _arg_2)) + (_arg_10 * _arg_3)) >= (_arg_4 - threshold)) + { + return (1); + }; + }; + } else + { + if (_arg_3 >= 0) + { + if ((((_arg_8 * _arg_1) + (_arg_6 * _arg_2)) + (_arg_10 * _arg_3)) <= (_arg_4 + threshold)) + { + return (-1); + }; + if ((((_arg_5 * _arg_1) + (_arg_9 * _arg_2)) + (_arg_7 * _arg_3)) >= (_arg_4 - threshold)) + { + return (1); + }; + } else + { + if ((((_arg_8 * _arg_1) + (_arg_6 * _arg_2)) + (_arg_7 * _arg_3)) <= (_arg_4 + threshold)) + { + return (-1); + }; + if ((((_arg_5 * _arg_1) + (_arg_9 * _arg_2)) + (_arg_10 * _arg_3)) >= (_arg_4 - threshold)) + { + return (1); + }; + }; + }; + } else + { + if (_arg_2 >= 0) + { + if (_arg_3 >= 0) + { + if ((((_arg_5 * _arg_1) + (_arg_9 * _arg_2)) + (_arg_10 * _arg_3)) <= (_arg_4 + threshold)) + { + return (-1); + }; + if ((((_arg_8 * _arg_1) + (_arg_6 * _arg_2)) + (_arg_7 * _arg_3)) >= (_arg_4 - threshold)) + { + return (1); + }; + } else + { + if ((((_arg_5 * _arg_1) + (_arg_9 * _arg_2)) + (_arg_7 * _arg_3)) <= (_arg_4 + threshold)) + { + return (-1); + }; + if ((((_arg_8 * _arg_1) + (_arg_6 * _arg_2)) + (_arg_10 * _arg_3)) >= (_arg_4 - threshold)) + { + return (1); + }; + }; + } else + { + if (_arg_3 >= 0) + { + if ((((_arg_5 * _arg_1) + (_arg_6 * _arg_2)) + (_arg_10 * _arg_3)) <= (_arg_4 + threshold)) + { + return (-1); + }; + if ((((_arg_8 * _arg_1) + (_arg_9 * _arg_2)) + (_arg_7 * _arg_3)) >= (_arg_4 - threshold)) + { + return (1); + }; + } else + { + if ((((_arg_5 * _arg_1) + (_arg_6 * _arg_2)) + (_arg_7 * _arg_3)) <= (_arg_4 + threshold)) + { + return (-1); + }; + if ((((_arg_8 * _arg_1) + (_arg_9 * _arg_2)) + (_arg_10 * _arg_3)) >= (_arg_4 - threshold)) + { + return (1); + }; + }; + }; + }; + }; + return (0); + } + + private function calculateCameraPlanes(_arg_1:Number, _arg_2:Number):void + { + this.directionX = imc; + this.directionY = img; + this.directionZ = imk; + var _local_3:Number = (1 / Math.sqrt((((this.directionX * this.directionX) + (this.directionY * this.directionY)) + (this.directionZ * this.directionZ)))); + this.directionX = (this.directionX * _local_3); + this.directionY = (this.directionY * _local_3); + this.directionZ = (this.directionZ * _local_3); + this.nearPlaneX = imc; + this.nearPlaneY = img; + this.nearPlaneZ = imk; + this.nearPlaneOffset = (((((imc * _arg_1) + imd) * this.nearPlaneX) + (((img * _arg_1) + imh) * this.nearPlaneY)) + (((imk * _arg_1) + iml) * this.nearPlaneZ)); + this.farPlaneX = -(imc); + this.farPlaneY = -(img); + this.farPlaneZ = -(imk); + this.farPlaneOffset = (((((imc * _arg_2) + imd) * this.farPlaneX) + (((img * _arg_2) + imh) * this.farPlaneY)) + (((imk * _arg_2) + iml) * this.farPlaneZ)); + var _local_4:Number = ((-(ima) - imb) + imc); + var _local_5:Number = ((-(ime) - imf) + img); + var _local_6:Number = ((-(imi) - imj) + imk); + var _local_7:Number = ((ima - imb) + imc); + var _local_8:Number = ((ime - imf) + img); + var _local_9:Number = ((imi - imj) + imk); + this.topPlaneX = ((_local_9 * _local_5) - (_local_8 * _local_6)); + this.topPlaneY = ((_local_7 * _local_6) - (_local_9 * _local_4)); + this.topPlaneZ = ((_local_8 * _local_4) - (_local_7 * _local_5)); + this.topPlaneOffset = (((imd * this.topPlaneX) + (imh * this.topPlaneY)) + (iml * this.topPlaneZ)); + _local_3 = (1 / Math.sqrt((((_local_4 * _local_4) + (_local_5 * _local_5)) + (_local_6 * _local_6)))); + _local_4 = (_local_4 * _local_3); + _local_5 = (_local_5 * _local_3); + _local_6 = (_local_6 * _local_3); + var _local_10:Number = (((_local_4 * this.directionX) + (_local_5 * this.directionY)) + (_local_6 * this.directionZ)); + this.viewAngle = _local_10; + _local_4 = _local_7; + _local_5 = _local_8; + _local_6 = _local_9; + _local_7 = ((ima + imb) + imc); + _local_8 = ((ime + imf) + img); + _local_9 = ((imi + imj) + imk); + this.rightPlaneX = ((_local_9 * _local_5) - (_local_8 * _local_6)); + this.rightPlaneY = ((_local_7 * _local_6) - (_local_9 * _local_4)); + this.rightPlaneZ = ((_local_8 * _local_4) - (_local_7 * _local_5)); + this.rightPlaneOffset = (((imd * this.rightPlaneX) + (imh * this.rightPlaneY)) + (iml * this.rightPlaneZ)); + _local_3 = (1 / Math.sqrt((((_local_4 * _local_4) + (_local_5 * _local_5)) + (_local_6 * _local_6)))); + _local_4 = (_local_4 * _local_3); + _local_5 = (_local_5 * _local_3); + _local_6 = (_local_6 * _local_3); + _local_10 = (((_local_4 * this.directionX) + (_local_5 * this.directionY)) + (_local_6 * this.directionZ)); + if (_local_10 < this.viewAngle) + { + this.viewAngle = _local_10; + }; + _local_4 = _local_7; + _local_5 = _local_8; + _local_6 = _local_9; + _local_7 = ((-(ima) + imb) + imc); + _local_8 = ((-(ime) + imf) + img); + _local_9 = ((-(imi) + imj) + imk); + this.bottomPlaneX = ((_local_9 * _local_5) - (_local_8 * _local_6)); + this.bottomPlaneY = ((_local_7 * _local_6) - (_local_9 * _local_4)); + this.bottomPlaneZ = ((_local_8 * _local_4) - (_local_7 * _local_5)); + this.bottomPlaneOffset = (((imd * this.bottomPlaneX) + (imh * this.bottomPlaneY)) + (iml * this.bottomPlaneZ)); + _local_3 = (1 / Math.sqrt((((_local_4 * _local_4) + (_local_5 * _local_5)) + (_local_6 * _local_6)))); + _local_4 = (_local_4 * _local_3); + _local_5 = (_local_5 * _local_3); + _local_6 = (_local_6 * _local_3); + _local_10 = (((_local_4 * this.directionX) + (_local_5 * this.directionY)) + (_local_6 * this.directionZ)); + if (_local_10 < this.viewAngle) + { + this.viewAngle = _local_10; + }; + _local_4 = _local_7; + _local_5 = _local_8; + _local_6 = _local_9; + _local_7 = ((-(ima) - imb) + imc); + _local_8 = ((-(ime) - imf) + img); + _local_9 = ((-(imi) - imj) + imk); + this.leftPlaneX = ((_local_9 * _local_5) - (_local_8 * _local_6)); + this.leftPlaneY = ((_local_7 * _local_6) - (_local_9 * _local_4)); + this.leftPlaneZ = ((_local_8 * _local_4) - (_local_7 * _local_5)); + this.leftPlaneOffset = (((imd * this.leftPlaneX) + (imh * this.leftPlaneY)) + (iml * this.leftPlaneZ)); + _local_3 = (1 / Math.sqrt((((_local_4 * _local_4) + (_local_5 * _local_5)) + (_local_6 * _local_6)))); + _local_4 = (_local_4 * _local_3); + _local_5 = (_local_5 * _local_3); + _local_6 = (_local_6 * _local_3); + _local_10 = (((_local_4 * this.directionX) + (_local_5 * this.directionY)) + (_local_6 * this.directionZ)); + if (_local_10 < this.viewAngle) + { + this.viewAngle = _local_10; + }; + this.viewAngle = Math.sin(Math.acos(this.viewAngle)); + } + + private function cullingInContainer(_arg_1:int, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number):int + { + if (_arg_1 > 0) + { + if ((_arg_1 & 0x01)) + { + if (this.nearPlaneX >= 0) + { + if (this.nearPlaneY >= 0) + { + if (this.nearPlaneZ >= 0) + { + if ((((_arg_5 * this.nearPlaneX) + (_arg_6 * this.nearPlaneY)) + (_arg_7 * this.nearPlaneZ)) <= this.nearPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.nearPlaneX) + (_arg_3 * this.nearPlaneY)) + (_arg_4 * this.nearPlaneZ)) > this.nearPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3E); + }; + } else + { + if ((((_arg_5 * this.nearPlaneX) + (_arg_6 * this.nearPlaneY)) + (_arg_4 * this.nearPlaneZ)) <= this.nearPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.nearPlaneX) + (_arg_3 * this.nearPlaneY)) + (_arg_7 * this.nearPlaneZ)) > this.nearPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3E); + }; + }; + } else + { + if (this.nearPlaneZ >= 0) + { + if ((((_arg_5 * this.nearPlaneX) + (_arg_3 * this.nearPlaneY)) + (_arg_7 * this.nearPlaneZ)) <= this.nearPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.nearPlaneX) + (_arg_6 * this.nearPlaneY)) + (_arg_4 * this.nearPlaneZ)) > this.nearPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3E); + }; + } else + { + if ((((_arg_5 * this.nearPlaneX) + (_arg_3 * this.nearPlaneY)) + (_arg_4 * this.nearPlaneZ)) <= this.nearPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.nearPlaneX) + (_arg_6 * this.nearPlaneY)) + (_arg_7 * this.nearPlaneZ)) > this.nearPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3E); + }; + }; + }; + } else + { + if (this.nearPlaneY >= 0) + { + if (this.nearPlaneZ >= 0) + { + if ((((_arg_2 * this.nearPlaneX) + (_arg_6 * this.nearPlaneY)) + (_arg_7 * this.nearPlaneZ)) <= this.nearPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.nearPlaneX) + (_arg_3 * this.nearPlaneY)) + (_arg_4 * this.nearPlaneZ)) > this.nearPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3E); + }; + } else + { + if ((((_arg_2 * this.nearPlaneX) + (_arg_6 * this.nearPlaneY)) + (_arg_4 * this.nearPlaneZ)) <= this.nearPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.nearPlaneX) + (_arg_3 * this.nearPlaneY)) + (_arg_7 * this.nearPlaneZ)) > this.nearPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3E); + }; + }; + } else + { + if (this.nearPlaneZ >= 0) + { + if ((((_arg_2 * this.nearPlaneX) + (_arg_3 * this.nearPlaneY)) + (_arg_7 * this.nearPlaneZ)) <= this.nearPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.nearPlaneX) + (_arg_6 * this.nearPlaneY)) + (_arg_4 * this.nearPlaneZ)) > this.nearPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3E); + }; + } else + { + if ((((_arg_2 * this.nearPlaneX) + (_arg_3 * this.nearPlaneY)) + (_arg_4 * this.nearPlaneZ)) <= this.nearPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.nearPlaneX) + (_arg_6 * this.nearPlaneY)) + (_arg_7 * this.nearPlaneZ)) > this.nearPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3E); + }; + }; + }; + }; + }; + if ((_arg_1 & 0x02)) + { + if (this.farPlaneX >= 0) + { + if (this.farPlaneY >= 0) + { + if (this.farPlaneZ >= 0) + { + if ((((_arg_5 * this.farPlaneX) + (_arg_6 * this.farPlaneY)) + (_arg_7 * this.farPlaneZ)) <= this.farPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.farPlaneX) + (_arg_3 * this.farPlaneY)) + (_arg_4 * this.farPlaneZ)) > this.farPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3D); + }; + } else + { + if ((((_arg_5 * this.farPlaneX) + (_arg_6 * this.farPlaneY)) + (_arg_4 * this.farPlaneZ)) <= this.farPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.farPlaneX) + (_arg_3 * this.farPlaneY)) + (_arg_7 * this.farPlaneZ)) > this.farPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3D); + }; + }; + } else + { + if (this.farPlaneZ >= 0) + { + if ((((_arg_5 * this.farPlaneX) + (_arg_3 * this.farPlaneY)) + (_arg_7 * this.farPlaneZ)) <= this.farPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.farPlaneX) + (_arg_6 * this.farPlaneY)) + (_arg_4 * this.farPlaneZ)) > this.farPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3D); + }; + } else + { + if ((((_arg_5 * this.farPlaneX) + (_arg_3 * this.farPlaneY)) + (_arg_4 * this.farPlaneZ)) <= this.farPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.farPlaneX) + (_arg_6 * this.farPlaneY)) + (_arg_7 * this.farPlaneZ)) > this.farPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3D); + }; + }; + }; + } else + { + if (this.farPlaneY >= 0) + { + if (this.farPlaneZ >= 0) + { + if ((((_arg_2 * this.farPlaneX) + (_arg_6 * this.farPlaneY)) + (_arg_7 * this.farPlaneZ)) <= this.farPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.farPlaneX) + (_arg_3 * this.farPlaneY)) + (_arg_4 * this.farPlaneZ)) > this.farPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3D); + }; + } else + { + if ((((_arg_2 * this.farPlaneX) + (_arg_6 * this.farPlaneY)) + (_arg_4 * this.farPlaneZ)) <= this.farPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.farPlaneX) + (_arg_3 * this.farPlaneY)) + (_arg_7 * this.farPlaneZ)) > this.farPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3D); + }; + }; + } else + { + if (this.farPlaneZ >= 0) + { + if ((((_arg_2 * this.farPlaneX) + (_arg_3 * this.farPlaneY)) + (_arg_7 * this.farPlaneZ)) <= this.farPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.farPlaneX) + (_arg_6 * this.farPlaneY)) + (_arg_4 * this.farPlaneZ)) > this.farPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3D); + }; + } else + { + if ((((_arg_2 * this.farPlaneX) + (_arg_3 * this.farPlaneY)) + (_arg_4 * this.farPlaneZ)) <= this.farPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.farPlaneX) + (_arg_6 * this.farPlaneY)) + (_arg_7 * this.farPlaneZ)) > this.farPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3D); + }; + }; + }; + }; + }; + if ((_arg_1 & 0x04)) + { + if (this.leftPlaneX >= 0) + { + if (this.leftPlaneY >= 0) + { + if (this.leftPlaneZ >= 0) + { + if ((((_arg_5 * this.leftPlaneX) + (_arg_6 * this.leftPlaneY)) + (_arg_7 * this.leftPlaneZ)) <= this.leftPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.leftPlaneX) + (_arg_3 * this.leftPlaneY)) + (_arg_4 * this.leftPlaneZ)) > this.leftPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3B); + }; + } else + { + if ((((_arg_5 * this.leftPlaneX) + (_arg_6 * this.leftPlaneY)) + (_arg_4 * this.leftPlaneZ)) <= this.leftPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.leftPlaneX) + (_arg_3 * this.leftPlaneY)) + (_arg_7 * this.leftPlaneZ)) > this.leftPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3B); + }; + }; + } else + { + if (this.leftPlaneZ >= 0) + { + if ((((_arg_5 * this.leftPlaneX) + (_arg_3 * this.leftPlaneY)) + (_arg_7 * this.leftPlaneZ)) <= this.leftPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.leftPlaneX) + (_arg_6 * this.leftPlaneY)) + (_arg_4 * this.leftPlaneZ)) > this.leftPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3B); + }; + } else + { + if ((((_arg_5 * this.leftPlaneX) + (_arg_3 * this.leftPlaneY)) + (_arg_4 * this.leftPlaneZ)) <= this.leftPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.leftPlaneX) + (_arg_6 * this.leftPlaneY)) + (_arg_7 * this.leftPlaneZ)) > this.leftPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3B); + }; + }; + }; + } else + { + if (this.leftPlaneY >= 0) + { + if (this.leftPlaneZ >= 0) + { + if ((((_arg_2 * this.leftPlaneX) + (_arg_6 * this.leftPlaneY)) + (_arg_7 * this.leftPlaneZ)) <= this.leftPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.leftPlaneX) + (_arg_3 * this.leftPlaneY)) + (_arg_4 * this.leftPlaneZ)) > this.leftPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3B); + }; + } else + { + if ((((_arg_2 * this.leftPlaneX) + (_arg_6 * this.leftPlaneY)) + (_arg_4 * this.leftPlaneZ)) <= this.leftPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.leftPlaneX) + (_arg_3 * this.leftPlaneY)) + (_arg_7 * this.leftPlaneZ)) > this.leftPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3B); + }; + }; + } else + { + if (this.leftPlaneZ >= 0) + { + if ((((_arg_2 * this.leftPlaneX) + (_arg_3 * this.leftPlaneY)) + (_arg_7 * this.leftPlaneZ)) <= this.leftPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.leftPlaneX) + (_arg_6 * this.leftPlaneY)) + (_arg_4 * this.leftPlaneZ)) > this.leftPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3B); + }; + } else + { + if ((((_arg_2 * this.leftPlaneX) + (_arg_3 * this.leftPlaneY)) + (_arg_4 * this.leftPlaneZ)) <= this.leftPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.leftPlaneX) + (_arg_6 * this.leftPlaneY)) + (_arg_7 * this.leftPlaneZ)) > this.leftPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3B); + }; + }; + }; + }; + }; + if ((_arg_1 & 0x08)) + { + if (this.rightPlaneX >= 0) + { + if (this.rightPlaneY >= 0) + { + if (this.rightPlaneZ >= 0) + { + if ((((_arg_5 * this.rightPlaneX) + (_arg_6 * this.rightPlaneY)) + (_arg_7 * this.rightPlaneZ)) <= this.rightPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.rightPlaneX) + (_arg_3 * this.rightPlaneY)) + (_arg_4 * this.rightPlaneZ)) > this.rightPlaneOffset) + { + _arg_1 = (_arg_1 & 0x37); + }; + } else + { + if ((((_arg_5 * this.rightPlaneX) + (_arg_6 * this.rightPlaneY)) + (_arg_4 * this.rightPlaneZ)) <= this.rightPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.rightPlaneX) + (_arg_3 * this.rightPlaneY)) + (_arg_7 * this.rightPlaneZ)) > this.rightPlaneOffset) + { + _arg_1 = (_arg_1 & 0x37); + }; + }; + } else + { + if (this.rightPlaneZ >= 0) + { + if ((((_arg_5 * this.rightPlaneX) + (_arg_3 * this.rightPlaneY)) + (_arg_7 * this.rightPlaneZ)) <= this.rightPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.rightPlaneX) + (_arg_6 * this.rightPlaneY)) + (_arg_4 * this.rightPlaneZ)) > this.rightPlaneOffset) + { + _arg_1 = (_arg_1 & 0x37); + }; + } else + { + if ((((_arg_5 * this.rightPlaneX) + (_arg_3 * this.rightPlaneY)) + (_arg_4 * this.rightPlaneZ)) <= this.rightPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.rightPlaneX) + (_arg_6 * this.rightPlaneY)) + (_arg_7 * this.rightPlaneZ)) > this.rightPlaneOffset) + { + _arg_1 = (_arg_1 & 0x37); + }; + }; + }; + } else + { + if (this.rightPlaneY >= 0) + { + if (this.rightPlaneZ >= 0) + { + if ((((_arg_2 * this.rightPlaneX) + (_arg_6 * this.rightPlaneY)) + (_arg_7 * this.rightPlaneZ)) <= this.rightPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.rightPlaneX) + (_arg_3 * this.rightPlaneY)) + (_arg_4 * this.rightPlaneZ)) > this.rightPlaneOffset) + { + _arg_1 = (_arg_1 & 0x37); + }; + } else + { + if ((((_arg_2 * this.rightPlaneX) + (_arg_6 * this.rightPlaneY)) + (_arg_4 * this.rightPlaneZ)) <= this.rightPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.rightPlaneX) + (_arg_3 * this.rightPlaneY)) + (_arg_7 * this.rightPlaneZ)) > this.rightPlaneOffset) + { + _arg_1 = (_arg_1 & 0x37); + }; + }; + } else + { + if (this.rightPlaneZ >= 0) + { + if ((((_arg_2 * this.rightPlaneX) + (_arg_3 * this.rightPlaneY)) + (_arg_7 * this.rightPlaneZ)) <= this.rightPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.rightPlaneX) + (_arg_6 * this.rightPlaneY)) + (_arg_4 * this.rightPlaneZ)) > this.rightPlaneOffset) + { + _arg_1 = (_arg_1 & 0x37); + }; + } else + { + if ((((_arg_2 * this.rightPlaneX) + (_arg_3 * this.rightPlaneY)) + (_arg_4 * this.rightPlaneZ)) <= this.rightPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.rightPlaneX) + (_arg_6 * this.rightPlaneY)) + (_arg_7 * this.rightPlaneZ)) > this.rightPlaneOffset) + { + _arg_1 = (_arg_1 & 0x37); + }; + }; + }; + }; + }; + if ((_arg_1 & 0x10)) + { + if (this.topPlaneX >= 0) + { + if (this.topPlaneY >= 0) + { + if (this.topPlaneZ >= 0) + { + if ((((_arg_5 * this.topPlaneX) + (_arg_6 * this.topPlaneY)) + (_arg_7 * this.topPlaneZ)) <= this.topPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.topPlaneX) + (_arg_3 * this.topPlaneY)) + (_arg_4 * this.topPlaneZ)) > this.topPlaneOffset) + { + _arg_1 = (_arg_1 & 0x2F); + }; + } else + { + if ((((_arg_5 * this.topPlaneX) + (_arg_6 * this.topPlaneY)) + (_arg_4 * this.topPlaneZ)) <= this.topPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.topPlaneX) + (_arg_3 * this.topPlaneY)) + (_arg_7 * this.topPlaneZ)) > this.topPlaneOffset) + { + _arg_1 = (_arg_1 & 0x2F); + }; + }; + } else + { + if (this.topPlaneZ >= 0) + { + if ((((_arg_5 * this.topPlaneX) + (_arg_3 * this.topPlaneY)) + (_arg_7 * this.topPlaneZ)) <= this.topPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.topPlaneX) + (_arg_6 * this.topPlaneY)) + (_arg_4 * this.topPlaneZ)) > this.topPlaneOffset) + { + _arg_1 = (_arg_1 & 0x2F); + }; + } else + { + if ((((_arg_5 * this.topPlaneX) + (_arg_3 * this.topPlaneY)) + (_arg_4 * this.topPlaneZ)) <= this.topPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.topPlaneX) + (_arg_6 * this.topPlaneY)) + (_arg_7 * this.topPlaneZ)) > this.topPlaneOffset) + { + _arg_1 = (_arg_1 & 0x2F); + }; + }; + }; + } else + { + if (this.topPlaneY >= 0) + { + if (this.topPlaneZ >= 0) + { + if ((((_arg_2 * this.topPlaneX) + (_arg_6 * this.topPlaneY)) + (_arg_7 * this.topPlaneZ)) <= this.topPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.topPlaneX) + (_arg_3 * this.topPlaneY)) + (_arg_4 * this.topPlaneZ)) > this.topPlaneOffset) + { + _arg_1 = (_arg_1 & 0x2F); + }; + } else + { + if ((((_arg_2 * this.topPlaneX) + (_arg_6 * this.topPlaneY)) + (_arg_4 * this.topPlaneZ)) <= this.topPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.topPlaneX) + (_arg_3 * this.topPlaneY)) + (_arg_7 * this.topPlaneZ)) > this.topPlaneOffset) + { + _arg_1 = (_arg_1 & 0x2F); + }; + }; + } else + { + if (this.topPlaneZ >= 0) + { + if ((((_arg_2 * this.topPlaneX) + (_arg_3 * this.topPlaneY)) + (_arg_7 * this.topPlaneZ)) <= this.topPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.topPlaneX) + (_arg_6 * this.topPlaneY)) + (_arg_4 * this.topPlaneZ)) > this.topPlaneOffset) + { + _arg_1 = (_arg_1 & 0x2F); + }; + } else + { + if ((((_arg_2 * this.topPlaneX) + (_arg_3 * this.topPlaneY)) + (_arg_4 * this.topPlaneZ)) <= this.topPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.topPlaneX) + (_arg_6 * this.topPlaneY)) + (_arg_7 * this.topPlaneZ)) > this.topPlaneOffset) + { + _arg_1 = (_arg_1 & 0x2F); + }; + }; + }; + }; + }; + if ((_arg_1 & 0x20)) + { + if (this.bottomPlaneX >= 0) + { + if (this.bottomPlaneY >= 0) + { + if (this.bottomPlaneZ >= 0) + { + if ((((_arg_5 * this.bottomPlaneX) + (_arg_6 * this.bottomPlaneY)) + (_arg_7 * this.bottomPlaneZ)) <= this.bottomPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.bottomPlaneX) + (_arg_3 * this.bottomPlaneY)) + (_arg_4 * this.bottomPlaneZ)) > this.bottomPlaneOffset) + { + _arg_1 = (_arg_1 & 0x1F); + }; + } else + { + if ((((_arg_5 * this.bottomPlaneX) + (_arg_6 * this.bottomPlaneY)) + (_arg_4 * this.bottomPlaneZ)) <= this.bottomPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.bottomPlaneX) + (_arg_3 * this.bottomPlaneY)) + (_arg_7 * this.bottomPlaneZ)) > this.bottomPlaneOffset) + { + _arg_1 = (_arg_1 & 0x1F); + }; + }; + } else + { + if (this.bottomPlaneZ >= 0) + { + if ((((_arg_5 * this.bottomPlaneX) + (_arg_3 * this.bottomPlaneY)) + (_arg_7 * this.bottomPlaneZ)) <= this.bottomPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.bottomPlaneX) + (_arg_6 * this.bottomPlaneY)) + (_arg_4 * this.bottomPlaneZ)) > this.bottomPlaneOffset) + { + _arg_1 = (_arg_1 & 0x1F); + }; + } else + { + if ((((_arg_5 * this.bottomPlaneX) + (_arg_3 * this.bottomPlaneY)) + (_arg_4 * this.bottomPlaneZ)) <= this.bottomPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.bottomPlaneX) + (_arg_6 * this.bottomPlaneY)) + (_arg_7 * this.bottomPlaneZ)) > this.bottomPlaneOffset) + { + _arg_1 = (_arg_1 & 0x1F); + }; + }; + }; + } else + { + if (this.bottomPlaneY >= 0) + { + if (this.bottomPlaneZ >= 0) + { + if ((((_arg_2 * this.bottomPlaneX) + (_arg_6 * this.bottomPlaneY)) + (_arg_7 * this.bottomPlaneZ)) <= this.bottomPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.bottomPlaneX) + (_arg_3 * this.bottomPlaneY)) + (_arg_4 * this.bottomPlaneZ)) > this.bottomPlaneOffset) + { + _arg_1 = (_arg_1 & 0x1F); + }; + } else + { + if ((((_arg_2 * this.bottomPlaneX) + (_arg_6 * this.bottomPlaneY)) + (_arg_4 * this.bottomPlaneZ)) <= this.bottomPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.bottomPlaneX) + (_arg_3 * this.bottomPlaneY)) + (_arg_7 * this.bottomPlaneZ)) > this.bottomPlaneOffset) + { + _arg_1 = (_arg_1 & 0x1F); + }; + }; + } else + { + if (this.bottomPlaneZ >= 0) + { + if ((((_arg_2 * this.bottomPlaneX) + (_arg_3 * this.bottomPlaneY)) + (_arg_7 * this.bottomPlaneZ)) <= this.bottomPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.bottomPlaneX) + (_arg_6 * this.bottomPlaneY)) + (_arg_4 * this.bottomPlaneZ)) > this.bottomPlaneOffset) + { + _arg_1 = (_arg_1 & 0x1F); + }; + } else + { + if ((((_arg_2 * this.bottomPlaneX) + (_arg_3 * this.bottomPlaneY)) + (_arg_4 * this.bottomPlaneZ)) <= this.bottomPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.bottomPlaneX) + (_arg_6 * this.bottomPlaneY)) + (_arg_7 * this.bottomPlaneZ)) > this.bottomPlaneOffset) + { + _arg_1 = (_arg_1 & 0x1F); + }; + }; + }; + }; + }; + }; + return (_arg_1); + } + + private function calculateFaceList(_arg_1:Mesh, _arg_2:Boolean, _arg_3:Face=null):Face + { + var _local_4:Vertex; + var _local_5:Number; + var _local_6:Number; + var _local_7:Number; + var _local_8:Face; + _arg_1.composeMatrix(); + _local_4 = _arg_1.vertexList; + while (_local_4.next != null) + { + _local_4.transformId = 0; + _local_4.id = null; + _local_5 = _local_4.x; + _local_6 = _local_4.y; + _local_7 = _local_4.z; + _local_4.x = ((((_arg_1.ma * _local_5) + (_arg_1.mb * _local_6)) + (_arg_1.mc * _local_7)) + _arg_1.md); + _local_4.y = ((((_arg_1.me * _local_5) + (_arg_1.mf * _local_6)) + (_arg_1.mg * _local_7)) + _arg_1.mh); + _local_4.z = ((((_arg_1.mi * _local_5) + (_arg_1.mj * _local_6)) + (_arg_1.mk * _local_7)) + _arg_1.ml); + _local_4 = _local_4.next; + }; + _local_4.transformId = 0; + _local_4.id = null; + _local_5 = _local_4.x; + _local_6 = _local_4.y; + _local_7 = _local_4.z; + _local_4.x = ((((_arg_1.ma * _local_5) + (_arg_1.mb * _local_6)) + (_arg_1.mc * _local_7)) + _arg_1.md); + _local_4.y = ((((_arg_1.me * _local_5) + (_arg_1.mf * _local_6)) + (_arg_1.mg * _local_7)) + _arg_1.mh); + _local_4.z = ((((_arg_1.mi * _local_5) + (_arg_1.mj * _local_6)) + (_arg_1.mk * _local_7)) + _arg_1.ml); + if (_arg_2) + { + _local_4.next = this.vertexList; + this.vertexList = _arg_1.vertexList; + }; + _arg_1.vertexList = null; + _local_8 = _arg_1.faceList; + while (_local_8.next != null) + { + _local_8.calculateBestSequenceAndNormal(); + _local_8.id = null; + _local_8 = _local_8.next; + }; + _local_8.calculateBestSequenceAndNormal(); + _local_8.id = null; + _local_8.next = _arg_3; + _arg_3 = _arg_1.faceList; + _arg_1.faceList = null; + return (_arg_3); + } + + private function createObjectBounds(_arg_1:Object3D):Object3D + { + var _local_2:Object3D = new Object3D(); + _local_2.boundMinX = 1E22; + _local_2.boundMinY = 1E22; + _local_2.boundMinZ = 1E22; + _local_2.boundMaxX = -1E22; + _local_2.boundMaxY = -1E22; + _local_2.boundMaxZ = -1E22; + _arg_1.composeMatrix(); + _arg_1.updateBounds(_local_2, _arg_1); + return (_local_2); + } + + private function calculateObjectBounds(_arg_1:Object3D):void + { + var _local_2:Object3D; + _arg_1.calculateBounds(); + if ((_arg_1 is Object3DContainer)) + { + _local_2 = Object3DContainer(_arg_1).childrenList; + while (_local_2 != null) + { + this.calculateObjectBounds(_local_2); + _local_2 = _local_2.next; + }; + }; + } + + private function createNode(_arg_1:Face, _arg_2:Face, _arg_3:Object3D, _arg_4:Object3D, _arg_5:Vector., _arg_6:Vector., _arg_7:Face=null):BSPNode + { + var _local_9:Face; + var _local_10:Face; + var _local_11:Face; + var _local_12:Face; + var _local_13:Face; + var _local_14:Object3D; + var _local_15:Object3D; + var _local_16:Object3D; + var _local_17:Object3D; + var _local_18:Face; + var _local_19:Face; + var _local_20:Face; + var _local_8:BSPNode = new BSPNode(); + this.calculateNodeBounds(_local_8, _arg_2, _arg_4); + if (_arg_1 != null) + { + _local_9 = ((_arg_1.next != null) ? this.findSplitter(_arg_1) : _arg_1); + } else + { + if (_arg_3 != null) + { + _local_19 = this.createBoundFaces(_arg_4); + _local_18 = _arg_7; + while (_local_18 != null) + { + _local_19 = this.cropBoundFaceList(_local_19, _local_18.normalX, _local_18.normalY, _local_18.normalZ, _local_18.offset); + if (_local_19 == null) break; + _local_18 = _local_18.next; + }; + }; + if (_local_19 != null) + { + _local_18 = _local_19; + while (_local_18.next != null) + { + _local_18 = _local_18.next; + }; + _local_18.next = _arg_2; + _local_9 = ((_local_19.next != null) ? this.findSplitter(_local_19) : _local_19); + } else + { + if (_arg_2 != null) + { + _local_9 = ((_arg_2.next != null) ? this.findSplitter(_arg_2) : _arg_2); + }; + }; + }; + if (_local_9 != null) + { + _local_8.normalX = _local_9.normalX; + _local_8.normalY = _local_9.normalY; + _local_8.normalZ = _local_9.normalZ; + _local_8.offset = _local_9.offset; + if (_arg_1 != null) + { + this.splitFaceList(_local_9, _arg_1, false, _arg_5); + _local_10 = _arg_5[0]; + _local_11 = _arg_5[2]; + }; + if (_arg_2 != null) + { + this.splitFaceList(_local_9, _arg_2, true, _arg_5); + _local_12 = _arg_5[0]; + _local_8.faceList = _arg_5[1]; + _local_13 = _arg_5[2]; + }; + if (_arg_3 != null) + { + this.splitObjectList(_local_9, _arg_3, _arg_4, _arg_6); + _local_14 = _arg_6[0]; + _local_16 = _arg_6[1]; + _local_15 = _arg_6[2]; + _local_17 = _arg_6[3]; + }; + _local_20 = new Face(); + _local_20.next = _arg_7; + if (((!(_local_12 == null)) || (!(_local_14 == null)))) + { + _local_20.normalX = -(_local_8.normalX); + _local_20.normalY = -(_local_8.normalY); + _local_20.normalZ = -(_local_8.normalZ); + _local_20.offset = -(_local_8.offset); + _local_8.negative = this.createNode(_local_10, _local_12, _local_14, _local_16, _arg_5, _arg_6, _local_20); + }; + if (((!(_local_13 == null)) || (!(_local_15 == null)))) + { + _local_20.normalX = _local_8.normalX; + _local_20.normalY = _local_8.normalY; + _local_20.normalZ = _local_8.normalZ; + _local_20.offset = _local_8.offset; + _local_8.positive = this.createNode(_local_11, _local_13, _local_15, _local_17, _arg_5, _arg_6, _local_20); + }; + } else + { + _local_8.objectList = _arg_3; + _local_8.boundList = _arg_4; + }; + return (_local_8); + } + + private function calculateNodeBounds(_arg_1:BSPNode, _arg_2:Face, _arg_3:Object3D):void + { + var _local_6:Wrapper; + var _local_7:Vertex; + _arg_1.boundMinX = 1E22; + _arg_1.boundMinY = 1E22; + _arg_1.boundMinZ = 1E22; + _arg_1.boundMaxX = -1E22; + _arg_1.boundMaxY = -1E22; + _arg_1.boundMaxZ = -1E22; + var _local_4:Object3D = _arg_3; + while (_local_4 != null) + { + if (_local_4.boundMinX < _arg_1.boundMinX) + { + _arg_1.boundMinX = _local_4.boundMinX; + }; + if (_local_4.boundMaxX > _arg_1.boundMaxX) + { + _arg_1.boundMaxX = _local_4.boundMaxX; + }; + if (_local_4.boundMinY < _arg_1.boundMinY) + { + _arg_1.boundMinY = _local_4.boundMinY; + }; + if (_local_4.boundMaxY > _arg_1.boundMaxY) + { + _arg_1.boundMaxY = _local_4.boundMaxY; + }; + if (_local_4.boundMinZ < _arg_1.boundMinZ) + { + _arg_1.boundMinZ = _local_4.boundMinZ; + }; + if (_local_4.boundMaxZ > _arg_1.boundMaxZ) + { + _arg_1.boundMaxZ = _local_4.boundMaxZ; + }; + _local_4 = _local_4.next; + }; + var _local_5:Face = _arg_2; + while (_local_5 != null) + { + _local_6 = _local_5.wrapper; + while (_local_6 != null) + { + _local_7 = _local_6.vertex; + if (_local_7.x < _arg_1.boundMinX) + { + _arg_1.boundMinX = _local_7.x; + }; + if (_local_7.x > _arg_1.boundMaxX) + { + _arg_1.boundMaxX = _local_7.x; + }; + if (_local_7.y < _arg_1.boundMinY) + { + _arg_1.boundMinY = _local_7.y; + }; + if (_local_7.y > _arg_1.boundMaxY) + { + _arg_1.boundMaxY = _local_7.y; + }; + if (_local_7.z < _arg_1.boundMinZ) + { + _arg_1.boundMinZ = _local_7.z; + }; + if (_local_7.z > _arg_1.boundMaxZ) + { + _arg_1.boundMaxZ = _local_7.z; + }; + _local_6 = _local_6.next; + }; + _local_5 = _local_5.next; + }; + } + + private function findSplitter(_arg_1:Face):Face + { + var _local_2:Face; + var _local_5:Number; + var _local_6:Number; + var _local_7:Number; + var _local_8:Number; + var _local_9:Number; + var _local_10:Number; + var _local_11:int; + var _local_12:Face; + var _local_13:Wrapper; + var _local_14:Vertex; + var _local_15:Vertex; + var _local_16:Vertex; + var _local_17:Number; + var _local_18:Number; + var _local_19:Number; + var _local_20:Boolean; + var _local_21:Boolean; + var _local_22:Vertex; + var _local_23:Number; + var _local_3:int = 2147483647; + var _local_4:Face = _arg_1; + while (_local_4 != null) + { + _local_5 = _local_4.normalX; + _local_6 = _local_4.normalY; + _local_7 = _local_4.normalZ; + _local_8 = _local_4.offset; + _local_9 = (_local_8 - threshold); + _local_10 = (_local_8 + threshold); + _local_11 = 0; + _local_12 = _arg_1; + while (_local_12 != null) + { + if (_local_12 != _local_4) + { + _local_13 = _local_12.wrapper; + _local_14 = _local_13.vertex; + _local_13 = _local_13.next; + _local_15 = _local_13.vertex; + _local_13 = _local_13.next; + _local_16 = _local_13.vertex; + _local_17 = (((_local_14.x * _local_5) + (_local_14.y * _local_6)) + (_local_14.z * _local_7)); + _local_18 = (((_local_15.x * _local_5) + (_local_15.y * _local_6)) + (_local_15.z * _local_7)); + _local_19 = (((_local_16.x * _local_5) + (_local_16.y * _local_6)) + (_local_16.z * _local_7)); + _local_20 = (((_local_17 < _local_9) || (_local_18 < _local_9)) || (_local_19 < _local_9)); + _local_21 = (((_local_17 > _local_10) || (_local_18 > _local_10)) || (_local_19 > _local_10)); + _local_13 = _local_13.next; + while (_local_13 != null) + { + _local_22 = _local_13.vertex; + _local_23 = (((_local_22.x * _local_5) + (_local_22.y * _local_6)) + (_local_22.z * _local_7)); + if (_local_23 < _local_9) + { + _local_20 = true; + if (_local_21) break; + } else + { + if (_local_23 > _local_10) + { + _local_21 = true; + if (_local_20) break; + }; + }; + _local_13 = _local_13.next; + }; + if (((_local_21) && (_local_20))) + { + _local_11++; + if (_local_11 >= _local_3) break; + }; + }; + _local_12 = _local_12.next; + }; + if (_local_11 < _local_3) + { + _local_2 = _local_4; + _local_3 = _local_11; + if (_local_3 == 0) break; + }; + _local_4 = _local_4.next; + }; + return (_local_2); + } + + private function createBoundFaces(_arg_1:Object3D):Face + { + var _local_2:Face; + var _local_4:Vertex; + var _local_5:Vertex; + var _local_6:Vertex; + var _local_7:Vertex; + var _local_8:Vertex; + var _local_9:Vertex; + var _local_10:Vertex; + var _local_11:Vertex; + var _local_12:Face; + var _local_3:Object3D = _arg_1; + while (_local_3 != null) + { + _local_4 = new Vertex(); + _local_4.x = _local_3.boundMinX; + _local_4.y = _local_3.boundMinY; + _local_4.z = _local_3.boundMinZ; + _local_5 = new Vertex(); + _local_5.x = _local_3.boundMaxX; + _local_5.y = _local_3.boundMinY; + _local_5.z = _local_3.boundMinZ; + _local_6 = new Vertex(); + _local_6.x = _local_3.boundMinX; + _local_6.y = _local_3.boundMaxY; + _local_6.z = _local_3.boundMinZ; + _local_7 = new Vertex(); + _local_7.x = _local_3.boundMaxX; + _local_7.y = _local_3.boundMaxY; + _local_7.z = _local_3.boundMinZ; + _local_8 = new Vertex(); + _local_8.x = _local_3.boundMinX; + _local_8.y = _local_3.boundMinY; + _local_8.z = _local_3.boundMaxZ; + _local_9 = new Vertex(); + _local_9.x = _local_3.boundMaxX; + _local_9.y = _local_3.boundMinY; + _local_9.z = _local_3.boundMaxZ; + _local_10 = new Vertex(); + _local_10.x = _local_3.boundMinX; + _local_10.y = _local_3.boundMaxY; + _local_10.z = _local_3.boundMaxZ; + _local_11 = new Vertex(); + _local_11.x = _local_3.boundMaxX; + _local_11.y = _local_3.boundMaxY; + _local_11.z = _local_3.boundMaxZ; + _local_12 = new Face(); + _local_12.normalX = -1; + _local_12.normalY = 0; + _local_12.normalZ = 0; + _local_12.offset = -(_local_3.boundMinX); + _local_12.wrapper = new Wrapper(); + _local_12.wrapper.vertex = _local_4; + _local_12.wrapper.next = new Wrapper(); + _local_12.wrapper.next.vertex = _local_8; + _local_12.wrapper.next.next = new Wrapper(); + _local_12.wrapper.next.next.vertex = _local_10; + _local_12.wrapper.next.next.next = new Wrapper(); + _local_12.wrapper.next.next.next.vertex = _local_6; + _local_12.next = _local_2; + _local_2 = _local_12; + _local_12 = new Face(); + _local_12.normalX = 1; + _local_12.normalY = 0; + _local_12.normalZ = 0; + _local_12.offset = _local_3.boundMaxX; + _local_12.wrapper = new Wrapper(); + _local_12.wrapper.vertex = _local_5; + _local_12.wrapper.next = new Wrapper(); + _local_12.wrapper.next.vertex = _local_7; + _local_12.wrapper.next.next = new Wrapper(); + _local_12.wrapper.next.next.vertex = _local_11; + _local_12.wrapper.next.next.next = new Wrapper(); + _local_12.wrapper.next.next.next.vertex = _local_9; + _local_12.next = _local_2; + _local_2 = _local_12; + _local_12 = new Face(); + _local_12.normalX = 0; + _local_12.normalY = -1; + _local_12.normalZ = 0; + _local_12.offset = -(_local_3.boundMinY); + _local_12.wrapper = new Wrapper(); + _local_12.wrapper.vertex = _local_4; + _local_12.wrapper.next = new Wrapper(); + _local_12.wrapper.next.vertex = _local_5; + _local_12.wrapper.next.next = new Wrapper(); + _local_12.wrapper.next.next.vertex = _local_9; + _local_12.wrapper.next.next.next = new Wrapper(); + _local_12.wrapper.next.next.next.vertex = _local_8; + _local_12.next = _local_2; + _local_2 = _local_12; + _local_12 = new Face(); + _local_12.normalX = 0; + _local_12.normalY = 1; + _local_12.normalZ = 0; + _local_12.offset = _local_3.boundMaxY; + _local_12.wrapper = new Wrapper(); + _local_12.wrapper.vertex = _local_6; + _local_12.wrapper.next = new Wrapper(); + _local_12.wrapper.next.vertex = _local_10; + _local_12.wrapper.next.next = new Wrapper(); + _local_12.wrapper.next.next.vertex = _local_11; + _local_12.wrapper.next.next.next = new Wrapper(); + _local_12.wrapper.next.next.next.vertex = _local_7; + _local_12.next = _local_2; + _local_2 = _local_12; + _local_12 = new Face(); + _local_12.normalX = 0; + _local_12.normalY = 0; + _local_12.normalZ = -1; + _local_12.offset = -(_local_3.boundMinZ); + _local_12.wrapper = new Wrapper(); + _local_12.wrapper.vertex = _local_4; + _local_12.wrapper.next = new Wrapper(); + _local_12.wrapper.next.vertex = _local_6; + _local_12.wrapper.next.next = new Wrapper(); + _local_12.wrapper.next.next.vertex = _local_7; + _local_12.wrapper.next.next.next = new Wrapper(); + _local_12.wrapper.next.next.next.vertex = _local_5; + _local_12.next = _local_2; + _local_2 = _local_12; + _local_12 = new Face(); + _local_12.normalX = 0; + _local_12.normalY = 0; + _local_12.normalZ = 1; + _local_12.offset = _local_3.boundMaxZ; + _local_12.wrapper = new Wrapper(); + _local_12.wrapper.vertex = _local_8; + _local_12.wrapper.next = new Wrapper(); + _local_12.wrapper.next.vertex = _local_9; + _local_12.wrapper.next.next = new Wrapper(); + _local_12.wrapper.next.next.vertex = _local_11; + _local_12.wrapper.next.next.next = new Wrapper(); + _local_12.wrapper.next.next.next.vertex = _local_10; + _local_12.next = _local_2; + _local_2 = _local_12; + _local_3 = _local_3.next; + }; + return (_local_2); + } + + private function cropBoundFaceList(_arg_1:Face, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number):Face + { + var _local_6:Face; + var _local_10:Face; + var _local_11:Vertex; + var _local_12:Wrapper; + var _local_13:Vertex; + var _local_14:Vertex; + var _local_15:Vertex; + var _local_16:Number; + var _local_17:Number; + var _local_18:Number; + var _local_19:Boolean; + var _local_20:Boolean; + var _local_21:Number; + var _local_22:Wrapper; + var _local_23:Wrapper; + var _local_24:Number; + var _local_7:Number = (_arg_5 - threshold); + var _local_8:Number = (_arg_5 + threshold); + var _local_9:Face = _arg_1; + while (_local_9 != null) + { + _local_10 = _local_9.next; + _local_9.next = null; + _local_12 = _local_9.wrapper; + _local_13 = _local_12.vertex; + _local_12 = _local_12.next; + _local_14 = _local_12.vertex; + _local_12 = _local_12.next; + _local_15 = _local_12.vertex; + _local_12 = _local_12.next; + _local_16 = (((_local_13.x * _arg_2) + (_local_13.y * _arg_3)) + (_local_13.z * _arg_4)); + _local_17 = (((_local_14.x * _arg_2) + (_local_14.y * _arg_3)) + (_local_14.z * _arg_4)); + _local_18 = (((_local_15.x * _arg_2) + (_local_15.y * _arg_3)) + (_local_15.z * _arg_4)); + _local_19 = (((_local_16 < _local_7) || (_local_17 < _local_7)) || (_local_18 < _local_7)); + _local_20 = (((_local_16 > _local_8) || (_local_17 > _local_8)) || (_local_18 > _local_8)); + while (_local_12 != null) + { + _local_11 = _local_12.vertex; + _local_21 = (((_local_11.x * _arg_2) + (_local_11.y * _arg_3)) + (_local_11.z * _arg_4)); + if (_local_21 < _local_7) + { + _local_19 = true; + } else + { + if (_local_21 > _local_8) + { + _local_20 = true; + }; + }; + _local_11.offset = _local_21; + _local_12 = _local_12.next; + }; + if (_local_20) + { + if ((!(_local_19))) + { + _local_9.next = _local_6; + _local_6 = _local_9; + } else + { + _local_13.offset = _local_16; + _local_14.offset = _local_17; + _local_15.offset = _local_18; + _local_22 = null; + _local_12 = _local_9.wrapper.next.next; + while (_local_12.next != null) + { + _local_12 = _local_12.next; + }; + _local_13 = _local_12.vertex; + _local_16 = _local_13.offset; + _local_12 = _local_9.wrapper; + _local_9.wrapper = null; + while (_local_12 != null) + { + _local_14 = _local_12.vertex; + _local_17 = _local_14.offset; + if ((((_local_16 < _local_7) && (_local_17 > _local_8)) || ((_local_16 > _local_8) && (_local_17 < _local_7)))) + { + _local_24 = ((_arg_5 - _local_16) / (_local_17 - _local_16)); + _local_11 = new Vertex(); + _local_11.x = (_local_13.x + ((_local_14.x - _local_13.x) * _local_24)); + _local_11.y = (_local_13.y + ((_local_14.y - _local_13.y) * _local_24)); + _local_11.z = (_local_13.z + ((_local_14.z - _local_13.z) * _local_24)); + _local_23 = _local_12.create(); + _local_23.vertex = _local_11; + if (_local_22 != null) + { + _local_22.next = _local_23; + } else + { + _local_9.wrapper = _local_23; + }; + _local_22 = _local_23; + }; + if (_local_17 >= _local_7) + { + _local_23 = _local_12.create(); + _local_23.vertex = _local_14; + if (_local_22 != null) + { + _local_22.next = _local_23; + } else + { + _local_9.wrapper = _local_23; + }; + _local_22 = _local_23; + }; + _local_13 = _local_14; + _local_16 = _local_17; + _local_12 = _local_12.next; + }; + _local_9.next = _local_6; + _local_6 = _local_9; + }; + }; + _local_9 = _local_10; + }; + return (_local_6); + } + + private function splitFaceList(_arg_1:Face, _arg_2:Face, _arg_3:Boolean, _arg_4:Vector.):void + { + var _local_11:Face; + var _local_12:Face; + var _local_13:Face; + var _local_14:Face; + var _local_15:Face; + var _local_16:Face; + var _local_17:Face; + var _local_18:Wrapper; + var _local_19:Vertex; + var _local_20:Vertex; + var _local_21:Vertex; + var _local_22:Number; + var _local_23:Number; + var _local_24:Number; + var _local_25:Boolean; + var _local_26:Boolean; + var _local_27:Vertex; + var _local_28:Number; + var _local_29:Face; + var _local_30:Face; + var _local_31:Wrapper; + var _local_32:Wrapper; + var _local_33:Wrapper; + var _local_34:Number; + var _local_5:Number = _arg_1.normalX; + var _local_6:Number = _arg_1.normalY; + var _local_7:Number = _arg_1.normalZ; + var _local_8:Number = _arg_1.offset; + var _local_9:Number = (_local_8 - threshold); + var _local_10:Number = (_local_8 + threshold); + while (_arg_2 != null) + { + _local_17 = _arg_2.next; + _arg_2.next = null; + if (_arg_2 == _arg_1) + { + if (_local_13 != null) + { + _local_14.next = _arg_2; + } else + { + _local_13 = _arg_2; + }; + _local_14 = _arg_2; + _arg_2 = _local_17; + } else + { + _local_18 = _arg_2.wrapper; + _local_19 = _local_18.vertex; + _local_18 = _local_18.next; + _local_20 = _local_18.vertex; + _local_18 = _local_18.next; + _local_21 = _local_18.vertex; + _local_22 = (((_local_19.x * _local_5) + (_local_19.y * _local_6)) + (_local_19.z * _local_7)); + _local_23 = (((_local_20.x * _local_5) + (_local_20.y * _local_6)) + (_local_20.z * _local_7)); + _local_24 = (((_local_21.x * _local_5) + (_local_21.y * _local_6)) + (_local_21.z * _local_7)); + _local_25 = (((_local_22 < _local_9) || (_local_23 < _local_9)) || (_local_24 < _local_9)); + _local_26 = (((_local_22 > _local_10) || (_local_23 > _local_10)) || (_local_24 > _local_10)); + _local_18 = _local_18.next; + while (_local_18 != null) + { + _local_27 = _local_18.vertex; + _local_28 = (((_local_27.x * _local_5) + (_local_27.y * _local_6)) + (_local_27.z * _local_7)); + if (_local_28 < _local_9) + { + _local_25 = true; + } else + { + if (_local_28 > _local_10) + { + _local_26 = true; + }; + }; + _local_27.offset = _local_28; + _local_18 = _local_18.next; + }; + if ((!(_local_25))) + { + if ((!(_local_26))) + { + if ((((_arg_2.normalX * _local_5) + (_arg_2.normalY * _local_6)) + (_arg_2.normalZ * _local_7)) > 0) + { + if (_local_13 != null) + { + _local_14.next = _arg_2; + } else + { + _local_13 = _arg_2; + }; + _local_14 = _arg_2; + } else + { + if (_local_11 != null) + { + _local_12.next = _arg_2; + } else + { + _local_11 = _arg_2; + }; + _local_12 = _arg_2; + }; + } else + { + if (_local_15 != null) + { + _local_16.next = _arg_2; + } else + { + _local_15 = _arg_2; + }; + _local_16 = _arg_2; + }; + } else + { + if ((!(_local_26))) + { + if (_local_11 != null) + { + _local_12.next = _arg_2; + } else + { + _local_11 = _arg_2; + }; + _local_12 = _arg_2; + } else + { + _local_19.offset = _local_22; + _local_20.offset = _local_23; + _local_21.offset = _local_24; + _local_29 = new Face(); + _local_30 = new Face(); + _local_31 = null; + _local_32 = null; + _local_18 = _arg_2.wrapper.next.next; + while (_local_18.next != null) + { + _local_18 = _local_18.next; + }; + _local_19 = _local_18.vertex; + _local_22 = _local_19.offset; + _local_18 = _arg_2.wrapper; + while (_local_18 != null) + { + _local_20 = _local_18.vertex; + _local_23 = _local_20.offset; + if ((((_local_22 < _local_9) && (_local_23 > _local_10)) || ((_local_22 > _local_10) && (_local_23 < _local_9)))) + { + _local_34 = ((_local_8 - _local_22) / (_local_23 - _local_22)); + _local_27 = new Vertex(); + if (_arg_3) + { + _local_27.next = this.vertexList; + this.vertexList = _local_27; + }; + _local_27.x = (_local_19.x + ((_local_20.x - _local_19.x) * _local_34)); + _local_27.y = (_local_19.y + ((_local_20.y - _local_19.y) * _local_34)); + _local_27.z = (_local_19.z + ((_local_20.z - _local_19.z) * _local_34)); + _local_27.u = (_local_19.u + ((_local_20.u - _local_19.u) * _local_34)); + _local_27.v = (_local_19.v + ((_local_20.v - _local_19.v) * _local_34)); + _local_27.normalX = (_local_19.normalX + ((_local_20.normalX - _local_19.normalX) * _local_34)); + _local_27.normalY = (_local_19.normalY + ((_local_20.normalY - _local_19.normalY) * _local_34)); + _local_27.normalZ = (_local_19.normalZ + ((_local_20.normalZ - _local_19.normalZ) * _local_34)); + _local_33 = new Wrapper(); + _local_33.vertex = _local_27; + if (_local_31 != null) + { + _local_31.next = _local_33; + } else + { + _local_29.wrapper = _local_33; + }; + _local_31 = _local_33; + _local_33 = new Wrapper(); + _local_33.vertex = _local_27; + if (_local_32 != null) + { + _local_32.next = _local_33; + } else + { + _local_30.wrapper = _local_33; + }; + _local_32 = _local_33; + }; + if (_local_23 <= _local_10) + { + _local_33 = new Wrapper(); + _local_33.vertex = _local_20; + if (_local_31 != null) + { + _local_31.next = _local_33; + } else + { + _local_29.wrapper = _local_33; + }; + _local_31 = _local_33; + }; + if (_local_23 >= _local_9) + { + _local_33 = new Wrapper(); + _local_33.vertex = _local_20; + if (_local_32 != null) + { + _local_32.next = _local_33; + } else + { + _local_30.wrapper = _local_33; + }; + _local_32 = _local_33; + }; + _local_19 = _local_20; + _local_22 = _local_23; + _local_18 = _local_18.next; + }; + _local_29.material = _arg_2.material; + _local_29.calculateBestSequenceAndNormal(); + if (_local_11 != null) + { + _local_12.next = _local_29; + } else + { + _local_11 = _local_29; + }; + _local_12 = _local_29; + _local_30.material = _arg_2.material; + _local_30.calculateBestSequenceAndNormal(); + if (_local_15 != null) + { + _local_16.next = _local_30; + } else + { + _local_15 = _local_30; + }; + _local_16 = _local_30; + }; + }; + _arg_2 = _local_17; + }; + }; + _arg_4[0] = _local_11; + _arg_4[1] = _local_13; + _arg_4[2] = _local_15; + } + + private function splitObjectList(_arg_1:Face, _arg_2:Object3D, _arg_3:Object3D, _arg_4:Vector.):void + { + var _local_5:Object3D; + var _local_6:Object3D; + var _local_7:Object3D; + var _local_8:Object3D; + var _local_9:Object3D; + var _local_10:Object3D; + var _local_11:Object3D; + var _local_12:Object3D; + var _local_13:int; + var _local_14:Vertex; + var _local_15:Vector3D; + var _local_16:Vector3D; + var _local_17:Vector3D; + var _local_18:int; + var _local_19:Vector.; + _local_9 = _arg_2; + _local_10 = _arg_3; + while (_local_9 != null) + { + _local_11 = _local_9.next; + _local_12 = _local_10.next; + _local_9.next = null; + _local_10.next = null; + _local_13 = this.checkBounds(_arg_1.normalX, _arg_1.normalY, _arg_1.normalZ, _arg_1.offset, _local_10.boundMinX, _local_10.boundMinY, _local_10.boundMinZ, _local_10.boundMaxX, _local_10.boundMaxY, _local_10.boundMaxZ, true); + if (_local_13 < 0) + { + _local_9.next = _local_5; + _local_5 = _local_9; + _local_10.next = _local_6; + _local_6 = _local_10; + } else + { + if (_local_13 > 0) + { + _local_9.next = _local_7; + _local_7 = _local_9; + _local_10.next = _local_8; + _local_8 = _local_10; + } else + { + _local_9.composeMatrix(); + _local_9.calculateInverseMatrix(); + _local_14 = _arg_1.wrapper.vertex; + _local_15 = new Vector3D(((((_local_9.ima * _local_14.x) + (_local_9.imb * _local_14.y)) + (_local_9.imc * _local_14.z)) + _local_9.imd), ((((_local_9.ime * _local_14.x) + (_local_9.imf * _local_14.y)) + (_local_9.img * _local_14.z)) + _local_9.imh), ((((_local_9.imi * _local_14.x) + (_local_9.imj * _local_14.y)) + (_local_9.imk * _local_14.z)) + _local_9.iml)); + _local_14 = _arg_1.wrapper.next.vertex; + _local_16 = new Vector3D(((((_local_9.ima * _local_14.x) + (_local_9.imb * _local_14.y)) + (_local_9.imc * _local_14.z)) + _local_9.imd), ((((_local_9.ime * _local_14.x) + (_local_9.imf * _local_14.y)) + (_local_9.img * _local_14.z)) + _local_9.imh), ((((_local_9.imi * _local_14.x) + (_local_9.imj * _local_14.y)) + (_local_9.imk * _local_14.z)) + _local_9.iml)); + _local_14 = _arg_1.wrapper.next.next.vertex; + _local_17 = new Vector3D(((((_local_9.ima * _local_14.x) + (_local_9.imb * _local_14.y)) + (_local_9.imc * _local_14.z)) + _local_9.imd), ((((_local_9.ime * _local_14.x) + (_local_9.imf * _local_14.y)) + (_local_9.img * _local_14.z)) + _local_9.imh), ((((_local_9.imi * _local_14.x) + (_local_9.imj * _local_14.y)) + (_local_9.imk * _local_14.z)) + _local_9.iml)); + _local_18 = _local_9.testSplit(_local_15, _local_16, _local_17, threshold); + if (_local_18 < 0) + { + _local_9.next = _local_5; + _local_5 = _local_9; + _local_10.next = _local_6; + _local_6 = _local_10; + } else + { + if (_local_18 > 0) + { + _local_9.next = _local_7; + _local_7 = _local_9; + _local_10.next = _local_8; + _local_8 = _local_10; + } else + { + _local_19 = _local_9.split(_local_15, _local_16, _local_17, threshold); + if (_local_19[0] != null) + { + _local_9 = _local_19[0]; + _local_9.setParent(this); + _local_9.next = _local_5; + _local_5 = _local_9; + _local_10 = this.createObjectBounds(_local_9); + _local_10.next = _local_6; + _local_6 = _local_10; + }; + if (_local_19[1] != null) + { + _local_9 = _local_19[1]; + _local_9.setParent(this); + _local_9.next = _local_7; + _local_7 = _local_9; + _local_10 = this.createObjectBounds(_local_9); + _local_10.next = _local_8; + _local_8 = _local_10; + }; + }; + }; + }; + }; + _local_9 = _local_11; + _local_10 = _local_12; + }; + _arg_4[0] = _local_5; + _arg_4[1] = _local_6; + _arg_4[2] = _local_7; + _arg_4[3] = _local_8; + } + + private function destroyNode(_arg_1:BSPNode):void + { + var _local_3:Object3D; + var _local_4:Object3D; + var _local_5:Face; + if (_arg_1.negative != null) + { + this.destroyNode(_arg_1.negative); + _arg_1.negative = null; + }; + if (_arg_1.positive != null) + { + this.destroyNode(_arg_1.positive); + _arg_1.positive = null; + }; + var _local_2:Face = _arg_1.faceList; + while (_local_2 != null) + { + _local_5 = _local_2.next; + _local_2.next = null; + _local_2 = _local_5; + }; + _local_3 = _arg_1.objectList; + while (_local_3 != null) + { + _local_4 = _local_3.next; + _local_3.setParent(null); + _local_3.next = null; + _local_3 = _local_4; + }; + _local_3 = _arg_1.boundList; + while (_local_3 != null) + { + _local_4 = _local_3.next; + _local_3.next = null; + _local_3 = _local_4; + }; + _arg_1.faceList = null; + _arg_1.objectList = null; + _arg_1.boundList = null; + } + + + } +}//package alternativa.engine3d.containers + +import alternativa.engine3d.core.Face; +import alternativa.engine3d.core.Object3D; + +class BSPNode +{ + + public var faceList:Face; + public var negative:BSPNode; + public var positive:BSPNode; + public var normalX:Number; + public var normalY:Number; + public var normalZ:Number; + public var offset:Number; + public var boundMinX:Number; + public var boundMinY:Number; + public var boundMinZ:Number; + public var boundMaxX:Number; + public var boundMaxY:Number; + public var boundMaxZ:Number; + public var objectList:Object3D; + public var boundList:Object3D; + + +} diff --git a/src/alternativa/engine3d/containers/ConflictContainer.as b/src/alternativa/engine3d/containers/ConflictContainer.as new file mode 100644 index 0000000..c1d03c4 --- /dev/null +++ b/src/alternativa/engine3d/containers/ConflictContainer.as @@ -0,0 +1,1263 @@ +package alternativa.engine3d.containers +{ + import alternativa.engine3d.core.Object3DContainer; + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.core.VG; + import alternativa.engine3d.core.Debug; + import alternativa.engine3d.core.Camera3D; + import alternativa.engine3d.core.Vertex; + import alternativa.engine3d.core.Wrapper; + import alternativa.engine3d.core.Face; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class ConflictContainer extends Object3DContainer + { + + public var resolveByAABB:Boolean = true; + public var resolveByOOBB:Boolean = true; + public var threshold:Number = 0.01; + + + override public function clone():Object3D + { + var _local_1:ConflictContainer = new ConflictContainer(); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + override protected function clonePropertiesFrom(_arg_1:Object3D):void + { + super.clonePropertiesFrom(_arg_1); + var _local_2:ConflictContainer = (_arg_1 as ConflictContainer); + this.resolveByAABB = _local_2.resolveByAABB; + this.resolveByOOBB = _local_2.resolveByOOBB; + this.threshold = _local_2.threshold; + } + + override alternativa3d function draw(_arg_1:Camera3D):void + { + var _local_2:int; + var _local_4:VG; + var _local_3:VG = getVG(_arg_1); + if (_local_3 != null) + { + if (((_arg_1.debug) && ((_local_2 = _arg_1.checkInDebug(this)) > 0))) + { + if ((_local_2 & Debug.BOUNDS)) + { + Debug.drawBounds(_arg_1, this, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ); + }; + }; + if (_local_3.next != null) + { + calculateInverseMatrix(); + if (this.resolveByAABB) + { + _local_4 = _local_3; + while (_local_4 != null) + { + _local_4.calculateAABB(ima, imb, imc, imd, ime, imf, img, imh, imi, imj, imk, iml); + _local_4 = _local_4.next; + }; + this.drawAABBGeometry(_arg_1, _local_3); + } else + { + if (this.resolveByOOBB) + { + _local_4 = _local_3; + while (_local_4 != null) + { + _local_4.calculateOOBB(this); + _local_4 = _local_4.next; + }; + this.drawOOBBGeometry(_arg_1, _local_3); + } else + { + this.drawConflictGeometry(_arg_1, _local_3); + }; + }; + } else + { + _local_3.draw(_arg_1, this.threshold, this); + _local_3.destroy(); + }; + }; + } + + alternativa3d function drawAABBGeometry(_arg_1:Camera3D, _arg_2:VG, _arg_3:Boolean=true, _arg_4:Boolean=false, _arg_5:Boolean=true, _arg_6:int=-1):void + { + var _local_7:Boolean; + var _local_8:Boolean; + var _local_9:Boolean; + var _local_14:Boolean; + var _local_10:VG = ((_arg_5) ? this.sortGeometry(_arg_2, _arg_3, _arg_4) : _arg_2); + var _local_11:VG = _local_10; + var _local_12:VG = _local_10.next; + var _local_13:Number = _local_10.boundMax; + while (_local_12 != null) + { + _local_14 = (_local_12.boundMin >= (_local_13 - this.threshold)); + if (((_local_14) || (_local_12.next == null))) + { + if (_local_14) + { + _local_11.next = null; + _arg_6 = 0; + } else + { + _local_12 = null; + _arg_6++; + }; + if (_arg_3) + { + _local_7 = (imd < _local_13); + _local_8 = false; + _local_9 = true; + } else + { + if (_arg_4) + { + _local_7 = (imh < _local_13); + _local_8 = false; + _local_9 = false; + } else + { + _local_7 = (iml < _local_13); + _local_8 = true; + _local_9 = false; + }; + }; + if (_local_7) + { + if (_local_10.next != null) + { + if (_arg_6 < 2) + { + this.drawAABBGeometry(_arg_1, _local_10, _local_8, _local_9, true, _arg_6); + } else + { + if (this.resolveByOOBB) + { + _local_11 = _local_10; + while (_local_11 != null) + { + _local_11.calculateOOBB(this); + _local_11 = _local_11.next; + }; + this.drawOOBBGeometry(_arg_1, _local_10); + } else + { + this.drawConflictGeometry(_arg_1, _local_10); + }; + }; + } else + { + _local_10.draw(_arg_1, this.threshold, this); + _local_10.destroy(); + }; + if (_local_12 != null) + { + if (_local_12.next != null) + { + this.drawAABBGeometry(_arg_1, _local_12, _arg_3, _arg_4, false, -1); + } else + { + _local_12.draw(_arg_1, this.threshold, this); + _local_12.destroy(); + }; + }; + } else + { + if (_local_12 != null) + { + if (_local_12.next != null) + { + this.drawAABBGeometry(_arg_1, _local_12, _arg_3, _arg_4, false, -1); + } else + { + _local_12.draw(_arg_1, this.threshold, this); + _local_12.destroy(); + }; + }; + if (_local_10.next != null) + { + if (_arg_6 < 2) + { + this.drawAABBGeometry(_arg_1, _local_10, _local_8, _local_9, true, _arg_6); + } else + { + if (this.resolveByOOBB) + { + _local_11 = _local_10; + while (_local_11 != null) + { + _local_11.calculateOOBB(this); + _local_11 = _local_11.next; + }; + this.drawOOBBGeometry(_arg_1, _local_10); + } else + { + this.drawConflictGeometry(_arg_1, _local_10); + }; + }; + } else + { + _local_10.draw(_arg_1, this.threshold, this); + _local_10.destroy(); + }; + }; + return; + }; + if (_local_12.boundMax > _local_13) + { + _local_13 = _local_12.boundMax; + }; + _local_11 = _local_12; + _local_12 = _local_12.next; + }; + } + + private function sortGeometry(_arg_1:VG, _arg_2:Boolean, _arg_3:Boolean):VG + { + var _local_4:VG = _arg_1; + var _local_5:VG = _arg_1.next; + while (((!(_local_5 == null)) && (!(_local_5.next == null)))) + { + _arg_1 = _arg_1.next; + _local_5 = _local_5.next.next; + }; + _local_5 = _arg_1.next; + _arg_1.next = null; + if (_local_4.next != null) + { + _local_4 = this.sortGeometry(_local_4, _arg_2, _arg_3); + } else + { + if (_arg_2) + { + _local_4.boundMin = _local_4.boundMinX; + _local_4.boundMax = _local_4.boundMaxX; + } else + { + if (_arg_3) + { + _local_4.boundMin = _local_4.boundMinY; + _local_4.boundMax = _local_4.boundMaxY; + } else + { + _local_4.boundMin = _local_4.boundMinZ; + _local_4.boundMax = _local_4.boundMaxZ; + }; + }; + }; + if (_local_5.next != null) + { + _local_5 = this.sortGeometry(_local_5, _arg_2, _arg_3); + } else + { + if (_arg_2) + { + _local_5.boundMin = _local_5.boundMinX; + _local_5.boundMax = _local_5.boundMaxX; + } else + { + if (_arg_3) + { + _local_5.boundMin = _local_5.boundMinY; + _local_5.boundMax = _local_5.boundMaxY; + } else + { + _local_5.boundMin = _local_5.boundMinZ; + _local_5.boundMax = _local_5.boundMaxZ; + }; + }; + }; + var _local_6:Boolean = (_local_4.boundMin < _local_5.boundMin); + if (_local_6) + { + _arg_1 = _local_4; + _local_4 = _local_4.next; + } else + { + _arg_1 = _local_5; + _local_5 = _local_5.next; + }; + var _local_7:VG = _arg_1; + while (true) + { + if (_local_4 == null) + { + _local_7.next = _local_5; + return (_arg_1); + }; + if (_local_5 == null) + { + _local_7.next = _local_4; + return (_arg_1); + }; + if (_local_6) + { + if (_local_4.boundMin < _local_5.boundMin) + { + _local_7 = _local_4; + _local_4 = _local_4.next; + } else + { + _local_7.next = _local_5; + _local_7 = _local_5; + _local_5 = _local_5.next; + _local_6 = false; + }; + } else + { + if (_local_5.boundMin < _local_4.boundMin) + { + _local_7 = _local_5; + _local_5 = _local_5.next; + } else + { + _local_7.next = _local_4; + _local_7 = _local_4; + _local_4 = _local_4.next; + _local_6 = true; + }; + }; + }; + return (null); + } + + alternativa3d function drawOOBBGeometry(_arg_1:Camera3D, _arg_2:VG):void + { + var _local_3:Vertex; + var _local_4:Vertex; + var _local_5:Wrapper; + var _local_6:Number; + var _local_7:Number; + var _local_8:Number; + var _local_9:Number; + var _local_10:Number; + var _local_11:Boolean; + var _local_12:Boolean; + var _local_13:VG; + var _local_14:VG; + var _local_15:Boolean; + var _local_16:VG; + var _local_17:VG; + var _local_18:VG; + var _local_19:VG; + _local_13 = _arg_2; + while (_local_13 != null) + { + if (_local_13.viewAligned) + { + _local_10 = _local_13.object.ml; + _local_14 = _arg_2; + while (_local_14 != null) + { + if ((!(_local_14.viewAligned))) + { + _local_11 = false; + _local_12 = false; + _local_3 = _local_14.boundVertexList; + while (_local_3 != null) + { + if (_local_3.cameraZ > _local_10) + { + if (_local_11) break; + _local_12 = true; + } else + { + if (_local_12) break; + _local_11 = true; + }; + _local_3 = _local_3.next; + }; + if (_local_3 != null) break; + }; + _local_14 = _local_14.next; + }; + if (_local_14 == null) break; + } else + { + _local_4 = _local_13.boundPlaneList; + while (_local_4 != null) + { + _local_7 = _local_4.cameraX; + _local_8 = _local_4.cameraY; + _local_9 = _local_4.cameraZ; + _local_10 = _local_4.offset; + _local_15 = false; + _local_14 = _arg_2; + while (_local_14 != null) + { + if (_local_13 != _local_14) + { + _local_11 = false; + _local_12 = false; + if (_local_14.viewAligned) + { + _local_5 = _local_14.faceStruct.wrapper; + while (_local_5 != null) + { + _local_3 = _local_5.vertex; + if ((((_local_3.cameraX * _local_7) + (_local_3.cameraY * _local_8)) + (_local_3.cameraZ * _local_9)) >= (_local_10 - this.threshold)) + { + if (_local_11) break; + _local_15 = true; + _local_12 = true; + } else + { + if (_local_12) break; + _local_11 = true; + }; + _local_5 = _local_5.next; + }; + if (_local_5 != null) break; + } else + { + _local_3 = _local_14.boundVertexList; + while (_local_3 != null) + { + if ((((_local_3.cameraX * _local_7) + (_local_3.cameraY * _local_8)) + (_local_3.cameraZ * _local_9)) >= (_local_10 - this.threshold)) + { + if (_local_11) break; + _local_15 = true; + _local_12 = true; + } else + { + if (_local_12) break; + _local_11 = true; + }; + _local_3 = _local_3.next; + }; + if (_local_3 != null) break; + }; + }; + _local_14 = _local_14.next; + }; + if (((_local_14 == null) && (_local_15))) break; + _local_4 = _local_4.next; + }; + if (_local_4 != null) break; + }; + _local_13 = _local_13.next; + }; + if (_local_13 != null) + { + if (_local_13.viewAligned) + { + while (_arg_2 != null) + { + _local_16 = _arg_2.next; + if (_arg_2.viewAligned) + { + _local_6 = (_arg_2.object.ml - _local_10); + if (_local_6 < -(this.threshold)) + { + _arg_2.next = _local_19; + _local_19 = _arg_2; + } else + { + if (_local_6 > this.threshold) + { + _arg_2.next = _local_17; + _local_17 = _arg_2; + } else + { + _arg_2.next = _local_18; + _local_18 = _arg_2; + }; + }; + } else + { + _local_3 = _arg_2.boundVertexList; + while (_local_3 != null) + { + _local_6 = (_local_3.cameraZ - _local_10); + if (_local_6 < -(this.threshold)) + { + _arg_2.next = _local_19; + _local_19 = _arg_2; + break; + }; + if (_local_6 > this.threshold) + { + _arg_2.next = _local_17; + _local_17 = _arg_2; + break; + }; + _local_3 = _local_3.next; + }; + if (_local_3 == null) + { + _arg_2.next = _local_18; + _local_18 = _arg_2; + }; + }; + _arg_2 = _local_16; + }; + } else + { + while (_arg_2 != null) + { + _local_16 = _arg_2.next; + if (_arg_2.viewAligned) + { + _local_5 = _arg_2.faceStruct.wrapper; + while (_local_5 != null) + { + _local_3 = _local_5.vertex; + _local_6 = ((((_local_3.cameraX * _local_7) + (_local_3.cameraY * _local_8)) + (_local_3.cameraZ * _local_9)) - _local_10); + if (_local_6 < -(this.threshold)) + { + _arg_2.next = _local_17; + _local_17 = _arg_2; + break; + }; + if (_local_6 > this.threshold) + { + _arg_2.next = _local_19; + _local_19 = _arg_2; + break; + }; + _local_5 = _local_5.next; + }; + if (_local_5 == null) + { + _arg_2.next = _local_18; + _local_18 = _arg_2; + }; + } else + { + _local_3 = _arg_2.boundVertexList; + while (_local_3 != null) + { + _local_6 = ((((_local_3.cameraX * _local_7) + (_local_3.cameraY * _local_8)) + (_local_3.cameraZ * _local_9)) - _local_10); + if (_local_6 < -(this.threshold)) + { + _arg_2.next = _local_17; + _local_17 = _arg_2; + break; + }; + if (_local_6 > this.threshold) + { + _arg_2.next = _local_19; + _local_19 = _arg_2; + break; + }; + _local_3 = _local_3.next; + }; + if (_local_3 == null) + { + _arg_2.next = _local_18; + _local_18 = _arg_2; + }; + }; + _arg_2 = _local_16; + }; + }; + if (((_local_13.viewAligned) || (_local_10 < 0))) + { + if (_local_19 != null) + { + if (_local_19.next != null) + { + this.drawOOBBGeometry(_arg_1, _local_19); + } else + { + _local_19.draw(_arg_1, this.threshold, this); + _local_19.destroy(); + }; + }; + while (_local_18 != null) + { + _local_16 = _local_18.next; + _local_18.draw(_arg_1, this.threshold, this); + _local_18.destroy(); + _local_18 = _local_16; + }; + if (_local_17 != null) + { + if (_local_17.next != null) + { + this.drawOOBBGeometry(_arg_1, _local_17); + } else + { + _local_17.draw(_arg_1, this.threshold, this); + _local_17.destroy(); + }; + }; + } else + { + if (_local_17 != null) + { + if (_local_17.next != null) + { + this.drawOOBBGeometry(_arg_1, _local_17); + } else + { + _local_17.draw(_arg_1, this.threshold, this); + _local_17.destroy(); + }; + }; + while (_local_18 != null) + { + _local_16 = _local_18.next; + _local_18.draw(_arg_1, this.threshold, this); + _local_18.destroy(); + _local_18 = _local_16; + }; + if (_local_19 != null) + { + if (_local_19.next != null) + { + this.drawOOBBGeometry(_arg_1, _local_19); + } else + { + _local_19.draw(_arg_1, this.threshold, this); + _local_19.destroy(); + }; + }; + }; + } else + { + this.drawConflictGeometry(_arg_1, _arg_2); + }; + } + + alternativa3d function drawConflictGeometry(_arg_1:Camera3D, _arg_2:VG):void + { + var _local_3:Face; + var _local_4:Face; + var _local_5:VG; + var _local_6:VG; + var _local_7:VG; + var _local_8:Face; + var _local_9:Face; + var _local_10:Face; + var _local_11:Face; + var _local_12:Face; + var _local_13:Face; + var _local_14:Face; + var _local_15:Face; + var _local_16:Face; + var _local_17:Boolean; + while (_arg_2 != null) + { + _local_5 = _arg_2.next; + if (_arg_2.space == 1) + { + _arg_2.transformStruct(_arg_2.faceStruct, ++_arg_2.object.transformId, ma, mb, mc, md, me, mf, mg, mh, mi, mj, mk, ml); + }; + if (_arg_2.sorting == 3) + { + _arg_2.next = _local_6; + _local_6 = _arg_2; + } else + { + if (_arg_2.sorting == 2) + { + if (_local_8 != null) + { + _local_9.processNext = _arg_2.faceStruct; + } else + { + _local_8 = _arg_2.faceStruct; + }; + _local_9 = _arg_2.faceStruct; + _local_9.geometry = _arg_2; + while (_local_9.processNext != null) + { + _local_9 = _local_9.processNext; + _local_9.geometry = _arg_2; + }; + } else + { + if (_local_10 != null) + { + _local_11.processNext = _arg_2.faceStruct; + } else + { + _local_10 = _arg_2.faceStruct; + }; + _local_11 = _arg_2.faceStruct; + _local_11.geometry = _arg_2; + while (_local_11.processNext != null) + { + _local_11 = _local_11.processNext; + _local_11.geometry = _arg_2; + }; + }; + _arg_2.faceStruct = null; + _arg_2.next = _local_7; + _local_7 = _arg_2; + }; + _arg_2 = _local_5; + }; + if (_local_7 != null) + { + _arg_2 = _local_7; + while (_arg_2.next != null) + { + _arg_2 = _arg_2.next; + }; + _arg_2.next = _local_6; + } else + { + _local_7 = _local_6; + }; + if (_local_8 != null) + { + _local_12 = _local_8; + _local_9.processNext = _local_10; + } else + { + _local_12 = _local_10; + }; + if (_local_6 != null) + { + _local_6.faceStruct.geometry = _local_6; + _local_12 = this.collectNode(_local_6.faceStruct, _local_12, _arg_1, this.threshold, true); + _local_6.faceStruct = null; + _local_6 = _local_6.next; + while (_local_6 != null) + { + _local_6.faceStruct.geometry = _local_6; + _local_12 = this.collectNode(_local_6.faceStruct, _local_12, _arg_1, this.threshold, false); + _local_6.faceStruct = null; + _local_6 = _local_6.next; + }; + } else + { + if (_local_8 != null) + { + _local_12 = this.collectNode(null, _local_12, _arg_1, this.threshold, true); + } else + { + if (_local_10 != null) + { + _local_12 = _arg_1.sortByAverageZ(_local_12); + }; + }; + }; + _local_3 = _local_12; + while (_local_3 != null) + { + _local_4 = _local_3.processNext; + _arg_2 = _local_3.geometry; + _local_3.geometry = null; + _local_17 = ((_local_4 == null) || (!(_arg_2 == _local_4.geometry))); + if (((_local_17) || (!(_local_3.material == _local_4.material)))) + { + _local_3.processNext = null; + if (_local_17) + { + if (_local_13 != null) + { + _local_14.processNegative = _local_12; + _local_13 = null; + _local_14 = null; + } else + { + _local_12.processPositive = _local_15; + _local_15 = _local_12; + _local_15.geometry = _arg_2; + }; + } else + { + if (_local_13 != null) + { + _local_14.processNegative = _local_12; + } else + { + _local_12.processPositive = _local_15; + _local_15 = _local_12; + _local_15.geometry = _arg_2; + _local_13 = _local_12; + }; + _local_14 = _local_12; + }; + _local_12 = _local_4; + }; + _local_3 = _local_4; + }; + if (_arg_1.debug) + { + _local_12 = _local_15; + while (_local_12 != null) + { + if ((_local_12.geometry.debug & Debug.EDGES)) + { + _local_3 = _local_12; + while (_local_3 != null) + { + Debug.drawEdges(_arg_1, _local_3, 0xFF0000); + _local_3 = _local_3.processNegative; + }; + }; + _local_12 = _local_12.processPositive; + }; + }; + while (_local_15 != null) + { + _local_12 = _local_15; + _local_15 = _local_12.processPositive; + _local_12.processPositive = null; + _arg_2 = _local_12.geometry; + _local_12.geometry = null; + _local_16 = null; + while (_local_12 != null) + { + _local_4 = _local_12.processNegative; + if (_local_12.material != null) + { + _local_12.processNegative = _local_16; + _local_16 = _local_12; + } else + { + _local_12.processNegative = null; + while (_local_12 != null) + { + _local_3 = _local_12.processNext; + _local_12.processNext = null; + _local_12 = _local_3; + }; + }; + _local_12 = _local_4; + }; + _local_12 = _local_16; + while (_local_12 != null) + { + _local_4 = _local_12.processNegative; + _local_12.processNegative = null; + _arg_1.addTransparent(_local_12, _arg_2.object); + _local_12 = _local_4; + }; + }; + _arg_2 = _local_7; + while (_arg_2 != null) + { + _local_5 = _arg_2.next; + _arg_2.destroy(); + _arg_2 = _local_5; + }; + } + + private function collectNode(_arg_1:Face, _arg_2:Face, _arg_3:Camera3D, _arg_4:Number, _arg_5:Boolean, _arg_6:Face=null):Face + { + var _local_7:Wrapper; + var _local_8:Vertex; + var _local_9:Vertex; + var _local_10:Vertex; + var _local_11:Vertex; + var _local_12:Number; + var _local_13:Number; + var _local_14:Number; + var _local_15:Number; + var _local_16:Face; + var _local_17:Face; + var _local_18:Face; + var _local_19:VG; + var _local_22:Face; + var _local_23:Face; + var _local_24:Face; + var _local_25:Face; + var _local_26:Face; + var _local_28:Number; + var _local_29:Number; + var _local_30:Number; + var _local_31:Number; + var _local_32:Number; + var _local_33:Number; + var _local_34:Number; + var _local_35:Number; + var _local_36:Number; + var _local_37:Number; + var _local_38:Number; + var _local_39:Number; + var _local_40:Number; + var _local_41:Number; + var _local_42:Number; + var _local_43:Number; + var _local_44:Number; + var _local_45:Boolean; + var _local_46:Boolean; + var _local_47:Number; + var _local_48:Face; + var _local_49:Face; + var _local_50:Wrapper; + var _local_51:Wrapper; + var _local_52:Wrapper; + var _local_53:Boolean; + var _local_54:Number; + if (_arg_1 != null) + { + _local_19 = _arg_1.geometry; + if (_arg_1.offset < 0) + { + _local_17 = _arg_1.processNegative; + _local_18 = _arg_1.processPositive; + _local_12 = _arg_1.normalX; + _local_13 = _arg_1.normalY; + _local_14 = _arg_1.normalZ; + _local_15 = _arg_1.offset; + } else + { + _local_17 = _arg_1.processPositive; + _local_18 = _arg_1.processNegative; + _local_12 = -(_arg_1.normalX); + _local_13 = -(_arg_1.normalY); + _local_14 = -(_arg_1.normalZ); + _local_15 = -(_arg_1.offset); + }; + _arg_1.processNegative = null; + _arg_1.processPositive = null; + if (_arg_1.wrapper != null) + { + _local_16 = _arg_1; + while (_local_16.processNext != null) + { + _local_16 = _local_16.processNext; + _local_16.geometry = _local_19; + }; + } else + { + _arg_1.geometry = null; + _arg_1 = null; + }; + } else + { + _arg_1 = _arg_2; + _arg_2 = _arg_1.processNext; + _local_16 = _arg_1; + _local_7 = _arg_1.wrapper; + _local_8 = _local_7.vertex; + _local_7 = _local_7.next; + _local_9 = _local_7.vertex; + _local_28 = _local_8.cameraX; + _local_29 = _local_8.cameraY; + _local_30 = _local_8.cameraZ; + _local_31 = (_local_9.cameraX - _local_28); + _local_32 = (_local_9.cameraY - _local_29); + _local_33 = (_local_9.cameraZ - _local_30); + _local_12 = 0; + _local_13 = 0; + _local_14 = 1; + _local_15 = _local_30; + _local_34 = 0; + _local_7 = _local_7.next; + while (_local_7 != null) + { + _local_11 = _local_7.vertex; + _local_35 = (_local_11.cameraX - _local_28); + _local_36 = (_local_11.cameraY - _local_29); + _local_37 = (_local_11.cameraZ - _local_30); + _local_38 = ((_local_37 * _local_32) - (_local_36 * _local_33)); + _local_39 = ((_local_35 * _local_33) - (_local_37 * _local_31)); + _local_40 = ((_local_36 * _local_31) - (_local_35 * _local_32)); + _local_41 = (((_local_38 * _local_38) + (_local_39 * _local_39)) + (_local_40 * _local_40)); + if (_local_41 > _arg_4) + { + _local_41 = (1 / Math.sqrt(_local_41)); + _local_12 = (_local_38 * _local_41); + _local_13 = (_local_39 * _local_41); + _local_14 = (_local_40 * _local_41); + _local_15 = (((_local_28 * _local_12) + (_local_29 * _local_13)) + (_local_30 * _local_14)); + break; + }; + if (_local_41 > _local_34) + { + _local_41 = (1 / Math.sqrt(_local_41)); + _local_12 = (_local_38 * _local_41); + _local_13 = (_local_39 * _local_41); + _local_14 = (_local_40 * _local_41); + _local_15 = (((_local_28 * _local_12) + (_local_29 * _local_13)) + (_local_30 * _local_14)); + _local_34 = _local_41; + }; + _local_7 = _local_7.next; + }; + }; + var _local_20:Number = (_local_15 - _arg_4); + var _local_21:Number = (_local_15 + _arg_4); + var _local_27:Face = _arg_2; + while (_local_27 != null) + { + _local_26 = _local_27.processNext; + _local_7 = _local_27.wrapper; + _local_8 = _local_7.vertex; + _local_7 = _local_7.next; + _local_9 = _local_7.vertex; + _local_7 = _local_7.next; + _local_10 = _local_7.vertex; + _local_7 = _local_7.next; + _local_42 = (((_local_8.cameraX * _local_12) + (_local_8.cameraY * _local_13)) + (_local_8.cameraZ * _local_14)); + _local_43 = (((_local_9.cameraX * _local_12) + (_local_9.cameraY * _local_13)) + (_local_9.cameraZ * _local_14)); + _local_44 = (((_local_10.cameraX * _local_12) + (_local_10.cameraY * _local_13)) + (_local_10.cameraZ * _local_14)); + _local_45 = (((_local_42 < _local_20) || (_local_43 < _local_20)) || (_local_44 < _local_20)); + _local_46 = (((_local_42 > _local_21) || (_local_43 > _local_21)) || (_local_44 > _local_21)); + while (_local_7 != null) + { + _local_11 = _local_7.vertex; + _local_47 = (((_local_11.cameraX * _local_12) + (_local_11.cameraY * _local_13)) + (_local_11.cameraZ * _local_14)); + if (_local_47 < _local_20) + { + _local_45 = true; + } else + { + if (_local_47 > _local_21) + { + _local_46 = true; + }; + }; + _local_11.offset = _local_47; + _local_7 = _local_7.next; + }; + if ((!(_local_45))) + { + if ((!(_local_46))) + { + if (_arg_1 != null) + { + _local_16.processNext = _local_27; + } else + { + _arg_1 = _local_27; + }; + _local_16 = _local_27; + } else + { + if (_local_24 != null) + { + _local_25.processNext = _local_27; + } else + { + _local_24 = _local_27; + }; + _local_25 = _local_27; + }; + } else + { + if ((!(_local_46))) + { + if (_local_22 != null) + { + _local_23.processNext = _local_27; + } else + { + _local_22 = _local_27; + }; + _local_23 = _local_27; + } else + { + _local_8.offset = _local_42; + _local_9.offset = _local_43; + _local_10.offset = _local_44; + _local_48 = _local_27.create(); + _local_48.material = _local_27.material; + _local_48.geometry = _local_27.geometry; + _arg_3.lastFace.next = _local_48; + _arg_3.lastFace = _local_48; + _local_49 = _local_27.create(); + _local_49.material = _local_27.material; + _local_49.geometry = _local_27.geometry; + _arg_3.lastFace.next = _local_49; + _arg_3.lastFace = _local_49; + _local_50 = null; + _local_51 = null; + _local_7 = _local_27.wrapper.next.next; + while (_local_7.next != null) + { + _local_7 = _local_7.next; + }; + _local_8 = _local_7.vertex; + _local_42 = _local_8.offset; + _local_53 = ((!(_local_27.material == null)) && (_local_27.material.useVerticesNormals)); + _local_7 = _local_27.wrapper; + while (_local_7 != null) + { + _local_9 = _local_7.vertex; + _local_43 = _local_9.offset; + if ((((_local_42 < _local_20) && (_local_43 > _local_21)) || ((_local_42 > _local_21) && (_local_43 < _local_20)))) + { + _local_54 = ((_local_15 - _local_42) / (_local_43 - _local_42)); + _local_11 = _local_9.create(); + _arg_3.lastVertex.next = _local_11; + _arg_3.lastVertex = _local_11; + _local_11.cameraX = (_local_8.cameraX + ((_local_9.cameraX - _local_8.cameraX) * _local_54)); + _local_11.cameraY = (_local_8.cameraY + ((_local_9.cameraY - _local_8.cameraY) * _local_54)); + _local_11.cameraZ = (_local_8.cameraZ + ((_local_9.cameraZ - _local_8.cameraZ) * _local_54)); + _local_11.u = (_local_8.u + ((_local_9.u - _local_8.u) * _local_54)); + _local_11.v = (_local_8.v + ((_local_9.v - _local_8.v) * _local_54)); + if (_local_53) + { + _local_11.x = (_local_8.x + ((_local_9.x - _local_8.x) * _local_54)); + _local_11.y = (_local_8.y + ((_local_9.y - _local_8.y) * _local_54)); + _local_11.z = (_local_8.z + ((_local_9.z - _local_8.z) * _local_54)); + _local_11.normalX = (_local_8.normalX + ((_local_9.normalX - _local_8.normalX) * _local_54)); + _local_11.normalY = (_local_8.normalY + ((_local_9.normalY - _local_8.normalY) * _local_54)); + _local_11.normalZ = (_local_8.normalZ + ((_local_9.normalZ - _local_8.normalZ) * _local_54)); + }; + _local_52 = _local_7.create(); + _local_52.vertex = _local_11; + if (_local_50 != null) + { + _local_50.next = _local_52; + } else + { + _local_48.wrapper = _local_52; + }; + _local_50 = _local_52; + _local_52 = _local_7.create(); + _local_52.vertex = _local_11; + if (_local_51 != null) + { + _local_51.next = _local_52; + } else + { + _local_49.wrapper = _local_52; + }; + _local_51 = _local_52; + }; + if (_local_43 <= _local_21) + { + _local_52 = _local_7.create(); + _local_52.vertex = _local_9; + if (_local_50 != null) + { + _local_50.next = _local_52; + } else + { + _local_48.wrapper = _local_52; + }; + _local_50 = _local_52; + }; + if (_local_43 >= _local_20) + { + _local_52 = _local_7.create(); + _local_52.vertex = _local_9; + if (_local_51 != null) + { + _local_51.next = _local_52; + } else + { + _local_49.wrapper = _local_52; + }; + _local_51 = _local_52; + }; + _local_8 = _local_9; + _local_42 = _local_43; + _local_7 = _local_7.next; + }; + if (_local_22 != null) + { + _local_23.processNext = _local_48; + } else + { + _local_22 = _local_48; + }; + _local_23 = _local_48; + if (_local_24 != null) + { + _local_25.processNext = _local_49; + } else + { + _local_24 = _local_49; + }; + _local_25 = _local_49; + _local_27.processNext = null; + _local_27.geometry = null; + }; + }; + _local_27 = _local_26; + }; + if (_local_18 != null) + { + _local_18.geometry = _local_19; + if (_local_25 != null) + { + _local_25.processNext = null; + }; + _arg_6 = this.collectNode(_local_18, _local_24, _arg_3, _arg_4, _arg_5, _arg_6); + } else + { + if (_local_24 != null) + { + if (((_arg_5) && (!(_local_24 == _local_25)))) + { + if (_local_25 != null) + { + _local_25.processNext = null; + }; + if (_local_24.geometry.sorting == 2) + { + _arg_6 = this.collectNode(null, _local_24, _arg_3, _arg_4, _arg_5, _arg_6); + } else + { + _local_24 = _arg_3.sortByAverageZ(_local_24); + _local_25 = _local_24.processNext; + while (_local_25.processNext != null) + { + _local_25 = _local_25.processNext; + }; + _local_25.processNext = _arg_6; + _arg_6 = _local_24; + }; + } else + { + _local_25.processNext = _arg_6; + _arg_6 = _local_24; + }; + }; + }; + if (_arg_1 != null) + { + _local_16.processNext = _arg_6; + _arg_6 = _arg_1; + }; + if (_local_17 != null) + { + _local_17.geometry = _local_19; + if (_local_23 != null) + { + _local_23.processNext = null; + }; + _arg_6 = this.collectNode(_local_17, _local_22, _arg_3, _arg_4, _arg_5, _arg_6); + } else + { + if (_local_22 != null) + { + if (((_arg_5) && (!(_local_22 == _local_23)))) + { + if (_local_23 != null) + { + _local_23.processNext = null; + }; + if (_local_22.geometry.sorting == 2) + { + _arg_6 = this.collectNode(null, _local_22, _arg_3, _arg_4, _arg_5, _arg_6); + } else + { + _local_22 = _arg_3.sortByAverageZ(_local_22); + _local_23 = _local_22.processNext; + while (_local_23.processNext != null) + { + _local_23 = _local_23.processNext; + }; + _local_23.processNext = _arg_6; + _arg_6 = _local_22; + }; + } else + { + _local_23.processNext = _arg_6; + _arg_6 = _local_22; + }; + }; + }; + return (_arg_6); + } + + + } +}//package alternativa.engine3d.containers \ No newline at end of file diff --git a/src/alternativa/engine3d/containers/DistanceSortContainer.as b/src/alternativa/engine3d/containers/DistanceSortContainer.as new file mode 100644 index 0000000..695be80 --- /dev/null +++ b/src/alternativa/engine3d/containers/DistanceSortContainer.as @@ -0,0 +1,161 @@ +package alternativa.engine3d.containers +{ + import alternativa.engine3d.core.Object3DContainer; + import __AS3__.vec.Vector; + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.core.Camera3D; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class DistanceSortContainer extends Object3DContainer + { + + private static const sortingStack:Vector. = new Vector.(); + + public var sortByZ:Boolean = false; + + + override public function clone():Object3D + { + var _local_1:DistanceSortContainer = new DistanceSortContainer(); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + override protected function clonePropertiesFrom(_arg_1:Object3D):void + { + super.clonePropertiesFrom(_arg_1); + var _local_2:DistanceSortContainer = (_arg_1 as DistanceSortContainer); + this.sortByZ = _local_2.sortByZ; + } + + override alternativa3d function drawVisibleChildren(_arg_1:Camera3D):void + { + var _local_2:int; + var _local_3:int; + var _local_4:Object3D; + var _local_7:int; + var _local_8:Number; + var _local_9:Number; + var _local_10:Number; + var _local_11:Number; + var _local_12:Number; + var _local_5:int; + var _local_6:int = (numVisibleChildren - 1); + sortingStack[0] = _local_5; + sortingStack[1] = _local_6; + _local_7 = 2; + if (this.sortByZ) + { + while (_local_7 > 0) + { + _local_6 = sortingStack[--_local_7]; + _local_5 = sortingStack[--_local_7]; + _local_3 = _local_6; + _local_2 = _local_5; + _local_4 = visibleChildren[((_local_6 + _local_5) >> 1)]; + _local_9 = _local_4.ml; + do + { + while ((_local_8 = (visibleChildren[_local_2] as Object3D).ml) > _local_9) + { + _local_2++; + }; + while ((_local_10 = (visibleChildren[_local_3] as Object3D).ml) < _local_9) + { + _local_3--; + }; + if (_local_2 <= _local_3) + { + _local_4 = visibleChildren[_local_2]; + var _local_13:* = _local_2++; + visibleChildren[_local_13] = visibleChildren[_local_3]; + var _local_14:* = _local_3--; + visibleChildren[_local_14] = _local_4; + }; + } while (_local_2 <= _local_3); + if (_local_5 < _local_3) + { + _local_13 = _local_7++; + sortingStack[_local_13] = _local_5; + _local_14 = _local_7++; + sortingStack[_local_14] = _local_3; + }; + if (_local_2 < _local_6) + { + _local_13 = _local_7++; + sortingStack[_local_13] = _local_2; + _local_14 = _local_7++; + sortingStack[_local_14] = _local_6; + }; + }; + } else + { + _local_2 = 0; + while (_local_2 < numVisibleChildren) + { + _local_4 = visibleChildren[_local_2]; + _local_11 = ((_local_4.md * _arg_1.viewSizeX) / _arg_1.focalLength); + _local_12 = ((_local_4.mh * _arg_1.viewSizeY) / _arg_1.focalLength); + _local_4.distance = (((_local_11 * _local_11) + (_local_12 * _local_12)) + (_local_4.ml * _local_4.ml)); + _local_2++; + }; + while (_local_7 > 0) + { + _local_6 = sortingStack[--_local_7]; + _local_5 = sortingStack[--_local_7]; + _local_3 = _local_6; + _local_2 = _local_5; + _local_4 = visibleChildren[((_local_6 + _local_5) >> 1)]; + _local_9 = _local_4.distance; + do + { + while ((_local_8 = (visibleChildren[_local_2] as Object3D).distance) > _local_9) + { + _local_2++; + }; + while ((_local_10 = (visibleChildren[_local_3] as Object3D).distance) < _local_9) + { + _local_3--; + }; + if (_local_2 <= _local_3) + { + _local_4 = visibleChildren[_local_2]; + _local_13 = _local_2++; + visibleChildren[_local_13] = visibleChildren[_local_3]; + _local_14 = _local_3--; + visibleChildren[_local_14] = _local_4; + }; + } while (_local_2 <= _local_3); + if (_local_5 < _local_3) + { + _local_13 = _local_7++; + sortingStack[_local_13] = _local_5; + _local_14 = _local_7++; + sortingStack[_local_14] = _local_3; + }; + if (_local_2 < _local_6) + { + _local_13 = _local_7++; + sortingStack[_local_13] = _local_2; + _local_14 = _local_7++; + sortingStack[_local_14] = _local_6; + }; + }; + }; + _local_2 = (numVisibleChildren - 1); + while (_local_2 >= 0) + { + _local_4 = visibleChildren[_local_2]; + _local_4.concat(this); + _local_4.draw(_arg_1); + visibleChildren[_local_2] = null; + _local_2--; + }; + } + + + } +}//package alternativa.engine3d.containers \ No newline at end of file diff --git a/src/alternativa/engine3d/containers/KDContainer.as b/src/alternativa/engine3d/containers/KDContainer.as new file mode 100644 index 0000000..4beeed3 --- /dev/null +++ b/src/alternativa/engine3d/containers/KDContainer.as @@ -0,0 +1,4012 @@ +package alternativa.engine3d.containers +{ + import flash.geom.Vector3D; + import __AS3__.vec.Vector; + import alternativa.engine3d.core.Vertex; + import flash.utils.Dictionary; + import alternativa.engine3d.core.Object3D; + import alternativa.gfx.core.VertexBufferResource; + import alternativa.gfx.core.IndexBufferResource; + import alternativa.engine3d.materials.Material; + import alternativa.engine3d.core.Face; + import alternativa.engine3d.objects.Mesh; + import alternativa.engine3d.objects.BSP; + import alternativa.engine3d.objects.Occluder; + import alternativa.engine3d.materials.TextureMaterial; + import alternativa.engine3d.core.RayIntersectionData; + import alternativa.engine3d.core.Camera3D; + import alternativa.engine3d.objects.Decal; + import flash.geom.Matrix3D; + import alternativa.engine3d.core.Object3DContainer; + import alternativa.engine3d.core.VG; + import alternativa.engine3d.core.ShadowAtlas; + import alternativa.engine3d.core.Debug; + import alternativa.engine3d.objects.Sprite3D; + import alternativa.gfx.core.Device; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class KDContainer extends ConflictContainer + { + + private static const treeSphere:Vector3D = new Vector3D(); + private static const splitCoordsX:Vector. = new Vector.(); + private static const splitCoordsY:Vector. = new Vector.(); + private static const splitCoordsZ:Vector. = new Vector.(); + + public var debugAlphaFade:Number = 0.8; + public var ignoreChildrenInCollider:Boolean = false; + alternativa3d var root:KDNode; + private var nearPlaneX:Number; + private var nearPlaneY:Number; + private var nearPlaneZ:Number; + private var nearPlaneOffset:Number; + private var farPlaneX:Number; + private var farPlaneY:Number; + private var farPlaneZ:Number; + private var farPlaneOffset:Number; + private var leftPlaneX:Number; + private var leftPlaneY:Number; + private var leftPlaneZ:Number; + private var leftPlaneOffset:Number; + private var rightPlaneX:Number; + private var rightPlaneY:Number; + private var rightPlaneZ:Number; + private var rightPlaneOffset:Number; + private var topPlaneX:Number; + private var topPlaneY:Number; + private var topPlaneZ:Number; + private var topPlaneOffset:Number; + private var bottomPlaneX:Number; + private var bottomPlaneY:Number; + private var bottomPlaneZ:Number; + private var bottomPlaneOffset:Number; + private var occluders:Vector. = new Vector.(); + private var numOccluders:int; + private var materials:Dictionary = new Dictionary(); + private var opaqueList:Object3D; + private var transparent:Vector. = new Vector.(); + private var transparentLength:int = 0; + private var receiversVertexBuffers:Vector. = new Vector.(); + private var receiversIndexBuffers:Vector. = new Vector.(); + private var isCreated:Boolean = false; + public var batched:Boolean = true; + + + public function createTree(_arg_1:Vector., _arg_2:Vector.=null):void + { + var _local_3:int; + var _local_4:Object3D; + var _local_5:Object3D; + var _local_8:Object3D; + var _local_9:Object3D; + var _local_10:Object3D; + var _local_11:Object3D; + var _local_12:Material; + var _local_14:Number; + var _local_15:Number; + var _local_16:Number; + var _local_17:Number; + var _local_18:Number; + var _local_19:Number; + var _local_20:Number; + var _local_21:Number; + var _local_22:Number; + var _local_23:Number; + var _local_24:Number; + var _local_25:Number; + var _local_26:Vertex; + var _local_27:Face; + var _local_28:Vertex; + var _local_29:Mesh; + var _local_30:Mesh; + var _local_31:BSP; + var _local_32:Vector.>; + var _local_33:Vector.>; + this.destroyTree(); + var _local_6:int = _arg_1.length; + var _local_7:int = ((_arg_2 != null) ? _arg_2.length : 0); + var _local_13:Dictionary = new Dictionary(); + _local_3 = 0; + while (_local_3 < _local_6) + { + _local_4 = _arg_1[_local_3]; + _local_12 = ((_local_4 is Mesh) ? (_local_4 as Mesh).faceList.material : ((_local_4 is BSP) ? (_local_4 as BSP).faces[0].material : null)); + if (_local_12 != null) + { + this.materials[_local_12] = true; + if (_local_12.transparent) + { + this.transparent[this.transparentLength] = _local_4; + this.transparentLength++; + } else + { + _local_29 = _local_13[_local_12]; + if (_local_29 == null) + { + _local_29 = new Mesh(); + _local_13[_local_12] = _local_29; + _local_29.next = this.opaqueList; + this.opaqueList = _local_29; + _local_29.setParent(this); + }; + _local_4 = _local_4.clone(); + _local_4.composeMatrix(); + if ((_local_4 is Mesh)) + { + _local_30 = (_local_4 as Mesh); + if (_local_30.faceList != null) + { + _local_26 = _local_30.vertexList; + while (_local_26 != null) + { + _local_20 = _local_26.x; + _local_21 = _local_26.y; + _local_22 = _local_26.z; + _local_26.x = ((((_local_4.ma * _local_20) + (_local_4.mb * _local_21)) + (_local_4.mc * _local_22)) + _local_4.md); + _local_26.y = ((((_local_4.me * _local_20) + (_local_4.mf * _local_21)) + (_local_4.mg * _local_22)) + _local_4.mh); + _local_26.z = ((((_local_4.mi * _local_20) + (_local_4.mj * _local_21)) + (_local_4.mk * _local_22)) + _local_4.ml); + _local_23 = _local_26.normalX; + _local_24 = _local_26.normalY; + _local_25 = _local_26.normalZ; + _local_26.normalX = (((_local_4.ma * _local_23) + (_local_4.mb * _local_24)) + (_local_4.mc * _local_25)); + _local_26.normalY = (((_local_4.me * _local_23) + (_local_4.mf * _local_24)) + (_local_4.mg * _local_25)); + _local_26.normalZ = (((_local_4.mi * _local_23) + (_local_4.mj * _local_24)) + (_local_4.mk * _local_25)); + _local_26.transformId = 0; + if (_local_26.next == null) + { + _local_28 = _local_26; + }; + _local_26 = _local_26.next; + }; + _local_28.next = _local_29.vertexList; + _local_29.vertexList = _local_30.vertexList; + _local_30.vertexList = null; + _local_27 = _local_30.faceList; + while (_local_27.next != null) + { + _local_27 = _local_27.next; + }; + _local_27.next = _local_29.faceList; + _local_29.faceList = _local_30.faceList; + _local_30.faceList = null; + }; + } else + { + if ((_local_4 is BSP)) + { + _local_31 = (_local_4 as BSP); + if (_local_31.root != null) + { + _local_26 = _local_31.vertexList; + while (_local_26 != null) + { + _local_20 = _local_26.x; + _local_21 = _local_26.y; + _local_22 = _local_26.z; + _local_26.x = ((((_local_4.ma * _local_20) + (_local_4.mb * _local_21)) + (_local_4.mc * _local_22)) + _local_4.md); + _local_26.y = ((((_local_4.me * _local_20) + (_local_4.mf * _local_21)) + (_local_4.mg * _local_22)) + _local_4.mh); + _local_26.z = ((((_local_4.mi * _local_20) + (_local_4.mj * _local_21)) + (_local_4.mk * _local_22)) + _local_4.ml); + _local_23 = _local_26.normalX; + _local_24 = _local_26.normalY; + _local_25 = _local_26.normalZ; + _local_26.normalX = (((_local_4.ma * _local_23) + (_local_4.mb * _local_24)) + (_local_4.mc * _local_25)); + _local_26.normalY = (((_local_4.me * _local_23) + (_local_4.mf * _local_24)) + (_local_4.mg * _local_25)); + _local_26.normalZ = (((_local_4.mi * _local_23) + (_local_4.mj * _local_24)) + (_local_4.mk * _local_25)); + _local_26.transformId = 0; + if (_local_26.next == null) + { + _local_28 = _local_26; + }; + _local_26 = _local_26.next; + }; + _local_28.next = _local_29.vertexList; + _local_29.vertexList = _local_31.vertexList; + _local_31.vertexList = null; + for each (_local_27 in _local_31.faces) + { + _local_27.next = _local_29.faceList; + _local_29.faceList = _local_27; + }; + _local_31.faces.length = 0; + _local_31.root = null; + }; + }; + }; + }; + }; + _local_3++; + }; + for each (_local_29 in _local_13) + { + _local_29.calculateFacesNormals(true); + _local_29.calculateBounds(); + }; + _local_14 = 1E22; + _local_15 = 1E22; + _local_16 = 1E22; + _local_17 = -1E22; + _local_18 = -1E22; + _local_19 = -1E22; + _local_3 = 0; + while (_local_3 < _local_6) + { + _local_4 = _arg_1[_local_3]; + _local_5 = this.createObjectBounds(_local_4); + if (_local_5.boundMinX <= _local_5.boundMaxX) + { + if (_local_4._parent != null) + { + _local_4._parent.removeChild(_local_4); + }; + _local_4.setParent(this); + _local_4.next = _local_8; + _local_8 = _local_4; + _local_5.next = _local_9; + _local_9 = _local_5; + if (_local_5.boundMinX < _local_14) + { + _local_14 = _local_5.boundMinX; + }; + if (_local_5.boundMaxX > _local_17) + { + _local_17 = _local_5.boundMaxX; + }; + if (_local_5.boundMinY < _local_15) + { + _local_15 = _local_5.boundMinY; + }; + if (_local_5.boundMaxY > _local_18) + { + _local_18 = _local_5.boundMaxY; + }; + if (_local_5.boundMinZ < _local_16) + { + _local_16 = _local_5.boundMinZ; + }; + if (_local_5.boundMaxZ > _local_19) + { + _local_19 = _local_5.boundMaxZ; + }; + }; + _local_3++; + }; + _local_3 = 0; + while (_local_3 < _local_7) + { + _local_4 = _arg_2[_local_3]; + _local_5 = this.createObjectBounds(_local_4); + if (_local_5.boundMinX <= _local_5.boundMaxX) + { + if (!((((((_local_5.boundMinX < _local_14) || (_local_5.boundMaxX > _local_17)) || (_local_5.boundMinY < _local_15)) || (_local_5.boundMaxY > _local_18)) || (_local_5.boundMinZ < _local_16)) || (_local_5.boundMaxZ > _local_19))) + { + if (_local_4._parent != null) + { + _local_4._parent.removeChild(_local_4); + }; + _local_4.setParent(this); + _local_4.next = _local_10; + _local_10 = _local_4; + _local_5.next = _local_11; + _local_11 = _local_5; + }; + }; + _local_3++; + }; + if (_local_8 != null) + { + this.root = this.createNode(_local_8, _local_9, _local_10, _local_11, _local_14, _local_15, _local_16, _local_17, _local_18, _local_19); + _local_32 = new Vector.>(); + _local_33 = new Vector.>(); + _local_32[0] = new Vector.(); + _local_33[0] = new Vector.(); + this.root.createReceivers(_local_32, _local_33); + _local_3 = 0; + while (_local_3 < _local_32.length) + { + this.receiversVertexBuffers[_local_3] = new VertexBufferResource(_local_32[_local_3], 3); + this.receiversIndexBuffers[_local_3] = new IndexBufferResource(_local_33[_local_3]); + _local_3++; + }; + }; + } + + public function destroyTree():void + { + var _local_1:int; + var _local_2:*; + var _local_3:Object3D; + var _local_4:Mesh; + var _local_5:BSP; + var _local_6:TextureMaterial; + for (_local_2 in this.materials) + { + _local_6 = (_local_2 as TextureMaterial); + if (_local_6.texture != null) + { + _local_6.textureResource.reset(); + }; + if (_local_6._textureATF != null) + { + _local_6.textureATFResource.reset(); + }; + if (_local_6._textureATFAlpha != null) + { + _local_6.textureATFAlphaResource.reset(); + }; + }; + _local_3 = this.opaqueList; + while (_local_3 != null) + { + if ((_local_3 is Mesh)) + { + _local_4 = (_local_3 as Mesh); + if (_local_4.vertexBuffer != null) + { + _local_4.vertexBuffer.reset(); + }; + if (_local_4.indexBuffer != null) + { + _local_4.indexBuffer.reset(); + }; + } else + { + if ((_local_3 is BSP)) + { + _local_5 = (_local_3 as BSP); + if (_local_5.vertexBuffer != null) + { + _local_5.vertexBuffer.reset(); + }; + if (_local_5.indexBuffer != null) + { + _local_5.indexBuffer.reset(); + }; + }; + }; + _local_3 = _local_3.next; + }; + _local_1 = 0; + while (_local_1 < this.transparentLength) + { + _local_3 = this.transparent[_local_1]; + if ((_local_3 is Mesh)) + { + _local_4 = (_local_3 as Mesh); + if (_local_4.vertexBuffer != null) + { + _local_4.vertexBuffer.reset(); + }; + if (_local_4.indexBuffer != null) + { + _local_4.indexBuffer.reset(); + }; + } else + { + if ((_local_3 is BSP)) + { + _local_5 = (_local_3 as BSP); + if (_local_5.vertexBuffer != null) + { + _local_5.vertexBuffer.reset(); + }; + if (_local_5.indexBuffer != null) + { + _local_5.indexBuffer.reset(); + }; + }; + }; + _local_1++; + }; + this.materials = new Dictionary(); + this.opaqueList = null; + this.transparent.length = 0; + this.transparentLength = 0; + if (this.root != null) + { + this.destroyNode(this.root); + this.root = null; + }; + _local_1 = 0; + while (_local_1 < this.receiversVertexBuffers.length) + { + VertexBufferResource(this.receiversVertexBuffers[_local_1]).dispose(); + IndexBufferResource(this.receiversIndexBuffers[_local_1]).dispose(); + _local_1++; + }; + this.receiversVertexBuffers.length = 0; + this.receiversIndexBuffers.length = 0; + this.isCreated = false; + } + + override public function intersectRay(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Dictionary=null, _arg_4:Camera3D=null):RayIntersectionData + { + var _local_6:RayIntersectionData; + if (((!(_arg_3 == null)) && (_arg_3[this]))) + { + return (null); + }; + if ((!(boundIntersectRay(_arg_1, _arg_2, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ)))) + { + return (null); + }; + var _local_5:RayIntersectionData = super.intersectRay(_arg_1, _arg_2, _arg_3, _arg_4); + if (((!(this.root == null)) && (boundIntersectRay(_arg_1, _arg_2, this.root.boundMinX, this.root.boundMinY, this.root.boundMinZ, this.root.boundMaxX, this.root.boundMaxY, this.root.boundMaxZ)))) + { + _local_6 = this.intersectRayNode(this.root, _arg_1, _arg_2, _arg_3, _arg_4); + if (((!(_local_6 == null)) && ((_local_5 == null) || (_local_6.time < _local_5.time)))) + { + _local_5 = _local_6; + }; + }; + return (_local_5); + } + + private function intersectRayNode(_arg_1:KDNode, _arg_2:Vector3D, _arg_3:Vector3D, _arg_4:Dictionary, _arg_5:Camera3D):RayIntersectionData + { + var _local_6:RayIntersectionData; + var _local_7:Number; + var _local_8:Object3D; + var _local_9:Object3D; + var _local_10:Vector3D; + var _local_11:Vector3D; + var _local_12:Boolean; + var _local_13:Boolean; + var _local_14:Number; + var _local_15:Number; + var _local_16:RayIntersectionData; + if (_arg_1.negative != null) + { + _local_12 = (_arg_1.axis == 0); + _local_13 = (_arg_1.axis == 1); + _local_14 = (((_local_12) ? _arg_2.x : ((_local_13) ? _arg_2.y : _arg_2.z)) - _arg_1.coord); + if (_local_14 > 0) + { + if (boundIntersectRay(_arg_2, _arg_3, _arg_1.positive.boundMinX, _arg_1.positive.boundMinY, _arg_1.positive.boundMinZ, _arg_1.positive.boundMaxX, _arg_1.positive.boundMaxY, _arg_1.positive.boundMaxZ)) + { + _local_6 = this.intersectRayNode(_arg_1.positive, _arg_2, _arg_3, _arg_4, _arg_5); + if (_local_6 != null) + { + return (_local_6); + }; + }; + _local_7 = ((_local_12) ? _arg_3.x : ((_local_13) ? _arg_3.y : _arg_3.z)); + if (_local_7 < 0) + { + _local_8 = _arg_1.objectList; + _local_9 = _arg_1.objectBoundList; + while (_local_8 != null) + { + if (boundIntersectRay(_arg_2, _arg_3, _local_9.boundMinX, _local_9.boundMinY, _local_9.boundMinZ, _local_9.boundMaxX, _local_9.boundMaxY, _local_9.boundMaxZ)) + { + _local_8.composeMatrix(); + _local_8.invertMatrix(); + if (_local_10 == null) + { + _local_10 = new Vector3D(); + _local_11 = new Vector3D(); + }; + _local_10.x = ((((_local_8.ma * _arg_2.x) + (_local_8.mb * _arg_2.y)) + (_local_8.mc * _arg_2.z)) + _local_8.md); + _local_10.y = ((((_local_8.me * _arg_2.x) + (_local_8.mf * _arg_2.y)) + (_local_8.mg * _arg_2.z)) + _local_8.mh); + _local_10.z = ((((_local_8.mi * _arg_2.x) + (_local_8.mj * _arg_2.y)) + (_local_8.mk * _arg_2.z)) + _local_8.ml); + _local_11.x = (((_local_8.ma * _arg_3.x) + (_local_8.mb * _arg_3.y)) + (_local_8.mc * _arg_3.z)); + _local_11.y = (((_local_8.me * _arg_3.x) + (_local_8.mf * _arg_3.y)) + (_local_8.mg * _arg_3.z)); + _local_11.z = (((_local_8.mi * _arg_3.x) + (_local_8.mj * _arg_3.y)) + (_local_8.mk * _arg_3.z)); + _local_6 = _local_8.intersectRay(_local_10, _local_11, _arg_4, _arg_5); + if (_local_6 != null) + { + return (_local_6); + }; + }; + _local_8 = _local_8.next; + _local_9 = _local_9.next; + }; + if (boundIntersectRay(_arg_2, _arg_3, _arg_1.negative.boundMinX, _arg_1.negative.boundMinY, _arg_1.negative.boundMinZ, _arg_1.negative.boundMaxX, _arg_1.negative.boundMaxY, _arg_1.negative.boundMaxZ)) + { + return (this.intersectRayNode(_arg_1.negative, _arg_2, _arg_3, _arg_4, _arg_5)); + }; + }; + } else + { + if (boundIntersectRay(_arg_2, _arg_3, _arg_1.negative.boundMinX, _arg_1.negative.boundMinY, _arg_1.negative.boundMinZ, _arg_1.negative.boundMaxX, _arg_1.negative.boundMaxY, _arg_1.negative.boundMaxZ)) + { + _local_6 = this.intersectRayNode(_arg_1.negative, _arg_2, _arg_3, _arg_4, _arg_5); + if (_local_6 != null) + { + return (_local_6); + }; + }; + _local_7 = ((_local_12) ? _arg_3.x : ((_local_13) ? _arg_3.y : _arg_3.z)); + if (_local_7 > 0) + { + _local_8 = _arg_1.objectList; + _local_9 = _arg_1.objectBoundList; + while (_local_8 != null) + { + if (boundIntersectRay(_arg_2, _arg_3, _local_9.boundMinX, _local_9.boundMinY, _local_9.boundMinZ, _local_9.boundMaxX, _local_9.boundMaxY, _local_9.boundMaxZ)) + { + _local_8.composeMatrix(); + _local_8.invertMatrix(); + if (_local_10 == null) + { + _local_10 = new Vector3D(); + _local_11 = new Vector3D(); + }; + _local_10.x = ((((_local_8.ma * _arg_2.x) + (_local_8.mb * _arg_2.y)) + (_local_8.mc * _arg_2.z)) + _local_8.md); + _local_10.y = ((((_local_8.me * _arg_2.x) + (_local_8.mf * _arg_2.y)) + (_local_8.mg * _arg_2.z)) + _local_8.mh); + _local_10.z = ((((_local_8.mi * _arg_2.x) + (_local_8.mj * _arg_2.y)) + (_local_8.mk * _arg_2.z)) + _local_8.ml); + _local_11.x = (((_local_8.ma * _arg_3.x) + (_local_8.mb * _arg_3.y)) + (_local_8.mc * _arg_3.z)); + _local_11.y = (((_local_8.me * _arg_3.x) + (_local_8.mf * _arg_3.y)) + (_local_8.mg * _arg_3.z)); + _local_11.z = (((_local_8.mi * _arg_3.x) + (_local_8.mj * _arg_3.y)) + (_local_8.mk * _arg_3.z)); + _local_6 = _local_8.intersectRay(_local_10, _local_11, _arg_4, _arg_5); + if (_local_6 != null) + { + return (_local_6); + }; + }; + _local_8 = _local_8.next; + _local_9 = _local_9.next; + }; + if (boundIntersectRay(_arg_2, _arg_3, _arg_1.positive.boundMinX, _arg_1.positive.boundMinY, _arg_1.positive.boundMinZ, _arg_1.positive.boundMaxX, _arg_1.positive.boundMaxY, _arg_1.positive.boundMaxZ)) + { + return (this.intersectRayNode(_arg_1.positive, _arg_2, _arg_3, _arg_4, _arg_5)); + }; + }; + }; + } else + { + _local_15 = 1E22; + _local_8 = _arg_1.objectList; + while (_local_8 != null) + { + _local_8.composeMatrix(); + _local_8.invertMatrix(); + if (_local_10 == null) + { + _local_10 = new Vector3D(); + _local_11 = new Vector3D(); + }; + _local_10.x = ((((_local_8.ma * _arg_2.x) + (_local_8.mb * _arg_2.y)) + (_local_8.mc * _arg_2.z)) + _local_8.md); + _local_10.y = ((((_local_8.me * _arg_2.x) + (_local_8.mf * _arg_2.y)) + (_local_8.mg * _arg_2.z)) + _local_8.mh); + _local_10.z = ((((_local_8.mi * _arg_2.x) + (_local_8.mj * _arg_2.y)) + (_local_8.mk * _arg_2.z)) + _local_8.ml); + _local_11.x = (((_local_8.ma * _arg_3.x) + (_local_8.mb * _arg_3.y)) + (_local_8.mc * _arg_3.z)); + _local_11.y = (((_local_8.me * _arg_3.x) + (_local_8.mf * _arg_3.y)) + (_local_8.mg * _arg_3.z)); + _local_11.z = (((_local_8.mi * _arg_3.x) + (_local_8.mj * _arg_3.y)) + (_local_8.mk * _arg_3.z)); + _local_6 = _local_8.intersectRay(_local_10, _local_11, _arg_4, _arg_5); + if (((!(_local_6 == null)) && (_local_6.time < _local_15))) + { + _local_15 = _local_6.time; + _local_16 = _local_6; + }; + _local_8 = _local_8.next; + }; + return (_local_16); + }; + return (null); + } + + override alternativa3d function checkIntersection(_arg_1:Number, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Dictionary):Boolean + { + if (super.checkIntersection(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8)) + { + return (true); + }; + if (((!(this.root == null)) && (boundCheckIntersection(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, this.root.boundMinX, this.root.boundMinY, this.root.boundMinZ, this.root.boundMaxX, this.root.boundMaxY, this.root.boundMaxZ)))) + { + return (this.checkIntersectionNode(this.root, _arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8)); + }; + return (false); + } + + private function checkIntersectionNode(_arg_1:KDNode, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Number, _arg_9:Dictionary):Boolean + { + var _local_10:Object3D; + var _local_11:Object3D; + var _local_12:Number; + var _local_13:Number; + var _local_14:Number; + var _local_15:Number; + var _local_16:Number; + var _local_17:Number; + var _local_18:Number; + var _local_19:Boolean; + var _local_20:Boolean; + var _local_21:Number; + var _local_22:Number; + if (_arg_1.negative != null) + { + _local_19 = (_arg_1.axis == 0); + _local_20 = (_arg_1.axis == 1); + _local_21 = (((_local_19) ? _arg_2 : ((_local_20) ? _arg_3 : _arg_4)) - _arg_1.coord); + _local_22 = ((_local_19) ? _arg_5 : ((_local_20) ? _arg_6 : _arg_7)); + if (_local_21 > 0) + { + if (_local_22 < 0) + { + _local_18 = (-(_local_21) / _local_22); + if (_local_18 < _arg_8) + { + _local_10 = _arg_1.objectList; + _local_11 = _arg_1.objectBoundList; + while (_local_10 != null) + { + if (boundCheckIntersection(_arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _local_11.boundMinX, _local_11.boundMinY, _local_11.boundMinZ, _local_11.boundMaxX, _local_11.boundMaxY, _local_11.boundMaxZ)) + { + _local_10.composeMatrix(); + _local_10.invertMatrix(); + _local_12 = ((((_local_10.ma * _arg_2) + (_local_10.mb * _arg_3)) + (_local_10.mc * _arg_4)) + _local_10.md); + _local_13 = ((((_local_10.me * _arg_2) + (_local_10.mf * _arg_3)) + (_local_10.mg * _arg_4)) + _local_10.mh); + _local_14 = ((((_local_10.mi * _arg_2) + (_local_10.mj * _arg_3)) + (_local_10.mk * _arg_4)) + _local_10.ml); + _local_15 = (((_local_10.ma * _arg_5) + (_local_10.mb * _arg_6)) + (_local_10.mc * _arg_7)); + _local_16 = (((_local_10.me * _arg_5) + (_local_10.mf * _arg_6)) + (_local_10.mg * _arg_7)); + _local_17 = (((_local_10.mi * _arg_5) + (_local_10.mj * _arg_6)) + (_local_10.mk * _arg_7)); + if (_local_10.checkIntersection(_local_12, _local_13, _local_14, _local_15, _local_16, _local_17, _arg_8, _arg_9)) + { + return (true); + }; + }; + _local_10 = _local_10.next; + _local_11 = _local_11.next; + }; + if (((boundCheckIntersection(_arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_1.negative.boundMinX, _arg_1.negative.boundMinY, _arg_1.negative.boundMinZ, _arg_1.negative.boundMaxX, _arg_1.negative.boundMaxY, _arg_1.negative.boundMaxZ)) && (this.checkIntersectionNode(_arg_1.negative, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9)))) + { + return (true); + }; + }; + }; + return ((boundCheckIntersection(_arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_1.positive.boundMinX, _arg_1.positive.boundMinY, _arg_1.positive.boundMinZ, _arg_1.positive.boundMaxX, _arg_1.positive.boundMaxY, _arg_1.positive.boundMaxZ)) && (this.checkIntersectionNode(_arg_1.positive, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9))); + }; + if (_local_22 > 0) + { + _local_18 = (-(_local_21) / _local_22); + if (_local_18 < _arg_8) + { + _local_10 = _arg_1.objectList; + _local_11 = _arg_1.objectBoundList; + while (_local_10 != null) + { + if (boundCheckIntersection(_arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _local_11.boundMinX, _local_11.boundMinY, _local_11.boundMinZ, _local_11.boundMaxX, _local_11.boundMaxY, _local_11.boundMaxZ)) + { + _local_10.composeMatrix(); + _local_10.invertMatrix(); + _local_12 = ((((_local_10.ma * _arg_2) + (_local_10.mb * _arg_3)) + (_local_10.mc * _arg_4)) + _local_10.md); + _local_13 = ((((_local_10.me * _arg_2) + (_local_10.mf * _arg_3)) + (_local_10.mg * _arg_4)) + _local_10.mh); + _local_14 = ((((_local_10.mi * _arg_2) + (_local_10.mj * _arg_3)) + (_local_10.mk * _arg_4)) + _local_10.ml); + _local_15 = (((_local_10.ma * _arg_5) + (_local_10.mb * _arg_6)) + (_local_10.mc * _arg_7)); + _local_16 = (((_local_10.me * _arg_5) + (_local_10.mf * _arg_6)) + (_local_10.mg * _arg_7)); + _local_17 = (((_local_10.mi * _arg_5) + (_local_10.mj * _arg_6)) + (_local_10.mk * _arg_7)); + if (_local_10.checkIntersection(_local_12, _local_13, _local_14, _local_15, _local_16, _local_17, _arg_8, _arg_9)) + { + return (true); + }; + }; + _local_10 = _local_10.next; + _local_11 = _local_11.next; + }; + if (((boundCheckIntersection(_arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_1.positive.boundMinX, _arg_1.positive.boundMinY, _arg_1.positive.boundMinZ, _arg_1.positive.boundMaxX, _arg_1.positive.boundMaxY, _arg_1.positive.boundMaxZ)) && (this.checkIntersectionNode(_arg_1.positive, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9)))) + { + return (true); + }; + }; + }; + return ((boundCheckIntersection(_arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_1.negative.boundMinX, _arg_1.negative.boundMinY, _arg_1.negative.boundMinZ, _arg_1.negative.boundMaxX, _arg_1.negative.boundMaxY, _arg_1.negative.boundMaxZ)) && (this.checkIntersectionNode(_arg_1.negative, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9))); + }; + _local_10 = _arg_1.objectList; + while (_local_10 != null) + { + _local_10.composeMatrix(); + _local_10.invertMatrix(); + _local_12 = ((((_local_10.ma * _arg_2) + (_local_10.mb * _arg_3)) + (_local_10.mc * _arg_4)) + _local_10.md); + _local_13 = ((((_local_10.me * _arg_2) + (_local_10.mf * _arg_3)) + (_local_10.mg * _arg_4)) + _local_10.mh); + _local_14 = ((((_local_10.mi * _arg_2) + (_local_10.mj * _arg_3)) + (_local_10.mk * _arg_4)) + _local_10.ml); + _local_15 = (((_local_10.ma * _arg_5) + (_local_10.mb * _arg_6)) + (_local_10.mc * _arg_7)); + _local_16 = (((_local_10.me * _arg_5) + (_local_10.mf * _arg_6)) + (_local_10.mg * _arg_7)); + _local_17 = (((_local_10.mi * _arg_5) + (_local_10.mj * _arg_6)) + (_local_10.mk * _arg_7)); + if (_local_10.checkIntersection(_local_12, _local_13, _local_14, _local_15, _local_16, _local_17, _arg_8, _arg_9)) + { + return (true); + }; + _local_10 = _local_10.next; + }; + return (false); + } + + override alternativa3d function collectPlanes(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Vector3D, _arg_4:Vector3D, _arg_5:Vector3D, _arg_6:Vector., _arg_7:Dictionary=null):void + { + var _local_9:Object3D; + if (((!(_arg_7 == null)) && (_arg_7[this]))) + { + return; + }; + var _local_8:Vector3D = calculateSphere(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5, treeSphere); + if ((!(this.ignoreChildrenInCollider))) + { + if ((!(boundIntersectSphere(_local_8, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ)))) + { + return; + }; + _local_9 = childrenList; + while (_local_9 != null) + { + _local_9.composeAndAppend(this); + _local_9.collectPlanes(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7); + _local_9 = _local_9.next; + }; + }; + if (((!(this.root == null)) && (boundIntersectSphere(_local_8, this.root.boundMinX, this.root.boundMinY, this.root.boundMinZ, this.root.boundMaxX, this.root.boundMaxY, this.root.boundMaxZ)))) + { + this.collectPlanesNode(this.root, _local_8, _arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7); + }; + } + + private function collectPlanesNode(_arg_1:KDNode, _arg_2:Vector3D, _arg_3:Vector3D, _arg_4:Vector3D, _arg_5:Vector3D, _arg_6:Vector3D, _arg_7:Vector3D, _arg_8:Vector., _arg_9:Dictionary=null):void + { + var _local_10:Object3D; + var _local_11:Object3D; + var _local_12:Boolean; + var _local_13:Boolean; + var _local_14:Number; + if (_arg_1.negative != null) + { + _local_12 = (_arg_1.axis == 0); + _local_13 = (_arg_1.axis == 1); + _local_14 = (((_local_12) ? _arg_2.x : ((_local_13) ? _arg_2.y : _arg_2.z)) - _arg_1.coord); + if (_local_14 >= _arg_2.w) + { + if (boundIntersectSphere(_arg_2, _arg_1.positive.boundMinX, _arg_1.positive.boundMinY, _arg_1.positive.boundMinZ, _arg_1.positive.boundMaxX, _arg_1.positive.boundMaxY, _arg_1.positive.boundMaxZ)) + { + this.collectPlanesNode(_arg_1.positive, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9); + }; + } else + { + if (_local_14 <= -(_arg_2.w)) + { + if (boundIntersectSphere(_arg_2, _arg_1.negative.boundMinX, _arg_1.negative.boundMinY, _arg_1.negative.boundMinZ, _arg_1.negative.boundMaxX, _arg_1.negative.boundMaxY, _arg_1.negative.boundMaxZ)) + { + this.collectPlanesNode(_arg_1.negative, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9); + }; + } else + { + _local_10 = _arg_1.objectList; + _local_11 = _arg_1.objectBoundList; + while (_local_10 != null) + { + if (boundIntersectSphere(_arg_2, _local_11.boundMinX, _local_11.boundMinY, _local_11.boundMinZ, _local_11.boundMaxX, _local_11.boundMaxY, _local_11.boundMaxZ)) + { + _local_10.composeAndAppend(this); + _local_10.collectPlanes(_arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9); + }; + _local_10 = _local_10.next; + _local_11 = _local_11.next; + }; + if (boundIntersectSphere(_arg_2, _arg_1.positive.boundMinX, _arg_1.positive.boundMinY, _arg_1.positive.boundMinZ, _arg_1.positive.boundMaxX, _arg_1.positive.boundMaxY, _arg_1.positive.boundMaxZ)) + { + this.collectPlanesNode(_arg_1.positive, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9); + }; + if (boundIntersectSphere(_arg_2, _arg_1.negative.boundMinX, _arg_1.negative.boundMinY, _arg_1.negative.boundMinZ, _arg_1.negative.boundMaxX, _arg_1.negative.boundMaxY, _arg_1.negative.boundMaxZ)) + { + this.collectPlanesNode(_arg_1.negative, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9); + }; + }; + }; + } else + { + _local_10 = _arg_1.objectList; + while (_local_10 != null) + { + _local_10.composeAndAppend(this); + _local_10.collectPlanes(_arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9); + _local_10 = _local_10.next; + }; + }; + } + + public function createDecal(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Material):Decal + { + var _local_8:Decal = new Decal(); + _local_8.attenuation = _arg_6; + var _local_9:Matrix3D = new Matrix3D(); + _local_9.appendRotation(((_arg_4 * 180) / Math.PI), Vector3D.Z_AXIS); + _local_9.appendRotation((((Math.atan2(-(_arg_2.z), Math.sqrt(((_arg_2.x * _arg_2.x) + (_arg_2.y * _arg_2.y)))) * 180) / Math.PI) - 90), Vector3D.X_AXIS); + _local_9.appendRotation(((-(Math.atan2(-(_arg_2.x), -(_arg_2.y))) * 180) / Math.PI), Vector3D.Z_AXIS); + _local_9.appendTranslation(_arg_1.x, _arg_1.y, _arg_1.z); + _local_8.matrix = _local_9; + _local_8.composeMatrix(); + _local_8.boundMinX = -(_arg_3); + _local_8.boundMaxX = _arg_3; + _local_8.boundMinY = -(_arg_3); + _local_8.boundMaxY = _arg_3; + _local_8.boundMinZ = -(_arg_6); + _local_8.boundMaxZ = _arg_6; + var _local_10:Number = 1E22; + var _local_11:Number = 1E22; + var _local_12:Number = 1E22; + var _local_13:Number = -1E22; + var _local_14:Number = -1E22; + var _local_15:Number = -1E22; + var _local_16:Vertex = boundVertexList; + _local_16.x = _local_8.boundMinX; + _local_16.y = _local_8.boundMinY; + _local_16.z = _local_8.boundMinZ; + _local_16 = _local_16.next; + _local_16.x = _local_8.boundMaxX; + _local_16.y = _local_8.boundMinY; + _local_16.z = _local_8.boundMinZ; + _local_16 = _local_16.next; + _local_16.x = _local_8.boundMinX; + _local_16.y = _local_8.boundMaxY; + _local_16.z = _local_8.boundMinZ; + _local_16 = _local_16.next; + _local_16.x = _local_8.boundMaxX; + _local_16.y = _local_8.boundMaxY; + _local_16.z = _local_8.boundMinZ; + _local_16 = _local_16.next; + _local_16.x = _local_8.boundMinX; + _local_16.y = _local_8.boundMinY; + _local_16.z = _local_8.boundMaxZ; + _local_16 = _local_16.next; + _local_16.x = _local_8.boundMaxX; + _local_16.y = _local_8.boundMinY; + _local_16.z = _local_8.boundMaxZ; + _local_16 = _local_16.next; + _local_16.x = _local_8.boundMinX; + _local_16.y = _local_8.boundMaxY; + _local_16.z = _local_8.boundMaxZ; + _local_16 = _local_16.next; + _local_16.x = _local_8.boundMaxX; + _local_16.y = _local_8.boundMaxY; + _local_16.z = _local_8.boundMaxZ; + _local_16 = boundVertexList; + while (_local_16 != null) + { + _local_16.cameraX = ((((_local_8.ma * _local_16.x) + (_local_8.mb * _local_16.y)) + (_local_8.mc * _local_16.z)) + _local_8.md); + _local_16.cameraY = ((((_local_8.me * _local_16.x) + (_local_8.mf * _local_16.y)) + (_local_8.mg * _local_16.z)) + _local_8.mh); + _local_16.cameraZ = ((((_local_8.mi * _local_16.x) + (_local_8.mj * _local_16.y)) + (_local_8.mk * _local_16.z)) + _local_8.ml); + if (_local_16.cameraX < _local_10) + { + _local_10 = _local_16.cameraX; + }; + if (_local_16.cameraX > _local_13) + { + _local_13 = _local_16.cameraX; + }; + if (_local_16.cameraY < _local_11) + { + _local_11 = _local_16.cameraY; + }; + if (_local_16.cameraY > _local_14) + { + _local_14 = _local_16.cameraY; + }; + if (_local_16.cameraZ < _local_12) + { + _local_12 = _local_16.cameraZ; + }; + if (_local_16.cameraZ > _local_15) + { + _local_15 = _local_16.cameraZ; + }; + _local_16 = _local_16.next; + }; + _local_8.invertMatrix(); + if (_arg_5 > (Math.PI / 2)) + { + _arg_5 = (Math.PI / 2); + }; + if (this.root != null) + { + this.root.collectPolygons(_local_8, Math.sqrt((((_arg_3 * _arg_3) + (_arg_3 * _arg_3)) + (_arg_6 * _arg_6))), (Math.cos(_arg_5) - 0.001), _local_10, _local_13, _local_11, _local_14, _local_12, _local_15); + }; + if (_local_8.faceList != null) + { + _local_8.calculateBounds(); + } else + { + _local_8.boundMinX = -1; + _local_8.boundMinY = -1; + _local_8.boundMinZ = -1; + _local_8.boundMaxX = 1; + _local_8.boundMaxY = 1; + _local_8.boundMaxZ = 1; + }; + _local_8.setMaterialToAllFaces(_arg_7); + return (_local_8); + } + + override public function clone():Object3D + { + var _local_1:KDContainer = new KDContainer(); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + override protected function clonePropertiesFrom(_arg_1:Object3D):void + { + super.clonePropertiesFrom(_arg_1); + var _local_2:KDContainer = (_arg_1 as KDContainer); + this.debugAlphaFade = _local_2.debugAlphaFade; + if (_local_2.root != null) + { + this.root = _local_2.cloneNode(_local_2.root, this); + }; + } + + private function cloneNode(_arg_1:KDNode, _arg_2:Object3DContainer):KDNode + { + var _local_4:Object3D; + var _local_5:Object3D; + var _local_6:Object3D; + var _local_3:KDNode = new KDNode(); + _local_3.axis = _arg_1.axis; + _local_3.coord = _arg_1.coord; + _local_3.minCoord = _arg_1.minCoord; + _local_3.maxCoord = _arg_1.maxCoord; + _local_3.boundMinX = _arg_1.boundMinX; + _local_3.boundMinY = _arg_1.boundMinY; + _local_3.boundMinZ = _arg_1.boundMinZ; + _local_3.boundMaxX = _arg_1.boundMaxX; + _local_3.boundMaxY = _arg_1.boundMaxY; + _local_3.boundMaxZ = _arg_1.boundMaxZ; + _local_4 = _arg_1.objectList; + _local_5 = null; + while (_local_4 != null) + { + _local_6 = _local_4.clone(); + if (_local_3.objectList != null) + { + _local_5.next = _local_6; + } else + { + _local_3.objectList = _local_6; + }; + _local_5 = _local_6; + _local_6.setParent(_arg_2); + _local_4 = _local_4.next; + }; + _local_4 = _arg_1.objectBoundList; + _local_5 = null; + while (_local_4 != null) + { + _local_6 = _local_4.clone(); + if (_local_3.objectBoundList != null) + { + _local_5.next = _local_6; + } else + { + _local_3.objectBoundList = _local_6; + }; + _local_5 = _local_6; + _local_4 = _local_4.next; + }; + _local_4 = _arg_1.occluderList; + _local_5 = null; + while (_local_4 != null) + { + _local_6 = _local_4.clone(); + if (_local_3.occluderList != null) + { + _local_5.next = _local_6; + } else + { + _local_3.occluderList = _local_6; + }; + _local_5 = _local_6; + _local_6.setParent(_arg_2); + _local_4 = _local_4.next; + }; + _local_4 = _arg_1.occluderBoundList; + _local_5 = null; + while (_local_4 != null) + { + _local_6 = _local_4.clone(); + if (_local_3.occluderBoundList != null) + { + _local_5.next = _local_6; + } else + { + _local_3.occluderBoundList = _local_6; + }; + _local_5 = _local_6; + _local_4 = _local_4.next; + }; + if (_arg_1.negative != null) + { + _local_3.negative = this.cloneNode(_arg_1.negative, _arg_2); + }; + if (_arg_1.positive != null) + { + _local_3.positive = this.cloneNode(_arg_1.positive, _arg_2); + }; + return (_local_3); + } + + override alternativa3d function draw(_arg_1:Camera3D):void + { + var _local_2:int; + var _local_3:Object3D; + var _local_4:VG; + var _local_5:VG; + var _local_7:Boolean; + var _local_8:Object3D; + var _local_9:VG; + var _local_10:int; + var _local_11:Vertex; + var _local_12:Vertex; + var _local_13:ShadowAtlas; + this.uploadResources(_arg_1.device); + calculateInverseMatrix(); + var _local_6:int = ((_arg_1.debug) ? _arg_1.checkInDebug(this) : 0); + if ((_local_6 & Debug.BOUNDS)) + { + Debug.drawBounds(_arg_1, this, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ); + }; + if (this.batched) + { + _local_7 = _arg_1.debug; + if (((_local_6) && (_local_6 & Debug.NODES))) + { + _arg_1.debug = false; + }; + _local_3 = this.opaqueList; + while (_local_3 != null) + { + _local_3.ma = ma; + _local_3.mb = mb; + _local_3.mc = mc; + _local_3.md = md; + _local_3.me = me; + _local_3.mf = mf; + _local_3.mg = mg; + _local_3.mh = mh; + _local_3.mi = mi; + _local_3.mj = mj; + _local_3.mk = mk; + _local_3.ml = ml; + _local_3.concat(this); + _local_3.draw(_arg_1); + if (((((!(_arg_1.view.constrained)) && (!(_arg_1.shadowMap == null))) && (_arg_1.shadowMapStrength > 0)) && (_local_3.concatenatedAlpha >= _local_3.shadowMapAlphaThreshold))) + { + _arg_1.casterObjects[_arg_1.casterCount] = _local_3; + _arg_1.casterCount++; + }; + _local_3 = _local_3.next; + }; + _arg_1.debug = _local_7; + _local_5 = super.getVG(_arg_1); + if ((((!(_arg_1.view.constrained)) && (!(_arg_1.shadowMap == null))) && (_arg_1.shadowMapStrength > 0))) + { + _local_3 = childrenList; + while (_local_3 != null) + { + if (_local_3.visible) + { + if ((((_local_3 is Mesh) || (_local_3 is BSP)) || (_local_3 is Sprite3D))) + { + if (_local_3.concatenatedAlpha >= _local_3.shadowMapAlphaThreshold) + { + _arg_1.casterObjects[_arg_1.casterCount] = _local_3; + _arg_1.casterCount++; + }; + } else + { + if ((_local_3 is Object3DContainer)) + { + _local_8 = Object3DContainer(_local_3).childrenList; + while (_local_8 != null) + { + if (((((_local_8 is Mesh) || (_local_8 is BSP)) || (_local_8 is Sprite3D)) && (_local_8.concatenatedAlpha >= _local_8.shadowMapAlphaThreshold))) + { + _arg_1.casterObjects[_arg_1.casterCount] = _local_8; + _arg_1.casterCount++; + }; + _local_8 = _local_8.next; + }; + }; + }; + }; + _local_3 = _local_3.next; + }; + }; + _local_2 = 0; + while (_local_2 < this.transparentLength) + { + _local_3 = this.transparent[_local_2]; + _local_3.composeAndAppend(this); + if (_local_3.cullingInCamera(_arg_1, culling) >= 0) + { + _local_3.concat(this); + _local_9 = _local_3.getVG(_arg_1); + if (_local_9 != null) + { + _local_9.next = _local_5; + _local_5 = _local_9; + }; + }; + if (((((!(_arg_1.view.constrained)) && (!(_arg_1.shadowMap == null))) && (_arg_1.shadowMapStrength > 0)) && (_local_3.concatenatedAlpha >= _local_3.shadowMapAlphaThreshold))) + { + _arg_1.casterObjects[_arg_1.casterCount] = _local_3; + _arg_1.casterCount++; + }; + _local_2++; + }; + if (_local_5 != null) + { + if (_local_5.next != null) + { + if (resolveByAABB) + { + _local_4 = _local_5; + while (_local_4 != null) + { + _local_4.calculateAABB(ima, imb, imc, imd, ime, imf, img, imh, imi, imj, imk, iml); + _local_4 = _local_4.next; + }; + drawAABBGeometry(_arg_1, _local_5); + } else + { + if (resolveByOOBB) + { + _local_4 = _local_5; + while (_local_4 != null) + { + _local_4.calculateOOBB(this); + _local_4 = _local_4.next; + }; + drawOOBBGeometry(_arg_1, _local_5); + } else + { + drawConflictGeometry(_arg_1, _local_5); + }; + }; + } else + { + _local_5.draw(_arg_1, threshold, this); + _local_5.destroy(); + }; + }; + } else + { + if (this.root != null) + { + this.calculateCameraPlanes(_arg_1.nearClipping, _arg_1.farClipping); + _local_10 = this.cullingInContainer(culling, this.root.boundMinX, this.root.boundMinY, this.root.boundMinZ, this.root.boundMaxX, this.root.boundMaxY, this.root.boundMaxZ); + if (_local_10 >= 0) + { + this.numOccluders = 0; + if (_arg_1.numOccluders > 0) + { + this.updateOccluders(_arg_1); + }; + _local_5 = super.getVG(_arg_1); + _local_4 = _local_5; + while (_local_4 != null) + { + _local_4.calculateAABB(ima, imb, imc, imd, ime, imf, img, imh, imi, imj, imk, iml); + _local_4 = _local_4.next; + }; + this.drawNode(this.root, _local_10, _arg_1, _local_5); + _local_2 = 0; + while (_local_2 < this.numOccluders) + { + _local_11 = this.occluders[_local_2]; + _local_12 = _local_11; + while (_local_12.next != null) + { + _local_12 = _local_12.next; + }; + _local_12.next = Vertex.collector; + Vertex.collector = _local_11; + this.occluders[_local_2] = null; + _local_2++; + }; + this.numOccluders = 0; + } else + { + super.draw(_arg_1); + }; + } else + { + super.draw(_arg_1); + }; + }; + if (((!(this.root == null)) && (_local_6 & Debug.NODES))) + { + this.debugNode(this.root, _local_10, _arg_1, 1); + Debug.drawBounds(_arg_1, this, this.root.boundMinX, this.root.boundMinY, this.root.boundMinZ, this.root.boundMaxX, this.root.boundMaxY, this.root.boundMaxZ, 14496733); + }; + if (this.root != null) + { + _arg_1.receiversVertexBuffers = this.receiversVertexBuffers; + _arg_1.receiversIndexBuffers = this.receiversIndexBuffers; + for each (_local_13 in _arg_1.shadowAtlases) + { + _local_2 = 0; + while (_local_2 < _local_13.shadowsCount) + { + this.root.collectReceivers(_local_13.shadows[_local_2]); + _local_2++; + }; + }; + }; + } + + override alternativa3d function getVG(_arg_1:Camera3D):VG + { + var _local_3:int; + var _local_2:VG = super.getVG(_arg_1); + if (this.root != null) + { + this.numOccluders = 0; + calculateInverseMatrix(); + this.calculateCameraPlanes(_arg_1.nearClipping, _arg_1.farClipping); + _local_3 = this.cullingInContainer(culling, this.root.boundMinX, this.root.boundMinY, this.root.boundMinZ, this.root.boundMaxX, this.root.boundMaxY, this.root.boundMaxZ); + if (_local_3 >= 0) + { + _local_2 = this.collectVGNode(this.root, _local_3, _arg_1, _local_2); + }; + }; + return (_local_2); + } + + private function collectVGNode(_arg_1:KDNode, _arg_2:int, _arg_3:Camera3D, _arg_4:VG=null):VG + { + var _local_5:VG; + var _local_6:VG; + var _local_9:VG; + var _local_10:int; + var _local_11:int; + var _local_7:Object3D = _arg_1.objectList; + var _local_8:Object3D = _arg_1.objectBoundList; + while (_local_7 != null) + { + if (((_local_7.visible) && (((_local_7.culling = _arg_2) == 0) || ((_local_7.culling = this.cullingInContainer(_arg_2, _local_8.boundMinX, _local_8.boundMinY, _local_8.boundMinZ, _local_8.boundMaxX, _local_8.boundMaxY, _local_8.boundMaxZ)) >= 0)))) + { + _local_7.composeAndAppend(this); + _local_7.concat(this); + _local_9 = _local_7.getVG(_arg_3); + if (_local_9 != null) + { + if (_local_5 != null) + { + _local_6.next = _local_9; + } else + { + _local_5 = _local_9; + _local_6 = _local_9; + }; + while (_local_6.next != null) + { + _local_6 = _local_6.next; + }; + }; + }; + _local_7 = _local_7.next; + _local_8 = _local_8.next; + }; + if (_local_5 != null) + { + _local_6.next = _arg_4; + _arg_4 = _local_5; + }; + if (_arg_1.negative != null) + { + _local_10 = ((_arg_2 > 0) ? this.cullingInContainer(_arg_2, _arg_1.negative.boundMinX, _arg_1.negative.boundMinY, _arg_1.negative.boundMinZ, _arg_1.negative.boundMaxX, _arg_1.negative.boundMaxY, _arg_1.negative.boundMaxZ) : 0); + _local_11 = ((_arg_2 > 0) ? this.cullingInContainer(_arg_2, _arg_1.positive.boundMinX, _arg_1.positive.boundMinY, _arg_1.positive.boundMinZ, _arg_1.positive.boundMaxX, _arg_1.positive.boundMaxY, _arg_1.positive.boundMaxZ) : 0); + if (_local_10 >= 0) + { + _arg_4 = this.collectVGNode(_arg_1.negative, _local_10, _arg_3, _arg_4); + }; + if (_local_11 >= 0) + { + _arg_4 = this.collectVGNode(_arg_1.positive, _local_11, _arg_3, _arg_4); + }; + }; + return (_arg_4); + } + + private function uploadResources(_arg_1:Device):void + { + var _local_2:*; + var _local_3:Object3D; + var _local_4:Mesh; + var _local_5:BSP; + var _local_7:TextureMaterial; + if (this.isCreated) + { + return; + }; + this.isCreated = true; + for (_local_2 in this.materials) + { + _local_7 = (_local_2 as TextureMaterial); + if (_local_7.texture != null) + { + _arg_1.uploadResource(_local_7.textureResource); + }; + if (_local_7._textureATF != null) + { + _arg_1.uploadResource(_local_7.textureATFResource); + }; + if (_local_7._textureATFAlpha != null) + { + _arg_1.uploadResource(_local_7.textureATFAlphaResource); + }; + }; + _local_3 = this.opaqueList; + while (_local_3 != null) + { + if ((_local_3 is Mesh)) + { + _local_4 = (_local_3 as Mesh); + _local_4.prepareResources(); + _arg_1.uploadResource(_local_4.vertexBuffer); + _arg_1.uploadResource(_local_4.indexBuffer); + } else + { + if ((_local_3 is BSP)) + { + _local_5 = (_local_3 as BSP); + _local_5.prepareResources(); + _arg_1.uploadResource(_local_5.vertexBuffer); + _arg_1.uploadResource(_local_5.indexBuffer); + }; + }; + _local_3 = _local_3.next; + }; + var _local_6:int; + while (_local_6 < this.transparentLength) + { + _local_3 = this.transparent[_local_6]; + if ((_local_3 is Mesh)) + { + _local_4 = (_local_3 as Mesh); + _local_4.prepareResources(); + _arg_1.uploadResource(_local_4.vertexBuffer); + _arg_1.uploadResource(_local_4.indexBuffer); + } else + { + if ((_local_3 is BSP)) + { + _local_5 = (_local_3 as BSP); + _local_5.prepareResources(); + _arg_1.uploadResource(_local_5.vertexBuffer); + _arg_1.uploadResource(_local_5.indexBuffer); + }; + }; + _local_6++; + }; + _local_6 = 0; + while (_local_6 < this.receiversVertexBuffers.length) + { + _arg_1.uploadResource(this.receiversVertexBuffers[_local_6]); + _arg_1.uploadResource(this.receiversIndexBuffers[_local_6]); + _local_6++; + }; + } + + override alternativa3d function updateBounds(_arg_1:Object3D, _arg_2:Object3D=null):void + { + super.updateBounds(_arg_1, _arg_2); + if (this.root != null) + { + if (_arg_2 != null) + { + this.updateBoundsNode(this.root, _arg_1, _arg_2); + } else + { + if (this.root.boundMinX < _arg_1.boundMinX) + { + _arg_1.boundMinX = this.root.boundMinX; + }; + if (this.root.boundMaxX > _arg_1.boundMaxX) + { + _arg_1.boundMaxX = this.root.boundMaxX; + }; + if (this.root.boundMinY < _arg_1.boundMinY) + { + _arg_1.boundMinY = this.root.boundMinY; + }; + if (this.root.boundMaxY > _arg_1.boundMaxY) + { + _arg_1.boundMaxY = this.root.boundMaxY; + }; + if (this.root.boundMinZ < _arg_1.boundMinZ) + { + _arg_1.boundMinZ = this.root.boundMinZ; + }; + if (this.root.boundMaxZ > _arg_1.boundMaxZ) + { + _arg_1.boundMaxZ = this.root.boundMaxZ; + }; + }; + }; + } + + private function updateBoundsNode(_arg_1:KDNode, _arg_2:Object3D, _arg_3:Object3D):void + { + var _local_4:Object3D = _arg_1.objectList; + while (_local_4 != null) + { + if (_arg_3 != null) + { + _local_4.composeAndAppend(_arg_3); + } else + { + _local_4.composeMatrix(); + }; + _local_4.updateBounds(_arg_2, _local_4); + _local_4 = _local_4.next; + }; + if (_arg_1.negative != null) + { + this.updateBoundsNode(_arg_1.negative, _arg_2, _arg_3); + this.updateBoundsNode(_arg_1.positive, _arg_2, _arg_3); + }; + } + + private function debugNode(_arg_1:KDNode, _arg_2:int, _arg_3:Camera3D, _arg_4:Number):void + { + var _local_5:int; + var _local_6:int; + if (((!(_arg_1 == null)) && (!(_arg_1.negative == null)))) + { + _local_5 = ((_arg_2 > 0) ? this.cullingInContainer(_arg_2, _arg_1.negative.boundMinX, _arg_1.negative.boundMinY, _arg_1.negative.boundMinZ, _arg_1.negative.boundMaxX, _arg_1.negative.boundMaxY, _arg_1.negative.boundMaxZ) : 0); + _local_6 = ((_arg_2 > 0) ? this.cullingInContainer(_arg_2, _arg_1.positive.boundMinX, _arg_1.positive.boundMinY, _arg_1.positive.boundMinZ, _arg_1.positive.boundMaxX, _arg_1.positive.boundMaxY, _arg_1.positive.boundMaxZ) : 0); + if (_local_5 >= 0) + { + this.debugNode(_arg_1.negative, _local_5, _arg_3, (_arg_4 * this.debugAlphaFade)); + }; + Debug.drawKDNode(_arg_3, this, _arg_1.axis, _arg_1.coord, _arg_1.boundMinX, _arg_1.boundMinY, _arg_1.boundMinZ, _arg_1.boundMaxX, _arg_1.boundMaxY, _arg_1.boundMaxZ, _arg_4); + if (_local_6 >= 0) + { + this.debugNode(_arg_1.positive, _local_6, _arg_3, (_arg_4 * this.debugAlphaFade)); + }; + }; + } + + private function drawNode(_arg_1:KDNode, _arg_2:int, _arg_3:Camera3D, _arg_4:VG):void + { + var _local_5:int; + var _local_6:VG; + var _local_7:VG; + var _local_8:VG; + var _local_9:VG; + var _local_10:Object3D; + var _local_11:Object3D; + var _local_12:int; + var _local_13:int; + var _local_14:Boolean; + var _local_15:Boolean; + var _local_16:Number; + var _local_17:Number; + if (_arg_3.occludedAll) + { + while (_arg_4 != null) + { + _local_6 = _arg_4.next; + _arg_4.destroy(); + _arg_4 = _local_6; + }; + return; + }; + if (_arg_1.negative != null) + { + _local_12 = (((_arg_2 > 0) || (this.numOccluders > 0)) ? this.cullingInContainer(_arg_2, _arg_1.negative.boundMinX, _arg_1.negative.boundMinY, _arg_1.negative.boundMinZ, _arg_1.negative.boundMaxX, _arg_1.negative.boundMaxY, _arg_1.negative.boundMaxZ) : 0); + _local_13 = (((_arg_2 > 0) || (this.numOccluders > 0)) ? this.cullingInContainer(_arg_2, _arg_1.positive.boundMinX, _arg_1.positive.boundMinY, _arg_1.positive.boundMinZ, _arg_1.positive.boundMaxX, _arg_1.positive.boundMaxY, _arg_1.positive.boundMaxZ) : 0); + _local_14 = (_arg_1.axis == 0); + _local_15 = (_arg_1.axis == 1); + if (((_local_12 >= 0) && (_local_13 >= 0))) + { + while (_arg_4 != null) + { + _local_6 = _arg_4.next; + if (((_arg_4.numOccluders < this.numOccluders) && (this.occludeGeometry(_arg_3, _arg_4)))) + { + _arg_4.destroy(); + } else + { + _local_16 = ((_local_14) ? _arg_4.boundMinX : ((_local_15) ? _arg_4.boundMinY : _arg_4.boundMinZ)); + _local_17 = ((_local_14) ? _arg_4.boundMaxX : ((_local_15) ? _arg_4.boundMaxY : _arg_4.boundMaxZ)); + if (_local_17 <= _arg_1.maxCoord) + { + if (_local_16 < _arg_1.minCoord) + { + _arg_4.next = _local_7; + _local_7 = _arg_4; + } else + { + _arg_4.next = _local_8; + _local_8 = _arg_4; + }; + } else + { + if (_local_16 >= _arg_1.minCoord) + { + _arg_4.next = _local_9; + _local_9 = _arg_4; + } else + { + _arg_4.split(_arg_3, ((_arg_1.axis == 0) ? 1 : 0), ((_arg_1.axis == 1) ? 1 : 0), ((_arg_1.axis == 2) ? 1 : 0), _arg_1.coord, threshold); + if (_arg_4.next != null) + { + _arg_4.next.next = _local_7; + _local_7 = _arg_4.next; + }; + if (_arg_4.faceStruct != null) + { + _arg_4.next = _local_9; + _local_9 = _arg_4; + } else + { + _arg_4.destroy(); + }; + }; + }; + }; + _arg_4 = _local_6; + }; + if (((((_local_14) && (imd > _arg_1.coord)) || ((_local_15) && (imh > _arg_1.coord))) || (((!(_local_14)) && (!(_local_15))) && (iml > _arg_1.coord)))) + { + this.drawNode(_arg_1.positive, _local_13, _arg_3, _local_9); + while (_local_8 != null) + { + _local_6 = _local_8.next; + if (((_local_8.numOccluders >= this.numOccluders) || (!(this.occludeGeometry(_arg_3, _local_8))))) + { + _local_8.draw(_arg_3, threshold, this); + }; + _local_8.destroy(); + _local_8 = _local_6; + }; + _local_10 = _arg_1.objectList; + _local_11 = _arg_1.objectBoundList; + while (_local_10 != null) + { + if (((_local_10.visible) && ((((_local_10.culling = _arg_2) == 0) && (this.numOccluders == 0)) || ((_local_10.culling = this.cullingInContainer(_arg_2, _local_11.boundMinX, _local_11.boundMinY, _local_11.boundMinZ, _local_11.boundMaxX, _local_11.boundMaxY, _local_11.boundMaxZ)) >= 0)))) + { + _local_10.copyAndAppend(_local_11, this); + _local_10.concat(this); + _local_10.draw(_arg_3); + }; + _local_10 = _local_10.next; + _local_11 = _local_11.next; + }; + _local_10 = _arg_1.occluderList; + _local_11 = _arg_1.occluderBoundList; + while (_local_10 != null) + { + if (((_local_10.visible) && ((((_local_10.culling = _arg_2) == 0) && (this.numOccluders == 0)) || ((_local_10.culling = this.cullingInContainer(_arg_2, _local_11.boundMinX, _local_11.boundMinY, _local_11.boundMinZ, _local_11.boundMaxX, _local_11.boundMaxY, _local_11.boundMaxZ)) >= 0)))) + { + _local_10.copyAndAppend(_local_11, this); + _local_10.concat(this); + _local_10.draw(_arg_3); + }; + _local_10 = _local_10.next; + _local_11 = _local_11.next; + }; + if (_arg_1.occluderList != null) + { + this.updateOccluders(_arg_3); + }; + this.drawNode(_arg_1.negative, _local_12, _arg_3, _local_7); + } else + { + this.drawNode(_arg_1.negative, _local_12, _arg_3, _local_7); + while (_local_8 != null) + { + _local_6 = _local_8.next; + if (((_local_8.numOccluders >= this.numOccluders) || (!(this.occludeGeometry(_arg_3, _local_8))))) + { + _local_8.draw(_arg_3, threshold, this); + }; + _local_8.destroy(); + _local_8 = _local_6; + }; + _local_10 = _arg_1.objectList; + _local_11 = _arg_1.objectBoundList; + while (_local_10 != null) + { + if (((_local_10.visible) && ((((_local_10.culling = _arg_2) == 0) && (this.numOccluders == 0)) || ((_local_10.culling = this.cullingInContainer(_arg_2, _local_11.boundMinX, _local_11.boundMinY, _local_11.boundMinZ, _local_11.boundMaxX, _local_11.boundMaxY, _local_11.boundMaxZ)) >= 0)))) + { + _local_10.copyAndAppend(_local_11, this); + _local_10.concat(this); + _local_10.draw(_arg_3); + }; + _local_10 = _local_10.next; + _local_11 = _local_11.next; + }; + _local_10 = _arg_1.occluderList; + _local_11 = _arg_1.occluderBoundList; + while (_local_10 != null) + { + if (((_local_10.visible) && ((((_local_10.culling = _arg_2) == 0) && (this.numOccluders == 0)) || ((_local_10.culling = this.cullingInContainer(_arg_2, _local_11.boundMinX, _local_11.boundMinY, _local_11.boundMinZ, _local_11.boundMaxX, _local_11.boundMaxY, _local_11.boundMaxZ)) >= 0)))) + { + _local_10.copyAndAppend(_local_11, this); + _local_10.concat(this); + _local_10.draw(_arg_3); + }; + _local_10 = _local_10.next; + _local_11 = _local_11.next; + }; + if (_arg_1.occluderList != null) + { + this.updateOccluders(_arg_3); + }; + this.drawNode(_arg_1.positive, _local_13, _arg_3, _local_9); + }; + } else + { + if (_local_12 >= 0) + { + while (_arg_4 != null) + { + _local_6 = _arg_4.next; + if (((_arg_4.numOccluders < this.numOccluders) && (this.occludeGeometry(_arg_3, _arg_4)))) + { + _arg_4.destroy(); + } else + { + _local_16 = ((_local_14) ? _arg_4.boundMinX : ((_local_15) ? _arg_4.boundMinY : _arg_4.boundMinZ)); + _local_17 = ((_local_14) ? _arg_4.boundMaxX : ((_local_15) ? _arg_4.boundMaxY : _arg_4.boundMaxZ)); + if (_local_17 <= _arg_1.maxCoord) + { + _arg_4.next = _local_7; + _local_7 = _arg_4; + } else + { + if (_local_16 >= _arg_1.minCoord) + { + _arg_4.destroy(); + } else + { + _arg_4.crop(_arg_3, ((_arg_1.axis == 0) ? -1 : 0), ((_arg_1.axis == 1) ? -1 : 0), ((_arg_1.axis == 2) ? -1 : 0), -(_arg_1.coord), threshold); + if (_arg_4.faceStruct != null) + { + _arg_4.next = _local_7; + _local_7 = _arg_4; + } else + { + _arg_4.destroy(); + }; + }; + }; + }; + _arg_4 = _local_6; + }; + this.drawNode(_arg_1.negative, _local_12, _arg_3, _local_7); + } else + { + if (_local_13 >= 0) + { + while (_arg_4 != null) + { + _local_6 = _arg_4.next; + if (((_arg_4.numOccluders < this.numOccluders) && (this.occludeGeometry(_arg_3, _arg_4)))) + { + _arg_4.destroy(); + } else + { + _local_16 = ((_local_14) ? _arg_4.boundMinX : ((_local_15) ? _arg_4.boundMinY : _arg_4.boundMinZ)); + _local_17 = ((_local_14) ? _arg_4.boundMaxX : ((_local_15) ? _arg_4.boundMaxY : _arg_4.boundMaxZ)); + if (_local_17 <= _arg_1.maxCoord) + { + _arg_4.destroy(); + } else + { + if (_local_16 >= _arg_1.minCoord) + { + _arg_4.next = _local_9; + _local_9 = _arg_4; + } else + { + _arg_4.crop(_arg_3, ((_arg_1.axis == 0) ? 1 : 0), ((_arg_1.axis == 1) ? 1 : 0), ((_arg_1.axis == 2) ? 1 : 0), _arg_1.coord, threshold); + if (_arg_4.faceStruct != null) + { + _arg_4.next = _local_9; + _local_9 = _arg_4; + } else + { + _arg_4.destroy(); + }; + }; + }; + }; + _arg_4 = _local_6; + }; + this.drawNode(_arg_1.positive, _local_13, _arg_3, _local_9); + } else + { + while (_arg_4 != null) + { + _local_6 = _arg_4.next; + _arg_4.destroy(); + _arg_4 = _local_6; + }; + }; + }; + }; + } else + { + if (_arg_1.objectList != null) + { + if (((!(_arg_1.objectList.next == null)) || (!(_arg_4 == null)))) + { + while (_arg_4 != null) + { + _local_6 = _arg_4.next; + if (((_arg_4.numOccluders < this.numOccluders) && (this.occludeGeometry(_arg_3, _arg_4)))) + { + _arg_4.destroy(); + } else + { + _arg_4.next = _local_8; + _local_8 = _arg_4; + }; + _arg_4 = _local_6; + }; + _local_10 = _arg_1.objectList; + _local_11 = _arg_1.objectBoundList; + while (_local_10 != null) + { + if (((_local_10.visible) && ((((_local_10.culling = _arg_2) == 0) && (this.numOccluders == 0)) || ((_local_10.culling = this.cullingInContainer(_arg_2, _local_11.boundMinX, _local_11.boundMinY, _local_11.boundMinZ, _local_11.boundMaxX, _local_11.boundMaxY, _local_11.boundMaxZ)) >= 0)))) + { + _local_10.copyAndAppend(_local_11, this); + _local_10.concat(this); + _arg_4 = _local_10.getVG(_arg_3); + while (_arg_4 != null) + { + _local_6 = _arg_4.next; + _arg_4.next = _local_8; + _local_8 = _arg_4; + _arg_4 = _local_6; + }; + }; + _local_10 = _local_10.next; + _local_11 = _local_11.next; + }; + if (_local_8 != null) + { + if (_local_8.next != null) + { + drawConflictGeometry(_arg_3, _local_8); + } else + { + _local_8.draw(_arg_3, threshold, this); + _local_8.destroy(); + }; + }; + } else + { + _local_10 = _arg_1.objectList; + if (_local_10.visible) + { + _local_10.copyAndAppend(_arg_1.objectBoundList, this); + _local_10.culling = _arg_2; + _local_10.concat(this); + _local_10.draw(_arg_3); + }; + }; + } else + { + if (_arg_4 != null) + { + if (_arg_4.next != null) + { + if (this.numOccluders > 0) + { + while (_arg_4 != null) + { + _local_6 = _arg_4.next; + if (((_arg_4.numOccluders < this.numOccluders) && (this.occludeGeometry(_arg_3, _arg_4)))) + { + _arg_4.destroy(); + } else + { + _arg_4.next = _local_8; + _local_8 = _arg_4; + }; + _arg_4 = _local_6; + }; + if (_local_8 != null) + { + if (_local_8.next != null) + { + if (resolveByAABB) + { + drawAABBGeometry(_arg_3, _local_8); + } else + { + if (resolveByOOBB) + { + _arg_4 = _local_8; + while (_arg_4 != null) + { + _arg_4.calculateOOBB(this); + _arg_4 = _arg_4.next; + }; + drawOOBBGeometry(_arg_3, _local_8); + } else + { + drawConflictGeometry(_arg_3, _local_8); + }; + }; + } else + { + _local_8.draw(_arg_3, threshold, this); + _local_8.destroy(); + }; + }; + } else + { + _local_8 = _arg_4; + if (resolveByAABB) + { + drawAABBGeometry(_arg_3, _local_8); + } else + { + if (resolveByOOBB) + { + _arg_4 = _local_8; + while (_arg_4 != null) + { + _arg_4.calculateOOBB(this); + _arg_4 = _arg_4.next; + }; + drawOOBBGeometry(_arg_3, _local_8); + } else + { + drawConflictGeometry(_arg_3, _local_8); + }; + }; + }; + } else + { + if (((_arg_4.numOccluders >= this.numOccluders) || (!(this.occludeGeometry(_arg_3, _arg_4))))) + { + _arg_4.draw(_arg_3, threshold, this); + }; + _arg_4.destroy(); + }; + }; + }; + _local_10 = _arg_1.occluderList; + _local_11 = _arg_1.occluderBoundList; + while (_local_10 != null) + { + if (((_local_10.visible) && ((((_local_10.culling = _arg_2) == 0) && (this.numOccluders == 0)) || ((_local_10.culling = this.cullingInContainer(_arg_2, _local_11.boundMinX, _local_11.boundMinY, _local_11.boundMinZ, _local_11.boundMaxX, _local_11.boundMaxY, _local_11.boundMaxZ)) >= 0)))) + { + _local_10.copyAndAppend(_local_11, this); + _local_10.concat(this); + _local_10.draw(_arg_3); + }; + _local_10 = _local_10.next; + _local_11 = _local_11.next; + }; + if (_arg_1.occluderList != null) + { + this.updateOccluders(_arg_3); + }; + }; + } + + private function createObjectBounds(_arg_1:Object3D):Object3D + { + var _local_2:Object3D = new Object3D(); + _local_2.boundMinX = 1E22; + _local_2.boundMinY = 1E22; + _local_2.boundMinZ = 1E22; + _local_2.boundMaxX = -1E22; + _local_2.boundMaxY = -1E22; + _local_2.boundMaxZ = -1E22; + _arg_1.composeMatrix(); + _arg_1.updateBounds(_local_2, _arg_1); + _local_2.ma = _arg_1.ma; + _local_2.mb = _arg_1.mb; + _local_2.mc = _arg_1.mc; + _local_2.md = _arg_1.md; + _local_2.me = _arg_1.me; + _local_2.mf = _arg_1.mf; + _local_2.mg = _arg_1.mg; + _local_2.mh = _arg_1.mh; + _local_2.mi = _arg_1.mi; + _local_2.mj = _arg_1.mj; + _local_2.mk = _arg_1.mk; + _local_2.ml = _arg_1.ml; + return (_local_2); + } + + private function createNode(_arg_1:Object3D, _arg_2:Object3D, _arg_3:Object3D, _arg_4:Object3D, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Number, _arg_9:Number, _arg_10:Number):KDNode + { + var _local_12:int; + var _local_13:int; + var _local_14:Object3D; + var _local_15:Object3D; + var _local_16:Number; + var _local_21:Number; + var _local_23:int; + var _local_24:int; + var _local_25:Number; + var _local_26:Number; + var _local_27:Number; + var _local_28:Number; + var _local_29:Object3D; + var _local_30:Object3D; + var _local_31:Object3D; + var _local_32:Object3D; + var _local_33:Object3D; + var _local_34:Object3D; + var _local_35:Object3D; + var _local_36:Object3D; + var _local_37:Number; + var _local_38:Number; + var _local_39:Object3D; + var _local_40:Object3D; + var _local_41:Number; + var _local_42:Number; + var _local_43:Number; + var _local_44:Number; + var _local_45:Number; + var _local_46:Number; + var _local_47:Number; + var _local_48:Number; + var _local_49:Number; + var _local_50:Number; + var _local_51:Number; + var _local_52:Number; + var _local_11:KDNode = new KDNode(); + _local_11.boundMinX = _arg_5; + _local_11.boundMinY = _arg_6; + _local_11.boundMinZ = _arg_7; + _local_11.boundMaxX = _arg_8; + _local_11.boundMaxY = _arg_9; + _local_11.boundMaxZ = _arg_10; + if (_arg_1 == null) + { + if (_arg_3 != null) + { + }; + return (_local_11); + }; + var _local_17:int; + var _local_18:int; + var _local_19:int; + _local_15 = _arg_2; + while (_local_15 != null) + { + if (_local_15.boundMinX > (_arg_5 + threshold)) + { + _local_13 = 0; + while (_local_13 < _local_17) + { + if (((_local_15.boundMinX >= (splitCoordsX[_local_13] - threshold)) && (_local_15.boundMinX <= (splitCoordsX[_local_13] + threshold)))) break; + _local_13++; + }; + if (_local_13 == _local_17) + { + var _local_53:* = _local_17++; + splitCoordsX[_local_53] = _local_15.boundMinX; + }; + }; + if (_local_15.boundMaxX < (_arg_8 - threshold)) + { + _local_13 = 0; + while (_local_13 < _local_17) + { + if (((_local_15.boundMaxX >= (splitCoordsX[_local_13] - threshold)) && (_local_15.boundMaxX <= (splitCoordsX[_local_13] + threshold)))) break; + _local_13++; + }; + if (_local_13 == _local_17) + { + _local_53 = _local_17++; + splitCoordsX[_local_53] = _local_15.boundMaxX; + }; + }; + if (_local_15.boundMinY > (_arg_6 + threshold)) + { + _local_13 = 0; + while (_local_13 < _local_18) + { + if (((_local_15.boundMinY >= (splitCoordsY[_local_13] - threshold)) && (_local_15.boundMinY <= (splitCoordsY[_local_13] + threshold)))) break; + _local_13++; + }; + if (_local_13 == _local_18) + { + _local_53 = _local_18++; + splitCoordsY[_local_53] = _local_15.boundMinY; + }; + }; + if (_local_15.boundMaxY < (_arg_9 - threshold)) + { + _local_13 = 0; + while (_local_13 < _local_18) + { + if (((_local_15.boundMaxY >= (splitCoordsY[_local_13] - threshold)) && (_local_15.boundMaxY <= (splitCoordsY[_local_13] + threshold)))) break; + _local_13++; + }; + if (_local_13 == _local_18) + { + _local_53 = _local_18++; + splitCoordsY[_local_53] = _local_15.boundMaxY; + }; + }; + if (_local_15.boundMinZ > (_arg_7 + threshold)) + { + _local_13 = 0; + while (_local_13 < _local_19) + { + if (((_local_15.boundMinZ >= (splitCoordsZ[_local_13] - threshold)) && (_local_15.boundMinZ <= (splitCoordsZ[_local_13] + threshold)))) break; + _local_13++; + }; + if (_local_13 == _local_19) + { + _local_53 = _local_19++; + splitCoordsZ[_local_53] = _local_15.boundMinZ; + }; + }; + if (_local_15.boundMaxZ < (_arg_10 - threshold)) + { + _local_13 = 0; + while (_local_13 < _local_19) + { + if (((_local_15.boundMaxZ >= (splitCoordsZ[_local_13] - threshold)) && (_local_15.boundMaxZ <= (splitCoordsZ[_local_13] + threshold)))) break; + _local_13++; + }; + if (_local_13 == _local_19) + { + _local_53 = _local_19++; + splitCoordsZ[_local_53] = _local_15.boundMaxZ; + }; + }; + _local_15 = _local_15.next; + }; + var _local_20:int = -1; + var _local_22:Number = 1E22; + _local_25 = ((_arg_9 - _arg_6) * (_arg_10 - _arg_7)); + _local_12 = 0; + while (_local_12 < _local_17) + { + _local_16 = splitCoordsX[_local_12]; + _local_26 = (_local_25 * (_local_16 - _arg_5)); + _local_27 = (_local_25 * (_arg_8 - _local_16)); + _local_23 = 0; + _local_24 = 0; + _local_15 = _arg_2; + while (_local_15 != null) + { + if (_local_15.boundMaxX <= (_local_16 + threshold)) + { + if (_local_15.boundMinX < (_local_16 - threshold)) + { + _local_23++; + }; + } else + { + if (_local_15.boundMinX >= (_local_16 - threshold)) + { + _local_24++; + } else + { + break; + }; + }; + _local_15 = _local_15.next; + }; + if (_local_15 == null) + { + _local_28 = ((_local_26 * _local_23) + (_local_27 * _local_24)); + if (_local_28 < _local_22) + { + _local_22 = _local_28; + _local_20 = 0; + _local_21 = _local_16; + }; + }; + _local_12++; + }; + _local_25 = ((_arg_8 - _arg_5) * (_arg_10 - _arg_7)); + _local_12 = 0; + while (_local_12 < _local_18) + { + _local_16 = splitCoordsY[_local_12]; + _local_26 = (_local_25 * (_local_16 - _arg_6)); + _local_27 = (_local_25 * (_arg_9 - _local_16)); + _local_23 = 0; + _local_24 = 0; + _local_15 = _arg_2; + while (_local_15 != null) + { + if (_local_15.boundMaxY <= (_local_16 + threshold)) + { + if (_local_15.boundMinY < (_local_16 - threshold)) + { + _local_23++; + }; + } else + { + if (_local_15.boundMinY >= (_local_16 - threshold)) + { + _local_24++; + } else + { + break; + }; + }; + _local_15 = _local_15.next; + }; + if (_local_15 == null) + { + _local_28 = ((_local_26 * _local_23) + (_local_27 * _local_24)); + if (_local_28 < _local_22) + { + _local_22 = _local_28; + _local_20 = 1; + _local_21 = _local_16; + }; + }; + _local_12++; + }; + _local_25 = ((_arg_8 - _arg_5) * (_arg_9 - _arg_6)); + _local_12 = 0; + while (_local_12 < _local_19) + { + _local_16 = splitCoordsZ[_local_12]; + _local_26 = (_local_25 * (_local_16 - _arg_7)); + _local_27 = (_local_25 * (_arg_10 - _local_16)); + _local_23 = 0; + _local_24 = 0; + _local_15 = _arg_2; + while (_local_15 != null) + { + if (_local_15.boundMaxZ <= (_local_16 + threshold)) + { + if (_local_15.boundMinZ < (_local_16 - threshold)) + { + _local_23++; + }; + } else + { + if (_local_15.boundMinZ >= (_local_16 - threshold)) + { + _local_24++; + } else + { + break; + }; + }; + _local_15 = _local_15.next; + }; + if (_local_15 == null) + { + _local_28 = ((_local_26 * _local_23) + (_local_27 * _local_24)); + if (_local_28 < _local_22) + { + _local_22 = _local_28; + _local_20 = 2; + _local_21 = _local_16; + }; + }; + _local_12++; + }; + if (_local_20 < 0) + { + _local_11.objectList = _arg_1; + _local_11.objectBoundList = _arg_2; + _local_11.occluderList = _arg_3; + _local_11.occluderBoundList = _arg_4; + } else + { + _local_11.axis = _local_20; + _local_11.coord = _local_21; + _local_11.minCoord = (_local_21 - threshold); + _local_11.maxCoord = (_local_21 + threshold); + _local_14 = _arg_1; + _local_15 = _arg_2; + while (_local_14 != null) + { + _local_39 = _local_14.next; + _local_40 = _local_15.next; + _local_14.next = null; + _local_15.next = null; + _local_37 = ((_local_20 == 0) ? _local_15.boundMinX : ((_local_20 == 1) ? _local_15.boundMinY : _local_15.boundMinZ)); + _local_38 = ((_local_20 == 0) ? _local_15.boundMaxX : ((_local_20 == 1) ? _local_15.boundMaxY : _local_15.boundMaxZ)); + if (_local_38 <= (_local_21 + threshold)) + { + if (_local_37 < (_local_21 - threshold)) + { + _local_14.next = _local_29; + _local_29 = _local_14; + _local_15.next = _local_30; + _local_30 = _local_15; + } else + { + _local_14.next = _local_11.objectList; + _local_11.objectList = _local_14; + _local_15.next = _local_11.objectBoundList; + _local_11.objectBoundList = _local_15; + }; + } else + { + if (_local_37 >= (_local_21 - threshold)) + { + _local_14.next = _local_33; + _local_33 = _local_14; + _local_15.next = _local_34; + _local_34 = _local_15; + }; + }; + _local_14 = _local_39; + _local_15 = _local_40; + }; + _local_14 = _arg_3; + _local_15 = _arg_4; + while (_local_14 != null) + { + _local_39 = _local_14.next; + _local_40 = _local_15.next; + _local_14.next = null; + _local_15.next = null; + _local_37 = ((_local_20 == 0) ? _local_15.boundMinX : ((_local_20 == 1) ? _local_15.boundMinY : _local_15.boundMinZ)); + _local_38 = ((_local_20 == 0) ? _local_15.boundMaxX : ((_local_20 == 1) ? _local_15.boundMaxY : _local_15.boundMaxZ)); + if (_local_38 <= (_local_21 + threshold)) + { + if (_local_37 < (_local_21 - threshold)) + { + _local_14.next = _local_31; + _local_31 = _local_14; + _local_15.next = _local_32; + _local_32 = _local_15; + } else + { + _local_14.next = _local_11.occluderList; + _local_11.occluderList = _local_14; + _local_15.next = _local_11.occluderBoundList; + _local_11.occluderBoundList = _local_15; + }; + } else + { + if (_local_37 >= (_local_21 - threshold)) + { + _local_14.next = _local_35; + _local_35 = _local_14; + _local_15.next = _local_36; + _local_36 = _local_15; + }; + }; + _local_14 = _local_39; + _local_15 = _local_40; + }; + _local_41 = _local_11.boundMinX; + _local_42 = _local_11.boundMinY; + _local_43 = _local_11.boundMinZ; + _local_44 = _local_11.boundMaxX; + _local_45 = _local_11.boundMaxY; + _local_46 = _local_11.boundMaxZ; + _local_47 = _local_11.boundMinX; + _local_48 = _local_11.boundMinY; + _local_49 = _local_11.boundMinZ; + _local_50 = _local_11.boundMaxX; + _local_51 = _local_11.boundMaxY; + _local_52 = _local_11.boundMaxZ; + if (_local_20 == 0) + { + _local_44 = _local_21; + _local_47 = _local_21; + } else + { + if (_local_20 == 1) + { + _local_45 = _local_21; + _local_48 = _local_21; + } else + { + _local_46 = _local_21; + _local_49 = _local_21; + }; + }; + _local_11.negative = this.createNode(_local_29, _local_30, _local_31, _local_32, _local_41, _local_42, _local_43, _local_44, _local_45, _local_46); + _local_11.positive = this.createNode(_local_33, _local_34, _local_35, _local_36, _local_47, _local_48, _local_49, _local_50, _local_51, _local_52); + }; + return (_local_11); + } + + private function destroyNode(_arg_1:KDNode):void + { + var _local_2:Object3D; + var _local_3:Object3D; + var _local_5:Receiver; + if (_arg_1.negative != null) + { + this.destroyNode(_arg_1.negative); + _arg_1.negative = null; + }; + if (_arg_1.positive != null) + { + this.destroyNode(_arg_1.positive); + _arg_1.positive = null; + }; + _local_2 = _arg_1.objectList; + while (_local_2 != null) + { + _local_3 = _local_2.next; + _local_2.setParent(null); + _local_2.next = null; + _local_2 = _local_3; + }; + _local_2 = _arg_1.objectBoundList; + while (_local_2 != null) + { + _local_3 = _local_2.next; + _local_2.next = null; + _local_2 = _local_3; + }; + _local_2 = _arg_1.occluderList; + while (_local_2 != null) + { + _local_3 = _local_2.next; + _local_2.setParent(null); + _local_2.next = null; + _local_2 = _local_3; + }; + _local_2 = _arg_1.occluderBoundList; + while (_local_2 != null) + { + _local_3 = _local_2.next; + _local_2.next = null; + _local_2 = _local_3; + }; + var _local_4:Receiver = _arg_1.receiverList; + while (_local_4 != null) + { + _local_5 = _local_4.next; + _local_4.next = null; + _local_4 = _local_5; + }; + _arg_1.objectList = null; + _arg_1.objectBoundList = null; + _arg_1.occluderList = null; + _arg_1.occluderBoundList = null; + _arg_1.receiverList = null; + } + + private function calculateCameraPlanes(_arg_1:Number, _arg_2:Number):void + { + this.nearPlaneX = imc; + this.nearPlaneY = img; + this.nearPlaneZ = imk; + this.nearPlaneOffset = (((((imc * _arg_1) + imd) * this.nearPlaneX) + (((img * _arg_1) + imh) * this.nearPlaneY)) + (((imk * _arg_1) + iml) * this.nearPlaneZ)); + this.farPlaneX = -(imc); + this.farPlaneY = -(img); + this.farPlaneZ = -(imk); + this.farPlaneOffset = (((((imc * _arg_2) + imd) * this.farPlaneX) + (((img * _arg_2) + imh) * this.farPlaneY)) + (((imk * _arg_2) + iml) * this.farPlaneZ)); + var _local_3:Number = ((-(ima) - imb) + imc); + var _local_4:Number = ((-(ime) - imf) + img); + var _local_5:Number = ((-(imi) - imj) + imk); + var _local_6:Number = ((ima - imb) + imc); + var _local_7:Number = ((ime - imf) + img); + var _local_8:Number = ((imi - imj) + imk); + this.topPlaneX = ((_local_8 * _local_4) - (_local_7 * _local_5)); + this.topPlaneY = ((_local_6 * _local_5) - (_local_8 * _local_3)); + this.topPlaneZ = ((_local_7 * _local_3) - (_local_6 * _local_4)); + this.topPlaneOffset = (((imd * this.topPlaneX) + (imh * this.topPlaneY)) + (iml * this.topPlaneZ)); + _local_3 = _local_6; + _local_4 = _local_7; + _local_5 = _local_8; + _local_6 = ((ima + imb) + imc); + _local_7 = ((ime + imf) + img); + _local_8 = ((imi + imj) + imk); + this.rightPlaneX = ((_local_8 * _local_4) - (_local_7 * _local_5)); + this.rightPlaneY = ((_local_6 * _local_5) - (_local_8 * _local_3)); + this.rightPlaneZ = ((_local_7 * _local_3) - (_local_6 * _local_4)); + this.rightPlaneOffset = (((imd * this.rightPlaneX) + (imh * this.rightPlaneY)) + (iml * this.rightPlaneZ)); + _local_3 = _local_6; + _local_4 = _local_7; + _local_5 = _local_8; + _local_6 = ((-(ima) + imb) + imc); + _local_7 = ((-(ime) + imf) + img); + _local_8 = ((-(imi) + imj) + imk); + this.bottomPlaneX = ((_local_8 * _local_4) - (_local_7 * _local_5)); + this.bottomPlaneY = ((_local_6 * _local_5) - (_local_8 * _local_3)); + this.bottomPlaneZ = ((_local_7 * _local_3) - (_local_6 * _local_4)); + this.bottomPlaneOffset = (((imd * this.bottomPlaneX) + (imh * this.bottomPlaneY)) + (iml * this.bottomPlaneZ)); + _local_3 = _local_6; + _local_4 = _local_7; + _local_5 = _local_8; + _local_6 = ((-(ima) - imb) + imc); + _local_7 = ((-(ime) - imf) + img); + _local_8 = ((-(imi) - imj) + imk); + this.leftPlaneX = ((_local_8 * _local_4) - (_local_7 * _local_5)); + this.leftPlaneY = ((_local_6 * _local_5) - (_local_8 * _local_3)); + this.leftPlaneZ = ((_local_7 * _local_3) - (_local_6 * _local_4)); + this.leftPlaneOffset = (((imd * this.leftPlaneX) + (imh * this.leftPlaneY)) + (iml * this.leftPlaneZ)); + } + + private function updateOccluders(_arg_1:Camera3D):void + { + var _local_3:Vertex; + var _local_4:Vertex; + var _local_5:Vertex; + var _local_6:Number; + var _local_7:Number; + var _local_8:Number; + var _local_9:Number; + var _local_10:Number; + var _local_11:Number; + var _local_2:int = this.numOccluders; + while (_local_2 < _arg_1.numOccluders) + { + _local_3 = null; + _local_4 = _arg_1.occluders[_local_2]; + while (_local_4 != null) + { + _local_5 = _local_4.create(); + _local_5.next = _local_3; + _local_3 = _local_5; + _local_6 = (((ima * _local_4.x) + (imb * _local_4.y)) + (imc * _local_4.z)); + _local_7 = (((ime * _local_4.x) + (imf * _local_4.y)) + (img * _local_4.z)); + _local_8 = (((imi * _local_4.x) + (imj * _local_4.y)) + (imk * _local_4.z)); + _local_9 = (((ima * _local_4.u) + (imb * _local_4.v)) + (imc * _local_4.offset)); + _local_10 = (((ime * _local_4.u) + (imf * _local_4.v)) + (img * _local_4.offset)); + _local_11 = (((imi * _local_4.u) + (imj * _local_4.v)) + (imk * _local_4.offset)); + _local_3.x = ((_local_11 * _local_7) - (_local_10 * _local_8)); + _local_3.y = ((_local_9 * _local_8) - (_local_11 * _local_6)); + _local_3.z = ((_local_10 * _local_6) - (_local_9 * _local_7)); + _local_3.offset = (((imd * _local_3.x) + (imh * _local_3.y)) + (iml * _local_3.z)); + _local_4 = _local_4.next; + }; + this.occluders[this.numOccluders] = _local_3; + this.numOccluders++; + _local_2++; + }; + } + + private function cullingInContainer(_arg_1:int, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number):int + { + var _local_9:Vertex; + if (_arg_1 > 0) + { + if ((_arg_1 & 0x01)) + { + if (this.nearPlaneX >= 0) + { + if (this.nearPlaneY >= 0) + { + if (this.nearPlaneZ >= 0) + { + if ((((_arg_5 * this.nearPlaneX) + (_arg_6 * this.nearPlaneY)) + (_arg_7 * this.nearPlaneZ)) <= this.nearPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.nearPlaneX) + (_arg_3 * this.nearPlaneY)) + (_arg_4 * this.nearPlaneZ)) > this.nearPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3E); + }; + } else + { + if ((((_arg_5 * this.nearPlaneX) + (_arg_6 * this.nearPlaneY)) + (_arg_4 * this.nearPlaneZ)) <= this.nearPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.nearPlaneX) + (_arg_3 * this.nearPlaneY)) + (_arg_7 * this.nearPlaneZ)) > this.nearPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3E); + }; + }; + } else + { + if (this.nearPlaneZ >= 0) + { + if ((((_arg_5 * this.nearPlaneX) + (_arg_3 * this.nearPlaneY)) + (_arg_7 * this.nearPlaneZ)) <= this.nearPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.nearPlaneX) + (_arg_6 * this.nearPlaneY)) + (_arg_4 * this.nearPlaneZ)) > this.nearPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3E); + }; + } else + { + if ((((_arg_5 * this.nearPlaneX) + (_arg_3 * this.nearPlaneY)) + (_arg_4 * this.nearPlaneZ)) <= this.nearPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.nearPlaneX) + (_arg_6 * this.nearPlaneY)) + (_arg_7 * this.nearPlaneZ)) > this.nearPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3E); + }; + }; + }; + } else + { + if (this.nearPlaneY >= 0) + { + if (this.nearPlaneZ >= 0) + { + if ((((_arg_2 * this.nearPlaneX) + (_arg_6 * this.nearPlaneY)) + (_arg_7 * this.nearPlaneZ)) <= this.nearPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.nearPlaneX) + (_arg_3 * this.nearPlaneY)) + (_arg_4 * this.nearPlaneZ)) > this.nearPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3E); + }; + } else + { + if ((((_arg_2 * this.nearPlaneX) + (_arg_6 * this.nearPlaneY)) + (_arg_4 * this.nearPlaneZ)) <= this.nearPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.nearPlaneX) + (_arg_3 * this.nearPlaneY)) + (_arg_7 * this.nearPlaneZ)) > this.nearPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3E); + }; + }; + } else + { + if (this.nearPlaneZ >= 0) + { + if ((((_arg_2 * this.nearPlaneX) + (_arg_3 * this.nearPlaneY)) + (_arg_7 * this.nearPlaneZ)) <= this.nearPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.nearPlaneX) + (_arg_6 * this.nearPlaneY)) + (_arg_4 * this.nearPlaneZ)) > this.nearPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3E); + }; + } else + { + if ((((_arg_2 * this.nearPlaneX) + (_arg_3 * this.nearPlaneY)) + (_arg_4 * this.nearPlaneZ)) <= this.nearPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.nearPlaneX) + (_arg_6 * this.nearPlaneY)) + (_arg_7 * this.nearPlaneZ)) > this.nearPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3E); + }; + }; + }; + }; + }; + if ((_arg_1 & 0x02)) + { + if (this.farPlaneX >= 0) + { + if (this.farPlaneY >= 0) + { + if (this.farPlaneZ >= 0) + { + if ((((_arg_5 * this.farPlaneX) + (_arg_6 * this.farPlaneY)) + (_arg_7 * this.farPlaneZ)) <= this.farPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.farPlaneX) + (_arg_3 * this.farPlaneY)) + (_arg_4 * this.farPlaneZ)) > this.farPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3D); + }; + } else + { + if ((((_arg_5 * this.farPlaneX) + (_arg_6 * this.farPlaneY)) + (_arg_4 * this.farPlaneZ)) <= this.farPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.farPlaneX) + (_arg_3 * this.farPlaneY)) + (_arg_7 * this.farPlaneZ)) > this.farPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3D); + }; + }; + } else + { + if (this.farPlaneZ >= 0) + { + if ((((_arg_5 * this.farPlaneX) + (_arg_3 * this.farPlaneY)) + (_arg_7 * this.farPlaneZ)) <= this.farPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.farPlaneX) + (_arg_6 * this.farPlaneY)) + (_arg_4 * this.farPlaneZ)) > this.farPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3D); + }; + } else + { + if ((((_arg_5 * this.farPlaneX) + (_arg_3 * this.farPlaneY)) + (_arg_4 * this.farPlaneZ)) <= this.farPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.farPlaneX) + (_arg_6 * this.farPlaneY)) + (_arg_7 * this.farPlaneZ)) > this.farPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3D); + }; + }; + }; + } else + { + if (this.farPlaneY >= 0) + { + if (this.farPlaneZ >= 0) + { + if ((((_arg_2 * this.farPlaneX) + (_arg_6 * this.farPlaneY)) + (_arg_7 * this.farPlaneZ)) <= this.farPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.farPlaneX) + (_arg_3 * this.farPlaneY)) + (_arg_4 * this.farPlaneZ)) > this.farPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3D); + }; + } else + { + if ((((_arg_2 * this.farPlaneX) + (_arg_6 * this.farPlaneY)) + (_arg_4 * this.farPlaneZ)) <= this.farPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.farPlaneX) + (_arg_3 * this.farPlaneY)) + (_arg_7 * this.farPlaneZ)) > this.farPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3D); + }; + }; + } else + { + if (this.farPlaneZ >= 0) + { + if ((((_arg_2 * this.farPlaneX) + (_arg_3 * this.farPlaneY)) + (_arg_7 * this.farPlaneZ)) <= this.farPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.farPlaneX) + (_arg_6 * this.farPlaneY)) + (_arg_4 * this.farPlaneZ)) > this.farPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3D); + }; + } else + { + if ((((_arg_2 * this.farPlaneX) + (_arg_3 * this.farPlaneY)) + (_arg_4 * this.farPlaneZ)) <= this.farPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.farPlaneX) + (_arg_6 * this.farPlaneY)) + (_arg_7 * this.farPlaneZ)) > this.farPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3D); + }; + }; + }; + }; + }; + if ((_arg_1 & 0x04)) + { + if (this.leftPlaneX >= 0) + { + if (this.leftPlaneY >= 0) + { + if (this.leftPlaneZ >= 0) + { + if ((((_arg_5 * this.leftPlaneX) + (_arg_6 * this.leftPlaneY)) + (_arg_7 * this.leftPlaneZ)) <= this.leftPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.leftPlaneX) + (_arg_3 * this.leftPlaneY)) + (_arg_4 * this.leftPlaneZ)) > this.leftPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3B); + }; + } else + { + if ((((_arg_5 * this.leftPlaneX) + (_arg_6 * this.leftPlaneY)) + (_arg_4 * this.leftPlaneZ)) <= this.leftPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.leftPlaneX) + (_arg_3 * this.leftPlaneY)) + (_arg_7 * this.leftPlaneZ)) > this.leftPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3B); + }; + }; + } else + { + if (this.leftPlaneZ >= 0) + { + if ((((_arg_5 * this.leftPlaneX) + (_arg_3 * this.leftPlaneY)) + (_arg_7 * this.leftPlaneZ)) <= this.leftPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.leftPlaneX) + (_arg_6 * this.leftPlaneY)) + (_arg_4 * this.leftPlaneZ)) > this.leftPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3B); + }; + } else + { + if ((((_arg_5 * this.leftPlaneX) + (_arg_3 * this.leftPlaneY)) + (_arg_4 * this.leftPlaneZ)) <= this.leftPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.leftPlaneX) + (_arg_6 * this.leftPlaneY)) + (_arg_7 * this.leftPlaneZ)) > this.leftPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3B); + }; + }; + }; + } else + { + if (this.leftPlaneY >= 0) + { + if (this.leftPlaneZ >= 0) + { + if ((((_arg_2 * this.leftPlaneX) + (_arg_6 * this.leftPlaneY)) + (_arg_7 * this.leftPlaneZ)) <= this.leftPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.leftPlaneX) + (_arg_3 * this.leftPlaneY)) + (_arg_4 * this.leftPlaneZ)) > this.leftPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3B); + }; + } else + { + if ((((_arg_2 * this.leftPlaneX) + (_arg_6 * this.leftPlaneY)) + (_arg_4 * this.leftPlaneZ)) <= this.leftPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.leftPlaneX) + (_arg_3 * this.leftPlaneY)) + (_arg_7 * this.leftPlaneZ)) > this.leftPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3B); + }; + }; + } else + { + if (this.leftPlaneZ >= 0) + { + if ((((_arg_2 * this.leftPlaneX) + (_arg_3 * this.leftPlaneY)) + (_arg_7 * this.leftPlaneZ)) <= this.leftPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.leftPlaneX) + (_arg_6 * this.leftPlaneY)) + (_arg_4 * this.leftPlaneZ)) > this.leftPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3B); + }; + } else + { + if ((((_arg_2 * this.leftPlaneX) + (_arg_3 * this.leftPlaneY)) + (_arg_4 * this.leftPlaneZ)) <= this.leftPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.leftPlaneX) + (_arg_6 * this.leftPlaneY)) + (_arg_7 * this.leftPlaneZ)) > this.leftPlaneOffset) + { + _arg_1 = (_arg_1 & 0x3B); + }; + }; + }; + }; + }; + if ((_arg_1 & 0x08)) + { + if (this.rightPlaneX >= 0) + { + if (this.rightPlaneY >= 0) + { + if (this.rightPlaneZ >= 0) + { + if ((((_arg_5 * this.rightPlaneX) + (_arg_6 * this.rightPlaneY)) + (_arg_7 * this.rightPlaneZ)) <= this.rightPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.rightPlaneX) + (_arg_3 * this.rightPlaneY)) + (_arg_4 * this.rightPlaneZ)) > this.rightPlaneOffset) + { + _arg_1 = (_arg_1 & 0x37); + }; + } else + { + if ((((_arg_5 * this.rightPlaneX) + (_arg_6 * this.rightPlaneY)) + (_arg_4 * this.rightPlaneZ)) <= this.rightPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.rightPlaneX) + (_arg_3 * this.rightPlaneY)) + (_arg_7 * this.rightPlaneZ)) > this.rightPlaneOffset) + { + _arg_1 = (_arg_1 & 0x37); + }; + }; + } else + { + if (this.rightPlaneZ >= 0) + { + if ((((_arg_5 * this.rightPlaneX) + (_arg_3 * this.rightPlaneY)) + (_arg_7 * this.rightPlaneZ)) <= this.rightPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.rightPlaneX) + (_arg_6 * this.rightPlaneY)) + (_arg_4 * this.rightPlaneZ)) > this.rightPlaneOffset) + { + _arg_1 = (_arg_1 & 0x37); + }; + } else + { + if ((((_arg_5 * this.rightPlaneX) + (_arg_3 * this.rightPlaneY)) + (_arg_4 * this.rightPlaneZ)) <= this.rightPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.rightPlaneX) + (_arg_6 * this.rightPlaneY)) + (_arg_7 * this.rightPlaneZ)) > this.rightPlaneOffset) + { + _arg_1 = (_arg_1 & 0x37); + }; + }; + }; + } else + { + if (this.rightPlaneY >= 0) + { + if (this.rightPlaneZ >= 0) + { + if ((((_arg_2 * this.rightPlaneX) + (_arg_6 * this.rightPlaneY)) + (_arg_7 * this.rightPlaneZ)) <= this.rightPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.rightPlaneX) + (_arg_3 * this.rightPlaneY)) + (_arg_4 * this.rightPlaneZ)) > this.rightPlaneOffset) + { + _arg_1 = (_arg_1 & 0x37); + }; + } else + { + if ((((_arg_2 * this.rightPlaneX) + (_arg_6 * this.rightPlaneY)) + (_arg_4 * this.rightPlaneZ)) <= this.rightPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.rightPlaneX) + (_arg_3 * this.rightPlaneY)) + (_arg_7 * this.rightPlaneZ)) > this.rightPlaneOffset) + { + _arg_1 = (_arg_1 & 0x37); + }; + }; + } else + { + if (this.rightPlaneZ >= 0) + { + if ((((_arg_2 * this.rightPlaneX) + (_arg_3 * this.rightPlaneY)) + (_arg_7 * this.rightPlaneZ)) <= this.rightPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.rightPlaneX) + (_arg_6 * this.rightPlaneY)) + (_arg_4 * this.rightPlaneZ)) > this.rightPlaneOffset) + { + _arg_1 = (_arg_1 & 0x37); + }; + } else + { + if ((((_arg_2 * this.rightPlaneX) + (_arg_3 * this.rightPlaneY)) + (_arg_4 * this.rightPlaneZ)) <= this.rightPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.rightPlaneX) + (_arg_6 * this.rightPlaneY)) + (_arg_7 * this.rightPlaneZ)) > this.rightPlaneOffset) + { + _arg_1 = (_arg_1 & 0x37); + }; + }; + }; + }; + }; + if ((_arg_1 & 0x10)) + { + if (this.topPlaneX >= 0) + { + if (this.topPlaneY >= 0) + { + if (this.topPlaneZ >= 0) + { + if ((((_arg_5 * this.topPlaneX) + (_arg_6 * this.topPlaneY)) + (_arg_7 * this.topPlaneZ)) <= this.topPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.topPlaneX) + (_arg_3 * this.topPlaneY)) + (_arg_4 * this.topPlaneZ)) > this.topPlaneOffset) + { + _arg_1 = (_arg_1 & 0x2F); + }; + } else + { + if ((((_arg_5 * this.topPlaneX) + (_arg_6 * this.topPlaneY)) + (_arg_4 * this.topPlaneZ)) <= this.topPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.topPlaneX) + (_arg_3 * this.topPlaneY)) + (_arg_7 * this.topPlaneZ)) > this.topPlaneOffset) + { + _arg_1 = (_arg_1 & 0x2F); + }; + }; + } else + { + if (this.topPlaneZ >= 0) + { + if ((((_arg_5 * this.topPlaneX) + (_arg_3 * this.topPlaneY)) + (_arg_7 * this.topPlaneZ)) <= this.topPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.topPlaneX) + (_arg_6 * this.topPlaneY)) + (_arg_4 * this.topPlaneZ)) > this.topPlaneOffset) + { + _arg_1 = (_arg_1 & 0x2F); + }; + } else + { + if ((((_arg_5 * this.topPlaneX) + (_arg_3 * this.topPlaneY)) + (_arg_4 * this.topPlaneZ)) <= this.topPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.topPlaneX) + (_arg_6 * this.topPlaneY)) + (_arg_7 * this.topPlaneZ)) > this.topPlaneOffset) + { + _arg_1 = (_arg_1 & 0x2F); + }; + }; + }; + } else + { + if (this.topPlaneY >= 0) + { + if (this.topPlaneZ >= 0) + { + if ((((_arg_2 * this.topPlaneX) + (_arg_6 * this.topPlaneY)) + (_arg_7 * this.topPlaneZ)) <= this.topPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.topPlaneX) + (_arg_3 * this.topPlaneY)) + (_arg_4 * this.topPlaneZ)) > this.topPlaneOffset) + { + _arg_1 = (_arg_1 & 0x2F); + }; + } else + { + if ((((_arg_2 * this.topPlaneX) + (_arg_6 * this.topPlaneY)) + (_arg_4 * this.topPlaneZ)) <= this.topPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.topPlaneX) + (_arg_3 * this.topPlaneY)) + (_arg_7 * this.topPlaneZ)) > this.topPlaneOffset) + { + _arg_1 = (_arg_1 & 0x2F); + }; + }; + } else + { + if (this.topPlaneZ >= 0) + { + if ((((_arg_2 * this.topPlaneX) + (_arg_3 * this.topPlaneY)) + (_arg_7 * this.topPlaneZ)) <= this.topPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.topPlaneX) + (_arg_6 * this.topPlaneY)) + (_arg_4 * this.topPlaneZ)) > this.topPlaneOffset) + { + _arg_1 = (_arg_1 & 0x2F); + }; + } else + { + if ((((_arg_2 * this.topPlaneX) + (_arg_3 * this.topPlaneY)) + (_arg_4 * this.topPlaneZ)) <= this.topPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.topPlaneX) + (_arg_6 * this.topPlaneY)) + (_arg_7 * this.topPlaneZ)) > this.topPlaneOffset) + { + _arg_1 = (_arg_1 & 0x2F); + }; + }; + }; + }; + }; + if ((_arg_1 & 0x20)) + { + if (this.bottomPlaneX >= 0) + { + if (this.bottomPlaneY >= 0) + { + if (this.bottomPlaneZ >= 0) + { + if ((((_arg_5 * this.bottomPlaneX) + (_arg_6 * this.bottomPlaneY)) + (_arg_7 * this.bottomPlaneZ)) <= this.bottomPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.bottomPlaneX) + (_arg_3 * this.bottomPlaneY)) + (_arg_4 * this.bottomPlaneZ)) > this.bottomPlaneOffset) + { + _arg_1 = (_arg_1 & 0x1F); + }; + } else + { + if ((((_arg_5 * this.bottomPlaneX) + (_arg_6 * this.bottomPlaneY)) + (_arg_4 * this.bottomPlaneZ)) <= this.bottomPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.bottomPlaneX) + (_arg_3 * this.bottomPlaneY)) + (_arg_7 * this.bottomPlaneZ)) > this.bottomPlaneOffset) + { + _arg_1 = (_arg_1 & 0x1F); + }; + }; + } else + { + if (this.bottomPlaneZ >= 0) + { + if ((((_arg_5 * this.bottomPlaneX) + (_arg_3 * this.bottomPlaneY)) + (_arg_7 * this.bottomPlaneZ)) <= this.bottomPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.bottomPlaneX) + (_arg_6 * this.bottomPlaneY)) + (_arg_4 * this.bottomPlaneZ)) > this.bottomPlaneOffset) + { + _arg_1 = (_arg_1 & 0x1F); + }; + } else + { + if ((((_arg_5 * this.bottomPlaneX) + (_arg_3 * this.bottomPlaneY)) + (_arg_4 * this.bottomPlaneZ)) <= this.bottomPlaneOffset) + { + return (-1); + }; + if ((((_arg_2 * this.bottomPlaneX) + (_arg_6 * this.bottomPlaneY)) + (_arg_7 * this.bottomPlaneZ)) > this.bottomPlaneOffset) + { + _arg_1 = (_arg_1 & 0x1F); + }; + }; + }; + } else + { + if (this.bottomPlaneY >= 0) + { + if (this.bottomPlaneZ >= 0) + { + if ((((_arg_2 * this.bottomPlaneX) + (_arg_6 * this.bottomPlaneY)) + (_arg_7 * this.bottomPlaneZ)) <= this.bottomPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.bottomPlaneX) + (_arg_3 * this.bottomPlaneY)) + (_arg_4 * this.bottomPlaneZ)) > this.bottomPlaneOffset) + { + _arg_1 = (_arg_1 & 0x1F); + }; + } else + { + if ((((_arg_2 * this.bottomPlaneX) + (_arg_6 * this.bottomPlaneY)) + (_arg_4 * this.bottomPlaneZ)) <= this.bottomPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.bottomPlaneX) + (_arg_3 * this.bottomPlaneY)) + (_arg_7 * this.bottomPlaneZ)) > this.bottomPlaneOffset) + { + _arg_1 = (_arg_1 & 0x1F); + }; + }; + } else + { + if (this.bottomPlaneZ >= 0) + { + if ((((_arg_2 * this.bottomPlaneX) + (_arg_3 * this.bottomPlaneY)) + (_arg_7 * this.bottomPlaneZ)) <= this.bottomPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.bottomPlaneX) + (_arg_6 * this.bottomPlaneY)) + (_arg_4 * this.bottomPlaneZ)) > this.bottomPlaneOffset) + { + _arg_1 = (_arg_1 & 0x1F); + }; + } else + { + if ((((_arg_2 * this.bottomPlaneX) + (_arg_3 * this.bottomPlaneY)) + (_arg_4 * this.bottomPlaneZ)) <= this.bottomPlaneOffset) + { + return (-1); + }; + if ((((_arg_5 * this.bottomPlaneX) + (_arg_6 * this.bottomPlaneY)) + (_arg_7 * this.bottomPlaneZ)) > this.bottomPlaneOffset) + { + _arg_1 = (_arg_1 & 0x1F); + }; + }; + }; + }; + }; + }; + var _local_8:int; + while (_local_8 < this.numOccluders) + { + _local_9 = this.occluders[_local_8]; + while (_local_9 != null) + { + if (_local_9.x >= 0) + { + if (_local_9.y >= 0) + { + if (_local_9.z >= 0) + { + if ((((_arg_5 * _local_9.x) + (_arg_6 * _local_9.y)) + (_arg_7 * _local_9.z)) > _local_9.offset) break; + } else + { + if ((((_arg_5 * _local_9.x) + (_arg_6 * _local_9.y)) + (_arg_4 * _local_9.z)) > _local_9.offset) break; + }; + } else + { + if (_local_9.z >= 0) + { + if ((((_arg_5 * _local_9.x) + (_arg_3 * _local_9.y)) + (_arg_7 * _local_9.z)) > _local_9.offset) break; + } else + { + if ((((_arg_5 * _local_9.x) + (_arg_3 * _local_9.y)) + (_arg_4 * _local_9.z)) > _local_9.offset) break; + }; + }; + } else + { + if (_local_9.y >= 0) + { + if (_local_9.z >= 0) + { + if ((((_arg_2 * _local_9.x) + (_arg_6 * _local_9.y)) + (_arg_7 * _local_9.z)) > _local_9.offset) break; + } else + { + if ((((_arg_2 * _local_9.x) + (_arg_6 * _local_9.y)) + (_arg_4 * _local_9.z)) > _local_9.offset) break; + }; + } else + { + if (_local_9.z >= 0) + { + if ((((_arg_2 * _local_9.x) + (_arg_3 * _local_9.y)) + (_arg_7 * _local_9.z)) > _local_9.offset) break; + } else + { + if ((((_arg_2 * _local_9.x) + (_arg_3 * _local_9.y)) + (_arg_4 * _local_9.z)) > _local_9.offset) break; + }; + }; + }; + _local_9 = _local_9.next; + }; + if (_local_9 == null) + { + return (-1); + }; + _local_8++; + }; + return (_arg_1); + } + + private function occludeGeometry(_arg_1:Camera3D, _arg_2:VG):Boolean + { + var _local_4:Vertex; + var _local_3:int = _arg_2.numOccluders; + while (_local_3 < this.numOccluders) + { + _local_4 = this.occluders[_local_3]; + while (_local_4 != null) + { + if (_local_4.x >= 0) + { + if (_local_4.y >= 0) + { + if (_local_4.z >= 0) + { + if ((((_arg_2.boundMaxX * _local_4.x) + (_arg_2.boundMaxY * _local_4.y)) + (_arg_2.boundMaxZ * _local_4.z)) > _local_4.offset) break; + } else + { + if ((((_arg_2.boundMaxX * _local_4.x) + (_arg_2.boundMaxY * _local_4.y)) + (_arg_2.boundMinZ * _local_4.z)) > _local_4.offset) break; + }; + } else + { + if (_local_4.z >= 0) + { + if ((((_arg_2.boundMaxX * _local_4.x) + (_arg_2.boundMinY * _local_4.y)) + (_arg_2.boundMaxZ * _local_4.z)) > _local_4.offset) break; + } else + { + if ((((_arg_2.boundMaxX * _local_4.x) + (_arg_2.boundMinY * _local_4.y)) + (_arg_2.boundMinZ * _local_4.z)) > _local_4.offset) break; + }; + }; + } else + { + if (_local_4.y >= 0) + { + if (_local_4.z >= 0) + { + if ((((_arg_2.boundMinX * _local_4.x) + (_arg_2.boundMaxY * _local_4.y)) + (_arg_2.boundMaxZ * _local_4.z)) > _local_4.offset) break; + } else + { + if ((((_arg_2.boundMinX * _local_4.x) + (_arg_2.boundMaxY * _local_4.y)) + (_arg_2.boundMinZ * _local_4.z)) > _local_4.offset) break; + }; + } else + { + if (_local_4.z >= 0) + { + if ((((_arg_2.boundMinX * _local_4.x) + (_arg_2.boundMinY * _local_4.y)) + (_arg_2.boundMaxZ * _local_4.z)) > _local_4.offset) break; + } else + { + if ((((_arg_2.boundMinX * _local_4.x) + (_arg_2.boundMinY * _local_4.y)) + (_arg_2.boundMinZ * _local_4.z)) > _local_4.offset) break; + }; + }; + }; + _local_4 = _local_4.next; + }; + if (_local_4 == null) + { + return (true); + }; + _local_3++; + }; + _arg_2.numOccluders = this.numOccluders; + return (false); + } + + + } +}//package alternativa.engine3d.containers + +import alternativa.engine3d.core.Object3D; +import alternativa.engine3d.core.Vertex; +import __AS3__.vec.Vector; +import alternativa.engine3d.core.Face; +import alternativa.engine3d.materials.TextureMaterial; +import alternativa.engine3d.core.Wrapper; +import alternativa.engine3d.objects.Mesh; +import alternativa.engine3d.objects.BSP; +import alternativa.engine3d.core.Shadow; +import alternativa.engine3d.objects.Decal; +import __AS3__.vec.*; +import alternativa.engine3d.alternativa3d; + +use namespace alternativa3d; + +class KDNode +{ + + public var negative:KDNode; + public var positive:KDNode; + public var axis:int; + public var coord:Number; + public var minCoord:Number; + public var maxCoord:Number; + public var boundMinX:Number; + public var boundMinY:Number; + public var boundMinZ:Number; + public var boundMaxX:Number; + public var boundMaxY:Number; + public var boundMaxZ:Number; + public var objectList:Object3D; + public var objectBoundList:Object3D; + public var occluderList:Object3D; + public var occluderBoundList:Object3D; + public var receiverList:Receiver; + + + public function createReceivers(_arg_1:Vector.>, _arg_2:Vector.>):void + { + var _local_3:Receiver; + var _local_5:Receiver; + var _local_6:Vertex; + var _local_7:Vertex; + var _local_8:Vector.; + var _local_9:int; + var _local_10:TextureMaterial; + var _local_11:int; + var _local_12:int; + var _local_13:Vector.; + var _local_14:Vector.; + var _local_15:int; + var _local_16:int; + var _local_17:int; + var _local_18:int; + var _local_19:Face; + var _local_20:Wrapper; + var _local_21:uint; + var _local_22:uint; + var _local_23:uint; + this.receiverList = null; + var _local_4:Object3D = this.objectList; + while (_local_4 != null) + { + _local_4.composeMatrix(); + _local_5 = new Receiver(); + if (_local_3 != null) + { + _local_3.next = _local_5; + } else + { + this.receiverList = _local_5; + }; + _local_3 = _local_5; + if ((_local_4 is Mesh)) + { + _local_7 = (_local_4 as Mesh).vertexList; + _local_8 = (_local_4 as Mesh).faces; + } else + { + if ((_local_4 is BSP)) + { + _local_7 = (_local_4 as BSP).vertexList; + _local_8 = (_local_4 as BSP).faces; + }; + }; + _local_9 = _local_8.length; + _local_10 = (_local_8[0].material as TextureMaterial); + if (((_local_9 > 0) && (!(_local_10 == null)))) + { + _local_11 = 0; + _local_6 = _local_7; + while (_local_6 != null) + { + _local_11++; + _local_6 = _local_6.next; + }; + _local_12 = (_arg_1.length - 1); + _local_13 = _arg_1[_local_12]; + if (((_local_13.length / 3) + _local_11) > 0xFFFF) + { + _local_12++; + _arg_1[_local_12] = new Vector.(); + _arg_2[_local_12] = new Vector.(); + _local_13 = _arg_1[_local_12]; + }; + _local_14 = _arg_2[_local_12]; + _local_15 = _local_13.length; + _local_16 = int((_local_15 / 3)); + _local_17 = _local_14.length; + _local_5.buffer = _local_12; + _local_5.firstIndex = _local_17; + _local_5.transparent = _local_10.transparent; + _local_6 = _local_7; + while (_local_6 != null) + { + _local_13[_local_15] = ((((_local_6.x * _local_4.ma) + (_local_6.y * _local_4.mb)) + (_local_6.z * _local_4.mc)) + _local_4.md); + _local_15++; + _local_13[_local_15] = ((((_local_6.x * _local_4.me) + (_local_6.y * _local_4.mf)) + (_local_6.z * _local_4.mg)) + _local_4.mh); + _local_15++; + _local_13[_local_15] = ((((_local_6.x * _local_4.mi) + (_local_6.y * _local_4.mj)) + (_local_6.z * _local_4.mk)) + _local_4.ml); + _local_15++; + _local_6.index = _local_16; + _local_16++; + _local_6 = _local_6.next; + }; + _local_18 = 0; + while (_local_18 < _local_9) + { + _local_19 = _local_8[_local_18]; + if ((((_local_19.normalX * _local_4.mi) + (_local_19.normalY * _local_4.mj)) + (_local_19.normalZ * _local_4.mk)) >= -0.5) + { + _local_20 = _local_19.wrapper; + _local_21 = _local_20.vertex.index; + _local_20 = _local_20.next; + _local_22 = _local_20.vertex.index; + _local_20 = _local_20.next; + while (_local_20 != null) + { + _local_23 = _local_20.vertex.index; + _local_14[_local_17] = _local_21; + _local_17++; + _local_14[_local_17] = _local_22; + _local_17++; + _local_14[_local_17] = _local_23; + _local_17++; + _local_5.numTriangles++; + _local_22 = _local_23; + _local_20 = _local_20.next; + }; + }; + _local_18++; + }; + }; + _local_4 = _local_4.next; + }; + if (this.negative != null) + { + this.negative.createReceivers(_arg_1, _arg_2); + }; + if (this.positive != null) + { + this.positive.createReceivers(_arg_1, _arg_2); + }; + } + + public function collectReceivers(_arg_1:Shadow):void + { + var _local_2:Object3D; + var _local_3:Object3D; + var _local_4:Receiver; + var _local_5:Boolean; + var _local_6:Boolean; + var _local_7:Number; + var _local_8:Number; + if (this.negative != null) + { + _local_5 = (this.axis == 0); + _local_6 = (this.axis == 1); + _local_7 = ((_local_5) ? _arg_1.boundMinX : ((_local_6) ? _arg_1.boundMinY : _arg_1.boundMinZ)); + _local_8 = ((_local_5) ? _arg_1.boundMaxX : ((_local_6) ? _arg_1.boundMaxY : _arg_1.boundMaxZ)); + if (_local_8 <= this.maxCoord) + { + this.negative.collectReceivers(_arg_1); + } else + { + if (_local_7 >= this.minCoord) + { + this.positive.collectReceivers(_arg_1); + } else + { + if (_local_5) + { + _local_3 = this.objectBoundList; + _local_2 = this.objectList; + _local_4 = this.receiverList; + while (_local_3 != null) + { + if ((((((_local_4.numTriangles > 0) && (_arg_1.boundMinY < _local_3.boundMaxY)) && (_arg_1.boundMaxY > _local_3.boundMinY)) && (_arg_1.boundMinZ < _local_3.boundMaxZ)) && (_arg_1.boundMaxZ > _local_3.boundMinZ))) + { + if ((!(_local_4.transparent))) + { + _arg_1.receiversBuffers[_arg_1.receiversCount] = _local_4.buffer; + _arg_1.receiversFirstIndexes[_arg_1.receiversCount] = _local_4.firstIndex; + _arg_1.receiversNumsTriangles[_arg_1.receiversCount] = _local_4.numTriangles; + _arg_1.receiversCount++; + }; + }; + _local_3 = _local_3.next; + _local_2 = _local_2.next; + _local_4 = _local_4.next; + }; + } else + { + if (_local_6) + { + _local_3 = this.objectBoundList; + _local_2 = this.objectList; + _local_4 = this.receiverList; + while (_local_3 != null) + { + if ((((((_local_4.numTriangles > 0) && (_arg_1.boundMinX < _local_3.boundMaxX)) && (_arg_1.boundMaxX > _local_3.boundMinX)) && (_arg_1.boundMinZ < _local_3.boundMaxZ)) && (_arg_1.boundMaxZ > _local_3.boundMinZ))) + { + if ((!(_local_4.transparent))) + { + _arg_1.receiversBuffers[_arg_1.receiversCount] = _local_4.buffer; + _arg_1.receiversFirstIndexes[_arg_1.receiversCount] = _local_4.firstIndex; + _arg_1.receiversNumsTriangles[_arg_1.receiversCount] = _local_4.numTriangles; + _arg_1.receiversCount++; + }; + }; + _local_3 = _local_3.next; + _local_2 = _local_2.next; + _local_4 = _local_4.next; + }; + } else + { + _local_3 = this.objectBoundList; + _local_2 = this.objectList; + _local_4 = this.receiverList; + while (_local_3 != null) + { + if ((((((_local_4.numTriangles > 0) && (_arg_1.boundMinX < _local_3.boundMaxX)) && (_arg_1.boundMaxX > _local_3.boundMinX)) && (_arg_1.boundMinY < _local_3.boundMaxY)) && (_arg_1.boundMaxY > _local_3.boundMinY))) + { + if ((!(_local_4.transparent))) + { + _arg_1.receiversBuffers[_arg_1.receiversCount] = _local_4.buffer; + _arg_1.receiversFirstIndexes[_arg_1.receiversCount] = _local_4.firstIndex; + _arg_1.receiversNumsTriangles[_arg_1.receiversCount] = _local_4.numTriangles; + _arg_1.receiversCount++; + }; + }; + _local_3 = _local_3.next; + _local_2 = _local_2.next; + _local_4 = _local_4.next; + }; + }; + }; + this.negative.collectReceivers(_arg_1); + this.positive.collectReceivers(_arg_1); + }; + }; + } else + { + _local_2 = this.objectList; + _local_4 = this.receiverList; + while (_local_4 != null) + { + if (_local_4.numTriangles > 0) + { + if ((!(_local_4.transparent))) + { + _arg_1.receiversBuffers[_arg_1.receiversCount] = _local_4.buffer; + _arg_1.receiversFirstIndexes[_arg_1.receiversCount] = _local_4.firstIndex; + _arg_1.receiversNumsTriangles[_arg_1.receiversCount] = _local_4.numTriangles; + _arg_1.receiversCount++; + }; + }; + _local_2 = _local_2.next; + _local_4 = _local_4.next; + }; + }; + } + + public function collectPolygons(_arg_1:Decal, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Number, _arg_9:Number):void + { + var _local_10:Object3D; + var _local_11:Object3D; + var _local_12:Boolean; + var _local_13:Boolean; + var _local_14:Number; + var _local_15:Number; + if (this.negative != null) + { + _local_12 = (this.axis == 0); + _local_13 = (this.axis == 1); + _local_14 = ((_local_12) ? _arg_4 : ((_local_13) ? _arg_6 : _arg_8)); + _local_15 = ((_local_12) ? _arg_5 : ((_local_13) ? _arg_7 : _arg_9)); + if (_local_15 <= this.maxCoord) + { + this.negative.collectPolygons(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9); + } else + { + if (_local_14 >= this.minCoord) + { + this.positive.collectPolygons(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9); + } else + { + _local_11 = this.objectBoundList; + _local_10 = this.objectList; + while (_local_11 != null) + { + if (_local_12) + { + if (((((_arg_6 < _local_11.boundMaxY) && (_arg_7 > _local_11.boundMinY)) && (_arg_8 < _local_11.boundMaxZ)) && (_arg_9 > _local_11.boundMinZ))) + { + this.clip(_arg_1, _arg_2, _arg_3, _local_10); + }; + } else + { + if (_local_13) + { + if (((((_arg_4 < _local_11.boundMaxX) && (_arg_5 > _local_11.boundMinX)) && (_arg_8 < _local_11.boundMaxZ)) && (_arg_9 > _local_11.boundMinZ))) + { + this.clip(_arg_1, _arg_2, _arg_3, _local_10); + }; + } else + { + if (((((_arg_4 < _local_11.boundMaxX) && (_arg_5 > _local_11.boundMinX)) && (_arg_6 < _local_11.boundMaxY)) && (_arg_7 > _local_11.boundMinY))) + { + this.clip(_arg_1, _arg_2, _arg_3, _local_10); + }; + }; + }; + _local_11 = _local_11.next; + _local_10 = _local_10.next; + }; + this.negative.collectPolygons(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9); + this.positive.collectPolygons(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9); + }; + }; + } else + { + _local_10 = this.objectList; + while (_local_10 != null) + { + this.clip(_arg_1, _arg_2, _arg_3, _local_10); + _local_10 = _local_10.next; + }; + }; + } + + private function clip(_arg_1:Decal, _arg_2:Number, _arg_3:Number, _arg_4:Object3D):void + { + var _local_5:Face; + var _local_6:Vertex; + var _local_7:Wrapper; + var _local_8:Vertex; + var _local_9:Vector.; + var _local_10:int; + var _local_11:int; + var _local_12:Number; + var _local_13:Number; + var _local_14:Vertex; + var _local_15:Vertex; + var _local_16:Vertex; + var _local_17:Vertex; + var _local_18:Vertex; + var _local_19:Vertex; + var _local_20:Wrapper; + if ((_arg_4 is Mesh)) + { + _local_8 = Mesh(_arg_4).vertexList; + _local_5 = Mesh(_arg_4).faceList; + if (((_local_5.material == null) || (_local_5.material.transparent))) + { + return; + }; + _local_9 = Mesh(_arg_4).faces; + } else + { + if ((_arg_4 is BSP)) + { + _local_8 = BSP(_arg_4).vertexList; + _local_9 = BSP(_arg_4).faces; + _local_5 = _local_9[0]; + if (((_local_5.material == null) || (_local_5.material.transparent))) + { + return; + }; + }; + }; + _arg_4.composeAndAppend(_arg_1); + _arg_4.calculateInverseMatrix(); + _arg_4.transformId++; + _local_10 = _local_9.length; + _local_11 = 0; + while (_local_11 < _local_10) + { + _local_5 = _local_9[_local_11]; + if ((((-(_local_5.normalX) * _arg_4.imc) - (_local_5.normalY * _arg_4.img)) - (_local_5.normalZ * _arg_4.imk)) >= _arg_3) + { + _local_12 = (((_local_5.normalX * _arg_4.imd) + (_local_5.normalY * _arg_4.imh)) + (_local_5.normalZ * _arg_4.iml)); + if (!((_local_12 <= (_local_5.offset - _arg_2)) || (_local_12 >= (_local_5.offset + _arg_2)))) + { + _local_7 = _local_5.wrapper; + while (_local_7 != null) + { + _local_6 = _local_7.vertex; + if (_local_6.transformId != _arg_4.transformId) + { + _local_6.cameraX = ((((_arg_4.ma * _local_6.x) + (_arg_4.mb * _local_6.y)) + (_arg_4.mc * _local_6.z)) + _arg_4.md); + _local_6.cameraY = ((((_arg_4.me * _local_6.x) + (_arg_4.mf * _local_6.y)) + (_arg_4.mg * _local_6.z)) + _arg_4.mh); + _local_6.cameraZ = ((((_arg_4.mi * _local_6.x) + (_arg_4.mj * _local_6.y)) + (_arg_4.mk * _local_6.z)) + _arg_4.ml); + _local_6.transformId = _arg_4.transformId; + }; + _local_7 = _local_7.next; + }; + _local_7 = _local_5.wrapper; + while (_local_7 != null) + { + if (_local_7.vertex.cameraX > _arg_1.boundMinX) break; + _local_7 = _local_7.next; + }; + if (_local_7 != null) + { + _local_7 = _local_5.wrapper; + while (_local_7 != null) + { + if (_local_7.vertex.cameraX < _arg_1.boundMaxX) break; + _local_7 = _local_7.next; + }; + if (_local_7 != null) + { + _local_7 = _local_5.wrapper; + while (_local_7 != null) + { + if (_local_7.vertex.cameraY > _arg_1.boundMinY) break; + _local_7 = _local_7.next; + }; + if (_local_7 != null) + { + _local_7 = _local_5.wrapper; + while (_local_7 != null) + { + if (_local_7.vertex.cameraY < _arg_1.boundMaxY) break; + _local_7 = _local_7.next; + }; + if (_local_7 != null) + { + _local_7 = _local_5.wrapper; + while (_local_7 != null) + { + if (_local_7.vertex.cameraZ > _arg_1.boundMinZ) break; + _local_7 = _local_7.next; + }; + if (_local_7 != null) + { + _local_7 = _local_5.wrapper; + while (_local_7 != null) + { + if (_local_7.vertex.cameraZ < _arg_1.boundMaxZ) break; + _local_7 = _local_7.next; + }; + if (_local_7 != null) + { + _local_18 = null; + _local_19 = null; + _local_7 = _local_5.wrapper; + while (_local_7 != null) + { + _local_6 = _local_7.vertex; + _local_16 = new Vertex(); + _local_16.x = _local_6.cameraX; + _local_16.y = _local_6.cameraY; + _local_16.z = _local_6.cameraZ; + _local_16.normalX = (((_arg_4.ma * _local_6.normalX) + (_arg_4.mb * _local_6.normalY)) + (_arg_4.mc * _local_6.normalZ)); + _local_16.normalY = (((_arg_4.me * _local_6.normalX) + (_arg_4.mf * _local_6.normalY)) + (_arg_4.mg * _local_6.normalZ)); + _local_16.normalZ = (((_arg_4.mi * _local_6.normalX) + (_arg_4.mj * _local_6.normalY)) + (_arg_4.mk * _local_6.normalZ)); + if (_local_19 != null) + { + _local_19.next = _local_16; + } else + { + _local_18 = _local_16; + }; + _local_19 = _local_16; + _local_7 = _local_7.next; + }; + _local_14 = _local_19; + _local_15 = _local_18; + _local_18 = null; + _local_19 = null; + while (_local_15 != null) + { + _local_17 = _local_15.next; + _local_15.next = null; + if ((((_local_15.z > _arg_1.boundMinZ) && (_local_14.z <= _arg_1.boundMinZ)) || ((_local_15.z <= _arg_1.boundMinZ) && (_local_14.z > _arg_1.boundMinZ)))) + { + _local_13 = ((_arg_1.boundMinZ - _local_14.z) / (_local_15.z - _local_14.z)); + _local_16 = new Vertex(); + _local_16.x = (_local_14.x + ((_local_15.x - _local_14.x) * _local_13)); + _local_16.y = (_local_14.y + ((_local_15.y - _local_14.y) * _local_13)); + _local_16.z = (_local_14.z + ((_local_15.z - _local_14.z) * _local_13)); + _local_16.normalX = (_local_14.normalX + ((_local_15.normalX - _local_14.normalX) * _local_13)); + _local_16.normalY = (_local_14.normalY + ((_local_15.normalY - _local_14.normalY) * _local_13)); + _local_16.normalZ = (_local_14.normalZ + ((_local_15.normalZ - _local_14.normalZ) * _local_13)); + if (_local_19 != null) + { + _local_19.next = _local_16; + } else + { + _local_18 = _local_16; + }; + _local_19 = _local_16; + }; + if (_local_15.z > _arg_1.boundMinZ) + { + if (_local_19 != null) + { + _local_19.next = _local_15; + } else + { + _local_18 = _local_15; + }; + _local_19 = _local_15; + }; + _local_14 = _local_15; + _local_15 = _local_17; + }; + if (_local_18 != null) + { + _local_14 = _local_19; + _local_15 = _local_18; + _local_18 = null; + _local_19 = null; + while (_local_15 != null) + { + _local_17 = _local_15.next; + _local_15.next = null; + if ((((_local_15.z < _arg_1.boundMaxZ) && (_local_14.z >= _arg_1.boundMaxZ)) || ((_local_15.z >= _arg_1.boundMaxZ) && (_local_14.z < _arg_1.boundMaxZ)))) + { + _local_13 = ((_arg_1.boundMaxZ - _local_14.z) / (_local_15.z - _local_14.z)); + _local_16 = new Vertex(); + _local_16.x = (_local_14.x + ((_local_15.x - _local_14.x) * _local_13)); + _local_16.y = (_local_14.y + ((_local_15.y - _local_14.y) * _local_13)); + _local_16.z = (_local_14.z + ((_local_15.z - _local_14.z) * _local_13)); + _local_16.normalX = (_local_14.normalX + ((_local_15.normalX - _local_14.normalX) * _local_13)); + _local_16.normalY = (_local_14.normalY + ((_local_15.normalY - _local_14.normalY) * _local_13)); + _local_16.normalZ = (_local_14.normalZ + ((_local_15.normalZ - _local_14.normalZ) * _local_13)); + if (_local_19 != null) + { + _local_19.next = _local_16; + } else + { + _local_18 = _local_16; + }; + _local_19 = _local_16; + }; + if (_local_15.z < _arg_1.boundMaxZ) + { + if (_local_19 != null) + { + _local_19.next = _local_15; + } else + { + _local_18 = _local_15; + }; + _local_19 = _local_15; + }; + _local_14 = _local_15; + _local_15 = _local_17; + }; + if (_local_18 != null) + { + _local_14 = _local_19; + _local_15 = _local_18; + _local_18 = null; + _local_19 = null; + while (_local_15 != null) + { + _local_17 = _local_15.next; + _local_15.next = null; + if ((((_local_15.x > _arg_1.boundMinX) && (_local_14.x <= _arg_1.boundMinX)) || ((_local_15.x <= _arg_1.boundMinX) && (_local_14.x > _arg_1.boundMinX)))) + { + _local_13 = ((_arg_1.boundMinX - _local_14.x) / (_local_15.x - _local_14.x)); + _local_16 = new Vertex(); + _local_16.x = (_local_14.x + ((_local_15.x - _local_14.x) * _local_13)); + _local_16.y = (_local_14.y + ((_local_15.y - _local_14.y) * _local_13)); + _local_16.z = (_local_14.z + ((_local_15.z - _local_14.z) * _local_13)); + _local_16.normalX = (_local_14.normalX + ((_local_15.normalX - _local_14.normalX) * _local_13)); + _local_16.normalY = (_local_14.normalY + ((_local_15.normalY - _local_14.normalY) * _local_13)); + _local_16.normalZ = (_local_14.normalZ + ((_local_15.normalZ - _local_14.normalZ) * _local_13)); + if (_local_19 != null) + { + _local_19.next = _local_16; + } else + { + _local_18 = _local_16; + }; + _local_19 = _local_16; + }; + if (_local_15.x > _arg_1.boundMinX) + { + if (_local_19 != null) + { + _local_19.next = _local_15; + } else + { + _local_18 = _local_15; + }; + _local_19 = _local_15; + }; + _local_14 = _local_15; + _local_15 = _local_17; + }; + if (_local_18 != null) + { + _local_14 = _local_19; + _local_15 = _local_18; + _local_18 = null; + _local_19 = null; + while (_local_15 != null) + { + _local_17 = _local_15.next; + _local_15.next = null; + if ((((_local_15.x < _arg_1.boundMaxX) && (_local_14.x >= _arg_1.boundMaxX)) || ((_local_15.x >= _arg_1.boundMaxX) && (_local_14.x < _arg_1.boundMaxX)))) + { + _local_13 = ((_arg_1.boundMaxX - _local_14.x) / (_local_15.x - _local_14.x)); + _local_16 = new Vertex(); + _local_16.x = (_local_14.x + ((_local_15.x - _local_14.x) * _local_13)); + _local_16.y = (_local_14.y + ((_local_15.y - _local_14.y) * _local_13)); + _local_16.z = (_local_14.z + ((_local_15.z - _local_14.z) * _local_13)); + _local_16.normalX = (_local_14.normalX + ((_local_15.normalX - _local_14.normalX) * _local_13)); + _local_16.normalY = (_local_14.normalY + ((_local_15.normalY - _local_14.normalY) * _local_13)); + _local_16.normalZ = (_local_14.normalZ + ((_local_15.normalZ - _local_14.normalZ) * _local_13)); + if (_local_19 != null) + { + _local_19.next = _local_16; + } else + { + _local_18 = _local_16; + }; + _local_19 = _local_16; + }; + if (_local_15.x < _arg_1.boundMaxX) + { + if (_local_19 != null) + { + _local_19.next = _local_15; + } else + { + _local_18 = _local_15; + }; + _local_19 = _local_15; + }; + _local_14 = _local_15; + _local_15 = _local_17; + }; + if (_local_18 != null) + { + _local_14 = _local_19; + _local_15 = _local_18; + _local_18 = null; + _local_19 = null; + while (_local_15 != null) + { + _local_17 = _local_15.next; + _local_15.next = null; + if ((((_local_15.y > _arg_1.boundMinY) && (_local_14.y <= _arg_1.boundMinY)) || ((_local_15.y <= _arg_1.boundMinY) && (_local_14.y > _arg_1.boundMinY)))) + { + _local_13 = ((_arg_1.boundMinY - _local_14.y) / (_local_15.y - _local_14.y)); + _local_16 = new Vertex(); + _local_16.x = (_local_14.x + ((_local_15.x - _local_14.x) * _local_13)); + _local_16.y = (_local_14.y + ((_local_15.y - _local_14.y) * _local_13)); + _local_16.z = (_local_14.z + ((_local_15.z - _local_14.z) * _local_13)); + _local_16.normalX = (_local_14.normalX + ((_local_15.normalX - _local_14.normalX) * _local_13)); + _local_16.normalY = (_local_14.normalY + ((_local_15.normalY - _local_14.normalY) * _local_13)); + _local_16.normalZ = (_local_14.normalZ + ((_local_15.normalZ - _local_14.normalZ) * _local_13)); + if (_local_19 != null) + { + _local_19.next = _local_16; + } else + { + _local_18 = _local_16; + }; + _local_19 = _local_16; + }; + if (_local_15.y > _arg_1.boundMinY) + { + if (_local_19 != null) + { + _local_19.next = _local_15; + } else + { + _local_18 = _local_15; + }; + _local_19 = _local_15; + }; + _local_14 = _local_15; + _local_15 = _local_17; + }; + if (_local_18 != null) + { + _local_14 = _local_19; + _local_15 = _local_18; + _local_18 = null; + _local_19 = null; + while (_local_15 != null) + { + _local_17 = _local_15.next; + _local_15.next = null; + if ((((_local_15.y < _arg_1.boundMaxY) && (_local_14.y >= _arg_1.boundMaxY)) || ((_local_15.y >= _arg_1.boundMaxY) && (_local_14.y < _arg_1.boundMaxY)))) + { + _local_13 = ((_arg_1.boundMaxY - _local_14.y) / (_local_15.y - _local_14.y)); + _local_16 = new Vertex(); + _local_16.x = (_local_14.x + ((_local_15.x - _local_14.x) * _local_13)); + _local_16.y = (_local_14.y + ((_local_15.y - _local_14.y) * _local_13)); + _local_16.z = (_local_14.z + ((_local_15.z - _local_14.z) * _local_13)); + _local_16.normalX = (_local_14.normalX + ((_local_15.normalX - _local_14.normalX) * _local_13)); + _local_16.normalY = (_local_14.normalY + ((_local_15.normalY - _local_14.normalY) * _local_13)); + _local_16.normalZ = (_local_14.normalZ + ((_local_15.normalZ - _local_14.normalZ) * _local_13)); + if (_local_19 != null) + { + _local_19.next = _local_16; + } else + { + _local_18 = _local_16; + }; + _local_19 = _local_16; + }; + if (_local_15.y < _arg_1.boundMaxY) + { + if (_local_19 != null) + { + _local_19.next = _local_15; + } else + { + _local_18 = _local_15; + }; + _local_19 = _local_15; + }; + _local_14 = _local_15; + _local_15 = _local_17; + }; + if (_local_18 != null) + { + _local_5 = new Face(); + _local_20 = null; + _local_6 = _local_18; + while (_local_6 != null) + { + _local_17 = _local_6.next; + _local_6.next = _arg_1.vertexList; + _arg_1.vertexList = _local_6; + _local_6.u = ((_local_6.x - _arg_1.boundMinX) / (_arg_1.boundMaxX - _arg_1.boundMinX)); + _local_6.v = ((_local_6.y - _arg_1.boundMinY) / (_arg_1.boundMaxY - _arg_1.boundMinY)); + if (_local_20 != null) + { + _local_20.next = new Wrapper(); + _local_20 = _local_20.next; + } else + { + _local_5.wrapper = new Wrapper(); + _local_20 = _local_5.wrapper; + }; + _local_20.vertex = _local_6; + _local_6 = _local_17; + }; + _local_5.calculateBestSequenceAndNormal(); + _local_5.next = _arg_1.faceList; + _arg_1.faceList = _local_5; + }; + }; + }; + }; + }; + }; + }; + }; + }; + }; + }; + }; + }; + }; + _local_11++; + }; + } + + +} + +class Receiver +{ + + public var next:Receiver; + public var transparent:Boolean = false; + public var buffer:int = -1; + public var firstIndex:int = -1; + public var numTriangles:int = 0; + + +} diff --git a/src/alternativa/engine3d/containers/LODContainer.as b/src/alternativa/engine3d/containers/LODContainer.as new file mode 100644 index 0000000..3ddbfc2 --- /dev/null +++ b/src/alternativa/engine3d/containers/LODContainer.as @@ -0,0 +1,262 @@ +package alternativa.engine3d.containers +{ + import alternativa.engine3d.core.Object3DContainer; + import alternativa.engine3d.core.Object3D; + import flash.geom.Vector3D; + import flash.utils.Dictionary; + import alternativa.engine3d.core.Camera3D; + import alternativa.engine3d.core.RayIntersectionData; + import __AS3__.vec.Vector; + import alternativa.engine3d.core.Face; + import alternativa.engine3d.core.Debug; + import alternativa.engine3d.core.VG; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class LODContainer extends Object3DContainer + { + + + public function getChildDistance(_arg_1:Object3D):Number + { + if (_arg_1 == null) + { + throw (new TypeError("Parameter child must be non-null.")); + }; + if (_arg_1._parent != this) + { + throw (new ArgumentError("The supplied Object3D must be a child of the caller.")); + }; + return (_arg_1.distance); + } + + public function setChildDistance(_arg_1:Object3D, _arg_2:Number):void + { + if (_arg_1 == null) + { + throw (new TypeError("Parameter child must be non-null.")); + }; + if (_arg_1._parent != this) + { + throw (new ArgumentError("The supplied Object3D must be a child of the caller.")); + }; + _arg_1.distance = _arg_2; + } + + public function addLOD(_arg_1:Object3D, _arg_2:Number):Object3D + { + this.addChild(_arg_1); + _arg_1.distance = _arg_2; + return (_arg_1); + } + + override public function addChild(_arg_1:Object3D):Object3D + { + if (_arg_1 == null) + { + throw (new TypeError("Parameter child must be non-null.")); + }; + if (_arg_1 == this) + { + throw (new ArgumentError("An object cannot be added as a child of itself.")); + }; + var _local_2:Object3DContainer = _parent; + while (_local_2 != null) + { + if (_local_2 == _arg_1) + { + throw (new ArgumentError("An object cannot be added as a child to one of it's children (or children's children, etc.).")); + }; + _local_2 = _local_2._parent; + }; + if (_arg_1._parent != this) + { + _arg_1.distance = 0; + }; + if (_arg_1._parent != null) + { + _arg_1._parent.removeChild(_arg_1); + }; + addToList(_arg_1); + return (_arg_1); + } + + override public function addChildAt(_arg_1:Object3D, _arg_2:int):Object3D + { + if (_arg_1 == null) + { + throw (new TypeError("Parameter child must be non-null.")); + }; + if (_arg_1 == this) + { + throw (new ArgumentError("An object cannot be added as a child of itself.")); + }; + if (_arg_2 < 0) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + var _local_3:Object3DContainer = _parent; + while (_local_3 != null) + { + if (_local_3 == _arg_1) + { + throw (new ArgumentError("An object cannot be added as a child to one of it's children (or children's children, etc.).")); + }; + _local_3 = _local_3._parent; + }; + var _local_4:Object3D = childrenList; + var _local_5:int; + while (_local_5 < _arg_2) + { + if (_local_4 == null) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + _local_4 = _local_4.next; + _local_5++; + }; + if (_arg_1._parent != this) + { + _arg_1.distance = 0; + }; + if (_arg_1._parent != null) + { + _arg_1._parent.removeChild(_arg_1); + }; + addToList(_arg_1, _local_4); + return (_arg_1); + } + + override public function intersectRay(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Dictionary=null, _arg_4:Camera3D=null):RayIntersectionData + { + if (((!(_arg_3 == null)) && (_arg_3[this]))) + { + return (null); + }; + if ((!(boundIntersectRay(_arg_1, _arg_2, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ)))) + { + return (null); + }; + var _local_5:Object3D = childrenList; + _local_5.composeMatrix(); + _local_5.invertMatrix(); + var _local_6:Vector3D = new Vector3D(); + var _local_7:Vector3D = new Vector3D(); + _local_6.x = ((((_local_5.ma * _arg_1.x) + (_local_5.mb * _arg_1.y)) + (_local_5.mc * _arg_1.z)) + _local_5.md); + _local_6.y = ((((_local_5.me * _arg_1.x) + (_local_5.mf * _arg_1.y)) + (_local_5.mg * _arg_1.z)) + _local_5.mh); + _local_6.z = ((((_local_5.mi * _arg_1.x) + (_local_5.mj * _arg_1.y)) + (_local_5.mk * _arg_1.z)) + _local_5.ml); + _local_7.x = (((_local_5.ma * _arg_2.x) + (_local_5.mb * _arg_2.y)) + (_local_5.mc * _arg_2.z)); + _local_7.y = (((_local_5.me * _arg_2.x) + (_local_5.mf * _arg_2.y)) + (_local_5.mg * _arg_2.z)); + _local_7.z = (((_local_5.mi * _arg_2.x) + (_local_5.mj * _arg_2.y)) + (_local_5.mk * _arg_2.z)); + return (_local_5.intersectRay(_local_6, _local_7, _arg_3, _arg_4)); + } + + override alternativa3d function checkIntersection(_arg_1:Number, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Dictionary):Boolean + { + var _local_10:Number; + var _local_11:Number; + var _local_12:Number; + var _local_13:Number; + var _local_14:Number; + var _local_15:Number; + var _local_9:Object3D = childrenList; + if (((!(_arg_8 == null)) && (!(_arg_8[_local_9])))) + { + _local_9.composeMatrix(); + _local_9.invertMatrix(); + _local_10 = ((((_local_9.ma * _arg_1) + (_local_9.mb * _arg_2)) + (_local_9.mc * _arg_3)) + _local_9.md); + _local_11 = ((((_local_9.me * _arg_1) + (_local_9.mf * _arg_2)) + (_local_9.mg * _arg_3)) + _local_9.mh); + _local_12 = ((((_local_9.mi * _arg_1) + (_local_9.mj * _arg_2)) + (_local_9.mk * _arg_3)) + _local_9.ml); + _local_13 = (((_local_9.ma * _arg_4) + (_local_9.mb * _arg_5)) + (_local_9.mc * _arg_6)); + _local_14 = (((_local_9.me * _arg_4) + (_local_9.mf * _arg_5)) + (_local_9.mg * _arg_6)); + _local_15 = (((_local_9.mi * _arg_4) + (_local_9.mj * _arg_5)) + (_local_9.mk * _arg_6)); + return ((boundCheckIntersection(_local_10, _local_11, _local_12, _local_13, _local_14, _local_15, _arg_7, _local_9.boundMinX, _local_9.boundMinY, _local_9.boundMinZ, _local_9.boundMaxX, _local_9.boundMaxY, _local_9.boundMaxZ)) && (_local_9.checkIntersection(_local_10, _local_11, _local_12, _local_13, _local_14, _local_15, _arg_7, _arg_8))); + }; + return (false); + } + + override alternativa3d function collectPlanes(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Vector3D, _arg_4:Vector3D, _arg_5:Vector3D, _arg_6:Vector., _arg_7:Dictionary=null):void + { + if (((!(_arg_7 == null)) && (_arg_7[this]))) + { + return; + }; + var _local_8:Vector3D = calculateSphere(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5); + if ((!(boundIntersectSphere(_local_8, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ)))) + { + return; + }; + var _local_9:Object3D = childrenList; + _local_9.composeAndAppend(this); + _local_9.collectPlanes(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7); + } + + override public function clone():Object3D + { + var _local_1:LODContainer = new LODContainer(); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + override alternativa3d function draw(_arg_1:Camera3D):void + { + var _local_3:int; + var _local_2:Object3D = this.getLODObject(_arg_1); + if (((!(_local_2 == null)) && (_local_2.visible))) + { + _local_2.composeAndAppend(this); + if (_local_2.cullingInCamera(_arg_1, culling) >= 0) + { + if (((_arg_1.debug) && ((_local_3 = _arg_1.checkInDebug(this)) > 0))) + { + if ((_local_3 & Debug.BOUNDS)) + { + Debug.drawBounds(_arg_1, this, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ); + }; + }; + _local_2.draw(_arg_1); + }; + }; + } + + override alternativa3d function getVG(_arg_1:Camera3D):VG + { + var _local_2:Object3D = this.getLODObject(_arg_1); + if (((!(_local_2 == null)) && (_local_2.visible))) + { + _local_2.composeAndAppend(this); + if (_local_2.cullingInCamera(_arg_1, culling) >= 0) + { + _local_2.concat(this); + return (_local_2.getVG(_arg_1)); + }; + }; + return (null); + } + + private function getLODObject(_arg_1:Camera3D):Object3D + { + var _local_6:Object3D; + var _local_8:Number; + var _local_2:Number = ((md * _arg_1.viewSizeX) / _arg_1.focalLength); + var _local_3:Number = ((mh * _arg_1.viewSizeY) / _arg_1.focalLength); + var _local_4:Number = Math.sqrt((((_local_2 * _local_2) + (_local_3 * _local_3)) + (ml * ml))); + var _local_5:Number = 1E22; + var _local_7:Object3D = childrenList; + while (_local_7 != null) + { + _local_8 = (_local_7.distance - _local_4); + if (((_local_8 > 0) && (_local_8 < _local_5))) + { + _local_5 = _local_8; + _local_6 = _local_7; + }; + _local_7 = _local_7.next; + }; + return (_local_6); + } + + + } +}//package alternativa.engine3d.containers \ No newline at end of file diff --git a/src/alternativa/engine3d/controllers/SimpleObjectController.as b/src/alternativa/engine3d/controllers/SimpleObjectController.as new file mode 100644 index 0000000..2ac85a3 --- /dev/null +++ b/src/alternativa/engine3d/controllers/SimpleObjectController.as @@ -0,0 +1,358 @@ +package alternativa.engine3d.controllers +{ + import flash.display.InteractiveObject; + import alternativa.engine3d.core.Object3D; + import flash.geom.Vector3D; + import flash.geom.Point; + import __AS3__.vec.Vector; + import flash.events.KeyboardEvent; + import flash.events.MouseEvent; + import flash.geom.Matrix3D; + import flash.utils.getTimer; + import alternativa.engine3d.core.Camera3D; + import flash.ui.Keyboard; + import __AS3__.vec.*; + + public class SimpleObjectController + { + + public static const ACTION_FORWARD:String = "ACTION_FORWARD"; + public static const ACTION_BACK:String = "ACTION_BACK"; + public static const ACTION_LEFT:String = "ACTION_LEFT"; + public static const ACTION_RIGHT:String = "ACTION_RIGHT"; + public static const ACTION_UP:String = "ACTION_UP"; + public static const ACTION_DOWN:String = "ACTION_DOWN"; + public static const ACTION_PITCH_UP:String = "ACTION_PITCH_UP"; + public static const ACTION_PITCH_DOWN:String = "ACTION_PITCH_DOWN"; + public static const ACTION_YAW_LEFT:String = "ACTION_YAW_LEFT"; + public static const ACTION_YAW_RIGHT:String = "ACTION_YAW_RIGHT"; + public static const ACTION_ACCELERATE:String = "ACTION_ACCELERATE"; + public static const ACTION_MOUSE_LOOK:String = "ACTION_MOUSE_LOOK"; + + public var speed:Number; + public var speedMultiplier:Number; + public var mouseSensitivity:Number; + public var maxPitch:Number = 1E22; + public var minPitch:Number = -1E22; + private var eventSource:InteractiveObject; + private var _object:Object3D; + private var _up:Boolean; + private var _down:Boolean; + private var _forward:Boolean; + private var _back:Boolean; + private var _left:Boolean; + private var _right:Boolean; + private var _accelerate:Boolean; + private var displacement:Vector3D = new Vector3D(); + private var mousePoint:Point = new Point(); + private var mouseLook:Boolean; + private var objectTransform:Vector.; + private var time:int; + private var actionBindings:Object = {}; + protected var keyBindings:Object = {}; + private var _vin:Vector. = new Vector.(3); + private var _vout:Vector. = new Vector.(3); + + public function SimpleObjectController(_arg_1:InteractiveObject, _arg_2:Object3D, _arg_3:Number, _arg_4:Number=3, _arg_5:Number=1) + { + this.eventSource = _arg_1; + this.object = _arg_2; + this.speed = _arg_3; + this.speedMultiplier = _arg_4; + this.mouseSensitivity = _arg_5; + this.actionBindings[ACTION_FORWARD] = this.moveForward; + this.actionBindings[ACTION_BACK] = this.moveBack; + this.actionBindings[ACTION_LEFT] = this.moveLeft; + this.actionBindings[ACTION_RIGHT] = this.moveRight; + this.actionBindings[ACTION_UP] = this.moveUp; + this.actionBindings[ACTION_DOWN] = this.moveDown; + this.actionBindings[ACTION_ACCELERATE] = this.accelerate; + this.setDefaultBindings(); + this.enable(); + } + + public function enable():void + { + this.eventSource.addEventListener(KeyboardEvent.KEY_DOWN, this.onKey); + this.eventSource.addEventListener(KeyboardEvent.KEY_UP, this.onKey); + this.eventSource.addEventListener(MouseEvent.MOUSE_DOWN, this.onMouseDown); + this.eventSource.addEventListener(MouseEvent.MOUSE_UP, this.onMouseUp); + } + + public function disable():void + { + this.eventSource.removeEventListener(KeyboardEvent.KEY_DOWN, this.onKey); + this.eventSource.removeEventListener(KeyboardEvent.KEY_UP, this.onKey); + this.eventSource.removeEventListener(MouseEvent.MOUSE_DOWN, this.onMouseDown); + this.eventSource.removeEventListener(MouseEvent.MOUSE_UP, this.onMouseUp); + this.stopMouseLook(); + } + + private function onMouseDown(_arg_1:MouseEvent):void + { + this.startMouseLook(); + } + + private function onMouseUp(_arg_1:MouseEvent):void + { + this.stopMouseLook(); + } + + public function startMouseLook():void + { + this.mousePoint.x = this.eventSource.mouseX; + this.mousePoint.y = this.eventSource.mouseY; + this.mouseLook = true; + } + + public function stopMouseLook():void + { + this.mouseLook = false; + } + + private function onKey(_arg_1:KeyboardEvent):void + { + var _local_2:Function = this.keyBindings[_arg_1.keyCode]; + if (_local_2 != null) + { + _local_2.call(this, (_arg_1.type == KeyboardEvent.KEY_DOWN)); + }; + } + + public function get object():Object3D + { + return (this._object); + } + + public function set object(_arg_1:Object3D):void + { + this._object = _arg_1; + this.updateObjectTransform(); + } + + public function updateObjectTransform():void + { + if (this._object != null) + { + this.objectTransform = this._object.matrix.decompose(); + }; + } + + public function update():void + { + var _local_3:Number; + var _local_4:Number; + var _local_5:Vector3D; + var _local_6:Number; + var _local_7:Matrix3D; + if (this._object == null) + { + return; + }; + var _local_1:Number = this.time; + this.time = getTimer(); + _local_1 = (0.001 * (this.time - _local_1)); + if (_local_1 > 0.1) + { + _local_1 = 0.1; + }; + var _local_2:Boolean; + if (this.mouseLook) + { + _local_3 = (this.eventSource.mouseX - this.mousePoint.x); + _local_4 = (this.eventSource.mouseY - this.mousePoint.y); + this.mousePoint.x = this.eventSource.mouseX; + this.mousePoint.y = this.eventSource.mouseY; + _local_5 = this.objectTransform[1]; + _local_5.x = (_local_5.x - (((_local_4 * Math.PI) / 180) * this.mouseSensitivity)); + if (_local_5.x > this.maxPitch) + { + _local_5.x = this.maxPitch; + }; + if (_local_5.x < this.minPitch) + { + _local_5.x = this.minPitch; + }; + _local_5.z = (_local_5.z - (((_local_3 * Math.PI) / 180) * this.mouseSensitivity)); + _local_2 = true; + }; + this.displacement.x = ((this._right) ? 1 : ((this._left) ? -1 : 0)); + this.displacement.y = ((this._forward) ? 1 : ((this._back) ? -1 : 0)); + this.displacement.z = ((this._up) ? 1 : ((this._down) ? -1 : 0)); + if (this.displacement.lengthSquared > 0) + { + if ((this._object is Camera3D)) + { + _local_6 = this.displacement.z; + this.displacement.z = this.displacement.y; + this.displacement.y = -(_local_6); + }; + this.deltaTransformVector(this.displacement); + if (this._accelerate) + { + this.displacement.scaleBy((((this.speedMultiplier * this.speed) * _local_1) / this.displacement.length)); + } else + { + this.displacement.scaleBy(((this.speed * _local_1) / this.displacement.length)); + }; + (this.objectTransform[0] as Vector3D).incrementBy(this.displacement); + _local_2 = true; + }; + if (_local_2) + { + _local_7 = new Matrix3D(); + _local_7.recompose(this.objectTransform); + this._object.matrix = _local_7; + }; + } + + public function setObjectPos(_arg_1:Vector3D):void + { + var _local_2:Vector3D; + if (this._object != null) + { + _local_2 = this.objectTransform[0]; + _local_2.x = _arg_1.x; + _local_2.y = _arg_1.y; + _local_2.z = _arg_1.z; + }; + } + + public function setObjectPosXYZ(_arg_1:Number, _arg_2:Number, _arg_3:Number):void + { + var _local_4:Vector3D; + if (this._object != null) + { + _local_4 = this.objectTransform[0]; + _local_4.x = _arg_1; + _local_4.y = _arg_2; + _local_4.z = _arg_3; + }; + } + + public function lookAt(_arg_1:Vector3D):void + { + this.lookAtXYZ(_arg_1.x, _arg_1.y, _arg_1.z); + } + + public function lookAtXYZ(_arg_1:Number, _arg_2:Number, _arg_3:Number):void + { + if (this._object == null) + { + return; + }; + var _local_4:Vector3D = this.objectTransform[0]; + var _local_5:Number = (_arg_1 - _local_4.x); + var _local_6:Number = (_arg_2 - _local_4.y); + var _local_7:Number = (_arg_3 - _local_4.z); + _local_4 = this.objectTransform[1]; + _local_4.x = Math.atan2(_local_7, Math.sqrt(((_local_5 * _local_5) + (_local_6 * _local_6)))); + if ((this._object is Camera3D)) + { + _local_4.x = (_local_4.x - (0.5 * Math.PI)); + }; + _local_4.y = 0; + _local_4.z = -(Math.atan2(_local_5, _local_6)); + var _local_8:Matrix3D = this._object.matrix; + _local_8.recompose(this.objectTransform); + this._object.matrix = _local_8; + } + + private function deltaTransformVector(_arg_1:Vector3D):void + { + this._vin[0] = _arg_1.x; + this._vin[1] = _arg_1.y; + this._vin[2] = _arg_1.z; + this._object.matrix.transformVectors(this._vin, this._vout); + var _local_2:Vector3D = this.objectTransform[0]; + _arg_1.x = (this._vout[0] - _local_2.x); + _arg_1.y = (this._vout[1] - _local_2.y); + _arg_1.z = (this._vout[2] - _local_2.z); + } + + public function moveForward(_arg_1:Boolean):void + { + this._forward = _arg_1; + } + + public function moveBack(_arg_1:Boolean):void + { + this._back = _arg_1; + } + + public function moveLeft(_arg_1:Boolean):void + { + this._left = _arg_1; + } + + public function moveRight(_arg_1:Boolean):void + { + this._right = _arg_1; + } + + public function moveUp(_arg_1:Boolean):void + { + this._up = _arg_1; + } + + public function moveDown(_arg_1:Boolean):void + { + this._down = _arg_1; + } + + public function accelerate(_arg_1:Boolean):void + { + this._accelerate = _arg_1; + } + + public function bindKey(_arg_1:uint, _arg_2:String):void + { + var _local_3:Function = this.actionBindings[_arg_2]; + if (_local_3 != null) + { + this.keyBindings[_arg_1] = _local_3; + }; + } + + public function bindKeys(_arg_1:Array):void + { + var _local_2:int; + while (_local_2 < _arg_1.length) + { + this.bindKey(_arg_1[_local_2], _arg_1[(_local_2 + 1)]); + _local_2 = (_local_2 + 2); + }; + } + + public function unbindKey(_arg_1:uint):void + { + delete this.keyBindings[_arg_1]; + } + + public function unbindAll():void + { + var _local_1:String; + for (_local_1 in this.keyBindings) + { + delete this.keyBindings[_local_1]; + }; + } + + public function setDefaultBindings():void + { + this.bindKey(87, ACTION_FORWARD); + this.bindKey(83, ACTION_BACK); + this.bindKey(65, ACTION_LEFT); + this.bindKey(68, ACTION_RIGHT); + this.bindKey(69, ACTION_UP); + this.bindKey(67, ACTION_DOWN); + this.bindKey(Keyboard.SHIFT, ACTION_ACCELERATE); + this.bindKey(Keyboard.UP, ACTION_FORWARD); + this.bindKey(Keyboard.DOWN, ACTION_BACK); + this.bindKey(Keyboard.LEFT, ACTION_LEFT); + this.bindKey(Keyboard.RIGHT, ACTION_RIGHT); + } + + + } +}//package alternativa.engine3d.controllers \ No newline at end of file diff --git a/src/alternativa/engine3d/core/BoundBox.as b/src/alternativa/engine3d/core/BoundBox.as new file mode 100644 index 0000000..92efe06 --- /dev/null +++ b/src/alternativa/engine3d/core/BoundBox.as @@ -0,0 +1,103 @@ +package alternativa.engine3d.core +{ + public class BoundBox + { + + + public var minX:Number = 1.7976931348623157E308; + + public var minY:Number = 1.7976931348623157E308; + + public var minZ:Number = 1.7976931348623157E308; + + public var maxX:Number; + + public var maxY:Number; + + public var maxZ:Number; + + public function BoundBox() + { + this.maxX = -Number.MAX_VALUE; + this.maxY = -Number.MAX_VALUE; + this.maxZ = -Number.MAX_VALUE; + super(); + } + + public function setSize(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number) : void + { + this.minX = param1; + this.minY = param2; + this.minZ = param3; + this.maxX = param4; + this.maxY = param5; + this.maxZ = param6; + } + + public function clone() : BoundBox + { + var _loc1_:BoundBox = new BoundBox(); + _loc1_.copyFrom(this); + return _loc1_; + } + + public function infinity() : void + { + this.minX = this.minY = this.minZ = Number.MAX_VALUE; + this.maxX = this.maxY = this.maxZ = -Number.MAX_VALUE; + } + + public function toString() : String + { + return "BoundBox [" + this.minX.toFixed(2) + ", " + this.minY.toFixed(2) + ", " + this.minZ.toFixed(2) + " - " + this.maxX.toFixed(2) + ", " + this.maxY.toFixed(2) + ", " + this.maxZ.toFixed(2) + "]"; + } + + public function addBoundBox(param1:BoundBox) : void + { + this.minX = param1.minX < this.minX ? Number(param1.minX) : Number(this.minX); + this.minY = param1.minY < this.minY ? Number(param1.minY) : Number(this.minY); + this.minZ = param1.minZ < this.minZ ? Number(param1.minZ) : Number(this.minZ); + this.maxX = param1.maxX > this.maxX ? Number(param1.maxX) : Number(this.maxX); + this.maxY = param1.maxY > this.maxY ? Number(param1.maxY) : Number(this.maxY); + this.maxZ = param1.maxZ > this.maxZ ? Number(param1.maxZ) : Number(this.maxZ); + } + + public function addPoint(param1:Number, param2:Number, param3:Number) : void + { + if(param1 < this.minX) + { + this.minX = param1; + } + if(param1 > this.maxX) + { + this.maxX = param1; + } + if(param2 < this.minY) + { + this.minY = param2; + } + if(param2 > this.maxY) + { + this.maxY = param2; + } + if(param3 < this.minZ) + { + this.minZ = param3; + } + if(param3 > this.maxZ) + { + this.maxZ = param3; + } + } + + public function copyFrom(param1:BoundBox) : void + { + this.minX = param1.minX; + this.minY = param1.minY; + this.minZ = param1.minZ; + this.maxX = param1.maxX; + this.maxY = param1.maxY; + this.maxZ = param1.maxZ; + } + } +} diff --git a/src/alternativa/engine3d/core/Camera3D.as b/src/alternativa/engine3d/core/Camera3D.as new file mode 100644 index 0000000..b673264 --- /dev/null +++ b/src/alternativa/engine3d/core/Camera3D.as @@ -0,0 +1,2975 @@ +package alternativa.engine3d.core +{ + import __AS3__.vec.Vector; + import alternativa.gfx.core.VertexBufferResource; + import alternativa.gfx.core.IndexBufferResource; + import alternativa.gfx.core.Device; + import alternativa.engine3d.materials.Material; + import alternativa.engine3d.objects.Decal; + import flash.utils.Dictionary; + import alternativa.gfx.core.TextureResource; + import alternativa.engine3d.lights.OmniLight; + import alternativa.engine3d.lights.SpotLight; + import alternativa.engine3d.lights.TubeLight; + import alternativa.engine3d.lights.DirectionalLight; + import flash.display.Sprite; + import flash.text.TextField; + import flash.display.Bitmap; + import flash.geom.Rectangle; + import alternativa.engine3d.objects.Sprite3D; + import flash.display3D.Context3DTriangleFace; + import flash.display3D.Context3DBlendFactor; + import flash.display3D.Context3DCompareMode; + import flash.display3D.Context3DProgramType; + import flash.display3D.Context3DClearMask; + import flash.display3D.Context3DStencilAction; + import flash.geom.Vector3D; + import flash.utils.getDefinitionByName; + import flash.utils.getQualifiedClassName; + import flash.utils.getQualifiedSuperclassName; + import flash.utils.getTimer; + import flash.display.DisplayObject; + import flash.events.Event; + import flash.text.TextFormat; + import flash.text.TextFieldAutoSize; + import flash.system.System; + import flash.display.BitmapData; + import flash.geom.Point; + import flash.display.StageAlign; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class Camera3D extends Object3D + { + + alternativa3d static var renderId:int = 0; + private static const constantsAttributesCount:int = 8; + private static const constantsOffset:int = 16; + private static const constantsMaxTriangles:int = 18; + private static const constants:Vector. = new Vector.(((constantsMaxTriangles * 3) * constantsAttributesCount)); + private static const constantsVertexBuffer:VertexBufferResource = createConstantsVertexBuffer((constantsMaxTriangles * 3)); + private static const constantsIndexBuffer:IndexBufferResource = createConstantsIndexBuffer((constantsMaxTriangles * 3)); + + public var view:View; + public var fov:Number = 1.5707963267949; + public var nearClipping:Number = 1; + public var farClipping:Number = 1000000; + public var onRender:Function; + alternativa3d var viewSizeX:Number; + alternativa3d var viewSizeY:Number; + alternativa3d var focalLength:Number; + alternativa3d var correctionX:Number; + alternativa3d var correctionY:Number; + alternativa3d var lights:Vector. = new Vector.(); + alternativa3d var lightsLength:int = 0; + alternativa3d var occluders:Vector. = new Vector.(); + alternativa3d var numOccluders:int; + alternativa3d var occludedAll:Boolean; + alternativa3d var numDraws:int; + alternativa3d var numShadows:int; + alternativa3d var numTriangles:int; + alternativa3d var device:Device; + alternativa3d var projection:Vector. = new Vector.(4); + alternativa3d var correction:Vector. = new Vector.(4); + alternativa3d var transform:Vector. = new Vector.(12); + private var opaqueMaterials:Vector. = new Vector.(); + private var opaqueVertexBuffers:Vector. = new Vector.(); + private var opaqueIndexBuffers:Vector. = new Vector.(); + private var opaqueFirstIndexes:Vector. = new Vector.(); + private var opaqueNumsTriangles:Vector. = new Vector.(); + private var opaqueObjects:Vector. = new Vector.(); + private var opaqueCount:int = 0; + private var skyMaterials:Vector. = new Vector.(); + private var skyVertexBuffers:Vector. = new Vector.(); + private var skyIndexBuffers:Vector. = new Vector.(); + private var skyFirstIndexes:Vector. = new Vector.(); + private var skyNumsTriangles:Vector. = new Vector.(); + private var skyObjects:Vector. = new Vector.(); + private var skyCount:int = 0; + private var transparentFaceLists:Vector. = new Vector.(); + private var transparentObjects:Vector. = new Vector.(); + private var transparentCount:int = 0; + private var transparentOpaqueFaceLists:Vector. = new Vector.(); + private var transparentOpaqueObjects:Vector. = new Vector.(); + private var transparentOpaqueCount:int = 0; + private var transparentBatchObjects:Vector. = new Vector.(); + private var decals:Vector. = new Vector.(); + private var decalsCount:int = 0; + alternativa3d var depthObjects:Vector. = new Vector.(); + alternativa3d var depthCount:int = 0; + alternativa3d var casterObjects:Vector. = new Vector.(); + alternativa3d var casterCount:int = 0; + alternativa3d var shadowAtlases:Array = new Array(); + alternativa3d var receiversVertexBuffers:Vector.; + alternativa3d var receiversIndexBuffers:Vector.; + alternativa3d var gma:Number; + alternativa3d var gmb:Number; + alternativa3d var gmc:Number; + alternativa3d var gmd:Number; + alternativa3d var gme:Number; + alternativa3d var gmf:Number; + alternativa3d var gmg:Number; + alternativa3d var gmh:Number; + alternativa3d var gmi:Number; + alternativa3d var gmj:Number; + alternativa3d var gmk:Number; + alternativa3d var gml:Number; + alternativa3d var fogParams:Vector. = Vector.([1, 1, 0, 1]); + alternativa3d var fogFragment:Vector. = Vector.([0, 0, 0, 1]); + private var fragmentConst:Vector. = Vector.([0, 0, 0, 1, 0.5, 0.5, 0, (1 / 0x1000)]); + private var shadows:Dictionary = new Dictionary(); + private var shadowList:Vector. = new Vector.(); + private var depthRenderer:DepthRenderer = new DepthRenderer(); + alternativa3d var depthMap:TextureResource; + alternativa3d var lightMap:TextureResource; + private var depthParams:Vector. = Vector.([0, 0, 0, 1]); + private var ssaoParams:Vector. = Vector.([0, 0, 0, 1]); + private var lightTransform:Vector. = Vector.([0, 0, 0, 1]); + private var lightParams:Vector. = Vector.([0, 0, 0, 1, 0, 0, 0, 1]); + alternativa3d var omnies:Vector. = new Vector.(); + alternativa3d var omniesCount:int = 0; + alternativa3d var spots:Vector. = new Vector.(); + alternativa3d var spotsCount:int = 0; + alternativa3d var tubes:Vector. = new Vector.(); + alternativa3d var tubesCount:int = 0; + public var fogNear:Number = 0; + public var fogFar:Number = 1000000; + public var fogAlpha:Number = 0; + public var fogColor:int = 0x7F7F7F; + public var softTransparency:Boolean = false; + public var depthBufferScale:Number = 1; + public var ssao:Boolean = false; + public var ssaoRadius:Number = 100; + public var ssaoRange:Number = 1000; + public var ssaoColor:int = 0; + public var ssaoAlpha:Number = 1; + public var directionalLight:DirectionalLight; + public var shadowMap:ShadowMap; + public var ambientColor:int = 0; + public var deferredLighting:Boolean = false; + public var fogStrength:Number = 1; + public var softTransparencyStrength:Number = 1; + public var ssaoStrength:Number = 1; + public var directionalLightStrength:Number = 1; + public var shadowMapStrength:Number = 1; + public var shadowsStrength:Number = 1; + public var shadowsDistanceMultiplier:Number = 1; + public var deferredLightingStrength:Number = 1; + public var debug:Boolean = false; + private var debugSet:Object = new Object(); + private var _diagram:Sprite; + public var fpsUpdatePeriod:int = 10; + public var timerUpdatePeriod:int = 10; + private var fpsTextField:TextField; + private var memoryTextField:TextField; + private var drawsTextField:TextField; + private var shadowsTextField:TextField; + private var trianglesTextField:TextField; + private var timerTextField:TextField; + private var graph:Bitmap; + private var rect:Rectangle; + private var _diagramAlign:String = "TR"; + private var _diagramHorizontalMargin:Number = 2; + private var _diagramVerticalMargin:Number = 2; + private var fpsUpdateCounter:int; + private var previousFrameTime:int; + private var previousPeriodTime:int; + private var maxMemory:int; + private var timerUpdateCounter:int; + private var timeSum:int; + private var timeCount:int; + private var timer:int; + private var firstVertex:Vertex; + private var firstFace:Face; + private var firstWrapper:Wrapper; + alternativa3d var lastWrapper:Wrapper; + alternativa3d var lastVertex:Vertex; + alternativa3d var lastFace:Face; + + public function Camera3D() + { + this._diagram = this.createDiagram(); + this.firstVertex = new Vertex(); + this.firstFace = new Face(); + this.firstWrapper = new Wrapper(); + this.lastWrapper = this.firstWrapper; + this.lastVertex = this.firstVertex; + this.lastFace = this.firstFace; + super(); + } + + private static function createConstantsVertexBuffer(_arg_1:int):VertexBufferResource + { + var _local_5:int; + var _local_2:Vector. = new Vector.(); + var _local_3:int; + while (_local_3 < _arg_1) + { + _local_2.push(((_local_3 << 1) + constantsOffset)); + _local_3++; + }; + var _local_4:int; + while (_local_4 < (_arg_1 << 1)) + { + _local_5 = ((_local_4 * 4) + 3); + constants[_local_5] = 1; + _local_4++; + }; + return (new VertexBufferResource(_local_2, 1)); + } + + private static function createConstantsIndexBuffer(_arg_1:int):IndexBufferResource + { + var _local_2:Vector. = new Vector.(); + var _local_3:int; + while (_local_3 < _arg_1) + { + _local_2.push(_local_3); + _local_3++; + }; + return (new IndexBufferResource(_local_2)); + } + + + public function addShadow(_arg_1:Shadow):void + { + this.shadows[_arg_1] = true; + } + + public function removeShadow(_arg_1:Shadow):void + { + delete this.shadows[_arg_1]; + } + + public function removeAllShadows():void + { + this.shadows = new Dictionary(); + } + + public function render():void + { + var _local_1:int; + var _local_2:int; + var _local_3:int; + var _local_4:Shadow; + var _local_5:Object3D; + var _local_6:Light3D; + var _local_7:ShadowAtlas; + var _local_8:Boolean; + var _local_9:Material; + var _local_10:*; + var _local_11:Decal; + var _local_12:int; + var _local_13:int; + var _local_14:int; + var _local_15:TextureResource; + var _local_16:Face; + var _local_17:Object3D; + var _local_18:Boolean; + var _local_19:Boolean; + var _local_20:int; + var _local_21:Sprite3D; + var _local_22:Face; + var _local_23:Face; + var _local_24:Object3D; + var _local_25:Sprite3D; + this.numDraws = 0; + this.numShadows = 0; + this.numTriangles = 0; + if ((((!(this.view == null)) && (!(this.view.device == null))) && (this.view.device.ready))) + { + renderId++; + this.device = this.view.device; + this.view.configure(); + if (this.nearClipping < 1) + { + this.nearClipping = 1; + }; + if (this.farClipping > 1000000) + { + this.farClipping = 1000000; + }; + this.viewSizeX = (this.view._width * 0.5); + this.viewSizeY = (this.view._height * 0.5); + this.focalLength = (Math.sqrt(((this.viewSizeX * this.viewSizeX) + (this.viewSizeY * this.viewSizeY))) / Math.tan((this.fov * 0.5))); + this.correctionX = (this.viewSizeX / this.focalLength); + this.correctionY = (this.viewSizeY / this.focalLength); + this.projection[0] = (1 << this.view.zBufferPrecision); + this.projection[1] = 1; + this.projection[2] = (this.farClipping / (this.farClipping - this.nearClipping)); + this.projection[3] = ((this.nearClipping * this.farClipping) / (this.nearClipping - this.farClipping)); + this.composeCameraMatrix(); + _local_5 = this; + while (_local_5._parent != null) + { + _local_5 = _local_5._parent; + _local_5.composeMatrix(); + appendMatrix(_local_5); + }; + this.gma = ma; + this.gmb = mb; + this.gmc = mc; + this.gmd = md; + this.gme = me; + this.gmf = mf; + this.gmg = mg; + this.gmh = mh; + this.gmi = mi; + this.gmj = mj; + this.gmk = mk; + this.gml = ml; + invertMatrix(); + this.transform[0] = ma; + this.transform[1] = mb; + this.transform[2] = mc; + this.transform[3] = md; + this.transform[4] = me; + this.transform[5] = mf; + this.transform[6] = mg; + this.transform[7] = mh; + this.transform[8] = mi; + this.transform[9] = mj; + this.transform[10] = mk; + this.transform[11] = ml; + this.numOccluders = 0; + this.occludedAll = false; + if (((!(_local_5 == this)) && (_local_5.visible))) + { + this.lightsLength = 0; + _local_6 = (_local_5 as Object3DContainer).lightList; + while (_local_6 != null) + { + if (_local_6.visible) + { + _local_6.calculateCameraMatrix(this); + if (_local_6.checkFrustumCulling(this)) + { + this.lights[this.lightsLength] = _local_6; + this.lightsLength++; + if ((((!(this.view.constrained)) && (this.deferredLighting)) && (this.deferredLightingStrength > 0))) + { + if ((_local_6 is OmniLight)) + { + this.omnies[this.omniesCount] = (_local_6 as OmniLight); + this.omniesCount++; + } else + { + if ((_local_6 is SpotLight)) + { + this.spots[this.spotsCount] = (_local_6 as SpotLight); + this.spotsCount++; + } else + { + if ((_local_6 is TubeLight)) + { + this.tubes[this.tubesCount] = (_local_6 as TubeLight); + this.tubesCount++; + }; + }; + }; + }; + }; + }; + _local_6 = _local_6.nextLight; + }; + _local_5.appendMatrix(this); + _local_5.cullingInCamera(this, 63); + if (this.debug) + { + _local_1 = 0; + while (_local_1 < this.lightsLength) + { + (this.lights[_local_1] as Light3D).drawDebug(this); + _local_1++; + }; + }; + _local_8 = false; + if (((!(this.view.constrained)) && (this.shadowsStrength > 0))) + { + for (_local_10 in this.shadows) + { + _local_4 = _local_10; + if (_local_4.checkVisibility(this)) + { + _local_2 = (_local_4.mapSize + _local_4.blur); + _local_7 = this.shadowAtlases[_local_2]; + if (_local_7 == null) + { + _local_7 = new ShadowAtlas(_local_4.mapSize, _local_4.blur); + this.shadowAtlases[_local_2] = _local_7; + }; + _local_7.shadows[_local_7.shadowsCount] = _local_4; + _local_7.shadowsCount++; + _local_8 = true; + }; + }; + }; + this.device.setCulling(Context3DTriangleFace.FRONT); + this.device.setBlendFactors(Context3DBlendFactor.ONE, Context3DBlendFactor.ZERO); + this.device.setStencilActions(Context3DTriangleFace.NONE); + this.device.setStencilReferenceValue(0); + if (_local_8) + { + this.device.setCulling(Context3DTriangleFace.BACK); + this.device.setDepthTest(true, Context3DCompareMode.GREATER_EQUAL); + this.device.setProgram(Shadow.getCasterProgram()); + for each (_local_7 in this.shadowAtlases) + { + if (_local_7.shadowsCount > 0) + { + _local_7.renderCasters(this); + }; + }; + this.device.setCulling(Context3DTriangleFace.FRONT); + this.device.setDepthTest(false, Context3DCompareMode.ALWAYS); + for each (_local_7 in this.shadowAtlases) + { + if (_local_7.shadowsCount > 0) + { + _local_7.renderBlur(this); + }; + }; + this.device.setTextureAt(0, null); + this.device.setVertexBufferAt(1, null); + }; + if (this.directionalLight != null) + { + this.directionalLight.composeAndAppend(this); + this.directionalLight.calculateInverseMatrix(); + }; + _local_5.concatenatedAlpha = _local_5.alpha; + _local_5.concatenatedBlendMode = _local_5.blendMode; + _local_5.concatenatedColorTransform = _local_5.colorTransform; + _local_5.draw(this); + this.device.setDepthTest(true, Context3DCompareMode.LESS); + if ((((!(this.view.constrained)) && (!(this.shadowMap == null))) && (this.shadowMapStrength > 0))) + { + this.shadowMap.calculateBounds(this); + this.shadowMap.render(this, this.casterObjects, this.casterCount); + }; + this.depthMap = null; + this.lightMap = null; + if (((!(this.view.constrained)) && ((((this.softTransparency) && (this.softTransparencyStrength > 0)) || ((this.ssao) && (this.ssaoStrength > 0))) || ((this.deferredLighting) && (this.deferredLightingStrength > 0))))) + { + this.depthRenderer.render(this, this.view._width, this.view._height, this.depthBufferScale, ((this.ssao) && (this.ssaoStrength > 0)), ((this.deferredLighting) && (this.deferredLightingStrength > 0)), ((((!(this.directionalLight == null)) && (this.directionalLightStrength > 0)) || ((!(this.shadowMap == null)) && (this.shadowMapStrength > 0))) ? 0 : 0.5), this.depthObjects, this.depthCount); + if ((((this.softTransparency) && (this.softTransparencyStrength > 0)) || ((this.ssao) && (this.ssaoStrength > 0)))) + { + this.depthMap = this.depthRenderer.depthBuffer; + }; + if (((this.deferredLighting) && (this.deferredLightingStrength > 0))) + { + this.lightMap = this.depthRenderer.lightBuffer; + }; + } else + { + this.depthRenderer.resetResources(); + }; + if ((((_local_8) || ((!(this.view.constrained)) && ((((this.softTransparency) && (this.softTransparencyStrength > 0)) || ((this.ssao) && (this.ssaoStrength > 0))) || ((this.deferredLighting) && (this.deferredLightingStrength > 0))))) || (((!(this.view.constrained)) && (!(this.shadowMap == null))) && (this.shadowMapStrength > 0)))) + { + this.device.setRenderToBackBuffer(); + }; + this.view.clearArea(); + this.device.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 3, this.projection, 1); + this.fragmentConst[0] = this.farClipping; + this.fragmentConst[1] = (this.farClipping / 0xFF); + this.device.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 17, this.fragmentConst, 2); + this.correction[0] = (this.view.rect.width / this.device.width); + this.correction[1] = (this.view.rect.height / this.device.height); + this.correction[2] = ((((this.view.rect.x * 2) + this.view.rect.width) - this.device.width) / this.device.width); + this.correction[3] = ((((this.view.rect.y * 2) + this.view.rect.height) - this.device.height) / this.device.height); + this.device.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 13, this.correction, 1); + if (((!(this.view.constrained)) && (((((this.softTransparency) && (this.softTransparencyStrength > 0)) || ((this.ssao) && (this.ssaoStrength > 0))) || ((this.deferredLighting) && (this.deferredLightingStrength > 0))) || ((!(this.shadowMap == null)) && (this.shadowMapStrength > 0))))) + { + this.depthParams[0] = this.depthRenderer.correctionX; + this.depthParams[1] = this.depthRenderer.correctionY; + this.device.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 4, this.depthParams, 1); + if (((this.ssao) && (this.ssaoStrength > 0))) + { + this.ssaoParams[0] = (((1 - ((2 * ((this.ssaoColor >> 16) & 0xFF)) / 0xFF)) * this.ssaoAlpha) * this.ssaoStrength); + this.ssaoParams[1] = (((1 - ((2 * ((this.ssaoColor >> 8) & 0xFF)) / 0xFF)) * this.ssaoAlpha) * this.ssaoStrength); + this.ssaoParams[2] = (((1 - ((2 * (this.ssaoColor & 0xFF)) / 0xFF)) * this.ssaoAlpha) * this.ssaoStrength); + this.device.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 12, this.ssaoParams, 1); + }; + }; + if ((((!(this.view.constrained)) && (!(this.shadowMap == null))) && (this.shadowMapStrength > 0))) + { + this.device.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 6, this.shadowMap.transform, 4); + this.device.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 5, this.shadowMap.params, 5); + }; + if (((this.fogAlpha > 0) && (this.fogStrength > 0))) + { + this.fogParams[2] = this.fogNear; + this.fogParams[3] = (this.fogFar - this.fogNear); + this.device.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 5, this.fogParams, 1); + this.fogFragment[0] = (((this.fogColor >> 16) & 0xFF) / 0xFF); + this.fogFragment[1] = (((this.fogColor >> 8) & 0xFF) / 0xFF); + this.fogFragment[2] = ((this.fogColor & 0xFF) / 0xFF); + this.fogFragment[3] = (this.fogAlpha * this.fogStrength); + this.device.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 2, this.fogFragment, 1); + }; + if ((((!(this.view.constrained)) && (!(this.directionalLight == null))) && (this.directionalLightStrength > 0))) + { + this.lightTransform[0] = -(this.directionalLight.imi); + this.lightTransform[1] = -(this.directionalLight.imj); + this.lightTransform[2] = -(this.directionalLight.imk); + this.device.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 10, this.lightTransform, 1); + this.lightParams[0] = ((((this.directionalLight.intensity * ((this.directionalLight.color >> 16) & 0xFF)) * 2) * this.directionalLightStrength) / 0xFF); + this.lightParams[1] = ((((this.directionalLight.intensity * ((this.directionalLight.color >> 8) & 0xFF)) * 2) * this.directionalLightStrength) / 0xFF); + this.lightParams[2] = ((((this.directionalLight.intensity * (this.directionalLight.color & 0xFF)) * 2) * this.directionalLightStrength) / 0xFF); + this.lightParams[4] = (1 + ((((((this.ambientColor >> 16) & 0xFF) * 2) / 0xFF) - 1) * this.directionalLightStrength)); + this.lightParams[5] = (1 + ((((((this.ambientColor >> 8) & 0xFF) * 2) / 0xFF) - 1) * this.directionalLightStrength)); + this.lightParams[6] = (1 + (((((this.ambientColor & 0xFF) * 2) / 0xFF) - 1) * this.directionalLightStrength)); + this.device.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 10, this.lightParams, 2); + } else + { + if ((((!(this.view.constrained)) && (!(this.shadowMap == null))) && (this.shadowMapStrength > 0))) + { + this.lightParams[0] = 0; + this.lightParams[1] = 0; + this.lightParams[2] = 0; + this.lightParams[4] = 1; + this.lightParams[5] = 1; + this.lightParams[6] = 1; + this.device.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 10, this.lightParams, 2); + }; + }; + _local_1 = 0; + while (_local_1 < this.opaqueCount) + { + _local_9 = this.opaqueMaterials[_local_1]; + _local_9.drawOpaque(this, this.opaqueVertexBuffers[_local_1], this.opaqueIndexBuffers[_local_1], this.opaqueFirstIndexes[_local_1], this.opaqueNumsTriangles[_local_1], this.opaqueObjects[_local_1]); + _local_1++; + }; + this.device.setDepthTest(false, Context3DCompareMode.LESS_EQUAL); + _local_1 = 0; + while (_local_1 < this.skyCount) + { + _local_9 = this.skyMaterials[_local_1]; + _local_9.drawOpaque(this, this.skyVertexBuffers[_local_1], this.skyIndexBuffers[_local_1], this.skyFirstIndexes[_local_1], this.skyNumsTriangles[_local_1], this.skyObjects[_local_1]); + _local_1++; + }; + this.device.setDepthTest(false, Context3DCompareMode.LESS); + _local_1 = (this.decalsCount - 1); + while (_local_1 >= 0) + { + _local_11 = this.decals[_local_1]; + if (_local_11.concatenatedBlendMode != "normal") + { + this.device.setBlendFactors(Context3DBlendFactor.SOURCE_ALPHA, Context3DBlendFactor.ONE); + } else + { + this.device.setBlendFactors(Context3DBlendFactor.SOURCE_ALPHA, Context3DBlendFactor.ONE_MINUS_SOURCE_ALPHA); + }; + _local_11.faceList.material.drawOpaque(this, _local_11.vertexBuffer, _local_11.indexBuffer, 0, _local_11.numTriangles, _local_11); + _local_1--; + }; + if (_local_8) + { + this.device.setTextureAt(0, null); + this.device.setTextureAt(1, null); + this.device.setTextureAt(2, null); + this.device.setTextureAt(3, null); + this.device.setTextureAt(5, null); + this.device.setVertexBufferAt(1, null); + this.device.setVertexBufferAt(2, null); + _local_12 = 0; + for each (_local_7 in this.shadowAtlases) + { + _local_1 = 0; + while (_local_1 < _local_7.shadowsCount) + { + this.shadowList[_local_12] = _local_7.shadows[_local_1]; + _local_12++; + _local_1++; + }; + }; + this.device.setDepthTest(false, Context3DCompareMode.LESS); + _local_15 = null; + _local_1 = 0; + while (_local_1 < _local_12) + { + if (_local_1 > 0) + { + this.device.clear(0, 0, 0, 0, 1, 0, Context3DClearMask.STENCIL); + }; + this.device.setBlendFactors(Context3DBlendFactor.ZERO, Context3DBlendFactor.ONE); + this.device.setCulling(Context3DTriangleFace.NONE); + this.device.setStencilActions(Context3DTriangleFace.FRONT_AND_BACK, Context3DCompareMode.ALWAYS, Context3DStencilAction.INVERT); + _local_13 = _local_1; + _local_14 = 1; + while (((_local_13 < (_local_1 + 8)) && (_local_13 < _local_12))) + { + _local_4 = this.shadowList[_local_13]; + if ((!(_local_4.cameraInside))) + { + this.device.setStencilReferenceValue(_local_14, _local_14, _local_14); + _local_4.renderVolume(this); + }; + _local_13++; + _local_14 = (_local_14 << 1); + }; + this.device.setBlendFactors(Context3DBlendFactor.SOURCE_ALPHA, Context3DBlendFactor.ONE_MINUS_SOURCE_ALPHA); + this.device.setCulling(Context3DTriangleFace.FRONT); + this.device.setStencilActions(Context3DTriangleFace.BACK, Context3DCompareMode.EQUAL); + _local_13 = _local_1; + _local_14 = 1; + while (((_local_13 < (_local_1 + 8)) && (_local_13 < _local_12))) + { + _local_4 = this.shadowList[_local_13]; + if (_local_4.texture != _local_15) + { + this.device.setTextureAt(0, _local_4.texture); + _local_15 = _local_4.texture; + }; + if ((!(_local_4.cameraInside))) + { + this.device.setStencilReferenceValue(_local_14, _local_14, _local_14); + _local_4.renderReceivers(this); + } else + { + this.device.setStencilActions(Context3DTriangleFace.BACK, Context3DCompareMode.ALWAYS); + _local_4.renderReceivers(this); + this.device.setStencilActions(Context3DTriangleFace.BACK, Context3DCompareMode.EQUAL); + }; + _local_13++; + _local_14 = (_local_14 << 1); + }; + this.device.setTextureAt(0, null); + _local_15 = null; + _local_1 = (_local_1 + 8); + }; + this.device.setStencilActions(); + this.device.setStencilReferenceValue(0); + }; + this.device.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 13, this.correction, 1); + this.device.setCulling(Context3DTriangleFace.FRONT); + _local_1 = 0; + while (_local_1 < this.transparentOpaqueCount) + { + if (((_local_1 < this.transparentOpaqueFaceLists.length) && (_local_1 < this.transparentOpaqueObjects.length))) + { + this.transparentFaceLists[this.transparentCount] = this.transparentOpaqueFaceLists[_local_1]; + this.transparentObjects[this.transparentCount] = this.transparentOpaqueObjects[_local_1]; + this.transparentCount++; + }; + _local_1++; + }; + this.transparentOpaqueCount = (this.transparentCount - this.transparentOpaqueCount); + this.device.setDepthTest(true, Context3DCompareMode.LESS); + _local_1 = (this.transparentCount - 1); + while (_local_1 >= 0) + { + if ((_local_1 + 1) == this.transparentOpaqueCount) + { + this.device.setDepthTest(false, Context3DCompareMode.LESS); + }; + _local_16 = this.transparentFaceLists[_local_1]; + _local_17 = this.transparentObjects[_local_1]; + if (_local_17.concatenatedBlendMode != "normal") + { + this.device.setBlendFactors(Context3DBlendFactor.SOURCE_ALPHA, Context3DBlendFactor.ONE); + } else + { + this.device.setBlendFactors(Context3DBlendFactor.SOURCE_ALPHA, Context3DBlendFactor.ONE_MINUS_SOURCE_ALPHA); + }; + _local_18 = (_local_17 is Sprite3D); + if (_local_18) + { + _local_20 = 0; + _local_21 = Sprite3D(_local_17); + _local_22 = _local_16; + while (_local_22.processNext != null) + { + _local_22.distance = _local_20; + _local_22 = _local_22.processNext; + }; + _local_22.distance = _local_20; + this.transparentBatchObjects[_local_20] = _local_17; + _local_20++; + _local_13 = (_local_1 - 1); + while (_local_13 >= 0) + { + _local_23 = this.transparentFaceLists[_local_13]; + if (_local_16.material != _local_23.material) break; + _local_24 = this.transparentObjects[_local_13]; + if ((_local_24 is Sprite3D)) + { + _local_25 = Sprite3D(_local_24); + if ((((((((((!(_local_21.useLight == _local_25.useLight)) || (!(_local_21.useShadowMap == _local_25.useShadowMap))) || (_local_21.lighted)) || (_local_25.lighted)) || (!(_local_21.softAttenuation == _local_25.softAttenuation))) || (!(_local_21.concatenatedAlpha == _local_25.concatenatedAlpha))) || (!(_local_21.concatenatedColorTransform == null))) || (!(_local_25.concatenatedColorTransform == null))) || (!(_local_21.concatenatedBlendMode == _local_25.concatenatedBlendMode)))) break; + } else + { + break; + }; + _local_22.processNext = _local_23; + _local_22 = _local_23; + while (_local_22.processNext != null) + { + _local_22.distance = _local_20; + _local_22 = _local_22.processNext; + }; + _local_22.distance = _local_20; + this.transparentBatchObjects[_local_20] = _local_24; + _local_20++; + _local_1--; + _local_13--; + }; + }; + _local_19 = ((_local_18) && (!(Sprite3D(_local_17).depthTest))); + if (_local_19) + { + this.device.setDepthTest(false, Context3DCompareMode.ALWAYS); + }; + this.drawTransparentList(_local_16, _local_17, _local_18); + if (_local_19) + { + this.device.setDepthTest(false, Context3DCompareMode.LESS); + }; + _local_1--; + }; + this.device.setTextureAt(0, null); + this.device.setTextureAt(1, null); + this.device.setTextureAt(2, null); + this.device.setTextureAt(3, null); + this.device.setTextureAt(5, null); + this.device.setTextureAt(6, null); + this.device.setTextureAt(7, null); + this.device.setVertexBufferAt(1, null); + this.device.setVertexBufferAt(2, null); + this.device.setVertexBufferAt(3, null); + this.device.setVertexBufferAt(4, null); + this.device.setVertexBufferAt(5, null); + this.device.setVertexBufferAt(6, null); + this.device.setVertexBufferAt(7, null); + this.opaqueMaterials.length = 0; + this.opaqueVertexBuffers.length = 0; + this.opaqueIndexBuffers.length = 0; + this.opaqueFirstIndexes.length = 0; + this.opaqueNumsTriangles.length = 0; + this.opaqueObjects.length = 0; + this.opaqueCount = 0; + this.skyMaterials.length = 0; + this.skyVertexBuffers.length = 0; + this.skyIndexBuffers.length = 0; + this.skyFirstIndexes.length = 0; + this.skyNumsTriangles.length = 0; + this.skyObjects.length = 0; + this.skyCount = 0; + this.transparentFaceLists.length = 0; + this.transparentObjects.length = 0; + this.transparentCount = 0; + this.transparentOpaqueFaceLists.length = 0; + this.transparentOpaqueObjects.length = 0; + this.transparentOpaqueCount = 0; + this.transparentBatchObjects.length = 0; + this.decals.length = 0; + this.decalsCount = 0; + this.depthObjects.length = 0; + this.depthCount = 0; + this.casterObjects.length = 0; + this.casterCount = 0; + this.omnies.length = 0; + this.omniesCount = 0; + this.spots.length = 0; + this.spotsCount = 0; + this.tubes.length = 0; + this.tubesCount = 0; + for each (_local_7 in this.shadowAtlases) + { + if (_local_7.shadowsCount > 0) + { + _local_7.clear(); + }; + }; + this.receiversVertexBuffers = null; + this.receiversIndexBuffers = null; + this.deferredDestroy(); + this.clearOccluders(); + this.view.onRender(this); + if (this.onRender != null) + { + this.onRender(); + }; + this.view.present(); + } else + { + this.view.clearArea(); + if (this.onRender != null) + { + this.onRender(); + }; + this.view.present(); + }; + this.device = null; + }; + } + + private function drawTransparentList(_arg_1:Face, _arg_2:Object3D, _arg_3:Boolean):void + { + var _local_4:Vertex; + var _local_5:Vertex; + var _local_6:Vertex; + var _local_7:Wrapper; + var _local_8:Face; + var _local_12:int; + var _local_13:Object3D; + var _local_9:int; + var _local_10:int; + var _local_11:Material = _arg_1.material; + while (_arg_1 != null) + { + _local_8 = _arg_1.processNext; + _arg_1.processNext = null; + _local_7 = _arg_1.wrapper; + _local_4 = _local_7.vertex; + _local_7 = _local_7.next; + _local_5 = _local_7.vertex; + if (_arg_3) + { + _local_12 = _arg_1.distance; + _local_13 = this.transparentBatchObjects[_local_12]; + _local_7 = _local_7.next; + while (_local_7 != null) + { + if (_local_10 == constantsMaxTriangles) + { + if (_local_11 != null) + { + this.device.setProgramConstantsFromVector(Context3DProgramType.VERTEX, constantsOffset, constants, (_local_10 * 6), false); + _local_11.drawTransparent(this, constantsVertexBuffer, constantsIndexBuffer, 0, _local_10, _arg_2, true); + }; + _local_10 = 0; + _local_9 = 0; + }; + _local_6 = _local_7.vertex; + constants[_local_9] = _local_4.cameraX; + _local_9++; + constants[_local_9] = _local_4.cameraY; + _local_9++; + constants[_local_9] = _local_4.cameraZ; + _local_9++; + constants[_local_9] = -(_local_13.md); + _local_9++; + constants[_local_9] = _local_4.u; + _local_9++; + constants[_local_9] = _local_4.v; + _local_9++; + constants[_local_9] = -(_local_13.mh); + _local_9++; + constants[_local_9] = -(_local_13.ml); + _local_9++; + constants[_local_9] = _local_5.cameraX; + _local_9++; + constants[_local_9] = _local_5.cameraY; + _local_9++; + constants[_local_9] = _local_5.cameraZ; + _local_9++; + constants[_local_9] = -(_local_13.md); + _local_9++; + constants[_local_9] = _local_5.u; + _local_9++; + constants[_local_9] = _local_5.v; + _local_9++; + constants[_local_9] = -(_local_13.mh); + _local_9++; + constants[_local_9] = -(_local_13.ml); + _local_9++; + constants[_local_9] = _local_6.cameraX; + _local_9++; + constants[_local_9] = _local_6.cameraY; + _local_9++; + constants[_local_9] = _local_6.cameraZ; + _local_9++; + constants[_local_9] = -(_local_13.md); + _local_9++; + constants[_local_9] = _local_6.u; + _local_9++; + constants[_local_9] = _local_6.v; + _local_9++; + constants[_local_9] = -(_local_13.mh); + _local_9++; + constants[_local_9] = -(_local_13.ml); + _local_9++; + _local_10++; + _local_5 = _local_6; + _local_7 = _local_7.next; + }; + } else + { + _local_7 = _local_7.next; + while (_local_7 != null) + { + if (_local_10 == constantsMaxTriangles) + { + if (_local_11 != null) + { + this.device.setProgramConstantsFromVector(Context3DProgramType.VERTEX, constantsOffset, constants, (_local_10 * 6), false); + _local_11.drawTransparent(this, constantsVertexBuffer, constantsIndexBuffer, 0, _local_10, _arg_2, true); + }; + _local_10 = 0; + _local_9 = 0; + }; + _local_6 = _local_7.vertex; + constants[_local_9] = _local_4.cameraX; + _local_9++; + constants[_local_9] = _local_4.cameraY; + _local_9++; + constants[_local_9] = _local_4.cameraZ; + _local_9++; + constants[_local_9] = _local_4.normalX; + _local_9++; + constants[_local_9] = _local_4.u; + _local_9++; + constants[_local_9] = _local_4.v; + _local_9++; + constants[_local_9] = _local_4.normalY; + _local_9++; + constants[_local_9] = _local_4.normalZ; + _local_9++; + constants[_local_9] = _local_5.cameraX; + _local_9++; + constants[_local_9] = _local_5.cameraY; + _local_9++; + constants[_local_9] = _local_5.cameraZ; + _local_9++; + constants[_local_9] = _local_5.normalX; + _local_9++; + constants[_local_9] = _local_5.u; + _local_9++; + constants[_local_9] = _local_5.v; + _local_9++; + constants[_local_9] = _local_5.normalY; + _local_9++; + constants[_local_9] = _local_5.normalZ; + _local_9++; + constants[_local_9] = _local_6.cameraX; + _local_9++; + constants[_local_9] = _local_6.cameraY; + _local_9++; + constants[_local_9] = _local_6.cameraZ; + _local_9++; + constants[_local_9] = _local_6.normalX; + _local_9++; + constants[_local_9] = _local_6.u; + _local_9++; + constants[_local_9] = _local_6.v; + _local_9++; + constants[_local_9] = _local_6.normalY; + _local_9++; + constants[_local_9] = _local_6.normalZ; + _local_9++; + _local_10++; + _local_5 = _local_6; + _local_7 = _local_7.next; + }; + }; + _arg_1 = _local_8; + }; + if (((_local_10 > 0) && (!(_local_11 == null)))) + { + this.device.setProgramConstantsFromVector(Context3DProgramType.VERTEX, constantsOffset, constants, (_local_10 * 6), false); + _local_11.drawTransparent(this, constantsVertexBuffer, constantsIndexBuffer, 0, _local_10, _arg_2, true); + }; + } + + public function lookAt(_arg_1:Number, _arg_2:Number, _arg_3:Number):void + { + var _local_4:Number = (_arg_1 - this.x); + var _local_5:Number = (_arg_2 - this.y); + var _local_6:Number = (_arg_3 - this.z); + rotationX = (Math.atan2(_local_6, Math.sqrt(((_local_4 * _local_4) + (_local_5 * _local_5)))) - (Math.PI / 2)); + rotationY = 0; + rotationZ = -(Math.atan2(_local_4, _local_5)); + } + + public function projectGlobal(_arg_1:Vector3D):Vector3D + { + if (this.view == null) + { + throw (new Error("It is necessary to have view set.")); + }; + this.viewSizeX = (this.view._width * 0.5); + this.viewSizeY = (this.view._height * 0.5); + this.focalLength = (Math.sqrt(((this.viewSizeX * this.viewSizeX) + (this.viewSizeY * this.viewSizeY))) / Math.tan((this.fov * 0.5))); + this.composeCameraMatrix(); + var _local_2:Object3D = this; + while (_local_2._parent != null) + { + _local_2 = _local_2._parent; + tA.composeMatrixFromSource(_local_2); + appendMatrix(tA); + }; + invertMatrix(); + var _local_3:Vector3D = new Vector3D(); + _local_3.x = ((((ma * _arg_1.x) + (mb * _arg_1.y)) + (mc * _arg_1.z)) + md); + _local_3.y = ((((me * _arg_1.x) + (mf * _arg_1.y)) + (mg * _arg_1.z)) + mh); + _local_3.z = ((((mi * _arg_1.x) + (mj * _arg_1.y)) + (mk * _arg_1.z)) + ml); + _local_3.x = (((_local_3.x * this.viewSizeX) / _local_3.z) + this.viewSizeX); + _local_3.y = (((_local_3.y * this.viewSizeY) / _local_3.z) + this.viewSizeY); + return (_local_3); + } + + public function calculateRay(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Number, _arg_4:Number):void + { + if (this.view == null) + { + throw (new Error("It is necessary to have view set.")); + }; + this.viewSizeX = (this.view._width * 0.5); + this.viewSizeY = (this.view._height * 0.5); + this.focalLength = (Math.sqrt(((this.viewSizeX * this.viewSizeX) + (this.viewSizeY * this.viewSizeY))) / Math.tan((this.fov * 0.5))); + _arg_3 = (_arg_3 - this.viewSizeX); + _arg_4 = (_arg_4 - this.viewSizeY); + var _local_5:Number = ((_arg_3 * this.focalLength) / this.viewSizeX); + var _local_6:Number = ((_arg_4 * this.focalLength) / this.viewSizeY); + var _local_7:Number = this.focalLength; + var _local_8:Number = ((_local_5 * this.nearClipping) / this.focalLength); + var _local_9:Number = ((_local_6 * this.nearClipping) / this.focalLength); + var _local_10:Number = this.nearClipping; + this.composeCameraMatrix(); + var _local_11:Object3D = this; + while (_local_11._parent != null) + { + _local_11 = _local_11._parent; + tA.composeMatrixFromSource(_local_11); + appendMatrix(tA); + }; + _arg_1.x = ((((ma * _local_8) + (mb * _local_9)) + (mc * _local_10)) + md); + _arg_1.y = ((((me * _local_8) + (mf * _local_9)) + (mg * _local_10)) + mh); + _arg_1.z = ((((mi * _local_8) + (mj * _local_9)) + (mk * _local_10)) + ml); + _arg_2.x = (((ma * _local_5) + (mb * _local_6)) + (mc * _local_7)); + _arg_2.y = (((me * _local_5) + (mf * _local_6)) + (mg * _local_7)); + _arg_2.z = (((mi * _local_5) + (mj * _local_6)) + (mk * _local_7)); + var _local_12:Number = (1 / Math.sqrt((((_arg_2.x * _arg_2.x) + (_arg_2.y * _arg_2.y)) + (_arg_2.z * _arg_2.z)))); + _arg_2.x = (_arg_2.x * _local_12); + _arg_2.y = (_arg_2.y * _local_12); + _arg_2.z = (_arg_2.z * _local_12); + } + + override public function clone():Object3D + { + var _local_1:Camera3D = new Camera3D(); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + override protected function clonePropertiesFrom(_arg_1:Object3D):void + { + var _local_3:*; + super.clonePropertiesFrom(_arg_1); + var _local_2:Camera3D = (_arg_1 as Camera3D); + this.fov = _local_2.fov; + this.nearClipping = _local_2.nearClipping; + this.farClipping = _local_2.farClipping; + this.debug = _local_2.debug; + this.fogNear = _local_2.fogNear; + this.fogFar = _local_2.fogFar; + this.fogAlpha = _local_2.fogAlpha; + this.fogColor = _local_2.fogColor; + this.softTransparency = _local_2.softTransparency; + this.depthBufferScale = _local_2.depthBufferScale; + this.ssao = _local_2.ssao; + this.ssaoRadius = _local_2.ssaoRadius; + this.ssaoRange = _local_2.ssaoRange; + this.ssaoColor = _local_2.ssaoColor; + this.ssaoAlpha = _local_2.ssaoAlpha; + this.directionalLight = _local_2.directionalLight; + this.shadowMap = _local_2.shadowMap; + this.ambientColor = _local_2.ambientColor; + this.deferredLighting = _local_2.deferredLighting; + this.fogStrength = _local_2.fogStrength; + this.softTransparencyStrength = _local_2.softTransparencyStrength; + this.ssaoStrength = _local_2.ssaoStrength; + this.directionalLightStrength = _local_2.directionalLightStrength; + this.shadowMapStrength = _local_2.shadowMapStrength; + this.shadowsStrength = _local_2.shadowsStrength; + this.shadowsDistanceMultiplier = _local_2.shadowsDistanceMultiplier; + this.deferredLightingStrength = _local_2.deferredLightingStrength; + for (_local_3 in _local_2.shadows) + { + this.shadows[_local_3] = true; + }; + } + + alternativa3d function addOpaque(_arg_1:Material, _arg_2:VertexBufferResource, _arg_3:IndexBufferResource, _arg_4:int, _arg_5:int, _arg_6:Object3D):void + { + this.opaqueMaterials[this.opaqueCount] = _arg_1; + this.opaqueVertexBuffers[this.opaqueCount] = _arg_2; + this.opaqueIndexBuffers[this.opaqueCount] = _arg_3; + this.opaqueFirstIndexes[this.opaqueCount] = _arg_4; + this.opaqueNumsTriangles[this.opaqueCount] = _arg_5; + this.opaqueObjects[this.opaqueCount] = _arg_6; + this.opaqueCount++; + } + + alternativa3d function addSky(_arg_1:Material, _arg_2:VertexBufferResource, _arg_3:IndexBufferResource, _arg_4:int, _arg_5:int, _arg_6:Object3D):void + { + this.skyMaterials[this.skyCount] = _arg_1; + this.skyVertexBuffers[this.skyCount] = _arg_2; + this.skyIndexBuffers[this.skyCount] = _arg_3; + this.skyFirstIndexes[this.skyCount] = _arg_4; + this.skyNumsTriangles[this.skyCount] = _arg_5; + this.skyObjects[this.skyCount] = _arg_6; + this.skyCount++; + } + + alternativa3d function addTransparent(_arg_1:Face, _arg_2:Object3D):void + { + this.transparentFaceLists[this.transparentCount] = _arg_1; + this.transparentObjects[this.transparentCount] = _arg_2; + this.transparentCount++; + } + + alternativa3d function addTransparentOpaque(_arg_1:Face, _arg_2:Object3D):void + { + this.transparentOpaqueFaceLists[this.transparentOpaqueCount] = _arg_1; + this.transparentOpaqueObjects[this.transparentOpaqueCount] = _arg_2; + this.transparentOpaqueCount++; + } + + alternativa3d function addDecal(_arg_1:Decal):void + { + this.decals[this.decalsCount] = _arg_1; + this.decalsCount++; + } + + alternativa3d function composeCameraMatrix():void + { + var _local_1:Number = (this.viewSizeX / this.focalLength); + var _local_2:Number = (this.viewSizeY / this.focalLength); + var _local_3:Number = Math.cos(rotationX); + var _local_4:Number = Math.sin(rotationX); + var _local_5:Number = Math.cos(rotationY); + var _local_6:Number = Math.sin(rotationY); + var _local_7:Number = Math.cos(rotationZ); + var _local_8:Number = Math.sin(rotationZ); + var _local_9:Number = (_local_7 * _local_6); + var _local_10:Number = (_local_8 * _local_6); + var _local_11:Number = (_local_5 * scaleX); + var _local_12:Number = (_local_4 * scaleY); + var _local_13:Number = (_local_3 * scaleY); + var _local_14:Number = (_local_3 * scaleZ); + var _local_15:Number = (_local_4 * scaleZ); + ma = ((_local_7 * _local_11) * _local_1); + mb = (((_local_9 * _local_12) - (_local_8 * _local_13)) * _local_2); + mc = ((_local_9 * _local_14) + (_local_8 * _local_15)); + md = x; + me = ((_local_8 * _local_11) * _local_1); + mf = (((_local_10 * _local_12) + (_local_7 * _local_13)) * _local_2); + mg = ((_local_10 * _local_14) - (_local_7 * _local_15)); + mh = y; + mi = ((-(_local_6) * scaleX) * _local_1); + mj = ((_local_5 * _local_12) * _local_2); + mk = (_local_5 * _local_14); + ml = z; + var _local_16:Number = (this.view.offsetX / this.viewSizeX); + var _local_17:Number = (this.view.offsetY / this.viewSizeY); + mc = (mc - ((ma * _local_16) + (mb * _local_17))); + mg = (mg - ((me * _local_16) + (mf * _local_17))); + mk = (mk - ((mi * _local_16) + (mj * _local_17))); + } + + public function addToDebug(_arg_1:int, _arg_2:*):void + { + if ((!(this.debugSet[_arg_1]))) + { + this.debugSet[_arg_1] = new Dictionary(); + }; + this.debugSet[_arg_1][_arg_2] = true; + } + + public function removeFromDebug(_arg_1:int, _arg_2:*):void + { + var _local_3:*; + if (this.debugSet[_arg_1]) + { + delete this.debugSet[_arg_1][_arg_2]; + for (_local_3 in this.debugSet[_arg_1]) + { + break; + }; + if ((!(_local_3))) + { + delete this.debugSet[_arg_1]; + }; + }; + } + + alternativa3d function checkInDebug(_arg_1:Object3D):int + { + var _local_4:Class; + var _local_2:int; + var _local_3:int = 1; + while (_local_3 <= 0x0200) + { + if (this.debugSet[_local_3]) + { + if (((this.debugSet[_local_3][Object3D]) || (this.debugSet[_local_3][_arg_1]))) + { + _local_2 = (_local_2 | _local_3); + } else + { + _local_4 = (getDefinitionByName(getQualifiedClassName(_arg_1)) as Class); + while (_local_4 != Object3D) + { + if (this.debugSet[_local_3][_local_4]) + { + _local_2 = (_local_2 | _local_3); + break; + }; + _local_4 = Class(getDefinitionByName(getQualifiedSuperclassName(_local_4))); + }; + }; + }; + _local_3 = (_local_3 << 1); + }; + return (_local_2); + } + + public function startTimer():void + { + this.timer = getTimer(); + } + + public function stopTimer():void + { + this.timeSum = (this.timeSum + (getTimer() - this.timer)); + this.timeCount++; + } + + public function get diagram():DisplayObject + { + return (this._diagram); + } + + public function get diagramAlign():String + { + return (this._diagramAlign); + } + + public function set diagramAlign(_arg_1:String):void + { + this._diagramAlign = _arg_1; + this.resizeDiagram(); + } + + public function get diagramHorizontalMargin():Number + { + return (this._diagramHorizontalMargin); + } + + public function set diagramHorizontalMargin(_arg_1:Number):void + { + this._diagramHorizontalMargin = _arg_1; + this.resizeDiagram(); + } + + public function get diagramVerticalMargin():Number + { + return (this._diagramVerticalMargin); + } + + public function set diagramVerticalMargin(_arg_1:Number):void + { + this._diagramVerticalMargin = _arg_1; + this.resizeDiagram(); + } + + private function createDiagram():Sprite + { + var diagram:Sprite; + diagram = new Sprite(); + diagram.mouseEnabled = false; + diagram.mouseChildren = false; + diagram.addEventListener(Event.ADDED_TO_STAGE, function ():void + { + while (internal::diagram.numChildren > 0) + { + internal::diagram.removeChildAt(0); + }; + fpsTextField = new TextField(); + fpsTextField.defaultTextFormat = new TextFormat("Tahoma", 10, 0xCCCCCC); + fpsTextField.autoSize = TextFieldAutoSize.LEFT; + fpsTextField.text = "FPS:"; + fpsTextField.selectable = false; + fpsTextField.x = -3; + fpsTextField.y = -5; + internal::diagram.addChild(fpsTextField); + fpsTextField = new TextField(); + fpsTextField.defaultTextFormat = new TextFormat("Tahoma", 10, 0xCCCCCC); + fpsTextField.autoSize = TextFieldAutoSize.RIGHT; + fpsTextField.text = Number(internal::diagram.stage.frameRate).toFixed(2); + fpsTextField.selectable = false; + fpsTextField.x = -3; + fpsTextField.y = -5; + fpsTextField.width = 65; + internal::diagram.addChild(fpsTextField); + timerTextField = new TextField(); + timerTextField.defaultTextFormat = new TextFormat("Tahoma", 10, 26367); + timerTextField.autoSize = TextFieldAutoSize.LEFT; + timerTextField.text = "MS:"; + timerTextField.selectable = false; + timerTextField.x = -3; + timerTextField.y = 4; + internal::diagram.addChild(timerTextField); + timerTextField = new TextField(); + timerTextField.defaultTextFormat = new TextFormat("Tahoma", 10, 26367); + timerTextField.autoSize = TextFieldAutoSize.RIGHT; + timerTextField.text = ""; + timerTextField.selectable = false; + timerTextField.x = -3; + timerTextField.y = 4; + timerTextField.width = 65; + internal::diagram.addChild(timerTextField); + memoryTextField = new TextField(); + memoryTextField.defaultTextFormat = new TextFormat("Tahoma", 10, 0xCCCC00); + memoryTextField.autoSize = TextFieldAutoSize.LEFT; + memoryTextField.text = "MEM:"; + memoryTextField.selectable = false; + memoryTextField.x = -3; + memoryTextField.y = 13; + internal::diagram.addChild(memoryTextField); + memoryTextField = new TextField(); + memoryTextField.defaultTextFormat = new TextFormat("Tahoma", 10, 0xCCCC00); + memoryTextField.autoSize = TextFieldAutoSize.RIGHT; + memoryTextField.text = bytesToString(System.totalMemory); + memoryTextField.selectable = false; + memoryTextField.x = -3; + memoryTextField.y = 13; + memoryTextField.width = 65; + internal::diagram.addChild(memoryTextField); + drawsTextField = new TextField(); + drawsTextField.defaultTextFormat = new TextFormat("Tahoma", 10, 0xCC00); + drawsTextField.autoSize = TextFieldAutoSize.LEFT; + drawsTextField.text = "DRW:"; + drawsTextField.selectable = false; + drawsTextField.x = -3; + drawsTextField.y = 22; + internal::diagram.addChild(drawsTextField); + drawsTextField = new TextField(); + drawsTextField.defaultTextFormat = new TextFormat("Tahoma", 10, 0xCC00); + drawsTextField.autoSize = TextFieldAutoSize.RIGHT; + drawsTextField.text = "0"; + drawsTextField.selectable = false; + drawsTextField.x = -3; + drawsTextField.y = 22; + drawsTextField.width = 52; + internal::diagram.addChild(drawsTextField); + shadowsTextField = new TextField(); + shadowsTextField.defaultTextFormat = new TextFormat("Tahoma", 10, 0xFF0033); + shadowsTextField.autoSize = TextFieldAutoSize.LEFT; + shadowsTextField.text = "SHD:"; + shadowsTextField.selectable = false; + shadowsTextField.x = -3; + shadowsTextField.y = 31; + internal::diagram.addChild(shadowsTextField); + shadowsTextField = new TextField(); + shadowsTextField.defaultTextFormat = new TextFormat("Tahoma", 10, 0xFF0033); + shadowsTextField.autoSize = TextFieldAutoSize.RIGHT; + shadowsTextField.text = "0"; + shadowsTextField.selectable = false; + shadowsTextField.x = -3; + shadowsTextField.y = 31; + shadowsTextField.width = 52; + internal::diagram.addChild(shadowsTextField); + trianglesTextField = new TextField(); + trianglesTextField.defaultTextFormat = new TextFormat("Tahoma", 10, 0xFF6600); + trianglesTextField.autoSize = TextFieldAutoSize.LEFT; + trianglesTextField.text = "TRI:"; + trianglesTextField.selectable = false; + trianglesTextField.x = -3; + trianglesTextField.y = 40; + internal::diagram.addChild(trianglesTextField); + trianglesTextField = new TextField(); + trianglesTextField.defaultTextFormat = new TextFormat("Tahoma", 10, 0xFF6600); + trianglesTextField.autoSize = TextFieldAutoSize.RIGHT; + trianglesTextField.text = "0"; + trianglesTextField.selectable = false; + trianglesTextField.x = -3; + trianglesTextField.y = 40; + trianglesTextField.width = 52; + internal::diagram.addChild(trianglesTextField); + graph = new Bitmap(new BitmapData(60, 40, true, 553648127)); + rect = new Rectangle(0, 0, 1, 40); + graph.x = 0; + graph.y = 54; + internal::diagram.addChild(graph); + previousPeriodTime = getTimer(); + previousFrameTime = previousPeriodTime; + fpsUpdateCounter = 0; + maxMemory = 0; + timerUpdateCounter = 0; + timeSum = 0; + timeCount = 0; + internal::diagram.stage.addEventListener(Event.ENTER_FRAME, updateDiagram, false, -1000); + internal::diagram.stage.addEventListener(Event.RESIZE, resizeDiagram, false, -1000); + resizeDiagram(); + }); + diagram.addEventListener(Event.REMOVED_FROM_STAGE, function ():void + { + while (internal::diagram.numChildren > 0) + { + internal::diagram.removeChildAt(0); + }; + fpsTextField = null; + memoryTextField = null; + drawsTextField = null; + shadowsTextField = null; + trianglesTextField = null; + timerTextField = null; + graph.bitmapData.dispose(); + graph = null; + rect = null; + internal::diagram.stage.removeEventListener(Event.ENTER_FRAME, updateDiagram); + internal::diagram.stage.removeEventListener(Event.RESIZE, resizeDiagram); + }); + return (diagram); + } + + private function resizeDiagram(_arg_1:Event=null):void + { + var _local_2:Point; + if (this._diagram.stage != null) + { + _local_2 = this._diagram.parent.globalToLocal(new Point()); + if ((((this._diagramAlign == StageAlign.TOP_LEFT) || (this._diagramAlign == StageAlign.LEFT)) || (this._diagramAlign == StageAlign.BOTTOM_LEFT))) + { + this._diagram.x = Math.round((_local_2.x + this._diagramHorizontalMargin)); + }; + if (((this._diagramAlign == StageAlign.TOP) || (this._diagramAlign == StageAlign.BOTTOM))) + { + this._diagram.x = Math.round(((_local_2.x + (this._diagram.stage.stageWidth / 2)) - (this.graph.width / 2))); + }; + if ((((this._diagramAlign == StageAlign.TOP_RIGHT) || (this._diagramAlign == StageAlign.RIGHT)) || (this._diagramAlign == StageAlign.BOTTOM_RIGHT))) + { + this._diagram.x = Math.round((((_local_2.x + this._diagram.stage.stageWidth) - this._diagramHorizontalMargin) - this.graph.width)); + }; + if ((((this._diagramAlign == StageAlign.TOP_LEFT) || (this._diagramAlign == StageAlign.TOP)) || (this._diagramAlign == StageAlign.TOP_RIGHT))) + { + this._diagram.y = Math.round((_local_2.y + this._diagramVerticalMargin)); + }; + if (((this._diagramAlign == StageAlign.LEFT) || (this._diagramAlign == StageAlign.RIGHT))) + { + this._diagram.y = Math.round(((_local_2.y + (this._diagram.stage.stageHeight / 2)) - ((this.graph.y + this.graph.height) / 2))); + }; + if ((((this._diagramAlign == StageAlign.BOTTOM_LEFT) || (this._diagramAlign == StageAlign.BOTTOM)) || (this._diagramAlign == StageAlign.BOTTOM_RIGHT))) + { + this._diagram.y = Math.round(((((_local_2.y + this._diagram.stage.stageHeight) - this._diagramVerticalMargin) - this.graph.y) - this.graph.height)); + }; + }; + } + + private function updateDiagram(_arg_1:Event):void + { + var _local_2:Number; + var _local_3:int; + var _local_4:String; + var _local_5:int = getTimer(); + var _local_6:int = this._diagram.stage.frameRate; + if (++this.fpsUpdateCounter == this.fpsUpdatePeriod) + { + _local_2 = ((1000 * this.fpsUpdatePeriod) / (_local_5 - this.previousPeriodTime)); + if (_local_2 > _local_6) + { + _local_2 = _local_6; + }; + _local_3 = ((_local_2 * 100) % 100); + _local_4 = ((_local_3 >= 10) ? String(_local_3) : ((_local_3 > 0) ? ("0" + String(_local_3)) : "00")); + this.fpsTextField.text = ((int(_local_2) + ".") + _local_4); + this.previousPeriodTime = _local_5; + this.fpsUpdateCounter = 0; + }; + _local_2 = (1000 / (_local_5 - this.previousFrameTime)); + if (_local_2 > _local_6) + { + _local_2 = _local_6; + }; + this.graph.bitmapData.scroll(1, 0); + this.graph.bitmapData.fillRect(this.rect, 553648127); + this.graph.bitmapData.setPixel32(0, (40 * (1 - (_local_2 / _local_6))), 4291611852); + this.previousFrameTime = _local_5; + if (++this.timerUpdateCounter == this.timerUpdatePeriod) + { + if (this.timeCount > 0) + { + _local_2 = (this.timeSum / this.timeCount); + _local_3 = ((_local_2 * 100) % 100); + _local_4 = ((_local_3 >= 10) ? String(_local_3) : ((_local_3 > 0) ? ("0" + String(_local_3)) : "00")); + this.timerTextField.text = ((int(_local_2) + ".") + _local_4); + } else + { + this.timerTextField.text = ""; + }; + this.timerUpdateCounter = 0; + this.timeSum = 0; + this.timeCount = 0; + }; + var _local_7:int = System.totalMemory; + _local_2 = (_local_7 / 0x100000); + _local_3 = ((_local_2 * 100) % 100); + _local_4 = ((_local_3 >= 10) ? String(_local_3) : ((_local_3 > 0) ? ("0" + String(_local_3)) : "00")); + this.memoryTextField.text = ((int(_local_2) + ".") + _local_4); + if (_local_7 > this.maxMemory) + { + this.maxMemory = _local_7; + }; + this.graph.bitmapData.setPixel32(0, (40 * (1 - (_local_7 / this.maxMemory))), 0xFFCCCC00); + this.drawsTextField.text = String(this.numDraws); + this.shadowsTextField.text = String(this.numShadows); + this.trianglesTextField.text = String(this.numTriangles); + } + + private function bytesToString(_arg_1:int):String + { + if (_arg_1 < 0x0400) + { + return (_arg_1 + "b"); + }; + if (_arg_1 < 0x2800) + { + return ((_arg_1 / 0x0400).toFixed(2) + "kb"); + }; + if (_arg_1 < 102400) + { + return ((_arg_1 / 0x0400).toFixed(1) + "kb"); + }; + if (_arg_1 < 0x100000) + { + return ((_arg_1 >> 10) + "kb"); + }; + if (_arg_1 < 0xA00000) + { + return ((_arg_1 / 0x100000).toFixed(2)); + }; + if (_arg_1 < 104857600) + { + return ((_arg_1 / 0x100000).toFixed(1)); + }; + return (String((_arg_1 >> 20))); + } + + alternativa3d function deferredDestroy():void + { + var _local_2:Wrapper; + var _local_3:Wrapper; + var _local_1:Face = this.firstFace.next; + while (_local_1 != null) + { + _local_2 = _local_1.wrapper; + if (_local_2 != null) + { + _local_3 = null; + while (_local_2 != null) + { + _local_2.vertex = null; + _local_3 = _local_2; + _local_2 = _local_2.next; + }; + this.lastWrapper.next = _local_1.wrapper; + this.lastWrapper = _local_3; + }; + _local_1.material = null; + _local_1.wrapper = null; + _local_1 = _local_1.next; + }; + if (this.firstFace != this.lastFace) + { + this.lastFace.next = Face.collector; + Face.collector = this.firstFace.next; + this.firstFace.next = null; + this.lastFace = this.firstFace; + }; + if (this.firstWrapper != this.lastWrapper) + { + this.lastWrapper.next = Wrapper.collector; + Wrapper.collector = this.firstWrapper.next; + this.firstWrapper.next = null; + this.lastWrapper = this.firstWrapper; + }; + if (this.firstVertex != this.lastVertex) + { + this.lastVertex.next = Vertex.collector; + Vertex.collector = this.firstVertex.next; + this.firstVertex.next = null; + this.lastVertex = this.firstVertex; + }; + } + + alternativa3d function clearOccluders():void + { + var _local_2:Vertex; + var _local_3:Vertex; + var _local_1:int; + while (_local_1 < this.numOccluders) + { + _local_2 = this.occluders[_local_1]; + _local_3 = _local_2; + while (_local_3.next != null) + { + _local_3 = _local_3.next; + }; + _local_3.next = Vertex.collector; + Vertex.collector = _local_2; + this.occluders[_local_1] = null; + _local_1++; + }; + this.numOccluders = 0; + } + + alternativa3d function sortByAverageZ(_arg_1:Face):Face + { + var _local_2:int; + var _local_3:Number; + var _local_4:Wrapper; + var _local_5:Face = _arg_1; + var _local_6:Face = _arg_1.processNext; + while (((!(_local_6 == null)) && (!(_local_6.processNext == null)))) + { + _arg_1 = _arg_1.processNext; + _local_6 = _local_6.processNext.processNext; + }; + _local_6 = _arg_1.processNext; + _arg_1.processNext = null; + if (_local_5.processNext != null) + { + _local_5 = this.sortByAverageZ(_local_5); + } else + { + _local_2 = 0; + _local_3 = 0; + _local_4 = _local_5.wrapper; + while (_local_4 != null) + { + _local_2++; + _local_3 = (_local_3 + _local_4.vertex.cameraZ); + _local_4 = _local_4.next; + }; + _local_5.distance = (_local_3 / _local_2); + }; + if (_local_6.processNext != null) + { + _local_6 = this.sortByAverageZ(_local_6); + } else + { + _local_2 = 0; + _local_3 = 0; + _local_4 = _local_6.wrapper; + while (_local_4 != null) + { + _local_2++; + _local_3 = (_local_3 + _local_4.vertex.cameraZ); + _local_4 = _local_4.next; + }; + _local_6.distance = (_local_3 / _local_2); + }; + var _local_7:Boolean = (_local_5.distance > _local_6.distance); + if (_local_7) + { + _arg_1 = _local_5; + _local_5 = _local_5.processNext; + } else + { + _arg_1 = _local_6; + _local_6 = _local_6.processNext; + }; + var _local_8:Face = _arg_1; + while (true) + { + if (_local_5 == null) + { + _local_8.processNext = _local_6; + return (_arg_1); + }; + if (_local_6 == null) + { + _local_8.processNext = _local_5; + return (_arg_1); + }; + if (_local_7) + { + if (_local_5.distance > _local_6.distance) + { + _local_8 = _local_5; + _local_5 = _local_5.processNext; + } else + { + _local_8.processNext = _local_6; + _local_8 = _local_6; + _local_6 = _local_6.processNext; + _local_7 = false; + }; + } else + { + if (_local_6.distance > _local_5.distance) + { + _local_8 = _local_6; + _local_6 = _local_6.processNext; + } else + { + _local_8.processNext = _local_5; + _local_8 = _local_5; + _local_5 = _local_5.processNext; + _local_7 = true; + }; + }; + }; + return (null); + } + + alternativa3d function sortByDynamicBSP(_arg_1:Face, _arg_2:Number, _arg_3:Face=null):Face + { + var _local_4:Wrapper; + var _local_5:Vertex; + var _local_6:Vertex; + var _local_7:Vertex; + var _local_8:Vertex; + var _local_23:Face; + var _local_24:Face; + var _local_26:Face; + var _local_27:Face; + var _local_28:Face; + var _local_30:Number; + var _local_31:Number; + var _local_32:Number; + var _local_33:Number; + var _local_34:Number; + var _local_35:Number; + var _local_36:Number; + var _local_37:Number; + var _local_38:Number; + var _local_39:Number; + var _local_40:Boolean; + var _local_41:Boolean; + var _local_42:Number; + var _local_43:Face; + var _local_44:Face; + var _local_45:Wrapper; + var _local_46:Wrapper; + var _local_47:Wrapper; + var _local_48:Boolean; + var _local_49:Number; + var _local_9:Face = _arg_1; + _arg_1 = _local_9.processNext; + _local_4 = _local_9.wrapper; + _local_5 = _local_4.vertex; + _local_4 = _local_4.next; + _local_6 = _local_4.vertex; + var _local_10:Number = _local_5.cameraX; + var _local_11:Number = _local_5.cameraY; + var _local_12:Number = _local_5.cameraZ; + var _local_13:Number = (_local_6.cameraX - _local_10); + var _local_14:Number = (_local_6.cameraY - _local_11); + var _local_15:Number = (_local_6.cameraZ - _local_12); + var _local_16:Number = 0; + var _local_17:Number = 0; + var _local_18:Number = 1; + var _local_19:Number = _local_12; + var _local_20:Number = 0; + _local_4 = _local_4.next; + while (_local_4 != null) + { + _local_8 = _local_4.vertex; + _local_30 = (_local_8.cameraX - _local_10); + _local_31 = (_local_8.cameraY - _local_11); + _local_32 = (_local_8.cameraZ - _local_12); + _local_33 = ((_local_32 * _local_14) - (_local_31 * _local_15)); + _local_34 = ((_local_30 * _local_15) - (_local_32 * _local_13)); + _local_35 = ((_local_31 * _local_13) - (_local_30 * _local_14)); + _local_36 = (((_local_33 * _local_33) + (_local_34 * _local_34)) + (_local_35 * _local_35)); + if (_local_36 > _arg_2) + { + _local_36 = (1 / Math.sqrt(_local_36)); + _local_16 = (_local_33 * _local_36); + _local_17 = (_local_34 * _local_36); + _local_18 = (_local_35 * _local_36); + _local_19 = (((_local_10 * _local_16) + (_local_11 * _local_17)) + (_local_12 * _local_18)); + break; + }; + if (_local_36 > _local_20) + { + _local_36 = (1 / Math.sqrt(_local_36)); + _local_16 = (_local_33 * _local_36); + _local_17 = (_local_34 * _local_36); + _local_18 = (_local_35 * _local_36); + _local_19 = (((_local_10 * _local_16) + (_local_11 * _local_17)) + (_local_12 * _local_18)); + _local_20 = _local_36; + }; + _local_4 = _local_4.next; + }; + var _local_21:Number = (_local_19 - _arg_2); + var _local_22:Number = (_local_19 + _arg_2); + var _local_25:Face = _local_9; + var _local_29:Face = _arg_1; + while (_local_29 != null) + { + _local_28 = _local_29.processNext; + _local_4 = _local_29.wrapper; + _local_5 = _local_4.vertex; + _local_4 = _local_4.next; + _local_6 = _local_4.vertex; + _local_4 = _local_4.next; + _local_7 = _local_4.vertex; + _local_4 = _local_4.next; + _local_37 = (((_local_5.cameraX * _local_16) + (_local_5.cameraY * _local_17)) + (_local_5.cameraZ * _local_18)); + _local_38 = (((_local_6.cameraX * _local_16) + (_local_6.cameraY * _local_17)) + (_local_6.cameraZ * _local_18)); + _local_39 = (((_local_7.cameraX * _local_16) + (_local_7.cameraY * _local_17)) + (_local_7.cameraZ * _local_18)); + _local_40 = (((_local_37 < _local_21) || (_local_38 < _local_21)) || (_local_39 < _local_21)); + _local_41 = (((_local_37 > _local_22) || (_local_38 > _local_22)) || (_local_39 > _local_22)); + while (_local_4 != null) + { + _local_8 = _local_4.vertex; + _local_42 = (((_local_8.cameraX * _local_16) + (_local_8.cameraY * _local_17)) + (_local_8.cameraZ * _local_18)); + if (_local_42 < _local_21) + { + _local_40 = true; + } else + { + if (_local_42 > _local_22) + { + _local_41 = true; + }; + }; + _local_8.offset = _local_42; + _local_4 = _local_4.next; + }; + if ((!(_local_40))) + { + if ((!(_local_41))) + { + _local_25.processNext = _local_29; + _local_25 = _local_29; + } else + { + if (_local_26 != null) + { + _local_27.processNext = _local_29; + } else + { + _local_26 = _local_29; + }; + _local_27 = _local_29; + }; + } else + { + if ((!(_local_41))) + { + if (_local_23 != null) + { + _local_24.processNext = _local_29; + } else + { + _local_23 = _local_29; + }; + _local_24 = _local_29; + } else + { + _local_5.offset = _local_37; + _local_6.offset = _local_38; + _local_7.offset = _local_39; + _local_43 = _local_29.create(); + _local_43.material = _local_29.material; + this.lastFace.next = _local_43; + this.lastFace = _local_43; + _local_44 = _local_29.create(); + _local_44.material = _local_29.material; + this.lastFace.next = _local_44; + this.lastFace = _local_44; + _local_45 = null; + _local_46 = null; + _local_4 = _local_29.wrapper.next.next; + while (_local_4.next != null) + { + _local_4 = _local_4.next; + }; + _local_5 = _local_4.vertex; + _local_37 = _local_5.offset; + _local_48 = ((!(_local_29.material == null)) && (_local_29.material.useVerticesNormals)); + _local_4 = _local_29.wrapper; + while (_local_4 != null) + { + _local_6 = _local_4.vertex; + _local_38 = _local_6.offset; + if ((((_local_37 < _local_21) && (_local_38 > _local_22)) || ((_local_37 > _local_22) && (_local_38 < _local_21)))) + { + _local_49 = ((_local_19 - _local_37) / (_local_38 - _local_37)); + _local_8 = _local_6.create(); + this.lastVertex.next = _local_8; + this.lastVertex = _local_8; + _local_8.cameraX = (_local_5.cameraX + ((_local_6.cameraX - _local_5.cameraX) * _local_49)); + _local_8.cameraY = (_local_5.cameraY + ((_local_6.cameraY - _local_5.cameraY) * _local_49)); + _local_8.cameraZ = (_local_5.cameraZ + ((_local_6.cameraZ - _local_5.cameraZ) * _local_49)); + _local_8.u = (_local_5.u + ((_local_6.u - _local_5.u) * _local_49)); + _local_8.v = (_local_5.v + ((_local_6.v - _local_5.v) * _local_49)); + if (_local_48) + { + _local_8.x = (_local_5.x + ((_local_6.x - _local_5.x) * _local_49)); + _local_8.y = (_local_5.y + ((_local_6.y - _local_5.y) * _local_49)); + _local_8.z = (_local_5.z + ((_local_6.z - _local_5.z) * _local_49)); + _local_8.normalX = (_local_5.normalX + ((_local_6.normalX - _local_5.normalX) * _local_49)); + _local_8.normalY = (_local_5.normalY + ((_local_6.normalY - _local_5.normalY) * _local_49)); + _local_8.normalZ = (_local_5.normalZ + ((_local_6.normalZ - _local_5.normalZ) * _local_49)); + }; + _local_47 = _local_4.create(); + _local_47.vertex = _local_8; + if (_local_45 != null) + { + _local_45.next = _local_47; + } else + { + _local_43.wrapper = _local_47; + }; + _local_45 = _local_47; + _local_47 = _local_4.create(); + _local_47.vertex = _local_8; + if (_local_46 != null) + { + _local_46.next = _local_47; + } else + { + _local_44.wrapper = _local_47; + }; + _local_46 = _local_47; + }; + if (_local_38 <= _local_22) + { + _local_47 = _local_4.create(); + _local_47.vertex = _local_6; + if (_local_45 != null) + { + _local_45.next = _local_47; + } else + { + _local_43.wrapper = _local_47; + }; + _local_45 = _local_47; + }; + if (_local_38 >= _local_21) + { + _local_47 = _local_4.create(); + _local_47.vertex = _local_6; + if (_local_46 != null) + { + _local_46.next = _local_47; + } else + { + _local_44.wrapper = _local_47; + }; + _local_46 = _local_47; + }; + _local_5 = _local_6; + _local_37 = _local_38; + _local_4 = _local_4.next; + }; + if (_local_23 != null) + { + _local_24.processNext = _local_43; + } else + { + _local_23 = _local_43; + }; + _local_24 = _local_43; + if (_local_26 != null) + { + _local_27.processNext = _local_44; + } else + { + _local_26 = _local_44; + }; + _local_27 = _local_44; + _local_29.processNext = null; + }; + }; + _local_29 = _local_28; + }; + if (_local_26 != null) + { + _local_27.processNext = null; + if (_local_26.processNext != null) + { + _arg_3 = this.sortByDynamicBSP(_local_26, _arg_2, _arg_3); + } else + { + _local_26.processNext = _arg_3; + _arg_3 = _local_26; + }; + }; + _local_25.processNext = _arg_3; + _arg_3 = _local_9; + if (_local_23 != null) + { + _local_24.processNext = null; + if (_local_23.processNext != null) + { + _arg_3 = this.sortByDynamicBSP(_local_23, _arg_2, _arg_3); + } else + { + _local_23.processNext = _arg_3; + _arg_3 = _local_23; + }; + }; + return (_arg_3); + } + + alternativa3d function cull(_arg_1:Face, _arg_2:int):Face + { + var _local_3:Face; + var _local_4:Face; + var _local_5:Face; + var _local_6:Vertex; + var _local_7:Vertex; + var _local_8:Vertex; + var _local_9:Wrapper; + var _local_10:Vertex; + var _local_11:Wrapper; + var _local_12:Number; + var _local_13:Number; + var _local_14:Number; + var _local_15:Number; + var _local_16:Number; + var _local_17:Number; + var _local_18:Number; + var _local_19:Number; + var _local_20:Number; + var _local_21:Boolean = ((_arg_2 & 0x01) > 0); + var _local_22:Boolean = ((_arg_2 & 0x02) > 0); + var _local_23:Boolean = ((_arg_2 & 0x04) > 0); + var _local_24:Boolean = ((_arg_2 & 0x08) > 0); + var _local_25:Boolean = ((_arg_2 & 0x10) > 0); + var _local_26:Boolean = ((_arg_2 & 0x20) > 0); + var _local_27:Number = this.nearClipping; + var _local_28:Number = this.farClipping; + var _local_29:Boolean = ((_local_23) || (_local_24)); + var _local_30:Boolean = ((_local_25) || (_local_26)); + var _local_31:Face = _arg_1; + for (;_local_31 != null;(_local_31 = _local_5)) + { + _local_5 = _local_31.processNext; + _local_9 = _local_31.wrapper; + _local_6 = _local_9.vertex; + _local_9 = _local_9.next; + _local_7 = _local_9.vertex; + _local_9 = _local_9.next; + _local_8 = _local_9.vertex; + _local_9 = _local_9.next; + if (_local_29) + { + _local_12 = _local_6.cameraX; + _local_15 = _local_7.cameraX; + _local_18 = _local_8.cameraX; + }; + if (_local_30) + { + _local_13 = _local_6.cameraY; + _local_16 = _local_7.cameraY; + _local_19 = _local_8.cameraY; + }; + _local_14 = _local_6.cameraZ; + _local_17 = _local_7.cameraZ; + _local_20 = _local_8.cameraZ; + if (_local_21) + { + if ((((_local_14 <= _local_27) || (_local_17 <= _local_27)) || (_local_20 <= _local_27))) + { + _local_31.processNext = null; + continue; + }; + _local_11 = _local_9; + while (_local_11 != null) + { + if (_local_11.vertex.cameraZ <= _local_27) break; + _local_11 = _local_11.next; + }; + if (_local_11 != null) + { + _local_31.processNext = null; + continue; + }; + }; + if (((((_local_22) && (_local_14 >= _local_28)) && (_local_17 >= _local_28)) && (_local_20 >= _local_28))) + { + _local_11 = _local_9; + while (_local_11 != null) + { + if (_local_11.vertex.cameraZ < _local_28) break; + _local_11 = _local_11.next; + }; + if (_local_11 == null) + { + _local_31.processNext = null; + continue; + }; + }; + if (((((_local_23) && (_local_14 <= -(_local_12))) && (_local_17 <= -(_local_15))) && (_local_20 <= -(_local_18)))) + { + _local_11 = _local_9; + while (_local_11 != null) + { + _local_10 = _local_11.vertex; + if (-(_local_10.cameraX) < _local_10.cameraZ) break; + _local_11 = _local_11.next; + }; + if (_local_11 == null) + { + _local_31.processNext = null; + continue; + }; + }; + if (((((_local_24) && (_local_14 <= _local_12)) && (_local_17 <= _local_15)) && (_local_20 <= _local_18))) + { + _local_11 = _local_9; + while (_local_11 != null) + { + _local_10 = _local_11.vertex; + if (_local_10.cameraX < _local_10.cameraZ) break; + _local_11 = _local_11.next; + }; + if (_local_11 == null) + { + _local_31.processNext = null; + continue; + }; + }; + if (((((_local_25) && (_local_14 <= -(_local_13))) && (_local_17 <= -(_local_16))) && (_local_20 <= -(_local_19)))) + { + _local_11 = _local_9; + while (_local_11 != null) + { + _local_10 = _local_11.vertex; + if (-(_local_10.cameraY) < _local_10.cameraZ) break; + _local_11 = _local_11.next; + }; + if (_local_11 == null) + { + _local_31.processNext = null; + continue; + }; + }; + if (((((_local_26) && (_local_14 <= _local_13)) && (_local_17 <= _local_16)) && (_local_20 <= _local_19))) + { + _local_11 = _local_9; + while (_local_11 != null) + { + _local_10 = _local_11.vertex; + if (_local_10.cameraY < _local_10.cameraZ) break; + _local_11 = _local_11.next; + }; + if (_local_11 == null) + { + _local_31.processNext = null; + continue; + }; + }; + if (_local_3 != null) + { + _local_4.processNext = _local_31; + } else + { + _local_3 = _local_31; + }; + _local_4 = _local_31; + }; + if (_local_4 != null) + { + _local_4.processNext = null; + }; + return (_local_3); + } + + alternativa3d function clip(_arg_1:Face, _arg_2:int):Face + { + var _local_3:Face; + var _local_4:Face; + var _local_5:Face; + var _local_6:Vertex; + var _local_7:Vertex; + var _local_8:Vertex; + var _local_9:Wrapper; + var _local_10:Vertex; + var _local_11:Wrapper; + var _local_12:Wrapper; + var _local_13:Wrapper; + var _local_14:Wrapper; + var _local_15:Wrapper; + var _local_16:Number; + var _local_17:Number; + var _local_18:Number; + var _local_19:Number; + var _local_20:Number; + var _local_21:Number; + var _local_22:Number; + var _local_23:Number; + var _local_24:Number; + var _local_25:Boolean; + var _local_26:Boolean; + var _local_27:Boolean; + var _local_28:Boolean; + var _local_29:Boolean; + var _local_30:Boolean; + var _local_31:Number; + var _local_32:Number; + var _local_33:Boolean; + var _local_34:Boolean; + var _local_35:int; + var _local_36:Number; + var _local_37:Face; + var _local_38:Boolean; + var _local_39:Face; + _local_25 = ((_arg_2 & 0x01) > 0); + _local_26 = ((_arg_2 & 0x02) > 0); + _local_27 = ((_arg_2 & 0x04) > 0); + _local_28 = ((_arg_2 & 0x08) > 0); + _local_29 = ((_arg_2 & 0x10) > 0); + _local_30 = ((_arg_2 & 0x20) > 0); + _local_31 = this.nearClipping; + _local_32 = this.farClipping; + _local_33 = ((_local_27) || (_local_28)); + _local_34 = ((_local_29) || (_local_30)); + _local_37 = _arg_1; + for (;_local_37 != null;(_local_37 = _local_5)) + { + _local_5 = _local_37.processNext; + _local_9 = _local_37.wrapper; + _local_6 = _local_9.vertex; + _local_9 = _local_9.next; + _local_7 = _local_9.vertex; + _local_9 = _local_9.next; + _local_8 = _local_9.vertex; + _local_9 = _local_9.next; + if (_local_33) + { + _local_16 = _local_6.cameraX; + _local_19 = _local_7.cameraX; + _local_22 = _local_8.cameraX; + }; + if (_local_34) + { + _local_17 = _local_6.cameraY; + _local_20 = _local_7.cameraY; + _local_23 = _local_8.cameraY; + }; + _local_18 = _local_6.cameraZ; + _local_21 = _local_7.cameraZ; + _local_24 = _local_8.cameraZ; + _local_35 = 0; + if (_local_25) + { + if ((((_local_18 <= _local_31) && (_local_21 <= _local_31)) && (_local_24 <= _local_31))) + { + _local_11 = _local_9; + while (_local_11 != null) + { + if (_local_11.vertex.cameraZ > _local_31) + { + _local_35 = (_local_35 | 0x01); + break; + }; + _local_11 = _local_11.next; + }; + if (_local_11 == null) + { + _local_37.processNext = null; + continue; + }; + } else + { + if ((((_local_18 > _local_31) && (_local_21 > _local_31)) && (_local_24 > _local_31))) + { + _local_11 = _local_9; + while (_local_11 != null) + { + if (_local_11.vertex.cameraZ <= _local_31) + { + _local_35 = (_local_35 | 0x01); + break; + }; + _local_11 = _local_11.next; + }; + } else + { + _local_35 = (_local_35 | 0x01); + }; + }; + }; + if (_local_26) + { + if ((((_local_18 >= _local_32) && (_local_21 >= _local_32)) && (_local_24 >= _local_32))) + { + _local_11 = _local_9; + while (_local_11 != null) + { + if (_local_11.vertex.cameraZ < _local_32) + { + _local_35 = (_local_35 | 0x02); + break; + }; + _local_11 = _local_11.next; + }; + if (_local_11 == null) + { + _local_37.processNext = null; + continue; + }; + } else + { + if ((((_local_18 < _local_32) && (_local_21 < _local_32)) && (_local_24 < _local_32))) + { + _local_11 = _local_9; + while (_local_11 != null) + { + if (_local_11.vertex.cameraZ >= _local_32) + { + _local_35 = (_local_35 | 0x02); + break; + }; + _local_11 = _local_11.next; + }; + } else + { + _local_35 = (_local_35 | 0x02); + }; + }; + }; + if (_local_27) + { + if ((((_local_18 <= -(_local_16)) && (_local_21 <= -(_local_19))) && (_local_24 <= -(_local_22)))) + { + _local_11 = _local_9; + while (_local_11 != null) + { + _local_10 = _local_11.vertex; + if (-(_local_10.cameraX) < _local_10.cameraZ) + { + _local_35 = (_local_35 | 0x04); + break; + }; + _local_11 = _local_11.next; + }; + if (_local_11 == null) + { + _local_37.processNext = null; + continue; + }; + } else + { + if ((((_local_18 > -(_local_16)) && (_local_21 > -(_local_19))) && (_local_24 > -(_local_22)))) + { + _local_11 = _local_9; + while (_local_11 != null) + { + _local_10 = _local_11.vertex; + if (-(_local_10.cameraX) >= _local_10.cameraZ) + { + _local_35 = (_local_35 | 0x04); + break; + }; + _local_11 = _local_11.next; + }; + } else + { + _local_35 = (_local_35 | 0x04); + }; + }; + }; + if (_local_28) + { + if ((((_local_18 <= _local_16) && (_local_21 <= _local_19)) && (_local_24 <= _local_22))) + { + _local_11 = _local_9; + while (_local_11 != null) + { + _local_10 = _local_11.vertex; + if (_local_10.cameraX < _local_10.cameraZ) + { + _local_35 = (_local_35 | 0x08); + break; + }; + _local_11 = _local_11.next; + }; + if (_local_11 == null) + { + _local_37.processNext = null; + continue; + }; + } else + { + if ((((_local_18 > _local_16) && (_local_21 > _local_19)) && (_local_24 > _local_22))) + { + _local_11 = _local_9; + while (_local_11 != null) + { + _local_10 = _local_11.vertex; + if (_local_10.cameraX >= _local_10.cameraZ) + { + _local_35 = (_local_35 | 0x08); + break; + }; + _local_11 = _local_11.next; + }; + } else + { + _local_35 = (_local_35 | 0x08); + }; + }; + }; + if (_local_29) + { + if ((((_local_18 <= -(_local_17)) && (_local_21 <= -(_local_20))) && (_local_24 <= -(_local_23)))) + { + _local_11 = _local_9; + while (_local_11 != null) + { + _local_10 = _local_11.vertex; + if (-(_local_10.cameraY) < _local_10.cameraZ) + { + _local_35 = (_local_35 | 0x10); + break; + }; + _local_11 = _local_11.next; + }; + if (_local_11 == null) + { + _local_37.processNext = null; + continue; + }; + } else + { + if ((((_local_18 > -(_local_17)) && (_local_21 > -(_local_20))) && (_local_24 > -(_local_23)))) + { + _local_11 = _local_9; + while (_local_11 != null) + { + _local_10 = _local_11.vertex; + if (-(_local_10.cameraY) >= _local_10.cameraZ) + { + _local_35 = (_local_35 | 0x10); + break; + }; + _local_11 = _local_11.next; + }; + } else + { + _local_35 = (_local_35 | 0x10); + }; + }; + }; + if (_local_30) + { + if ((((_local_18 <= _local_17) && (_local_21 <= _local_20)) && (_local_24 <= _local_23))) + { + _local_11 = _local_9; + while (_local_11 != null) + { + _local_10 = _local_11.vertex; + if (_local_10.cameraY < _local_10.cameraZ) + { + _local_35 = (_local_35 | 0x20); + break; + }; + _local_11 = _local_11.next; + }; + if (_local_11 == null) + { + _local_37.processNext = null; + continue; + }; + } else + { + if ((((_local_18 > _local_17) && (_local_21 > _local_20)) && (_local_24 > _local_23))) + { + _local_11 = _local_9; + while (_local_11 != null) + { + _local_10 = _local_11.vertex; + if (_local_10.cameraY >= _local_10.cameraZ) + { + _local_35 = (_local_35 | 0x20); + break; + }; + _local_11 = _local_11.next; + }; + } else + { + _local_35 = (_local_35 | 0x20); + }; + }; + }; + if (_local_35 > 0) + { + _local_38 = ((!(_local_37.material == null)) && (_local_37.material.useVerticesNormals)); + _local_12 = null; + _local_13 = null; + _local_11 = _local_37.wrapper; + while (_local_11 != null) + { + _local_15 = _local_11.create(); + _local_15.vertex = _local_11.vertex; + if (_local_12 != null) + { + _local_13.next = _local_15; + } else + { + _local_12 = _local_15; + }; + _local_13 = _local_15; + _local_11 = _local_11.next; + }; + if ((_local_35 & 0x01)) + { + _local_6 = _local_13.vertex; + _local_18 = _local_6.cameraZ; + _local_11 = _local_12; + _local_12 = null; + _local_13 = null; + while (_local_11 != null) + { + _local_14 = _local_11.next; + _local_7 = _local_11.vertex; + _local_21 = _local_7.cameraZ; + if ((((_local_21 > _local_31) && (_local_18 <= _local_31)) || ((_local_21 <= _local_31) && (_local_18 > _local_31)))) + { + _local_36 = ((_local_31 - _local_18) / (_local_21 - _local_18)); + _local_10 = _local_7.create(); + this.lastVertex.next = _local_10; + this.lastVertex = _local_10; + _local_10.cameraX = (_local_6.cameraX + ((_local_7.cameraX - _local_6.cameraX) * _local_36)); + _local_10.cameraY = (_local_6.cameraY + ((_local_7.cameraY - _local_6.cameraY) * _local_36)); + _local_10.cameraZ = (_local_18 + ((_local_21 - _local_18) * _local_36)); + _local_10.x = (_local_6.x + ((_local_7.x - _local_6.x) * _local_36)); + _local_10.y = (_local_6.y + ((_local_7.y - _local_6.y) * _local_36)); + _local_10.z = (_local_6.z + ((_local_7.z - _local_6.z) * _local_36)); + _local_10.u = (_local_6.u + ((_local_7.u - _local_6.u) * _local_36)); + _local_10.v = (_local_6.v + ((_local_7.v - _local_6.v) * _local_36)); + if (_local_38) + { + _local_10.normalX = (_local_6.normalX + ((_local_7.normalX - _local_6.normalX) * _local_36)); + _local_10.normalY = (_local_6.normalY + ((_local_7.normalY - _local_6.normalY) * _local_36)); + _local_10.normalZ = (_local_6.normalZ + ((_local_7.normalZ - _local_6.normalZ) * _local_36)); + }; + _local_15 = _local_11.create(); + _local_15.vertex = _local_10; + if (_local_12 != null) + { + _local_13.next = _local_15; + } else + { + _local_12 = _local_15; + }; + _local_13 = _local_15; + }; + if (_local_21 > _local_31) + { + if (_local_12 != null) + { + _local_13.next = _local_11; + } else + { + _local_12 = _local_11; + }; + _local_13 = _local_11; + _local_11.next = null; + } else + { + _local_11.vertex = null; + _local_11.next = Wrapper.collector; + Wrapper.collector = _local_11; + }; + _local_6 = _local_7; + _local_18 = _local_21; + _local_11 = _local_14; + }; + if (_local_12 == null) + { + _local_37.processNext = null; + continue; + }; + }; + if ((_local_35 & 0x02)) + { + _local_6 = _local_13.vertex; + _local_18 = _local_6.cameraZ; + _local_11 = _local_12; + _local_12 = null; + _local_13 = null; + while (_local_11 != null) + { + _local_14 = _local_11.next; + _local_7 = _local_11.vertex; + _local_21 = _local_7.cameraZ; + if ((((_local_21 < _local_32) && (_local_18 >= _local_32)) || ((_local_21 >= _local_32) && (_local_18 < _local_32)))) + { + _local_36 = ((_local_32 - _local_18) / (_local_21 - _local_18)); + _local_10 = _local_7.create(); + this.lastVertex.next = _local_10; + this.lastVertex = _local_10; + _local_10.cameraX = (_local_6.cameraX + ((_local_7.cameraX - _local_6.cameraX) * _local_36)); + _local_10.cameraY = (_local_6.cameraY + ((_local_7.cameraY - _local_6.cameraY) * _local_36)); + _local_10.cameraZ = (_local_18 + ((_local_21 - _local_18) * _local_36)); + _local_10.x = (_local_6.x + ((_local_7.x - _local_6.x) * _local_36)); + _local_10.y = (_local_6.y + ((_local_7.y - _local_6.y) * _local_36)); + _local_10.z = (_local_6.z + ((_local_7.z - _local_6.z) * _local_36)); + _local_10.u = (_local_6.u + ((_local_7.u - _local_6.u) * _local_36)); + _local_10.v = (_local_6.v + ((_local_7.v - _local_6.v) * _local_36)); + if (_local_38) + { + _local_10.normalX = (_local_6.normalX + ((_local_7.normalX - _local_6.normalX) * _local_36)); + _local_10.normalY = (_local_6.normalY + ((_local_7.normalY - _local_6.normalY) * _local_36)); + _local_10.normalZ = (_local_6.normalZ + ((_local_7.normalZ - _local_6.normalZ) * _local_36)); + }; + _local_15 = _local_11.create(); + _local_15.vertex = _local_10; + if (_local_12 != null) + { + _local_13.next = _local_15; + } else + { + _local_12 = _local_15; + }; + _local_13 = _local_15; + }; + if (_local_21 < _local_32) + { + if (_local_12 != null) + { + _local_13.next = _local_11; + } else + { + _local_12 = _local_11; + }; + _local_13 = _local_11; + _local_11.next = null; + } else + { + _local_11.vertex = null; + _local_11.next = Wrapper.collector; + Wrapper.collector = _local_11; + }; + _local_6 = _local_7; + _local_18 = _local_21; + _local_11 = _local_14; + }; + if (_local_12 == null) + { + _local_37.processNext = null; + continue; + }; + }; + if ((_local_35 & 0x04)) + { + _local_6 = _local_13.vertex; + _local_16 = _local_6.cameraX; + _local_18 = _local_6.cameraZ; + _local_11 = _local_12; + _local_12 = null; + _local_13 = null; + while (_local_11 != null) + { + _local_14 = _local_11.next; + _local_7 = _local_11.vertex; + _local_19 = _local_7.cameraX; + _local_21 = _local_7.cameraZ; + if ((((_local_21 > -(_local_19)) && (_local_18 <= -(_local_16))) || ((_local_21 <= -(_local_19)) && (_local_18 > -(_local_16))))) + { + _local_36 = ((_local_16 + _local_18) / (((_local_16 + _local_18) - _local_19) - _local_21)); + _local_10 = _local_7.create(); + this.lastVertex.next = _local_10; + this.lastVertex = _local_10; + _local_10.cameraX = (_local_16 + ((_local_19 - _local_16) * _local_36)); + _local_10.cameraY = (_local_6.cameraY + ((_local_7.cameraY - _local_6.cameraY) * _local_36)); + _local_10.cameraZ = (_local_18 + ((_local_21 - _local_18) * _local_36)); + _local_10.x = (_local_6.x + ((_local_7.x - _local_6.x) * _local_36)); + _local_10.y = (_local_6.y + ((_local_7.y - _local_6.y) * _local_36)); + _local_10.z = (_local_6.z + ((_local_7.z - _local_6.z) * _local_36)); + _local_10.u = (_local_6.u + ((_local_7.u - _local_6.u) * _local_36)); + _local_10.v = (_local_6.v + ((_local_7.v - _local_6.v) * _local_36)); + if (_local_38) + { + _local_10.normalX = (_local_6.normalX + ((_local_7.normalX - _local_6.normalX) * _local_36)); + _local_10.normalY = (_local_6.normalY + ((_local_7.normalY - _local_6.normalY) * _local_36)); + _local_10.normalZ = (_local_6.normalZ + ((_local_7.normalZ - _local_6.normalZ) * _local_36)); + }; + _local_15 = _local_11.create(); + _local_15.vertex = _local_10; + if (_local_12 != null) + { + _local_13.next = _local_15; + } else + { + _local_12 = _local_15; + }; + _local_13 = _local_15; + }; + if (_local_21 > -(_local_19)) + { + if (_local_12 != null) + { + _local_13.next = _local_11; + } else + { + _local_12 = _local_11; + }; + _local_13 = _local_11; + _local_11.next = null; + } else + { + _local_11.vertex = null; + _local_11.next = Wrapper.collector; + Wrapper.collector = _local_11; + }; + _local_6 = _local_7; + _local_16 = _local_19; + _local_18 = _local_21; + _local_11 = _local_14; + }; + if (_local_12 == null) + { + _local_37.processNext = null; + continue; + }; + }; + if ((_local_35 & 0x08)) + { + _local_6 = _local_13.vertex; + _local_16 = _local_6.cameraX; + _local_18 = _local_6.cameraZ; + _local_11 = _local_12; + _local_12 = null; + _local_13 = null; + while (_local_11 != null) + { + _local_14 = _local_11.next; + _local_7 = _local_11.vertex; + _local_19 = _local_7.cameraX; + _local_21 = _local_7.cameraZ; + if ((((_local_21 > _local_19) && (_local_18 <= _local_16)) || ((_local_21 <= _local_19) && (_local_18 > _local_16)))) + { + _local_36 = ((_local_18 - _local_16) / (((_local_18 - _local_16) + _local_19) - _local_21)); + _local_10 = _local_7.create(); + this.lastVertex.next = _local_10; + this.lastVertex = _local_10; + _local_10.cameraX = (_local_16 + ((_local_19 - _local_16) * _local_36)); + _local_10.cameraY = (_local_6.cameraY + ((_local_7.cameraY - _local_6.cameraY) * _local_36)); + _local_10.cameraZ = (_local_18 + ((_local_21 - _local_18) * _local_36)); + _local_10.x = (_local_6.x + ((_local_7.x - _local_6.x) * _local_36)); + _local_10.y = (_local_6.y + ((_local_7.y - _local_6.y) * _local_36)); + _local_10.z = (_local_6.z + ((_local_7.z - _local_6.z) * _local_36)); + _local_10.u = (_local_6.u + ((_local_7.u - _local_6.u) * _local_36)); + _local_10.v = (_local_6.v + ((_local_7.v - _local_6.v) * _local_36)); + if (_local_38) + { + _local_10.normalX = (_local_6.normalX + ((_local_7.normalX - _local_6.normalX) * _local_36)); + _local_10.normalY = (_local_6.normalY + ((_local_7.normalY - _local_6.normalY) * _local_36)); + _local_10.normalZ = (_local_6.normalZ + ((_local_7.normalZ - _local_6.normalZ) * _local_36)); + }; + _local_15 = _local_11.create(); + _local_15.vertex = _local_10; + if (_local_12 != null) + { + _local_13.next = _local_15; + } else + { + _local_12 = _local_15; + }; + _local_13 = _local_15; + }; + if (_local_21 > _local_19) + { + if (_local_12 != null) + { + _local_13.next = _local_11; + } else + { + _local_12 = _local_11; + }; + _local_13 = _local_11; + _local_11.next = null; + } else + { + _local_11.vertex = null; + _local_11.next = Wrapper.collector; + Wrapper.collector = _local_11; + }; + _local_6 = _local_7; + _local_16 = _local_19; + _local_18 = _local_21; + _local_11 = _local_14; + }; + if (_local_12 == null) + { + _local_37.processNext = null; + continue; + }; + }; + if ((_local_35 & 0x10)) + { + _local_6 = _local_13.vertex; + _local_17 = _local_6.cameraY; + _local_18 = _local_6.cameraZ; + _local_11 = _local_12; + _local_12 = null; + _local_13 = null; + while (_local_11 != null) + { + _local_14 = _local_11.next; + _local_7 = _local_11.vertex; + _local_20 = _local_7.cameraY; + _local_21 = _local_7.cameraZ; + if ((((_local_21 > -(_local_20)) && (_local_18 <= -(_local_17))) || ((_local_21 <= -(_local_20)) && (_local_18 > -(_local_17))))) + { + _local_36 = ((_local_17 + _local_18) / (((_local_17 + _local_18) - _local_20) - _local_21)); + _local_10 = _local_7.create(); + this.lastVertex.next = _local_10; + this.lastVertex = _local_10; + _local_10.cameraX = (_local_6.cameraX + ((_local_7.cameraX - _local_6.cameraX) * _local_36)); + _local_10.cameraY = (_local_17 + ((_local_20 - _local_17) * _local_36)); + _local_10.cameraZ = (_local_18 + ((_local_21 - _local_18) * _local_36)); + _local_10.x = (_local_6.x + ((_local_7.x - _local_6.x) * _local_36)); + _local_10.y = (_local_6.y + ((_local_7.y - _local_6.y) * _local_36)); + _local_10.z = (_local_6.z + ((_local_7.z - _local_6.z) * _local_36)); + _local_10.u = (_local_6.u + ((_local_7.u - _local_6.u) * _local_36)); + _local_10.v = (_local_6.v + ((_local_7.v - _local_6.v) * _local_36)); + if (_local_38) + { + _local_10.normalX = (_local_6.normalX + ((_local_7.normalX - _local_6.normalX) * _local_36)); + _local_10.normalY = (_local_6.normalY + ((_local_7.normalY - _local_6.normalY) * _local_36)); + _local_10.normalZ = (_local_6.normalZ + ((_local_7.normalZ - _local_6.normalZ) * _local_36)); + }; + _local_15 = _local_11.create(); + _local_15.vertex = _local_10; + if (_local_12 != null) + { + _local_13.next = _local_15; + } else + { + _local_12 = _local_15; + }; + _local_13 = _local_15; + }; + if (_local_21 > -(_local_20)) + { + if (_local_12 != null) + { + _local_13.next = _local_11; + } else + { + _local_12 = _local_11; + }; + _local_13 = _local_11; + _local_11.next = null; + } else + { + _local_11.vertex = null; + _local_11.next = Wrapper.collector; + Wrapper.collector = _local_11; + }; + _local_6 = _local_7; + _local_17 = _local_20; + _local_18 = _local_21; + _local_11 = _local_14; + }; + if (_local_12 == null) + { + _local_37.processNext = null; + continue; + }; + }; + if ((_local_35 & 0x20)) + { + _local_6 = _local_13.vertex; + _local_17 = _local_6.cameraY; + _local_18 = _local_6.cameraZ; + _local_11 = _local_12; + _local_12 = null; + _local_13 = null; + while (_local_11 != null) + { + _local_14 = _local_11.next; + _local_7 = _local_11.vertex; + _local_20 = _local_7.cameraY; + _local_21 = _local_7.cameraZ; + if ((((_local_21 > _local_20) && (_local_18 <= _local_17)) || ((_local_21 <= _local_20) && (_local_18 > _local_17)))) + { + _local_36 = ((_local_18 - _local_17) / (((_local_18 - _local_17) + _local_20) - _local_21)); + _local_10 = _local_7.create(); + this.lastVertex.next = _local_10; + this.lastVertex = _local_10; + _local_10.cameraX = (_local_6.cameraX + ((_local_7.cameraX - _local_6.cameraX) * _local_36)); + _local_10.cameraY = (_local_17 + ((_local_20 - _local_17) * _local_36)); + _local_10.cameraZ = (_local_18 + ((_local_21 - _local_18) * _local_36)); + _local_10.x = (_local_6.x + ((_local_7.x - _local_6.x) * _local_36)); + _local_10.y = (_local_6.y + ((_local_7.y - _local_6.y) * _local_36)); + _local_10.z = (_local_6.z + ((_local_7.z - _local_6.z) * _local_36)); + _local_10.u = (_local_6.u + ((_local_7.u - _local_6.u) * _local_36)); + _local_10.v = (_local_6.v + ((_local_7.v - _local_6.v) * _local_36)); + if (_local_38) + { + _local_10.normalX = (_local_6.normalX + ((_local_7.normalX - _local_6.normalX) * _local_36)); + _local_10.normalY = (_local_6.normalY + ((_local_7.normalY - _local_6.normalY) * _local_36)); + _local_10.normalZ = (_local_6.normalZ + ((_local_7.normalZ - _local_6.normalZ) * _local_36)); + }; + _local_15 = _local_11.create(); + _local_15.vertex = _local_10; + if (_local_12 != null) + { + _local_13.next = _local_15; + } else + { + _local_12 = _local_15; + }; + _local_13 = _local_15; + }; + if (_local_21 > _local_20) + { + if (_local_12 != null) + { + _local_13.next = _local_11; + } else + { + _local_12 = _local_11; + }; + _local_13 = _local_11; + _local_11.next = null; + } else + { + _local_11.vertex = null; + _local_11.next = Wrapper.collector; + Wrapper.collector = _local_11; + }; + _local_6 = _local_7; + _local_17 = _local_20; + _local_18 = _local_21; + _local_11 = _local_14; + }; + if (_local_12 == null) + { + _local_37.processNext = null; + continue; + }; + }; + _local_37.processNext = null; + _local_39 = _local_37.create(); + _local_39.material = _local_37.material; + this.lastFace.next = _local_39; + this.lastFace = _local_39; + _local_39.wrapper = _local_12; + _local_37 = _local_39; + }; + if (_local_3 != null) + { + _local_4.processNext = _local_37; + } else + { + _local_3 = _local_37; + }; + _local_4 = _local_37; + }; + if (_local_4 != null) + { + _local_4.processNext = null; + }; + return (_local_3); + } + + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/Canvas.as b/src/alternativa/engine3d/core/Canvas.as new file mode 100644 index 0000000..5dff59c --- /dev/null +++ b/src/alternativa/engine3d/core/Canvas.as @@ -0,0 +1,14 @@ +package alternativa.engine3d.core +{ + import flash.display.Sprite; + + public class Canvas extends Sprite + { + + + public function Canvas() + { + super(); + } + } +} diff --git a/src/alternativa/engine3d/core/Clipping.as b/src/alternativa/engine3d/core/Clipping.as new file mode 100644 index 0000000..e4c0086 --- /dev/null +++ b/src/alternativa/engine3d/core/Clipping.as @@ -0,0 +1,18 @@ +package alternativa.engine3d.core +{ + public class Clipping + { + + public static const BOUND_CULLING:int = 0; + + public static const FACE_CULLING:int = 1; + + public static const FACE_CLIPPING:int = 2; + + + public function Clipping() + { + super(); + } + } +} diff --git a/src/alternativa/engine3d/core/Debug.as b/src/alternativa/engine3d/core/Debug.as new file mode 100644 index 0000000..ed3b6e1 --- /dev/null +++ b/src/alternativa/engine3d/core/Debug.as @@ -0,0 +1,257 @@ +package alternativa.engine3d.core +{ + import flash.display.Sprite; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa.engine3d.alternativa3d; + + public class Debug + { + + public static const BOUNDS:int = 8; + public static const EDGES:int = 16; + public static const NODES:int = 128; + public static const LIGHTS:int = 0x0100; + public static const BONES:int = 0x0200; + private static const boundVertexList:Vertex = Vertex.createList(8); + private static const nodeVertexList:Vertex = Vertex.createList(4); + + + alternativa3d static function drawEdges(_arg_1:Camera3D, _arg_2:Face, _arg_3:int):void + { + var _local_6:Number; + var _local_9:Wrapper; + var _local_10:Vertex; + var _local_11:Number; + var _local_12:Number; + var _local_4:Number = _arg_1.viewSizeX; + var _local_5:Number = _arg_1.viewSizeY; + var _local_7:Sprite = _arg_1.view.canvas; + _local_7.graphics.lineStyle(0, _arg_3); + var _local_8:Face = _arg_2; + while (_local_8 != null) + { + _local_9 = _local_8.wrapper; + _local_10 = _local_9.vertex; + _local_6 = (1 / _local_10.cameraZ); + _local_11 = ((_local_10.cameraX * _local_4) * _local_6); + _local_12 = ((_local_10.cameraY * _local_5) * _local_6); + _local_7.graphics.moveTo(_local_11, _local_12); + _local_9 = _local_9.next; + while (_local_9 != null) + { + _local_10 = _local_9.vertex; + _local_6 = (1 / _local_10.cameraZ); + _local_7.graphics.lineTo(((_local_10.cameraX * _local_4) * _local_6), ((_local_10.cameraY * _local_5) * _local_6)); + _local_9 = _local_9.next; + }; + _local_7.graphics.lineTo(_local_11, _local_12); + _local_8 = _local_8.processNext; + }; + } + + alternativa3d static function drawBounds(_arg_1:Camera3D, _arg_2:Object3D, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Number, _arg_9:int=-1, _arg_10:Number=1):void + { + var _local_11:Vertex; + var _local_23:Number; + var _local_12:Vertex = boundVertexList; + _local_12.x = _arg_3; + _local_12.y = _arg_4; + _local_12.z = _arg_5; + var _local_13:Vertex = _local_12.next; + _local_13.x = _arg_6; + _local_13.y = _arg_4; + _local_13.z = _arg_5; + var _local_14:Vertex = _local_13.next; + _local_14.x = _arg_3; + _local_14.y = _arg_7; + _local_14.z = _arg_5; + var _local_15:Vertex = _local_14.next; + _local_15.x = _arg_6; + _local_15.y = _arg_7; + _local_15.z = _arg_5; + var _local_16:Vertex = _local_15.next; + _local_16.x = _arg_3; + _local_16.y = _arg_4; + _local_16.z = _arg_8; + var _local_17:Vertex = _local_16.next; + _local_17.x = _arg_6; + _local_17.y = _arg_4; + _local_17.z = _arg_8; + var _local_18:Vertex = _local_17.next; + _local_18.x = _arg_3; + _local_18.y = _arg_7; + _local_18.z = _arg_8; + var _local_19:Vertex = _local_18.next; + _local_19.x = _arg_6; + _local_19.y = _arg_7; + _local_19.z = _arg_8; + _local_11 = _local_12; + while (_local_11 != null) + { + _local_11.cameraX = ((((_arg_2.ma * _local_11.x) + (_arg_2.mb * _local_11.y)) + (_arg_2.mc * _local_11.z)) + _arg_2.md); + _local_11.cameraY = ((((_arg_2.me * _local_11.x) + (_arg_2.mf * _local_11.y)) + (_arg_2.mg * _local_11.z)) + _arg_2.mh); + _local_11.cameraZ = ((((_arg_2.mi * _local_11.x) + (_arg_2.mj * _local_11.y)) + (_arg_2.mk * _local_11.z)) + _arg_2.ml); + if (_local_11.cameraZ <= 0) + { + return; + }; + _local_11 = _local_11.next; + }; + var _local_20:Number = _arg_1.viewSizeX; + var _local_21:Number = _arg_1.viewSizeY; + _local_11 = _local_12; + while (_local_11 != null) + { + _local_23 = (1 / _local_11.cameraZ); + _local_11.cameraX = ((_local_11.cameraX * _local_20) * _local_23); + _local_11.cameraY = ((_local_11.cameraY * _local_21) * _local_23); + _local_11 = _local_11.next; + }; + var _local_22:Sprite = _arg_1.view.canvas; + _local_22.graphics.lineStyle(0, ((_arg_9 < 0) ? ((_arg_2.culling > 0) ? 0xFFFF00 : 0xFF00) : _arg_9), _arg_10); + _local_22.graphics.moveTo(_local_12.cameraX, _local_12.cameraY); + _local_22.graphics.lineTo(_local_13.cameraX, _local_13.cameraY); + _local_22.graphics.lineTo(_local_15.cameraX, _local_15.cameraY); + _local_22.graphics.lineTo(_local_14.cameraX, _local_14.cameraY); + _local_22.graphics.lineTo(_local_12.cameraX, _local_12.cameraY); + _local_22.graphics.moveTo(_local_16.cameraX, _local_16.cameraY); + _local_22.graphics.lineTo(_local_17.cameraX, _local_17.cameraY); + _local_22.graphics.lineTo(_local_19.cameraX, _local_19.cameraY); + _local_22.graphics.lineTo(_local_18.cameraX, _local_18.cameraY); + _local_22.graphics.lineTo(_local_16.cameraX, _local_16.cameraY); + _local_22.graphics.moveTo(_local_12.cameraX, _local_12.cameraY); + _local_22.graphics.lineTo(_local_16.cameraX, _local_16.cameraY); + _local_22.graphics.moveTo(_local_13.cameraX, _local_13.cameraY); + _local_22.graphics.lineTo(_local_17.cameraX, _local_17.cameraY); + _local_22.graphics.moveTo(_local_15.cameraX, _local_15.cameraY); + _local_22.graphics.lineTo(_local_19.cameraX, _local_19.cameraY); + _local_22.graphics.moveTo(_local_14.cameraX, _local_14.cameraY); + _local_22.graphics.lineTo(_local_18.cameraX, _local_18.cameraY); + } + + alternativa3d static function drawKDNode(_arg_1:Camera3D, _arg_2:Object3D, _arg_3:int, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Number, _arg_9:Number, _arg_10:Number, _arg_11:Number):void + { + var _local_12:Vertex; + var _local_20:Number; + var _local_13:Vertex = nodeVertexList; + var _local_14:Vertex = _local_13.next; + var _local_15:Vertex = _local_14.next; + var _local_16:Vertex = _local_15.next; + if (_arg_3 == 0) + { + _local_13.x = _arg_4; + _local_13.y = _arg_6; + _local_13.z = _arg_10; + _local_14.x = _arg_4; + _local_14.y = _arg_9; + _local_14.z = _arg_10; + _local_15.x = _arg_4; + _local_15.y = _arg_9; + _local_15.z = _arg_7; + _local_16.x = _arg_4; + _local_16.y = _arg_6; + _local_16.z = _arg_7; + } else + { + if (_arg_3 == 1) + { + _local_13.x = _arg_8; + _local_13.y = _arg_4; + _local_13.z = _arg_10; + _local_14.x = _arg_5; + _local_14.y = _arg_4; + _local_14.z = _arg_10; + _local_15.x = _arg_5; + _local_15.y = _arg_4; + _local_15.z = _arg_7; + _local_16.x = _arg_8; + _local_16.y = _arg_4; + _local_16.z = _arg_7; + } else + { + _local_13.x = _arg_5; + _local_13.y = _arg_6; + _local_13.z = _arg_4; + _local_14.x = _arg_8; + _local_14.y = _arg_6; + _local_14.z = _arg_4; + _local_15.x = _arg_8; + _local_15.y = _arg_9; + _local_15.z = _arg_4; + _local_16.x = _arg_5; + _local_16.y = _arg_9; + _local_16.z = _arg_4; + }; + }; + _local_12 = _local_13; + while (_local_12 != null) + { + _local_12.cameraX = ((((_arg_2.ma * _local_12.x) + (_arg_2.mb * _local_12.y)) + (_arg_2.mc * _local_12.z)) + _arg_2.md); + _local_12.cameraY = ((((_arg_2.me * _local_12.x) + (_arg_2.mf * _local_12.y)) + (_arg_2.mg * _local_12.z)) + _arg_2.mh); + _local_12.cameraZ = ((((_arg_2.mi * _local_12.x) + (_arg_2.mj * _local_12.y)) + (_arg_2.mk * _local_12.z)) + _arg_2.ml); + if (_local_12.cameraZ <= 0) + { + return; + }; + _local_12 = _local_12.next; + }; + var _local_17:Number = _arg_1.viewSizeX; + var _local_18:Number = _arg_1.viewSizeY; + _local_12 = _local_13; + while (_local_12 != null) + { + _local_20 = (1 / _local_12.cameraZ); + _local_12.cameraX = ((_local_12.cameraX * _local_17) * _local_20); + _local_12.cameraY = ((_local_12.cameraY * _local_18) * _local_20); + _local_12 = _local_12.next; + }; + var _local_19:Sprite = _arg_1.view.canvas; + _local_19.graphics.lineStyle(0, ((_arg_3 == 0) ? 0xFF0000 : ((_arg_3 == 1) ? 0xFF00 : 0xFF)), _arg_11); + _local_19.graphics.moveTo(_local_13.cameraX, _local_13.cameraY); + _local_19.graphics.lineTo(_local_14.cameraX, _local_14.cameraY); + _local_19.graphics.lineTo(_local_15.cameraX, _local_15.cameraY); + _local_19.graphics.lineTo(_local_16.cameraX, _local_16.cameraY); + _local_19.graphics.lineTo(_local_13.cameraX, _local_13.cameraY); + } + + alternativa3d static function drawBone(_arg_1:Camera3D, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:int):void + { + var _local_11:Number; + var _local_12:Number; + var _local_13:Number; + var _local_14:Number; + var _local_15:Sprite; + var _local_8:Number = (_arg_4 - _arg_2); + var _local_9:Number = (_arg_5 - _arg_3); + var _local_10:Number = Math.sqrt(((_local_8 * _local_8) + (_local_9 * _local_9))); + if (_local_10 > 0.001) + { + _local_8 = (_local_8 / _local_10); + _local_9 = (_local_9 / _local_10); + _local_11 = (_local_9 * _arg_6); + _local_12 = (-(_local_8) * _arg_6); + _local_13 = (-(_local_9) * _arg_6); + _local_14 = (_local_8 * _arg_6); + if (_local_10 > (_arg_6 * 2)) + { + _local_10 = _arg_6; + } else + { + _local_10 = (_local_10 / 2); + }; + _local_15 = _arg_1.view.canvas; + _local_15.graphics.lineStyle(1, _arg_7); + _local_15.graphics.beginFill(_arg_7, 0.6); + _local_15.graphics.moveTo(_arg_2, _arg_3); + _local_15.graphics.lineTo(((_arg_2 + (_local_8 * _local_10)) + _local_11), ((_arg_3 + (_local_9 * _local_10)) + _local_12)); + _local_15.graphics.lineTo(_arg_4, _arg_5); + _local_15.graphics.lineTo(((_arg_2 + (_local_8 * _local_10)) + _local_13), ((_arg_3 + (_local_9 * _local_10)) + _local_14)); + _local_15.graphics.lineTo(_arg_2, _arg_3); + _local_15.graphics.endFill(); + }; + } + + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/DepthRenderer.as b/src/alternativa/engine3d/core/DepthRenderer.as new file mode 100644 index 0000000..b4d640a --- /dev/null +++ b/src/alternativa/engine3d/core/DepthRenderer.as @@ -0,0 +1,770 @@ +package alternativa.engine3d.core{ + import __AS3__.vec.Vector; + import alternativa.gfx.core.ProgramResource; + import alternativa.gfx.core.VertexBufferResource; + import alternativa.gfx.core.IndexBufferResource; + import alternativa.gfx.core.RenderTargetTextureResource; + import flash.geom.Rectangle; + import alternativa.gfx.core.BitmapTextureResource; + import flash.display.BitmapData; + import alternativa.engine3d.materials.TextureMaterial; + import alternativa.engine3d.objects.Mesh; + import alternativa.engine3d.objects.BSP; + import alternativa.engine3d.lights.OmniLight; + import alternativa.engine3d.lights.SpotLight; + import alternativa.engine3d.lights.TubeLight; + import alternativa.gfx.core.Device; + import flash.display3D.Context3DProgramType; + import flash.display3D.Context3DVertexBufferFormat; + import flash.display3D.Context3DBlendFactor; + import flash.utils.ByteArray; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class DepthRenderer { + + private static const limit2const:int = 62; + private static const limit5const:int = 24; + + private var depthPrograms:Array = new Array(); + private var correction:Vector. = Vector.([0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0.5]); + private var depthFragment:Vector. = Vector.([(1 / 0xFF), 0, 0, 1, 0.5, 0.5, 0, 1]); + private var alphaTestConst:Vector. = Vector.([0, 0, 0, 1]); + private var ssaoProgram:ProgramResource; + private var ssaoVertexBuffer:VertexBufferResource = new VertexBufferResource(Vector.([-1, 1, 0, 0, 0, -1, -1, 0, 0, 1, 1, -1, 0, 1, 1, 1, 1, 0, 1, 0]), 5); + private var ssaoIndexBuffer:IndexBufferResource = new IndexBufferResource(Vector.([0, 1, 3, 2, 3, 1])); + private var ssaoVertex:Vector. = Vector.([0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1]); + private var ssaoFragment:Vector. = Vector.([0, 0, 0, (Math.PI * 2), 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, (Math.PI * 2), (Math.PI * 2)]); + private var blurProgram:ProgramResource; + private var blurFragment:Vector. = Vector.([0, 0, 0, 1, 0, 0, 0, 1]); + private var omniProgram:ProgramResource; + private var spotProgram:ProgramResource; + private var tubeProgram:ProgramResource; + private var lightConst:Vector. = new Vector.(); + private var lightVertexBuffer:VertexBufferResource; + private var lightIndexBuffer:IndexBufferResource; + alternativa3d var depthBuffer:RenderTargetTextureResource; + alternativa3d var lightBuffer:RenderTargetTextureResource; + private var temporaryBuffer:RenderTargetTextureResource; + private var scissor:Rectangle = new Rectangle(); + private var table:BitmapTextureResource; + private var noise:BitmapTextureResource; + private var bias:Number = 0.1; + private var tableSize:int = 128; + private var noiseSize:int = 4; + private var blurSamples:int = 16; + private var intensity:Number = 2.5; + private var noiseRandom:Number = 0.2; + private var samples:int = 6; + private var noiseAngle:Number = ((Math.PI * 2) / samples); + alternativa3d var correctionX:Number; + alternativa3d var correctionY:Number; + + public function DepthRenderer(){ + var _local_1:int; + var _local_2:int; + var _local_11:int; + var _local_12:int; + var _local_13:int; + var _local_14:int; + var _local_15:int; + var _local_16:int; + var _local_17:int; + var _local_18:int; + var _local_19:int; + var _local_20:int; + var _local_21:Number; + var _local_22:Number; + var _local_23:Number; + var _local_24:Number; + var _local_25:int; + var _local_26:int; + var _local_27:int; + super(); + var _local_3:int; + var _local_4:int; + var _local_5:Vector. = new Vector.(); + var _local_6:Vector. = new Vector.(); + _local_1 = 0; + while (_local_1 < limit2const) + { + _local_11 = (4 + (_local_1 * 2)); + _local_12 = (4 + (_local_1 * 5)); + _local_13 = (_local_1 * 8); + _local_5[_local_3] = -1; + _local_3++; + _local_5[_local_3] = 1; + _local_3++; + _local_5[_local_3] = -1; + _local_3++; + _local_5[_local_3] = _local_11; + _local_3++; + _local_5[_local_3] = _local_12; + _local_3++; + _local_14 = (_local_13 + 1); + _local_5[_local_3] = 1; + _local_3++; + _local_5[_local_3] = 1; + _local_3++; + _local_5[_local_3] = -1; + _local_3++; + _local_5[_local_3] = _local_11; + _local_3++; + _local_5[_local_3] = _local_12; + _local_3++; + _local_15 = (_local_14 + 1); + _local_5[_local_3] = 1; + _local_3++; + _local_5[_local_3] = 1; + _local_3++; + _local_5[_local_3] = 1; + _local_3++; + _local_5[_local_3] = _local_11; + _local_3++; + _local_5[_local_3] = _local_12; + _local_3++; + _local_16 = (_local_15 + 1); + _local_5[_local_3] = -1; + _local_3++; + _local_5[_local_3] = 1; + _local_3++; + _local_5[_local_3] = 1; + _local_3++; + _local_5[_local_3] = _local_11; + _local_3++; + _local_5[_local_3] = _local_12; + _local_3++; + _local_17 = (_local_16 + 1); + _local_5[_local_3] = -1; + _local_3++; + _local_5[_local_3] = -1; + _local_3++; + _local_5[_local_3] = -1; + _local_3++; + _local_5[_local_3] = _local_11; + _local_3++; + _local_5[_local_3] = _local_12; + _local_3++; + _local_18 = (_local_17 + 1); + _local_5[_local_3] = 1; + _local_3++; + _local_5[_local_3] = -1; + _local_3++; + _local_5[_local_3] = -1; + _local_3++; + _local_5[_local_3] = _local_11; + _local_3++; + _local_5[_local_3] = _local_12; + _local_3++; + _local_19 = (_local_18 + 1); + _local_5[_local_3] = 1; + _local_3++; + _local_5[_local_3] = -1; + _local_3++; + _local_5[_local_3] = 1; + _local_3++; + _local_5[_local_3] = _local_11; + _local_3++; + _local_5[_local_3] = _local_12; + _local_3++; + _local_20 = (_local_19 + 1); + _local_5[_local_3] = -1; + _local_3++; + _local_5[_local_3] = -1; + _local_3++; + _local_5[_local_3] = 1; + _local_3++; + _local_5[_local_3] = _local_11; + _local_3++; + _local_5[_local_3] = _local_12; + _local_3++; + _local_6[_local_4] = _local_13; + _local_4++; + _local_6[_local_4] = _local_17; + _local_4++; + _local_6[_local_4] = _local_14; + _local_4++; + _local_6[_local_4] = _local_14; + _local_4++; + _local_6[_local_4] = _local_17; + _local_4++; + _local_6[_local_4] = _local_18; + _local_4++; + _local_6[_local_4] = _local_14; + _local_4++; + _local_6[_local_4] = _local_18; + _local_4++; + _local_6[_local_4] = _local_19; + _local_4++; + _local_6[_local_4] = _local_14; + _local_4++; + _local_6[_local_4] = _local_19; + _local_4++; + _local_6[_local_4] = _local_15; + _local_4++; + _local_6[_local_4] = _local_17; + _local_4++; + _local_6[_local_4] = _local_19; + _local_4++; + _local_6[_local_4] = _local_18; + _local_4++; + _local_6[_local_4] = _local_17; + _local_4++; + _local_6[_local_4] = _local_20; + _local_4++; + _local_6[_local_4] = _local_19; + _local_4++; + _local_6[_local_4] = _local_15; + _local_4++; + _local_6[_local_4] = _local_19; + _local_4++; + _local_6[_local_4] = _local_20; + _local_4++; + _local_6[_local_4] = _local_15; + _local_4++; + _local_6[_local_4] = _local_20; + _local_4++; + _local_6[_local_4] = _local_16; + _local_4++; + _local_6[_local_4] = _local_13; + _local_4++; + _local_6[_local_4] = _local_16; + _local_4++; + _local_6[_local_4] = _local_20; + _local_4++; + _local_6[_local_4] = _local_13; + _local_4++; + _local_6[_local_4] = _local_20; + _local_4++; + _local_6[_local_4] = _local_17; + _local_4++; + _local_6[_local_4] = _local_13; + _local_4++; + _local_6[_local_4] = _local_14; + _local_4++; + _local_6[_local_4] = _local_15; + _local_4++; + _local_6[_local_4] = _local_13; + _local_4++; + _local_6[_local_4] = _local_15; + _local_4++; + _local_6[_local_4] = _local_16; + _local_4++; + _local_1++; + }; + this.lightVertexBuffer = new VertexBufferResource(_local_5, 5); + this.lightIndexBuffer = new IndexBufferResource(_local_6); + var _local_7:Vector. = new Vector.(); + var _local_8:int; + var _local_9:Number = (Math.PI * 2); + var _local_10:int = (this.tableSize - 1); + _local_1 = 0; + while (_local_1 < this.tableSize) + { + _local_21 = (((_local_1 / _local_10) - 0.5) * 2); + _local_2 = 0; + while (_local_2 < this.tableSize) + { + _local_22 = (((_local_2 / _local_10) - 0.5) * 2); + _local_23 = Math.atan2(_local_21, _local_22); + if (_local_23 < 0) + { + _local_23 = (_local_23 + _local_9); + }; + _local_7[_local_8] = Math.round(((0xFF * _local_23) / _local_9)); + _local_8++; + _local_2++; + }; + _local_1++; + }; + this.table = new BitmapTextureResource(new BitmapData(this.tableSize, this.tableSize, false, 0), false); + this.table.bitmapData.setVector(this.table.bitmapData.rect, _local_7); + _local_7 = new Vector.(); + _local_8 = 0; + _local_1 = 0; + while (_local_1 < this.noiseSize) + { + _local_2 = 0; + while (_local_2 < this.noiseSize) + { + _local_24 = (Math.random() * this.noiseAngle); + _local_25 = (Math.sin(_local_24) * 0xFF); + _local_26 = (Math.cos(_local_24) * 0xFF); + _local_27 = ((this.noiseRandom + (Math.random() * (1 - this.noiseRandom))) * 0xFF); + _local_7[_local_8] = (((_local_25 << 16) | (_local_26 << 8)) | _local_27); + _local_8++; + _local_2++; + }; + _local_1++; + }; + this.noise = new BitmapTextureResource(new BitmapData(this.noiseSize, this.noiseSize, false, 0), false); + this.noise.bitmapData.setVector(this.noise.bitmapData.rect, _local_7); + this.depthBuffer = new RenderTargetTextureResource(1, 1); + this.temporaryBuffer = new RenderTargetTextureResource(1, 1); + this.lightBuffer = new RenderTargetTextureResource(1, 1); + } + + alternativa3d function render(_arg_1:Camera3D, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Boolean, _arg_6:Boolean, _arg_7:Number, _arg_8:Vector., _arg_9:int):void{ + var _local_10:int; + var _local_14:Object3D; + var _local_15:VertexBufferResource; + var _local_16:IndexBufferResource; + var _local_17:int; + var _local_18:TextureMaterial; + var _local_19:Mesh; + var _local_20:BSP; + var _local_21:int; + var _local_22:int; + var _local_23:OmniLight; + var _local_24:SpotLight; + var _local_25:Number; + var _local_26:Number; + var _local_27:TubeLight; + var _local_11:Device = _arg_1.device; + if (_arg_2 > 0x0800) + { + _arg_2 = 0x0800; + }; + if (_arg_3 > 0x0800) + { + _arg_3 = 0x0800; + }; + if (_arg_4 > 1) + { + _arg_4 = 1; + }; + _arg_2 = Math.round((_arg_2 * _arg_4)); + _arg_3 = Math.round((_arg_3 * _arg_4)); + if (_arg_2 < 1) + { + _arg_2 = 1; + }; + if (_arg_3 < 1) + { + _arg_3 = 1; + }; + this.scissor.width = _arg_2; + this.scissor.height = _arg_3; + var _local_12:int = int((1 << Math.ceil((Math.log(_arg_2) / Math.LN2)))); + var _local_13:int = int((1 << Math.ceil((Math.log(_arg_3) / Math.LN2)))); + if (((!(_local_12 == this.depthBuffer.width)) || (!(_local_13 == this.depthBuffer.height)))) + { + this.depthBuffer.dispose(); + this.depthBuffer = new RenderTargetTextureResource(_local_12, _local_13); + this.temporaryBuffer.dispose(); + this.temporaryBuffer = new RenderTargetTextureResource(_local_12, _local_13); + this.lightBuffer.dispose(); + this.lightBuffer = new RenderTargetTextureResource(_local_12, _local_13); + }; + if ((!(_arg_5))) + { + this.noise.reset(); + this.temporaryBuffer.reset(); + this.ssaoVertexBuffer.reset(); + this.ssaoIndexBuffer.reset(); + }; + if ((!(_arg_6))) + { + this.lightBuffer.reset(); + this.lightVertexBuffer.reset(); + this.lightIndexBuffer.reset(); + }; + if (((!(_arg_5)) && (!(_arg_6)))) + { + this.table.reset(); + }; + this.correctionX = (_arg_2 / this.depthBuffer.width); + this.correctionY = (_arg_3 / this.depthBuffer.height); + _local_11.setRenderToTexture(this.depthBuffer, true); + _local_11.clear(1, 0, 0.25, 1); + _local_11.setScissorRectangle(this.scissor); + this.correction[0] = this.correctionX; + this.correction[1] = this.correctionY; + this.correction[2] = (0xFF / _arg_1.farClipping); + this.correction[4] = (1 - this.correctionX); + this.correction[5] = (1 - this.correctionY); + this.correction[8] = _arg_1.correctionX; + this.correction[9] = _arg_1.correctionY; + _local_11.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 3, _arg_1.projection, 1, false); + _local_11.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 4, this.correction, 3, false); + if (((_arg_5) || (_arg_6))) + { + _local_11.setTextureAt(0, this.table); + }; + _local_10 = 0; + while (_local_10 < _arg_9) + { + _local_14 = _arg_8[_local_10]; + if ((_local_14 is Mesh)) + { + _local_19 = Mesh(_local_14); + _local_15 = _local_19.vertexBuffer; + _local_16 = _local_19.indexBuffer; + _local_17 = _local_19.numTriangles; + _local_18 = (_local_19.faceList.material as TextureMaterial); + } + else + { + if ((_local_14 is BSP)) + { + _local_20 = BSP(_local_14); + _local_15 = _local_20.vertexBuffer; + _local_16 = _local_20.indexBuffer; + _local_17 = _local_20.numTriangles; + _local_18 = (_local_20.faces[0].material as TextureMaterial); + }; + }; + if ((((!(_local_18 == null)) && (_local_18.alphaTestThreshold > 0)) && (_local_18.transparent))) + { + _local_11.setProgram(this.getDepthProgram(((_arg_5) || (_arg_6)), true, _arg_1.view.quality, _local_18.repeat, (_local_18._mipMapping > 0), false, false)); + _local_11.setVertexBufferAt(2, _local_15, 3, Context3DVertexBufferFormat.FLOAT_2); + _local_11.setTextureAt(1, _local_18.textureResource); + this.alphaTestConst[0] = _local_18.textureResource.correctionU; + this.alphaTestConst[1] = _local_18.textureResource.correctionV; + this.alphaTestConst[3] = _local_18.alphaTestThreshold; + _local_11.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 7, this.alphaTestConst, 1); + } + else + { + _local_11.setProgram(this.getDepthProgram(((_arg_5) || (_arg_6)), false)); + }; + _local_11.setVertexBufferAt(0, _local_15, 0, Context3DVertexBufferFormat.FLOAT_3); + _local_11.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 0, _local_14.transformConst, 3, false); + _local_11.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 0, this.depthFragment, 2); + if (((_arg_5) || (_arg_6))) + { + _local_11.setVertexBufferAt(1, _local_15, 5, Context3DVertexBufferFormat.FLOAT_3); + }; + _local_11.drawTriangles(_local_16, 0, _local_17); + _local_11.setTextureAt(1, null); + _local_11.setVertexBufferAt(2, null); + _local_10++; + }; + if (_arg_6) + { + _local_11.setRenderToTexture(this.lightBuffer, false); + _local_11.clear(_arg_7, _arg_7, _arg_7, 0); + _local_11.setBlendFactors(Context3DBlendFactor.ONE, Context3DBlendFactor.ONE); + _local_11.setTextureAt(0, this.depthBuffer); + _local_11.setVertexBufferAt(0, this.lightVertexBuffer, 0, Context3DVertexBufferFormat.FLOAT_3); + _local_11.setVertexBufferAt(1, this.lightVertexBuffer, 3, Context3DVertexBufferFormat.FLOAT_2); + _local_11.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 0, _arg_1.projection, 1, false); + _local_11.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 1, this.correction, 3, false); + this.ssaoFragment[0] = _arg_1.farClipping; + this.ssaoFragment[1] = (_arg_1.farClipping / 0xFF); + this.ssaoFragment[4] = (2 / this.correctionX); + this.ssaoFragment[5] = (2 / this.correctionY); + this.ssaoFragment[6] = 0; + this.ssaoFragment[8] = 1; + this.ssaoFragment[9] = 1; + this.ssaoFragment[10] = 0.5; + this.ssaoFragment[12] = _arg_1.correctionX; + this.ssaoFragment[13] = _arg_1.correctionY; + this.ssaoFragment[16] = 0.5; + this.ssaoFragment[17] = 0.5; + _local_11.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 0, this.ssaoFragment, 7, false); + _local_11.setProgram(this.getOmniProgram()); + _local_21 = 0; + _local_22 = 0; + _local_10 = 0; + while (_local_10 < _arg_1.omniesCount) + { + _local_23 = _arg_1.omnies[_local_10]; + this.lightConst[_local_21] = (_local_23.cmd * _arg_1.correctionX); + _local_21++; + this.lightConst[_local_21] = (_local_23.cmh * _arg_1.correctionY); + _local_21++; + this.lightConst[_local_21] = _local_23.cml; + _local_21++; + this.lightConst[_local_21] = _local_23.attenuationEnd; + _local_21++; + this.lightConst[_local_21] = (((_local_23.intensity * _arg_1.deferredLightingStrength) * ((_local_23.color >> 16) & 0xFF)) / 0xFF); + _local_21++; + this.lightConst[_local_21] = (((_local_23.intensity * _arg_1.deferredLightingStrength) * ((_local_23.color >> 8) & 0xFF)) / 0xFF); + _local_21++; + this.lightConst[_local_21] = (((_local_23.intensity * _arg_1.deferredLightingStrength) * (_local_23.color & 0xFF)) / 0xFF); + _local_21++; + this.lightConst[_local_21] = (1 / (_local_23.attenuationEnd - _local_23.attenuationBegin)); + _local_21++; + _local_22++; + if (((_local_22 == limit2const) || (_local_10 == (_arg_1.omniesCount - 1)))) + { + _local_11.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 4, this.lightConst, (_local_22 * 2), false); + _local_11.drawTriangles(this.lightIndexBuffer, 0, ((_local_22 * 6) * 2)); + _local_22 = 0; + _local_21 = 0; + }; + _local_10++; + }; + _local_11.setProgram(this.getSpotProgram()); + _local_21 = 0; + _local_22 = 0; + _local_10 = 0; + while (_local_10 < _arg_1.spotsCount) + { + _local_24 = _arg_1.spots[_local_10]; + _local_25 = Math.cos((_local_24.hotspot * 0.5)); + _local_26 = Math.cos((_local_24.falloff * 0.5)); + this.lightConst[_local_21] = _local_24.cma; + _local_21++; + this.lightConst[_local_21] = _local_24.cmb; + _local_21++; + this.lightConst[_local_21] = _local_24.cmc; + _local_21++; + this.lightConst[_local_21] = _local_24.cmd; + _local_21++; + this.lightConst[_local_21] = _local_24.cme; + _local_21++; + this.lightConst[_local_21] = _local_24.cmf; + _local_21++; + this.lightConst[_local_21] = _local_24.cmg; + _local_21++; + this.lightConst[_local_21] = _local_24.cmh; + _local_21++; + this.lightConst[_local_21] = _local_24.cmi; + _local_21++; + this.lightConst[_local_21] = _local_24.cmj; + _local_21++; + this.lightConst[_local_21] = _local_24.cmk; + _local_21++; + this.lightConst[_local_21] = _local_24.cml; + _local_21++; + this.lightConst[_local_21] = _local_24.attenuationEnd; + _local_21++; + this.lightConst[_local_21] = (1 / (_local_24.attenuationEnd - _local_24.attenuationBegin)); + _local_21++; + this.lightConst[_local_21] = _local_26; + _local_21++; + this.lightConst[_local_21] = (1 / (_local_25 - _local_26)); + _local_21++; + this.lightConst[_local_21] = (((_local_24.intensity * _arg_1.deferredLightingStrength) * ((_local_24.color >> 16) & 0xFF)) / 0xFF); + _local_21++; + this.lightConst[_local_21] = (((_local_24.intensity * _arg_1.deferredLightingStrength) * ((_local_24.color >> 8) & 0xFF)) / 0xFF); + _local_21++; + this.lightConst[_local_21] = (((_local_24.intensity * _arg_1.deferredLightingStrength) * (_local_24.color & 0xFF)) / 0xFF); + _local_21++; + this.lightConst[_local_21] = (Math.sin((_local_24.falloff * 0.5)) * _local_24.attenuationEnd); + _local_21++; + _local_22++; + if (((_local_22 == limit5const) || (_local_10 == (_arg_1.spotsCount - 1)))) + { + _local_11.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 4, this.lightConst, (_local_22 * 5), false); + _local_11.drawTriangles(this.lightIndexBuffer, 0, ((_local_22 * 6) * 2)); + _local_22 = 0; + _local_21 = 0; + }; + _local_10++; + }; + _local_11.setProgram(this.getTubeProgram()); + _local_21 = 0; + _local_22 = 0; + _local_10 = 0; + while (_local_10 < _arg_1.tubesCount) + { + _local_27 = _arg_1.tubes[_local_10]; + this.lightConst[_local_21] = _local_27.cma; + _local_21++; + this.lightConst[_local_21] = _local_27.cmb; + _local_21++; + this.lightConst[_local_21] = _local_27.cmc; + _local_21++; + this.lightConst[_local_21] = _local_27.cmd; + _local_21++; + this.lightConst[_local_21] = _local_27.cme; + _local_21++; + this.lightConst[_local_21] = _local_27.cmf; + _local_21++; + this.lightConst[_local_21] = _local_27.cmg; + _local_21++; + this.lightConst[_local_21] = _local_27.cmh; + _local_21++; + this.lightConst[_local_21] = _local_27.cmi; + _local_21++; + this.lightConst[_local_21] = _local_27.cmj; + _local_21++; + this.lightConst[_local_21] = _local_27.cmk; + _local_21++; + this.lightConst[_local_21] = _local_27.cml; + _local_21++; + this.lightConst[_local_21] = _local_27.attenuationEnd; + _local_21++; + this.lightConst[_local_21] = (1 / (_local_27.attenuationEnd - _local_27.attenuationBegin)); + _local_21++; + this.lightConst[_local_21] = ((_local_27.length * 0.5) + _local_27.falloff); + _local_21++; + this.lightConst[_local_21] = (1 / _local_27.falloff); + _local_21++; + this.lightConst[_local_21] = (((_local_27.intensity * _arg_1.deferredLightingStrength) * ((_local_27.color >> 16) & 0xFF)) / 0xFF); + _local_21++; + this.lightConst[_local_21] = (((_local_27.intensity * _arg_1.deferredLightingStrength) * ((_local_27.color >> 8) & 0xFF)) / 0xFF); + _local_21++; + this.lightConst[_local_21] = (((_local_27.intensity * _arg_1.deferredLightingStrength) * (_local_27.color & 0xFF)) / 0xFF); + _local_21++; + this.lightConst[_local_21] = (_local_27.length * 0.5); + _local_21++; + _local_22++; + if (((_local_22 == limit5const) || (_local_10 == (_arg_1.tubesCount - 1)))) + { + _local_11.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 4, this.lightConst, (_local_22 * 5), false); + _local_11.drawTriangles(this.lightIndexBuffer, 0, ((_local_22 * 6) * 2)); + _local_22 = 0; + _local_21 = 0; + }; + _local_10++; + }; + _local_11.setBlendFactors(Context3DBlendFactor.ONE, Context3DBlendFactor.ZERO); + }; + if (_arg_5) + { + _local_11.setRenderToTexture(this.temporaryBuffer, false); + _local_11.clear(0, 0, 0, 0); + _local_11.setProgram(this.getSSAOProgram()); + _local_11.setTextureAt(0, this.depthBuffer); + _local_11.setTextureAt(1, this.noise); + _local_11.setVertexBufferAt(0, this.ssaoVertexBuffer, 0, Context3DVertexBufferFormat.FLOAT_3); + _local_11.setVertexBufferAt(1, this.ssaoVertexBuffer, 3, Context3DVertexBufferFormat.FLOAT_2); + this.ssaoVertex[0] = (_local_12 / this.noiseSize); + this.ssaoVertex[1] = (_local_13 / this.noiseSize); + this.ssaoVertex[4] = (2 / this.correctionX); + this.ssaoVertex[5] = (2 / this.correctionY); + _local_11.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 0, this.ssaoVertex, 3, false); + this.ssaoFragment[0] = _arg_1.farClipping; + this.ssaoFragment[1] = (_arg_1.farClipping / 0xFF); + this.ssaoFragment[4] = (2 / this.correctionX); + this.ssaoFragment[5] = (2 / this.correctionY); + this.ssaoFragment[6] = _arg_1.ssaoRadius; + this.ssaoFragment[8] = 1; + this.ssaoFragment[9] = 1; + this.ssaoFragment[10] = this.bias; + this.ssaoFragment[11] = ((this.intensity * 1) / this.samples); + this.ssaoFragment[12] = _arg_1.correctionX; + this.ssaoFragment[13] = _arg_1.correctionY; + this.ssaoFragment[15] = (1 / _arg_1.ssaoRange); + this.ssaoFragment[16] = Math.cos(this.noiseAngle); + this.ssaoFragment[17] = Math.sin(this.noiseAngle); + this.ssaoFragment[20] = -(Math.sin(this.noiseAngle)); + this.ssaoFragment[21] = Math.cos(this.noiseAngle); + this.ssaoFragment[24] = (this.correctionX - (1 / _local_12)); + this.ssaoFragment[25] = (this.correctionY - (1 / _local_13)); + _local_11.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 0, this.ssaoFragment, 7, false); + _local_11.drawTriangles(this.ssaoIndexBuffer, 0, 2); + _local_11.setTextureAt(1, null); + _local_11.setRenderToTexture(this.depthBuffer, false); + _local_11.clear(0, 0, 0, 0); + _local_11.setProgram(this.getBlurProgram()); + _local_11.setTextureAt(0, this.temporaryBuffer); + this.blurFragment[0] = (1 / _local_12); + this.blurFragment[1] = (1 / _local_13); + this.blurFragment[3] = (1 / this.blurSamples); + this.blurFragment[4] = (this.correctionX - (1 / _local_12)); + this.blurFragment[5] = (this.correctionY - (1 / _local_13)); + _local_11.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 0, this.blurFragment, 2, false); + _local_11.drawTriangles(this.ssaoIndexBuffer, 0, 2); + }; + _local_11.setVertexBufferAt(1, null); + _local_11.setTextureAt(0, null); + _local_11.setScissorRectangle(null); + } + + alternativa3d function resetResources():void{ + this.noise.reset(); + this.table.reset(); + this.depthBuffer.reset(); + this.temporaryBuffer.reset(); + this.lightBuffer.reset(); + this.ssaoVertexBuffer.reset(); + this.ssaoIndexBuffer.reset(); + this.lightVertexBuffer.reset(); + this.lightIndexBuffer.reset(); + } + + private function getDepthProgram(_arg_1:Boolean, _arg_2:Boolean, _arg_3:Boolean=false, _arg_4:Boolean=false, _arg_5:Boolean=false, _arg_6:Boolean=false, _arg_7:Boolean=false):ProgramResource{ + var _local_10:ByteArray; + var _local_11:ByteArray; + var _local_8:int = ((((((int(_arg_1) | (int(_arg_2) << 1)) | (int(_arg_3) << 2)) | (int(_arg_4) << 3)) | (int(_arg_5) << 4)) | (int(_arg_6) << 5)) | (int(_arg_7) << 6)); + var _local_9:ProgramResource = this.depthPrograms[_local_8]; + if (_local_9 == null) + { + _local_10 = new DepthRendererDepthVertexShader(_arg_1, _arg_2).agalcode; + _local_11 = new DepthRendererDepthFragmentShader(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5).agalcode; + _local_9 = new ProgramResource(_local_10, _local_11); + this.depthPrograms[_local_8] = _local_9; + }; + return (_local_9); + } + + private function getSSAOProgram():ProgramResource{ + var _local_2:ByteArray; + var _local_3:ByteArray; + var _local_1:ProgramResource = this.ssaoProgram; + if (_local_1 == null) + { + _local_2 = new DepthRendererSSAOVertexShader().agalcode; + _local_3 = new DepthRendererSSAOFragmentShader(this.samples).agalcode; + _local_1 = new ProgramResource(_local_2, _local_3); + this.ssaoProgram = _local_1; + }; + return (_local_1); + } + + private function getBlurProgram():ProgramResource{ + var _local_2:ByteArray; + var _local_3:ByteArray; + var _local_1:ProgramResource = this.blurProgram; + if (_local_1 == null) + { + _local_2 = new DepthRendererBlurVertexShader().agalcode; + _local_3 = new DepthRendererBlurFragmentShader().agalcode; + _local_1 = new ProgramResource(_local_2, _local_3); + this.blurProgram = _local_1; + }; + return (_local_1); + } + + private function getOmniProgram():ProgramResource{ + var _local_2:ByteArray; + var _local_3:ByteArray; + var _local_1:ProgramResource = this.omniProgram; + if (_local_1 == null) + { + _local_2 = new DepthRendererLightVertexShader(0).agalcode; + _local_3 = new DepthRendererLightFragmentShader(0).agalcode; + _local_1 = new ProgramResource(_local_2, _local_3); + this.omniProgram = _local_1; + }; + return (_local_1); + } + + private function getSpotProgram():ProgramResource{ + var _local_2:ByteArray; + var _local_3:ByteArray; + var _local_1:ProgramResource = this.spotProgram; + if (_local_1 == null) + { + _local_2 = new DepthRendererLightVertexShader(1).agalcode; + _local_3 = new DepthRendererLightFragmentShader(1).agalcode; + _local_1 = new ProgramResource(_local_2, _local_3); + this.spotProgram = _local_1; + }; + return (_local_1); + } + + private function getTubeProgram():ProgramResource{ + var _local_2:ByteArray; + var _local_3:ByteArray; + var _local_1:ProgramResource = this.tubeProgram; + if (_local_1 == null) + { + _local_2 = new DepthRendererLightVertexShader(2).agalcode; + _local_3 = new DepthRendererLightFragmentShader(2).agalcode; + _local_1 = new ProgramResource(_local_2, _local_3); + this.tubeProgram = _local_1; + }; + return (_local_1); + } + + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/DepthRendererBlurFragmentShader.as b/src/alternativa/engine3d/core/DepthRendererBlurFragmentShader.as new file mode 100644 index 0000000..e9eb6e6 --- /dev/null +++ b/src/alternativa/engine3d/core/DepthRendererBlurFragmentShader.as @@ -0,0 +1,81 @@ +package alternativa.engine3d.core +{ + import alternativa.gfx.agal.FragmentShader; + import alternativa.gfx.agal.SamplerDim; + import alternativa.gfx.agal.SamplerRepeat; + import alternativa.gfx.agal.SamplerFilter; + import alternativa.gfx.agal.SamplerMipMap; + + public class DepthRendererBlurFragmentShader extends FragmentShader + { + + public function DepthRendererBlurFragmentShader() + { + mov(ft1, v0); + tex(ft0, ft1, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + sub(ft1.y, ft1, fc[0]); + min(ft2, ft1, fc[1]); + tex(ft2, ft2, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + add(ft0.w, ft0, ft2); + sub(ft1.x, ft1, fc[0]); + min(ft2, ft1, fc[1]); + tex(ft2, ft2, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + add(ft0.w, ft0, ft2); + add(ft1.y, ft1, fc[0]); + min(ft2, ft1, fc[1]); + tex(ft2, ft2, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + add(ft0.w, ft0, ft2); + add(ft1.y, ft1, fc[0]); + min(ft2, ft1, fc[1]); + tex(ft2, ft2, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + add(ft0.w, ft0, ft2); + add(ft1.y, ft1, fc[0]); + min(ft2, ft1, fc[1]); + tex(ft2, ft2, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + add(ft0.w, ft0, ft2); + add(ft1.x, ft1, fc[0]); + min(ft2, ft1, fc[1]); + tex(ft2, ft2, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + add(ft0.w, ft0, ft2); + add(ft1.x, ft1, fc[0]); + min(ft2, ft1, fc[1]); + tex(ft2, ft2, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + add(ft0.w, ft0, ft2); + add(ft1.x, ft1, fc[0]); + min(ft2, ft1, fc[1]); + tex(ft2, ft2, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + add(ft0.w, ft0, ft2); + sub(ft1.y, ft1, fc[0]); + min(ft2, ft1, fc[1]); + tex(ft2, ft2, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + add(ft0.w, ft0, ft2); + sub(ft1.y, ft1, fc[0]); + min(ft2, ft1, fc[1]); + tex(ft2, ft2, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + add(ft0.w, ft0, ft2); + sub(ft1.y, ft1, fc[0]); + min(ft2, ft1, fc[1]); + tex(ft2, ft2, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + add(ft0.w, ft0, ft2); + sub(ft1.x, ft1, fc[0]); + min(ft2, ft1, fc[1]); + tex(ft2, ft2, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + add(ft0.w, ft0, ft2); + add(ft1.y, ft1, fc[0]); + min(ft2, ft1, fc[1]); + tex(ft2, ft2, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + add(ft0.w, ft0, ft2); + add(ft1.y, ft1, fc[0]); + min(ft2, ft1, fc[1]); + tex(ft2, ft2, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + add(ft0.w, ft0, ft2); + sub(ft1.x, ft1, fc[0]); + min(ft2, ft1, fc[1]); + tex(ft2, ft2, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + add(ft0.w, ft0, ft2); + mul(ft0.w, ft0, fc[0]); + mov(oc, ft0); + } + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/DepthRendererBlurVertexShader.as b/src/alternativa/engine3d/core/DepthRendererBlurVertexShader.as new file mode 100644 index 0000000..efd4bf7 --- /dev/null +++ b/src/alternativa/engine3d/core/DepthRendererBlurVertexShader.as @@ -0,0 +1,15 @@ +package alternativa.engine3d.core +{ + import alternativa.gfx.agal.VertexShader; + + public class DepthRendererBlurVertexShader extends VertexShader + { + + public function DepthRendererBlurVertexShader() + { + mov(op, va0); + mov(v0, va1); + } + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/DepthRendererDepthFragmentShader.as b/src/alternativa/engine3d/core/DepthRendererDepthFragmentShader.as new file mode 100644 index 0000000..8b97256 --- /dev/null +++ b/src/alternativa/engine3d/core/DepthRendererDepthFragmentShader.as @@ -0,0 +1,55 @@ +package alternativa.engine3d.core +{ + import alternativa.gfx.agal.FragmentShader; + import alternativa.gfx.agal.SamplerRepeat; + import alternativa.gfx.agal.SamplerFilter; + import alternativa.gfx.agal.SamplerMipMap; + import alternativa.gfx.agal.SamplerType; + import alternativa.gfx.agal.SamplerDim; + + public class DepthRendererDepthFragmentShader extends FragmentShader + { + + public function DepthRendererDepthFragmentShader(_arg_1:Boolean, _arg_2:Boolean, _arg_3:Boolean, _arg_4:Boolean, _arg_5:Boolean) + { + var _local_6:SamplerRepeat; + var _local_7:SamplerFilter; + var _local_8:SamplerMipMap; + var _local_9:SamplerType; + super(); + if (_arg_2) + { + _local_6 = ((_arg_4) ? SamplerRepeat.WRAP : SamplerRepeat.CLAMP); + _local_7 = ((_arg_3) ? SamplerFilter.LINEAR : SamplerFilter.NEAREST); + _local_8 = ((_arg_5) ? ((_arg_3) ? SamplerMipMap.LINEAR : SamplerMipMap.NEAREST) : SamplerMipMap.NONE); + _local_9 = SamplerType.RGBA; + tex(ft0, v1, fs1.dim(SamplerDim.D2).repeat(_local_6).filter(_local_7).mipmap(_local_8).type(_local_9)); + sub(ft0.w, ft0, v1); + kil(ft0.w); + }; + frc(ft0, v0.z); + sub(ft0.x, v0.z, ft0); + mul(ft0.x, ft0, fc[0]); + if (_arg_1) + { + mov(ft1.zw, fc[0]); + mov(ft1.xy, v0); + nrm(ft1.xyz, ft1.xyz); + mul(ft1.xy, ft1, fc[1]); + add(ft1.xy, ft1, fc[1]); + tex(ft2, ft1, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + mov(ft0.w, ft2.z); + mul(ft1.xy, v0, v0); + add(ft1.x, ft1, ft1.y); + sqt(ft1.x, ft1); + neg(ft1.y, v0.w); + mul(ft1.xy, ft1, fc[1]); + add(ft1.xy, ft1, fc[1]); + tex(ft2, ft1, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + mov(ft0.z, ft2.z); + }; + mov(oc, ft0); + } + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/DepthRendererDepthVertexShader.as b/src/alternativa/engine3d/core/DepthRendererDepthVertexShader.as new file mode 100644 index 0000000..779fe05 --- /dev/null +++ b/src/alternativa/engine3d/core/DepthRendererDepthVertexShader.as @@ -0,0 +1,36 @@ +package alternativa.engine3d.core +{ + import alternativa.gfx.agal.VertexShader; + + public class DepthRendererDepthVertexShader extends VertexShader + { + + public function DepthRendererDepthVertexShader(_arg_1:Boolean, _arg_2:Boolean) + { + mov(vt0, vc[0]); + dp4(vt0.x, va0, vc[0]); + dp4(vt0.y, va0, vc[1]); + dp4(vt0.z, va0, vc[2]); + mul(vt0.xy, vt0, vc[4]); + mul(vt1, vc[5], vt0.z); + sub(vt0.xy, vt0, vt1); + mul(v0, vt0, vc[4]); + if (_arg_1) + { + dp3(vt1, va1, vc[0]); + dp3(vt1.y, va1, vc[1]); + mul(v0.xy, vt1, vc[6]); + dp3(v0.w, va1, vc[2]); + }; + mov(op.xw, vt0.xz); + neg(op.y, vt0); + mul(vt0.z, vt0, vc[3]); + add(op.z, vt0, vc[3].w); + if (_arg_2) + { + mul(v1, va2, vc[7]); + }; + } + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/DepthRendererLightFragmentShader.as b/src/alternativa/engine3d/core/DepthRendererLightFragmentShader.as new file mode 100644 index 0000000..0577fc6 --- /dev/null +++ b/src/alternativa/engine3d/core/DepthRendererLightFragmentShader.as @@ -0,0 +1,95 @@ +package alternativa.engine3d.core{ + import alternativa.gfx.agal.FragmentShader; + import alternativa.gfx.agal.SamplerDim; + import alternativa.gfx.agal.SamplerRepeat; + import alternativa.gfx.agal.SamplerFilter; + import alternativa.gfx.agal.SamplerMipMap; + + public class DepthRendererLightFragmentShader extends FragmentShader { + + public function DepthRendererLightFragmentShader(_arg_1:int){ + div(ft4, v0, v0.z); + mul(ft4, ft4, fc[4]); + add(ft4, ft4, fc[4]); + tex(ft0, ft4, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + mul(ft0.zw, ft0, fc[6]); + cos(ft1, ft0); + sin(ft2, ft0); + mul(ft1.x, ft1.w, ft1.z); + mul(ft1.y, ft2.w, ft1.z); + neg(ft1.z, ft2); + dp3(ft2.z, ft0, fc[0]); + mul(ft2.xy, ft4, fc[1]); + sub(ft2.xy, ft2, fc[2]); + mul(ft2.xy, ft2, ft2.z); + mul(ft2.xy, ft2, fc[3]); + if (_arg_1 == 0) + { + sub(ft3, v1, ft2); + dp3(ft3.w, ft3, ft3); + sqt(ft3.w, ft3); + div(ft3.xyz, ft3, ft3.w); + sub(ft3.w, v1, ft3); + mul(ft3.w, ft3, v2); + sat(ft3.w, ft3); + mul(ft3.w, ft3, ft3); + dp3(ft2.w, ft3, ft1); + max(ft2.w, ft2, fc[4]); + mul(ft3.w, ft3, ft2); + mul(ft0.xyz, v2, ft3.w); + } else + { + if (_arg_1 == 1) + { + sub(ft3, v1, ft2); + dp3(ft3.w, ft3, ft3); + sqt(ft3.w, ft3); + div(ft3.xyz, ft3, ft3.w); + sub(ft3.w, v3.x, ft3); + mul(ft3.w, ft3, v3.y); + sat(ft3.w, ft3); + mul(ft3.w, ft3, ft3); + dp3(ft4.w, ft3, ft1); + max(ft4.w, ft4, fc[4]); + mul(ft3.w, ft3, ft4); + dp3(ft4.w, ft3, v2); + neg(ft4.w, ft4); + sub(ft4.w, ft4, v3.z); + mul(ft4.w, ft4, v3); + sat(ft4.w, ft4); + mul(ft4.w, ft4, ft4); + mul(ft3.w, ft3, ft4); + } else + { + if (_arg_1 == 2) + { + sub(ft4, ft2, v1); + dp3(ft4.w, ft4, v2); + mul(ft4.xyz, v2, ft4.w); + add(ft4.xyz, v1, ft4); + abs(ft4.w, ft4); + sub(ft4.w, v3.z, ft4); + mul(ft4.w, ft4, v3); + sat(ft4.w, ft4); + mul(ft4.w, ft4, ft4); + sub(ft3, ft4, ft2); + dp3(ft3.w, ft3, ft3); + sqt(ft3.w, ft3); + div(ft3.xyz, ft3, ft3.w); + sub(ft3.w, v3.x, ft3); + mul(ft3.w, ft3, v3.y); + sat(ft3.w, ft3); + mul(ft3.w, ft3, ft3); + mul(ft3.w, ft3, ft4); + dp3(ft4.w, ft3, ft1); + max(ft4.w, ft4, fc[4]); + mul(ft3.w, ft3, ft4); + }; + }; + mul(ft0.xyz, v4, ft3.w); + }; + mov(oc, ft0); + } + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/DepthRendererLightVertexShader.as b/src/alternativa/engine3d/core/DepthRendererLightVertexShader.as new file mode 100644 index 0000000..9322a7c --- /dev/null +++ b/src/alternativa/engine3d/core/DepthRendererLightVertexShader.as @@ -0,0 +1,73 @@ +package alternativa.engine3d.core{ + import alternativa.gfx.agal.VertexShader; + + public class DepthRendererLightVertexShader extends VertexShader { + + public function DepthRendererLightVertexShader(_arg_1:int){ + if (_arg_1 == 0) + { + mov(vt1, cc.rel(va1.x, 0)); + mov(v1, vt1); + mov(v2, cc.rel(va1.x, 1)); + mul(vt0, va0, vt1.w); + add(vt0, vt0, vt1); + div(vt0.xy, vt0, vc[3]); + } else + { + mov(vt2, cc.rel(va1.y, 0)); + mov(vt3, cc.rel(va1.y, 1)); + mov(vt4, cc.rel(va1.y, 2)); + mov(vt5, cc.rel(va1.y, 3)); + mov(vt6, cc.rel(va1.y, 4)); + if (_arg_1 == 1) + { + mul(v1.x, vt2.w, vc[3]); + mul(v1.y, vt3.w, vc[3]); + mov(v1.zw, vt4.w); + mul(v2.x, vt2.z, vc[3]); + mul(v2.y, vt3.z, vc[3]); + mov(v2.zw, vt4.z); + mov(v3, vt5); + mov(v4, vt6); + mul(vt0, va0, vt6.w); + mul(vt0.z, va0, vt5.x); + add(vt0.z, vt0, vt5.x); + mul(vt0.z, vt0, vc[3].w); + } else + { + if (_arg_1 == 2) + { + mul(vt0.x, vt2.z, vc[3]); + mul(vt0.y, vt3.z, vc[3]); + mov(vt0.zw, vt4.z); + mov(v2, vt0); + mul(vt1.x, vt2.w, vc[3]); + mul(vt1.y, vt3.w, vc[3]); + mov(vt1.zw, vt4.w); + mul(vt0, vt0, vt6.w); + add(v1, vt1, vt0); + mov(v3, vt5); + mov(v4, vt6); + mul(vt0.xy, va0, vt5.x); + mul(vt0.z, va0, vt5); + add(vt0.z, vt0, vt6.w); + }; + }; + mov(vt0.w, vc[1]); + dp4(vt1.x, vt0, vt2); + dp4(vt1.y, vt0, vt3); + dp4(vt1.z, vt0, vt4); + mov(vt0.xyz, vt1.xyz); + }; + mul(vt0.xy, vt0, vc[1]); + mul(vt1, vc[2], vt0.z); + sub(vt0.xy, vt0, vt1); + mov(v0, vt0); + mov(op.xw, vt0.xz); + neg(op.y, vt0); + mul(vt0.z, vt0, vc[0]); + add(op.z, vt0, vc[0].w); + } + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/DepthRendererSSAOFragmentShader.as b/src/alternativa/engine3d/core/DepthRendererSSAOFragmentShader.as new file mode 100644 index 0000000..cb4f4bb --- /dev/null +++ b/src/alternativa/engine3d/core/DepthRendererSSAOFragmentShader.as @@ -0,0 +1,80 @@ +package alternativa.engine3d.core{ + import alternativa.gfx.agal.FragmentShader; + import alternativa.gfx.agal.SamplerDim; + import alternativa.gfx.agal.SamplerRepeat; + import alternativa.gfx.agal.SamplerFilter; + import alternativa.gfx.agal.SamplerMipMap; + + public class DepthRendererSSAOFragmentShader extends FragmentShader { + + public function DepthRendererSSAOFragmentShader(_arg_1:int){ + tex(ft0, v0, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + mul(ft0.zw, ft0, fc[6]); + cos(ft1, ft0); + sin(ft2, ft0); + mul(ft1.x, ft1.w, ft1.z); + mul(ft1.y, ft2.w, ft1.z); + neg(ft1.z, ft2); + dp3(ft2.z, ft0, fc[0]); + mul(ft2.xy, v2, ft2.z); + tex(ft3, v1, fs1.dim(SamplerDim.D2).repeat(SamplerRepeat.WRAP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + mul(ft3.z, ft3, fc[1]); + mul(ft3, ft3.z, ft3); + var _local_2:int; + while (_local_2 < _arg_1) + { + if (_local_2 > 0) + { + if ((_local_2 % 2) > 0) + { + dp3(ft6, ft3, fc[4]); + dp3(ft6.y, ft3, fc[5]); + } else + { + dp3(ft3.x, ft6, fc[4]); + dp3(ft3.y, ft6, fc[5]); + }; + }; + if ((_local_2 % 2) > 0) + { + div(ft4, ft6, fc[3]); + } else + { + div(ft4, ft3, fc[3]); + }; + div(ft4, ft4, ft2.z); + div(ft4, ft4, fc[1]); + add(ft4, v0, ft4); + min(ft5, ft4, fc[6]); + tex(ft5, ft5, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + dp3(ft5.z, ft5, fc[0]); + mul(ft5.xy, ft4, fc[1]); + sub(ft5.xy, ft5, fc[2]); + mul(ft5.xy, ft5, ft5.z); + sub(ft5, ft5, ft2); + mul(ft5, ft5, fc[3]); + dp3(ft5.w, ft5, ft5); + sqt(ft5.w, ft5); + div(ft5.xyz, ft5, ft5.w); + mul(ft5.w, ft5, fc[3]); + sub(ft5.w, fc[1], ft5); + max(ft5.w, ft5, fc[4]); + dp3(ft5.z, ft5, ft1); + sub(ft5.z, ft5, fc[2]); + max(ft5.z, ft5, fc[0]); + mul(ft5.w, ft5, ft5.z); + if (_local_2 == 0) + { + mov(ft0.w, ft5); + } else + { + add(ft0.w, ft0, ft5); + }; + _local_2++; + }; + mul(ft0.w, ft0, fc[2]); + mov(oc, ft0); + } + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/DepthRendererSSAOVertexShader.as b/src/alternativa/engine3d/core/DepthRendererSSAOVertexShader.as new file mode 100644 index 0000000..840a26f --- /dev/null +++ b/src/alternativa/engine3d/core/DepthRendererSSAOVertexShader.as @@ -0,0 +1,15 @@ +package alternativa.engine3d.core{ + import alternativa.gfx.agal.VertexShader; + + public class DepthRendererSSAOVertexShader extends VertexShader { + + public function DepthRendererSSAOVertexShader(){ + mov(op, va0); + mov(v0, va1); + mul(v1, va1, vc[0]); + mul(vt1, va1, vc[1]); + sub(v2, vt1, vc[2]); + } + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/EllipsoidCollider.as b/src/alternativa/engine3d/core/EllipsoidCollider.as new file mode 100644 index 0000000..453fda2 --- /dev/null +++ b/src/alternativa/engine3d/core/EllipsoidCollider.as @@ -0,0 +1,426 @@ +package alternativa.engine3d.core{ + import __AS3__.vec.Vector; + import flash.geom.Vector3D; + import flash.utils.Dictionary; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class EllipsoidCollider { + + public var radiusX:Number; + public var radiusY:Number; + public var radiusZ:Number; + public var threshold:Number = 0.001; + private var matrix:Object3D = new Object3D(); + private var faces:Vector. = new Vector.(); + private var facesLength:int; + private var radius:Number; + private var src:Vector3D = new Vector3D(); + private var displ:Vector3D = new Vector3D(); + private var dest:Vector3D = new Vector3D(); + private var collisionPoint:Vector3D = new Vector3D(); + private var collisionPlane:Vector3D = new Vector3D(); + private var vCenter:Vector3D = new Vector3D(); + private var vA:Vector3D = new Vector3D(); + private var vB:Vector3D = new Vector3D(); + private var vC:Vector3D = new Vector3D(); + private var vD:Vector3D = new Vector3D(); + + public function EllipsoidCollider(_arg_1:Number, _arg_2:Number, _arg_3:Number){ + this.radiusX = _arg_1; + this.radiusY = _arg_2; + this.radiusZ = _arg_3; + } + + private function prepare(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Object3D, _arg_4:Dictionary, _arg_5:Boolean):void{ + var _local_6:Number; + this.radius = this.radiusX; + if (this.radiusY > this.radius) + { + this.radius = this.radiusY; + }; + if (this.radiusZ > this.radius) + { + this.radius = this.radiusZ; + }; + this.matrix.scaleX = (this.radiusX / this.radius); + this.matrix.scaleY = (this.radiusY / this.radius); + this.matrix.scaleZ = (this.radiusZ / this.radius); + this.matrix.x = _arg_1.x; + this.matrix.y = _arg_1.y; + this.matrix.z = _arg_1.z; + this.matrix.composeMatrix(); + this.matrix.invertMatrix(); + this.src.x = 0; + this.src.y = 0; + this.src.z = 0; + this.displ.x = (((this.matrix.ma * _arg_2.x) + (this.matrix.mb * _arg_2.y)) + (this.matrix.mc * _arg_2.z)); + this.displ.y = (((this.matrix.me * _arg_2.x) + (this.matrix.mf * _arg_2.y)) + (this.matrix.mg * _arg_2.z)); + this.displ.z = (((this.matrix.mi * _arg_2.x) + (this.matrix.mj * _arg_2.y)) + (this.matrix.mk * _arg_2.z)); + this.dest.x = (this.src.x + this.displ.x); + this.dest.y = (this.src.y + this.displ.y); + this.dest.z = (this.src.z + this.displ.z); + if (_arg_5) + { + this.vCenter.x = (this.displ.x / 2); + this.vCenter.y = (this.displ.y / 2); + this.vCenter.z = (this.displ.z / 2); + _local_6 = (this.radius + (this.displ.length / 2)); + } + else + { + this.vCenter.x = 0; + this.vCenter.y = 0; + this.vCenter.z = 0; + _local_6 = (this.radius + this.displ.length); + }; + this.vA.x = -(_local_6); + this.vA.y = -(_local_6); + this.vA.z = -(_local_6); + this.vB.x = _local_6; + this.vB.y = -(_local_6); + this.vB.z = -(_local_6); + this.vC.x = _local_6; + this.vC.y = _local_6; + this.vC.z = -(_local_6); + this.vD.x = -(_local_6); + this.vD.y = _local_6; + this.vD.z = -(_local_6); + _arg_3.composeAndAppend(this.matrix); + _arg_3.collectPlanes(this.vCenter, this.vA, this.vB, this.vC, this.vD, this.faces, _arg_4); + this.facesLength = this.faces.length; + } + + public function calculateDestination(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Object3D, _arg_4:Dictionary=null):Vector3D{ + var _local_5:int; + var _local_6:int; + var _local_7:Number; + if (_arg_2.length <= this.threshold) + { + return (_arg_1.clone()); + }; + this.prepare(_arg_1, _arg_2, _arg_3, _arg_4, false); + if (this.facesLength > 0) + { + _local_5 = 50; + _local_6 = 0; + while (_local_6 < _local_5) + { + if (this.checkCollision()) + { + _local_7 = (((((this.radius + this.threshold) + this.collisionPlane.w) - (this.dest.x * this.collisionPlane.x)) - (this.dest.y * this.collisionPlane.y)) - (this.dest.z * this.collisionPlane.z)); + this.dest.x = (this.dest.x + (this.collisionPlane.x * _local_7)); + this.dest.y = (this.dest.y + (this.collisionPlane.y * _local_7)); + this.dest.z = (this.dest.z + (this.collisionPlane.z * _local_7)); + this.src.x = (this.collisionPoint.x + (this.collisionPlane.x * (this.radius + this.threshold))); + this.src.y = (this.collisionPoint.y + (this.collisionPlane.y * (this.radius + this.threshold))); + this.src.z = (this.collisionPoint.z + (this.collisionPlane.z * (this.radius + this.threshold))); + this.displ.x = (this.dest.x - this.src.x); + this.displ.y = (this.dest.y - this.src.y); + this.displ.z = (this.dest.z - this.src.z); + if (this.displ.length < this.threshold) break; + } + else + { + break; + }; + _local_6++; + }; + this.faces.length = 0; + this.matrix.composeMatrix(); + return (new Vector3D(((((this.matrix.ma * this.dest.x) + (this.matrix.mb * this.dest.y)) + (this.matrix.mc * this.dest.z)) + this.matrix.md), ((((this.matrix.me * this.dest.x) + (this.matrix.mf * this.dest.y)) + (this.matrix.mg * this.dest.z)) + this.matrix.mh), ((((this.matrix.mi * this.dest.x) + (this.matrix.mj * this.dest.y)) + (this.matrix.mk * this.dest.z)) + this.matrix.ml))); + }; + return (new Vector3D((_arg_1.x + _arg_2.x), (_arg_1.y + _arg_2.y), (_arg_1.z + _arg_2.z))); + } + + public function getCollision(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Vector3D, _arg_4:Vector3D, _arg_5:Object3D, _arg_6:Dictionary=null):Boolean{ + var _local_7:Number; + var _local_8:Number; + var _local_9:Number; + var _local_10:Number; + var _local_11:Number; + var _local_12:Number; + var _local_13:Number; + var _local_14:Number; + var _local_15:Number; + var _local_16:Number; + var _local_17:Number; + var _local_18:Number; + if (_arg_2.length <= this.threshold) + { + return (false); + }; + this.prepare(_arg_1, _arg_2, _arg_5, _arg_6, true); + if (this.facesLength > 0) + { + if (this.checkCollision()) + { + this.matrix.composeMatrix(); + _arg_3.x = ((((this.matrix.ma * this.collisionPoint.x) + (this.matrix.mb * this.collisionPoint.y)) + (this.matrix.mc * this.collisionPoint.z)) + this.matrix.md); + _arg_3.y = ((((this.matrix.me * this.collisionPoint.x) + (this.matrix.mf * this.collisionPoint.y)) + (this.matrix.mg * this.collisionPoint.z)) + this.matrix.mh); + _arg_3.z = ((((this.matrix.mi * this.collisionPoint.x) + (this.matrix.mj * this.collisionPoint.y)) + (this.matrix.mk * this.collisionPoint.z)) + this.matrix.ml); + if (this.collisionPlane.x < this.collisionPlane.y) + { + if (this.collisionPlane.x < this.collisionPlane.z) + { + _local_7 = 0; + _local_8 = -(this.collisionPlane.z); + _local_9 = this.collisionPlane.y; + } + else + { + _local_7 = -(this.collisionPlane.y); + _local_8 = this.collisionPlane.x; + _local_9 = 0; + }; + } + else + { + if (this.collisionPlane.y < this.collisionPlane.z) + { + _local_7 = this.collisionPlane.z; + _local_8 = 0; + _local_9 = -(this.collisionPlane.x); + } + else + { + _local_7 = -(this.collisionPlane.y); + _local_8 = this.collisionPlane.x; + _local_9 = 0; + }; + }; + _local_10 = ((this.collisionPlane.z * _local_8) - (this.collisionPlane.y * _local_9)); + _local_11 = ((this.collisionPlane.x * _local_9) - (this.collisionPlane.z * _local_7)); + _local_12 = ((this.collisionPlane.y * _local_7) - (this.collisionPlane.x * _local_8)); + _local_13 = (((this.matrix.ma * _local_7) + (this.matrix.mb * _local_8)) + (this.matrix.mc * _local_9)); + _local_14 = (((this.matrix.me * _local_7) + (this.matrix.mf * _local_8)) + (this.matrix.mg * _local_9)); + _local_15 = (((this.matrix.mi * _local_7) + (this.matrix.mj * _local_8)) + (this.matrix.mk * _local_9)); + _local_16 = (((this.matrix.ma * _local_10) + (this.matrix.mb * _local_11)) + (this.matrix.mc * _local_12)); + _local_17 = (((this.matrix.me * _local_10) + (this.matrix.mf * _local_11)) + (this.matrix.mg * _local_12)); + _local_18 = (((this.matrix.mi * _local_10) + (this.matrix.mj * _local_11)) + (this.matrix.mk * _local_12)); + _arg_4.x = ((_local_15 * _local_17) - (_local_14 * _local_18)); + _arg_4.y = ((_local_13 * _local_18) - (_local_15 * _local_16)); + _arg_4.z = ((_local_14 * _local_16) - (_local_13 * _local_17)); + _arg_4.normalize(); + _arg_4.w = (((_arg_3.x * _arg_4.x) + (_arg_3.y * _arg_4.y)) + (_arg_3.z * _arg_4.z)); + this.faces.length = 0; + return (true); + }; + this.faces.length = 0; + return (false); + }; + return (false); + } + + private function checkCollision():Boolean{ + var _local_4:Face; + var _local_5:Wrapper; + var _local_6:Vertex; + var _local_7:Vertex; + var _local_8:Vertex; + var _local_9:Number; + var _local_10:Number; + var _local_11:Number; + var _local_12:Number; + var _local_13:Number; + var _local_14:Number; + var _local_15:Number; + var _local_16:Number; + var _local_17:Number; + var _local_18:Number; + var _local_19:Number; + var _local_20:Number; + var _local_21:Number; + var _local_22:Number; + var _local_23:Number; + var _local_24:Number; + var _local_25:Number; + var _local_26:Number; + var _local_27:Number; + var _local_28:Boolean; + var _local_29:Wrapper; + var _local_30:Number; + var _local_31:Number; + var _local_32:Number; + var _local_33:Number; + var _local_34:Number; + var _local_35:Number; + var _local_36:Number; + var _local_37:Number; + var _local_38:Number; + var _local_39:Number; + var _local_40:Number; + var _local_41:Number; + var _local_42:Number; + var _local_43:Number; + var _local_44:Number; + var _local_45:Number; + var _local_46:Number; + var _local_1:Number = 1; + var _local_2:Number = this.displ.length; + var _local_3:int; + for (;_local_3 < this.facesLength;_local_3++) + { + _local_4 = this.faces[_local_3]; + _local_5 = _local_4.wrapper; + _local_6 = _local_5.vertex; + _local_5 = _local_5.next; + _local_7 = _local_5.vertex; + _local_5 = _local_5.next; + _local_8 = _local_5.vertex; + _local_9 = (_local_7.cameraX - _local_6.cameraX); + _local_10 = (_local_7.cameraY - _local_6.cameraY); + _local_11 = (_local_7.cameraZ - _local_6.cameraZ); + _local_12 = (_local_8.cameraX - _local_6.cameraX); + _local_13 = (_local_8.cameraY - _local_6.cameraY); + _local_14 = (_local_8.cameraZ - _local_6.cameraZ); + _local_15 = ((_local_14 * _local_10) - (_local_13 * _local_11)); + _local_16 = ((_local_12 * _local_11) - (_local_14 * _local_9)); + _local_17 = ((_local_13 * _local_9) - (_local_12 * _local_10)); + _local_18 = (((_local_15 * _local_15) + (_local_16 * _local_16)) + (_local_17 * _local_17)); + if (_local_18 > 0.001) + { + _local_18 = (1 / Math.sqrt(_local_18)); + _local_15 = (_local_15 * _local_18); + _local_16 = (_local_16 * _local_18); + _local_17 = (_local_17 * _local_18); + } + else + { + continue; + }; + _local_19 = (((_local_6.cameraX * _local_15) + (_local_6.cameraY * _local_16)) + (_local_6.cameraZ * _local_17)); + _local_20 = ((((this.src.x * _local_15) + (this.src.y * _local_16)) + (this.src.z * _local_17)) - _local_19); + if (_local_20 < this.radius) + { + _local_21 = (this.src.x - (_local_15 * _local_20)); + _local_22 = (this.src.y - (_local_16 * _local_20)); + _local_23 = (this.src.z - (_local_17 * _local_20)); + } + else + { + _local_33 = ((_local_20 - this.radius) / ((((_local_20 - (this.dest.x * _local_15)) - (this.dest.y * _local_16)) - (this.dest.z * _local_17)) + _local_19)); + _local_21 = ((this.src.x + (this.displ.x * _local_33)) - (_local_15 * this.radius)); + _local_22 = ((this.src.y + (this.displ.y * _local_33)) - (_local_16 * this.radius)); + _local_23 = ((this.src.z + (this.displ.z * _local_33)) - (_local_17 * this.radius)); + }; + _local_27 = 1E22; + _local_28 = true; + _local_29 = _local_4.wrapper; + while (_local_29 != null) + { + _local_6 = _local_29.vertex; + _local_7 = ((_local_29.next != null) ? _local_29.next.vertex : _local_4.wrapper.vertex); + _local_9 = (_local_7.cameraX - _local_6.cameraX); + _local_10 = (_local_7.cameraY - _local_6.cameraY); + _local_11 = (_local_7.cameraZ - _local_6.cameraZ); + _local_12 = (_local_21 - _local_6.cameraX); + _local_13 = (_local_22 - _local_6.cameraY); + _local_14 = (_local_23 - _local_6.cameraZ); + _local_34 = ((_local_14 * _local_10) - (_local_13 * _local_11)); + _local_35 = ((_local_12 * _local_11) - (_local_14 * _local_9)); + _local_36 = ((_local_13 * _local_9) - (_local_12 * _local_10)); + if ((((_local_34 * _local_15) + (_local_35 * _local_16)) + (_local_36 * _local_17)) < 0) + { + _local_37 = (((_local_9 * _local_9) + (_local_10 * _local_10)) + (_local_11 * _local_11)); + _local_38 = ((((_local_34 * _local_34) + (_local_35 * _local_35)) + (_local_36 * _local_36)) / _local_37); + if (_local_38 < _local_27) + { + _local_37 = Math.sqrt(_local_37); + _local_9 = (_local_9 / _local_37); + _local_10 = (_local_10 / _local_37); + _local_11 = (_local_11 / _local_37); + _local_33 = (((_local_9 * _local_12) + (_local_10 * _local_13)) + (_local_11 * _local_14)); + if (_local_33 < 0) + { + _local_39 = (((_local_12 * _local_12) + (_local_13 * _local_13)) + (_local_14 * _local_14)); + if (_local_39 < _local_27) + { + _local_27 = _local_39; + _local_24 = _local_6.cameraX; + _local_25 = _local_6.cameraY; + _local_26 = _local_6.cameraZ; + }; + } + else + { + if (_local_33 > _local_37) + { + _local_12 = (_local_21 - _local_7.cameraX); + _local_13 = (_local_22 - _local_7.cameraY); + _local_14 = (_local_23 - _local_7.cameraZ); + _local_39 = (((_local_12 * _local_12) + (_local_13 * _local_13)) + (_local_14 * _local_14)); + if (_local_39 < _local_27) + { + _local_27 = _local_39; + _local_24 = _local_7.cameraX; + _local_25 = _local_7.cameraY; + _local_26 = _local_7.cameraZ; + }; + } + else + { + _local_27 = _local_38; + _local_24 = (_local_6.cameraX + (_local_9 * _local_33)); + _local_25 = (_local_6.cameraY + (_local_10 * _local_33)); + _local_26 = (_local_6.cameraZ + (_local_11 * _local_33)); + }; + }; + }; + _local_28 = false; + }; + _local_29 = _local_29.next; + }; + if (_local_28) + { + _local_24 = _local_21; + _local_25 = _local_22; + _local_26 = _local_23; + }; + _local_30 = (this.src.x - _local_24); + _local_31 = (this.src.y - _local_25); + _local_32 = (this.src.z - _local_26); + if ((((_local_30 * this.displ.x) + (_local_31 * this.displ.y)) + (_local_32 * this.displ.z)) <= 0) + { + _local_40 = (-(this.displ.x) / _local_2); + _local_41 = (-(this.displ.y) / _local_2); + _local_42 = (-(this.displ.z) / _local_2); + _local_43 = (((_local_30 * _local_30) + (_local_31 * _local_31)) + (_local_32 * _local_32)); + _local_44 = (((_local_30 * _local_40) + (_local_31 * _local_41)) + (_local_32 * _local_42)); + _local_45 = (((this.radius * this.radius) - _local_43) + (_local_44 * _local_44)); + if (_local_45 > 0) + { + _local_46 = ((_local_44 - Math.sqrt(_local_45)) / _local_2); + if (_local_46 < _local_1) + { + _local_1 = _local_46; + this.collisionPoint.x = _local_24; + this.collisionPoint.y = _local_25; + this.collisionPoint.z = _local_26; + if (_local_28) + { + this.collisionPlane.x = _local_15; + this.collisionPlane.y = _local_16; + this.collisionPlane.z = _local_17; + this.collisionPlane.w = _local_19; + } + else + { + _local_43 = Math.sqrt(_local_43); + this.collisionPlane.x = (_local_30 / _local_43); + this.collisionPlane.y = (_local_31 / _local_43); + this.collisionPlane.z = (_local_32 / _local_43); + this.collisionPlane.w = (((this.collisionPoint.x * this.collisionPlane.x) + (this.collisionPoint.y * this.collisionPlane.y)) + (this.collisionPoint.z * this.collisionPlane.z)); + }; + }; + }; + }; + }; + return (_local_1 < 1); + } + + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/Face.as b/src/alternativa/engine3d/core/Face.as new file mode 100644 index 0000000..ea0efab --- /dev/null +++ b/src/alternativa/engine3d/core/Face.as @@ -0,0 +1,256 @@ +package alternativa.engine3d.core +{ + import alternativa.engine3d.materials.Material; + import flash.geom.Vector3D; + import __AS3__.vec.Vector; + import flash.geom.Point; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class Face + { + + alternativa3d static var collector:Face; + + public var material:Material; + public var smoothingGroups:uint = 0; + alternativa3d var normalX:Number; + alternativa3d var normalY:Number; + alternativa3d var normalZ:Number; + alternativa3d var offset:Number; + alternativa3d var wrapper:Wrapper; + alternativa3d var next:Face; + alternativa3d var processNext:Face; + alternativa3d var processNegative:Face; + alternativa3d var processPositive:Face; + alternativa3d var distance:Number; + alternativa3d var geometry:VG; + public var id:Object; + + + alternativa3d static function create():Face + { + var _local_1:Face; + if (collector != null) + { + _local_1 = collector; + collector = _local_1.next; + _local_1.next = null; + return (_local_1); + }; + return (new (Face)()); + } + + + alternativa3d function create():Face + { + var _local_1:Face; + if (collector != null) + { + _local_1 = collector; + collector = _local_1.next; + _local_1.next = null; + return (_local_1); + }; + return (new Face()); + } + + public function get normal():Vector3D + { + var _local_1:Wrapper = this.wrapper; + var _local_2:Vertex = _local_1.vertex; + _local_1 = _local_1.next; + var _local_3:Vertex = _local_1.vertex; + _local_1 = _local_1.next; + var _local_4:Vertex = _local_1.vertex; + var _local_5:Number = (_local_3.x - _local_2.x); + var _local_6:Number = (_local_3.y - _local_2.y); + var _local_7:Number = (_local_3.z - _local_2.z); + var _local_8:Number = (_local_4.x - _local_2.x); + var _local_9:Number = (_local_4.y - _local_2.y); + var _local_10:Number = (_local_4.z - _local_2.z); + var _local_11:Number = ((_local_10 * _local_6) - (_local_9 * _local_7)); + var _local_12:Number = ((_local_8 * _local_7) - (_local_10 * _local_5)); + var _local_13:Number = ((_local_9 * _local_5) - (_local_8 * _local_6)); + var _local_14:Number = (((_local_11 * _local_11) + (_local_12 * _local_12)) + (_local_13 * _local_13)); + if (_local_14 > 0.001) + { + _local_14 = (1 / Math.sqrt(_local_14)); + _local_11 = (_local_11 * _local_14); + _local_12 = (_local_12 * _local_14); + _local_13 = (_local_13 * _local_14); + }; + return (new Vector3D(_local_11, _local_12, _local_13, (((_local_2.x * _local_11) + (_local_2.y * _local_12)) + (_local_2.z * _local_13)))); + } + + public function get vertices():Vector. + { + var _local_1:Vector. = new Vector.(); + var _local_2:int; + var _local_3:Wrapper = this.wrapper; + while (_local_3 != null) + { + _local_1[_local_2] = _local_3.vertex; + _local_2++; + _local_3 = _local_3.next; + }; + return (_local_1); + } + + public function getUV(_arg_1:Vector3D):Point + { + var _local_2:Vertex = this.wrapper.vertex; + var _local_3:Vertex = this.wrapper.next.vertex; + var _local_4:Vertex = this.wrapper.next.next.vertex; + var _local_5:Number = (_local_3.x - _local_2.x); + var _local_6:Number = (_local_3.y - _local_2.y); + var _local_7:Number = (_local_3.z - _local_2.z); + var _local_8:Number = (_local_3.u - _local_2.u); + var _local_9:Number = (_local_3.v - _local_2.v); + var _local_10:Number = (_local_4.x - _local_2.x); + var _local_11:Number = (_local_4.y - _local_2.y); + var _local_12:Number = (_local_4.z - _local_2.z); + var _local_13:Number = (_local_4.u - _local_2.u); + var _local_14:Number = (_local_4.v - _local_2.v); + var _local_15:Number = (((((((-(this.normalX) * _local_11) * _local_7) + ((_local_10 * this.normalY) * _local_7)) + ((this.normalX * _local_6) * _local_12)) - ((_local_5 * this.normalY) * _local_12)) - ((_local_10 * _local_6) * this.normalZ)) + ((_local_5 * _local_11) * this.normalZ)); + var _local_16:Number = (((-(this.normalY) * _local_12) + (_local_11 * this.normalZ)) / _local_15); + var _local_17:Number = (((this.normalX * _local_12) - (_local_10 * this.normalZ)) / _local_15); + var _local_18:Number = (((-(this.normalX) * _local_11) + (_local_10 * this.normalY)) / _local_15); + var _local_19:Number = ((((((((_local_2.x * this.normalY) * _local_12) - ((this.normalX * _local_2.y) * _local_12)) - ((_local_2.x * _local_11) * this.normalZ)) + ((_local_10 * _local_2.y) * this.normalZ)) + ((this.normalX * _local_11) * _local_2.z)) - ((_local_10 * this.normalY) * _local_2.z)) / _local_15); + var _local_20:Number = (((this.normalY * _local_7) - (_local_6 * this.normalZ)) / _local_15); + var _local_21:Number = (((-(this.normalX) * _local_7) + (_local_5 * this.normalZ)) / _local_15); + var _local_22:Number = (((this.normalX * _local_6) - (_local_5 * this.normalY)) / _local_15); + var _local_23:Number = ((((((((this.normalX * _local_2.y) * _local_7) - ((_local_2.x * this.normalY) * _local_7)) + ((_local_2.x * _local_6) * this.normalZ)) - ((_local_5 * _local_2.y) * this.normalZ)) - ((this.normalX * _local_6) * _local_2.z)) + ((_local_5 * this.normalY) * _local_2.z)) / _local_15); + var _local_24:Number = ((_local_8 * _local_16) + (_local_13 * _local_20)); + var _local_25:Number = ((_local_8 * _local_17) + (_local_13 * _local_21)); + var _local_26:Number = ((_local_8 * _local_18) + (_local_13 * _local_22)); + var _local_27:Number = (((_local_8 * _local_19) + (_local_13 * _local_23)) + _local_2.u); + var _local_28:Number = ((_local_9 * _local_16) + (_local_14 * _local_20)); + var _local_29:Number = ((_local_9 * _local_17) + (_local_14 * _local_21)); + var _local_30:Number = ((_local_9 * _local_18) + (_local_14 * _local_22)); + var _local_31:Number = (((_local_9 * _local_19) + (_local_14 * _local_23)) + _local_2.v); + return (new Point(((((_local_24 * _arg_1.x) + (_local_25 * _arg_1.y)) + (_local_26 * _arg_1.z)) + _local_27), ((((_local_28 * _arg_1.x) + (_local_29 * _arg_1.y)) + (_local_30 * _arg_1.z)) + _local_31))); + } + + public function toString():String + { + return (("[Face " + this.id) + "]"); + } + + alternativa3d function calculateBestSequenceAndNormal():void + { + var _local_1:Wrapper; + var _local_2:Vertex; + var _local_3:Vertex; + var _local_4:Vertex; + var _local_5:Number; + var _local_6:Number; + var _local_7:Number; + var _local_8:Number; + var _local_9:Number; + var _local_10:Number; + var _local_11:Number; + var _local_12:Number; + var _local_13:Number; + var _local_14:Number; + var _local_15:Number; + var _local_16:Wrapper; + var _local_17:Wrapper; + var _local_18:Wrapper; + var _local_19:Wrapper; + var _local_20:Wrapper; + if (this.wrapper.next.next.next != null) + { + _local_15 = -1E22; + _local_1 = this.wrapper; + while (_local_1 != null) + { + _local_19 = ((_local_1.next != null) ? _local_1.next : this.wrapper); + _local_20 = ((_local_19.next != null) ? _local_19.next : this.wrapper); + _local_2 = _local_1.vertex; + _local_3 = _local_19.vertex; + _local_4 = _local_20.vertex; + _local_5 = (_local_3.x - _local_2.x); + _local_6 = (_local_3.y - _local_2.y); + _local_7 = (_local_3.z - _local_2.z); + _local_8 = (_local_4.x - _local_2.x); + _local_9 = (_local_4.y - _local_2.y); + _local_10 = (_local_4.z - _local_2.z); + _local_11 = ((_local_10 * _local_6) - (_local_9 * _local_7)); + _local_12 = ((_local_8 * _local_7) - (_local_10 * _local_5)); + _local_13 = ((_local_9 * _local_5) - (_local_8 * _local_6)); + _local_14 = (((_local_11 * _local_11) + (_local_12 * _local_12)) + (_local_13 * _local_13)); + if (_local_14 > _local_15) + { + _local_15 = _local_14; + _local_16 = _local_1; + }; + _local_1 = _local_1.next; + }; + if (_local_16 != this.wrapper) + { + _local_17 = this.wrapper.next.next.next; + while (_local_17.next != null) + { + _local_17 = _local_17.next; + }; + _local_18 = this.wrapper; + while (((!(_local_18.next == _local_16)) && (!(_local_18.next == null)))) + { + _local_18 = _local_18.next; + }; + _local_17.next = this.wrapper; + _local_18.next = null; + this.wrapper = _local_16; + }; + }; + _local_1 = this.wrapper; + _local_2 = _local_1.vertex; + _local_1 = _local_1.next; + _local_3 = _local_1.vertex; + _local_1 = _local_1.next; + _local_4 = _local_1.vertex; + _local_5 = (_local_3.x - _local_2.x); + _local_6 = (_local_3.y - _local_2.y); + _local_7 = (_local_3.z - _local_2.z); + _local_8 = (_local_4.x - _local_2.x); + _local_9 = (_local_4.y - _local_2.y); + _local_10 = (_local_4.z - _local_2.z); + _local_11 = ((_local_10 * _local_6) - (_local_9 * _local_7)); + _local_12 = ((_local_8 * _local_7) - (_local_10 * _local_5)); + _local_13 = ((_local_9 * _local_5) - (_local_8 * _local_6)); + _local_14 = (((_local_11 * _local_11) + (_local_12 * _local_12)) + (_local_13 * _local_13)); + if (_local_14 > 0) + { + _local_14 = (1 / Math.sqrt(_local_14)); + _local_11 = (_local_11 * _local_14); + _local_12 = (_local_12 * _local_14); + _local_13 = (_local_13 * _local_14); + this.normalX = _local_11; + this.normalY = _local_12; + this.normalZ = _local_13; + }; + this.offset = (((_local_2.x * _local_11) + (_local_2.y * _local_12)) + (_local_2.z * _local_13)); + } + + + public function destroy() : void + { + this.material = null; + if(this.wrapper != null) + { + this.wrapper.destroy(); + this.wrapper = null; + } + if(this.geometry != null) + { + this.geometry.destroy(); + this.geometry = null; + } + } + + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/Light3D.as b/src/alternativa/engine3d/core/Light3D.as new file mode 100644 index 0000000..483ae61 --- /dev/null +++ b/src/alternativa/engine3d/core/Light3D.as @@ -0,0 +1,406 @@ +package alternativa.engine3d.core +{ + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class Light3D extends Object3D + { + + public var color:uint; + public var intensity:Number = 1; + alternativa3d var localWeight:Number; + alternativa3d var localRed:Number; + alternativa3d var localGreen:Number; + alternativa3d var localBlue:Number; + alternativa3d var cma:Number; + alternativa3d var cmb:Number; + alternativa3d var cmc:Number; + alternativa3d var cmd:Number; + alternativa3d var cme:Number; + alternativa3d var cmf:Number; + alternativa3d var cmg:Number; + alternativa3d var cmh:Number; + alternativa3d var cmi:Number; + alternativa3d var cmj:Number; + alternativa3d var cmk:Number; + alternativa3d var cml:Number; + alternativa3d var oma:Number; + alternativa3d var omb:Number; + alternativa3d var omc:Number; + alternativa3d var omd:Number; + alternativa3d var ome:Number; + alternativa3d var omf:Number; + alternativa3d var omg:Number; + alternativa3d var omh:Number; + alternativa3d var omi:Number; + alternativa3d var omj:Number; + alternativa3d var omk:Number; + alternativa3d var oml:Number; + alternativa3d var nextLight:Light3D; + + + override public function clone():Object3D + { + var _local_1:Light3D = new Light3D(); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + override protected function clonePropertiesFrom(_arg_1:Object3D):void + { + super.clonePropertiesFrom(_arg_1); + var _local_2:Light3D = (_arg_1 as Light3D); + this.color = _local_2.color; + this.intensity = _local_2.intensity; + } + + alternativa3d function calculateCameraMatrix(_arg_1:Camera3D):void + { + composeMatrix(); + var _local_2:Object3D = this; + while (_local_2._parent != null) + { + _local_2 = _local_2._parent; + _local_2.composeMatrix(); + appendMatrix(_local_2); + }; + appendMatrix(_arg_1); + this.cma = ma; + this.cmb = mb; + this.cmc = mc; + this.cmd = md; + this.cme = me; + this.cmf = mf; + this.cmg = mg; + this.cmh = mh; + this.cmi = mi; + this.cmj = mj; + this.cmk = mk; + this.cml = ml; + } + + alternativa3d function calculateObjectMatrix(_arg_1:Object3D):void + { + this.oma = (((_arg_1.ima * this.cma) + (_arg_1.imb * this.cme)) + (_arg_1.imc * this.cmi)); + this.omb = (((_arg_1.ima * this.cmb) + (_arg_1.imb * this.cmf)) + (_arg_1.imc * this.cmj)); + this.omc = (((_arg_1.ima * this.cmc) + (_arg_1.imb * this.cmg)) + (_arg_1.imc * this.cmk)); + this.omd = ((((_arg_1.ima * this.cmd) + (_arg_1.imb * this.cmh)) + (_arg_1.imc * this.cml)) + _arg_1.imd); + this.ome = (((_arg_1.ime * this.cma) + (_arg_1.imf * this.cme)) + (_arg_1.img * this.cmi)); + this.omf = (((_arg_1.ime * this.cmb) + (_arg_1.imf * this.cmf)) + (_arg_1.img * this.cmj)); + this.omg = (((_arg_1.ime * this.cmc) + (_arg_1.imf * this.cmg)) + (_arg_1.img * this.cmk)); + this.omh = ((((_arg_1.ime * this.cmd) + (_arg_1.imf * this.cmh)) + (_arg_1.img * this.cml)) + _arg_1.imh); + this.omi = (((_arg_1.imi * this.cma) + (_arg_1.imj * this.cme)) + (_arg_1.imk * this.cmi)); + this.omj = (((_arg_1.imi * this.cmb) + (_arg_1.imj * this.cmf)) + (_arg_1.imk * this.cmj)); + this.omk = (((_arg_1.imi * this.cmc) + (_arg_1.imj * this.cmg)) + (_arg_1.imk * this.cmk)); + this.oml = ((((_arg_1.imi * this.cmd) + (_arg_1.imj * this.cmh)) + (_arg_1.imk * this.cml)) + _arg_1.iml); + } + + override alternativa3d function setParent(_arg_1:Object3DContainer):void + { + var _local_2:Object3DContainer; + var _local_3:Light3D; + var _local_4:Light3D; + if (_arg_1 == null) + { + _local_2 = _parent; + while (_local_2._parent != null) + { + _local_2 = _local_2._parent; + }; + _local_4 = _local_2.lightList; + while (_local_4 != null) + { + if (_local_4 == this) + { + if (_local_3 != null) + { + _local_3.nextLight = this.nextLight; + } + else + { + _local_2.lightList = this.nextLight; + }; + this.nextLight = null; + break; + }; + _local_3 = _local_4; + _local_4 = _local_4.nextLight; + }; + } + else + { + _local_2 = _arg_1; + while (_local_2._parent != null) + { + _local_2 = _local_2._parent; + }; + this.nextLight = _local_2.lightList; + _local_2.lightList = this; + }; + _parent = _arg_1; + } + + alternativa3d function drawDebug(_arg_1:Camera3D):void + { + } + + override alternativa3d function updateBounds(_arg_1:Object3D, _arg_2:Object3D=null):void + { + _arg_1.boundMinX = -1E22; + _arg_1.boundMinY = -1E22; + _arg_1.boundMinZ = -1E22; + _arg_1.boundMaxX = 1E22; + _arg_1.boundMaxY = 1E22; + _arg_1.boundMaxZ = 1E22; + } + + override alternativa3d function cullingInCamera(_arg_1:Camera3D, _arg_2:int):int + { + return (-1); + } + + alternativa3d function checkFrustumCulling(_arg_1:Camera3D):Boolean + { + var _local_2:Vertex = boundVertexList; + _local_2.x = boundMinX; + _local_2.y = boundMinY; + _local_2.z = boundMinZ; + _local_2 = _local_2.next; + _local_2.x = boundMaxX; + _local_2.y = boundMinY; + _local_2.z = boundMinZ; + _local_2 = _local_2.next; + _local_2.x = boundMinX; + _local_2.y = boundMaxY; + _local_2.z = boundMinZ; + _local_2 = _local_2.next; + _local_2.x = boundMaxX; + _local_2.y = boundMaxY; + _local_2.z = boundMinZ; + _local_2 = _local_2.next; + _local_2.x = boundMinX; + _local_2.y = boundMinY; + _local_2.z = boundMaxZ; + _local_2 = _local_2.next; + _local_2.x = boundMaxX; + _local_2.y = boundMinY; + _local_2.z = boundMaxZ; + _local_2 = _local_2.next; + _local_2.x = boundMinX; + _local_2.y = boundMaxY; + _local_2.z = boundMaxZ; + _local_2 = _local_2.next; + _local_2.x = boundMaxX; + _local_2.y = boundMaxY; + _local_2.z = boundMaxZ; + _local_2 = boundVertexList; + while (_local_2 != null) + { + _local_2.cameraX = ((((ma * _local_2.x) + (mb * _local_2.y)) + (mc * _local_2.z)) + md); + _local_2.cameraY = ((((me * _local_2.x) + (mf * _local_2.y)) + (mg * _local_2.z)) + mh); + _local_2.cameraZ = ((((mi * _local_2.x) + (mj * _local_2.y)) + (mk * _local_2.z)) + ml); + _local_2 = _local_2.next; + }; + _local_2 = boundVertexList; + while (_local_2 != null) + { + if (_local_2.cameraZ > _arg_1.nearClipping) break; + _local_2 = _local_2.next; + }; + if (_local_2 == null) + { + return (false); + }; + _local_2 = boundVertexList; + while (_local_2 != null) + { + if (_local_2.cameraZ < _arg_1.farClipping) break; + _local_2 = _local_2.next; + }; + if (_local_2 == null) + { + return (false); + }; + _local_2 = boundVertexList; + while (_local_2 != null) + { + if (-(_local_2.cameraX) < _local_2.cameraZ) break; + _local_2 = _local_2.next; + }; + if (_local_2 == null) + { + return (false); + }; + _local_2 = boundVertexList; + while (_local_2 != null) + { + if (_local_2.cameraX < _local_2.cameraZ) break; + _local_2 = _local_2.next; + }; + if (_local_2 == null) + { + return (false); + }; + _local_2 = boundVertexList; + while (_local_2 != null) + { + if (-(_local_2.cameraY) < _local_2.cameraZ) break; + _local_2 = _local_2.next; + }; + if (_local_2 == null) + { + return (false); + }; + _local_2 = boundVertexList; + while (_local_2 != null) + { + if (_local_2.cameraY < _local_2.cameraZ) break; + _local_2 = _local_2.next; + }; + if (_local_2 == null) + { + return (false); + }; + return (true); + } + + alternativa3d function checkBoundsIntersection(_arg_1:Object3D):Boolean + { + var _local_2:Number; + var _local_3:Number; + var _local_4:Number = ((boundMaxX - boundMinX) * 0.5); + var _local_5:Number = ((boundMaxY - boundMinY) * 0.5); + var _local_6:Number = ((boundMaxZ - boundMinZ) * 0.5); + var _local_7:Number = (this.oma * _local_4); + var _local_8:Number = (this.ome * _local_4); + var _local_9:Number = (this.omi * _local_4); + var _local_10:Number = (this.omb * _local_5); + var _local_11:Number = (this.omf * _local_5); + var _local_12:Number = (this.omj * _local_5); + var _local_13:Number = (this.omc * _local_6); + var _local_14:Number = (this.omg * _local_6); + var _local_15:Number = (this.omk * _local_6); + var _local_16:Number = ((_arg_1.boundMaxX - _arg_1.boundMinX) * 0.5); + var _local_17:Number = ((_arg_1.boundMaxY - _arg_1.boundMinY) * 0.5); + var _local_18:Number = ((_arg_1.boundMaxZ - _arg_1.boundMinZ) * 0.5); + var _local_19:Number = ((((((this.oma * (boundMinX + _local_4)) + (this.omb * (boundMinY + _local_5))) + (this.omc * (boundMinZ + _local_6))) + this.omd) - _arg_1.boundMinX) - _local_16); + var _local_20:Number = ((((((this.ome * (boundMinX + _local_4)) + (this.omf * (boundMinY + _local_5))) + (this.omg * (boundMinZ + _local_6))) + this.omh) - _arg_1.boundMinY) - _local_17); + var _local_21:Number = ((((((this.omi * (boundMinX + _local_4)) + (this.omj * (boundMinY + _local_5))) + (this.omk * (boundMinZ + _local_6))) + this.oml) - _arg_1.boundMinZ) - _local_18); + _local_2 = 0; + _local_3 = ((_local_7 >= 0) ? _local_7 : -(_local_7)); + _local_2 = (_local_2 + _local_3); + _local_3 = ((_local_10 >= 0) ? _local_10 : -(_local_10)); + _local_2 = (_local_2 + _local_3); + _local_3 = ((_local_13 >= 0) ? _local_13 : -(_local_13)); + _local_2 = (_local_2 + _local_3); + _local_2 = (_local_2 + _local_16); + _local_3 = ((_local_19 >= 0) ? _local_19 : -(_local_19)); + _local_2 = (_local_2 - _local_3); + if (_local_2 <= 0) + { + return (false); + }; + _local_2 = 0; + _local_3 = ((_local_8 >= 0) ? _local_8 : -(_local_8)); + _local_2 = (_local_2 + _local_3); + _local_3 = ((_local_11 >= 0) ? _local_11 : -(_local_11)); + _local_2 = (_local_2 + _local_3); + _local_3 = ((_local_14 >= 0) ? _local_14 : -(_local_14)); + _local_2 = (_local_2 + _local_3); + _local_2 = (_local_2 + _local_17); + _local_3 = ((_local_20 >= 0) ? _local_20 : -(_local_20)); + _local_2 = (_local_2 - _local_3); + if (_local_2 <= 0) + { + return (false); + }; + _local_2 = 0; + _local_3 = ((_local_9 >= 0) ? _local_9 : -(_local_9)); + _local_2 = (_local_2 + _local_3); + _local_3 = ((_local_12 >= 0) ? _local_12 : -(_local_12)); + _local_2 = (_local_2 + _local_3); + _local_3 = ((_local_15 >= 0) ? _local_15 : -(_local_15)); + _local_2 = (_local_2 + _local_3); + _local_2 = (_local_2 + _local_17); + _local_3 = ((_local_21 >= 0) ? _local_21 : -(_local_21)); + _local_2 = (_local_2 - _local_3); + if (_local_2 <= 0) + { + return (false); + }; + _local_2 = 0; + _local_3 = (((this.oma * _local_7) + (this.ome * _local_8)) + (this.omi * _local_9)); + _local_3 = ((_local_3 >= 0) ? _local_3 : -(_local_3)); + _local_2 = (_local_2 + _local_3); + _local_3 = (((this.oma * _local_10) + (this.ome * _local_11)) + (this.omi * _local_12)); + _local_3 = ((_local_3 >= 0) ? _local_3 : -(_local_3)); + _local_2 = (_local_2 + _local_3); + _local_3 = (((this.oma * _local_13) + (this.ome * _local_14)) + (this.omi * _local_15)); + _local_3 = ((_local_3 >= 0) ? _local_3 : -(_local_3)); + _local_2 = (_local_2 + _local_3); + _local_3 = ((this.oma >= 0) ? (this.oma * _local_16) : (-(this.oma) * _local_16)); + _local_2 = (_local_2 + _local_3); + _local_3 = ((this.ome >= 0) ? (this.ome * _local_17) : (-(this.ome) * _local_17)); + _local_2 = (_local_2 + _local_3); + _local_3 = ((this.omi >= 0) ? (this.omi * _local_18) : (-(this.omi) * _local_18)); + _local_2 = (_local_2 + _local_3); + _local_3 = (((this.oma * _local_19) + (this.ome * _local_20)) + (this.omi * _local_21)); + _local_3 = ((_local_3 >= 0) ? _local_3 : -(_local_3)); + _local_2 = (_local_2 - _local_3); + if (_local_2 <= 0) + { + return (false); + }; + _local_2 = 0; + _local_3 = (((this.omb * _local_7) + (this.omf * _local_8)) + (this.omj * _local_9)); + _local_3 = ((_local_3 >= 0) ? _local_3 : -(_local_3)); + _local_2 = (_local_2 + _local_3); + _local_3 = (((this.omb * _local_10) + (this.omf * _local_11)) + (this.omj * _local_12)); + _local_3 = ((_local_3 >= 0) ? _local_3 : -(_local_3)); + _local_2 = (_local_2 + _local_3); + _local_3 = (((this.omb * _local_13) + (this.omf * _local_14)) + (this.omj * _local_15)); + _local_3 = ((_local_3 >= 0) ? _local_3 : -(_local_3)); + _local_2 = (_local_2 + _local_3); + _local_3 = ((this.omb >= 0) ? (this.omb * _local_16) : (-(this.omb) * _local_16)); + _local_2 = (_local_2 + _local_3); + _local_3 = ((this.omf >= 0) ? (this.omf * _local_17) : (-(this.omf) * _local_17)); + _local_2 = (_local_2 + _local_3); + _local_3 = ((this.omj >= 0) ? (this.omj * _local_18) : (-(this.omj) * _local_18)); + _local_2 = (_local_2 + _local_3); + _local_3 = (((this.omb * _local_19) + (this.omf * _local_20)) + (this.omj * _local_21)); + _local_3 = ((_local_3 >= 0) ? _local_3 : -(_local_3)); + _local_2 = (_local_2 - _local_3); + if (_local_2 <= 0) + { + return (false); + }; + _local_2 = 0; + _local_3 = (((this.omc * _local_7) + (this.omg * _local_8)) + (this.omk * _local_9)); + _local_3 = ((_local_3 >= 0) ? _local_3 : -(_local_3)); + _local_2 = (_local_2 + _local_3); + _local_3 = (((this.omc * _local_10) + (this.omg * _local_11)) + (this.omk * _local_12)); + _local_3 = ((_local_3 >= 0) ? _local_3 : -(_local_3)); + _local_2 = (_local_2 + _local_3); + _local_3 = (((this.omc * _local_13) + (this.omg * _local_14)) + (this.omk * _local_15)); + _local_3 = ((_local_3 >= 0) ? _local_3 : -(_local_3)); + _local_2 = (_local_2 + _local_3); + _local_3 = ((this.omc >= 0) ? (this.omc * _local_16) : (-(this.omc) * _local_16)); + _local_2 = (_local_2 + _local_3); + _local_3 = ((this.omg >= 0) ? (this.omg * _local_17) : (-(this.omg) * _local_17)); + _local_2 = (_local_2 + _local_3); + _local_3 = ((this.omk >= 0) ? (this.omk * _local_18) : (-(this.omk) * _local_18)); + _local_2 = (_local_2 + _local_3); + _local_3 = (((this.omc * _local_19) + (this.omg * _local_20)) + (this.omk * _local_21)); + _local_3 = ((_local_3 >= 0) ? _local_3 : -(_local_3)); + _local_2 = (_local_2 - _local_3); + if (_local_2 <= 0) + { + return (false); + }; + return (true); + } + + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/MipMapping.as b/src/alternativa/engine3d/core/MipMapping.as new file mode 100644 index 0000000..5afcbf2 --- /dev/null +++ b/src/alternativa/engine3d/core/MipMapping.as @@ -0,0 +1,18 @@ +package alternativa.engine3d.core +{ + public class MipMapping + { + + public static const NONE:int = 0; + + public static const OBJECT_DISTANCE:int = 1; + + public static const PER_PIXEL:int = 2; + + + public function MipMapping() + { + super(); + } + } +} diff --git a/src/alternativa/engine3d/core/MouseEvent3D.as b/src/alternativa/engine3d/core/MouseEvent3D.as new file mode 100644 index 0000000..f8e2a97 --- /dev/null +++ b/src/alternativa/engine3d/core/MouseEvent3D.as @@ -0,0 +1,117 @@ +package alternativa.engine3d.core +{ + import flash.events.Event; + import flash.geom.Vector3D; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class MouseEvent3D extends Event + { + + public static const CLICK:String = "click3D"; + public static const DOUBLE_CLICK:String = "doubleClick3D"; + public static const MOUSE_DOWN:String = "mouseDown3D"; + public static const MOUSE_UP:String = "mouseUp3D"; + public static const MOUSE_OVER:String = "mouseOver3D"; + public static const MOUSE_OUT:String = "mouseOut3D"; + public static const ROLL_OVER:String = "rollOver3D"; + public static const ROLL_OUT:String = "rollOut3D"; + public static const MOUSE_MOVE:String = "mouseMove3D"; + public static const MOUSE_WHEEL:String = "mouseWheel3D"; + + public var ctrlKey:Boolean; + public var altKey:Boolean; + public var shiftKey:Boolean; + public var buttonDown:Boolean; + public var delta:int; + public var relatedObject:Object3D; + public var localOrigin:Vector3D = new Vector3D(); + public var localDirection:Vector3D = new Vector3D(); + alternativa3d var _target:Object3D; + alternativa3d var _currentTarget:Object3D; + alternativa3d var _bubbles:Boolean; + alternativa3d var _eventPhase:uint = 3; + alternativa3d var stop:Boolean = false; + alternativa3d var stopImmediate:Boolean = false; + + public function MouseEvent3D(_arg_1:String, _arg_2:Boolean=true, _arg_3:Object3D=null, _arg_4:Boolean=false, _arg_5:Boolean=false, _arg_6:Boolean=false, _arg_7:Boolean=false, _arg_8:int=0) + { + super(_arg_1, _arg_2); + this.relatedObject = _arg_3; + this.altKey = _arg_4; + this.ctrlKey = _arg_5; + this.shiftKey = _arg_6; + this.buttonDown = _arg_7; + this.delta = _arg_8; + } + + alternativa3d function calculateLocalRay(_arg_1:Number, _arg_2:Number, _arg_3:Object3D, _arg_4:Camera3D):void + { + _arg_4.calculateRay(this.localOrigin, this.localDirection, _arg_1, _arg_2); + _arg_3.composeMatrix(); + var _local_5:Object3D = _arg_3; + while (_local_5._parent != null) + { + _local_5 = _local_5._parent; + _local_5.composeMatrix(); + _arg_3.appendMatrix(_local_5); + }; + _arg_3.invertMatrix(); + var _local_6:Number = this.localOrigin.x; + var _local_7:Number = this.localOrigin.y; + var _local_8:Number = this.localOrigin.z; + var _local_9:Number = this.localDirection.x; + var _local_10:Number = this.localDirection.y; + var _local_11:Number = this.localDirection.z; + this.localOrigin.x = ((((_arg_3.ma * _local_6) + (_arg_3.mb * _local_7)) + (_arg_3.mc * _local_8)) + _arg_3.md); + this.localOrigin.y = ((((_arg_3.me * _local_6) + (_arg_3.mf * _local_7)) + (_arg_3.mg * _local_8)) + _arg_3.mh); + this.localOrigin.z = ((((_arg_3.mi * _local_6) + (_arg_3.mj * _local_7)) + (_arg_3.mk * _local_8)) + _arg_3.ml); + this.localDirection.x = (((_arg_3.ma * _local_9) + (_arg_3.mb * _local_10)) + (_arg_3.mc * _local_11)); + this.localDirection.y = (((_arg_3.me * _local_9) + (_arg_3.mf * _local_10)) + (_arg_3.mg * _local_11)); + this.localDirection.z = (((_arg_3.mi * _local_9) + (_arg_3.mj * _local_10)) + (_arg_3.mk * _local_11)); + } + + override public function get bubbles():Boolean + { + return (this._bubbles); + } + + override public function get eventPhase():uint + { + return (this._eventPhase); + } + + override public function get target():Object + { + return (this._target); + } + + override public function get currentTarget():Object + { + return (this._currentTarget); + } + + override public function stopPropagation():void + { + this.stop = true; + } + + override public function stopImmediatePropagation():void + { + this.stopImmediate = true; + } + + override public function clone():Event + { + return (new MouseEvent3D(type, this._bubbles, this.relatedObject, this.altKey, this.ctrlKey, this.shiftKey, this.buttonDown, this.delta)); + } + + override public function toString():String + { + return (formatToString("MouseEvent3D", "type", "bubbles", "eventPhase", "relatedObject", "altKey", "ctrlKey", "shiftKey", "buttonDown", "delta")); + } + + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/Object3D.as b/src/alternativa/engine3d/core/Object3D.as new file mode 100644 index 0000000..54a1d5a --- /dev/null +++ b/src/alternativa/engine3d/core/Object3D.as @@ -0,0 +1,1465 @@ +package alternativa.engine3d.core +{ + import flash.events.IEventDispatcher; + import flash.geom.Vector3D; + import flash.geom.ColorTransform; + import __AS3__.vec.Vector; + import flash.geom.Matrix3D; + import flash.events.Event; + import flash.utils.Dictionary; + import flash.utils.getQualifiedClassName; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + import alternativa.types.Matrix4; + + use namespace alternativa3d; + + [Event(name="click", type="alternativa.engine3d.core.MouseEvent3D")] + [Event(name="doubleClick", type="alternativa.engine3d.core.MouseEvent3D")] + [Event(name="mouseDown", type="alternativa.engine3d.core.MouseEvent3D")] + [Event(name="mouseUp", type="alternativa.engine3d.core.MouseEvent3D")] + [Event(name="mouseOver", type="alternativa.engine3d.core.MouseEvent3D")] + [Event(name="mouseOut", type="alternativa.engine3d.core.MouseEvent3D")] + [Event(name="rollOver", type="alternativa.engine3d.core.MouseEvent3D")] + [Event(name="rollOut", type="alternativa.engine3d.core.MouseEvent3D")] + [Event(name="mouseMove", type="alternativa.engine3d.core.MouseEvent3D")] + [Event(name="mouseWheel", type="alternativa.engine3d.core.MouseEvent3D")] + public class Object3D implements IEventDispatcher + { + + alternativa3d static const boundVertexList:Vertex = Vertex.createList(8); + alternativa3d static const tA:Object3D = new (Object3D)(); + alternativa3d static const tB:Object3D = new (Object3D)(); + private static const staticSphere:Vector3D = new Vector3D(); + + private var _x:Number = 0; + private var _y:Number = 0; + private var _z:Number = 0; + private var _rotationX:Number = 0; + private var _rotationY:Number = 0; + private var _rotationZ:Number = 0; + private var _scaleX:Number = 1; + private var _scaleY:Number = 1; + private var _scaleZ:Number = 1; + public var name:String; + public var originalName:String; + public var visible:Boolean = true; + public var alpha:Number = 1; + public var blendMode:String = "normal"; + public var colorTransform:ColorTransform = null; + public var filters:Array = null; + public var mouseEnabled:Boolean = true; + public var doubleClickEnabled:Boolean = false; + public var useHandCursor:Boolean = false; + public var depthMapAlphaThreshold:Number = 1; + public var shadowMapAlphaThreshold:Number = 1; + public var softAttenuation:Number = 0; + public var useShadowMap:Boolean = true; + public var useLight:Boolean = true; + public var boundMinX:Number = -1E22; + public var boundMinY:Number = -1E22; + public var boundMinZ:Number = -1E22; + public var boundMaxX:Number = 1E22; + public var boundMaxY:Number = 1E22; + public var boundMaxZ:Number = 1E22; + alternativa3d var ma:Number; + alternativa3d var mb:Number; + alternativa3d var mc:Number; + alternativa3d var md:Number; + alternativa3d var me:Number; + alternativa3d var mf:Number; + alternativa3d var mg:Number; + alternativa3d var mh:Number; + alternativa3d var mi:Number; + alternativa3d var mj:Number; + alternativa3d var mk:Number; + alternativa3d var ml:Number; + alternativa3d var ima:Number; + alternativa3d var imb:Number; + alternativa3d var imc:Number; + alternativa3d var imd:Number; + alternativa3d var ime:Number; + alternativa3d var imf:Number; + alternativa3d var img:Number; + alternativa3d var imh:Number; + alternativa3d var imi:Number; + alternativa3d var imj:Number; + alternativa3d var imk:Number; + alternativa3d var iml:Number; + alternativa3d var _parent:Object3DContainer; + alternativa3d var next:Object3D; + alternativa3d var culling:int = 0; + alternativa3d var transformId:int = 0; + alternativa3d var distance:Number; + alternativa3d var concatenatedAlpha:Number = 1; + alternativa3d var concatenatedBlendMode:String = "normal"; + alternativa3d var concatenatedColorTransform:ColorTransform = null; + alternativa3d var bubbleListeners:Object; + alternativa3d var captureListeners:Object; + alternativa3d var useDepth:Boolean = false; + alternativa3d var transformConst:Vector. = new Vector.(12); + alternativa3d var colorConst:Vector. = Vector.([0, 0, 0, 1, 0, 0, 0, 1]); + + + public function destroy() : void + { + name = null; + colorTransform = null; + _parent = null; + next = null; + concatenatedColorTransform = null; + transformConst = null; + colorConst = null; + } + + public function get x() : Number + { + return this._x; + } + public function set x(val:Number) : void + { + this._x = val; + } + + public function get y() : Number + { + return this._y; + } + public function set y(val:Number) : void + { + this._y = val; + } + + public function get z() : Number + { + return this._z; + } + public function set z(val:Number) : void + { + this._z = val; + } + + public function get rotationX() : Number + { + return this._rotationX; + } + public function set rotationX(val:Number) : void + { + this._rotationX = val; + } + + public function get rotationY() : Number + { + return this._rotationY; + } + public function set rotationY(val:Number) : void + { + this._rotationY = val; + } + + public function get rotationZ() : Number + { + return this._rotationZ; + } + public function set rotationZ(val:Number) : void + { + this._rotationZ = val; + } + + public function get scaleX() : Number + { + return this._scaleX; + } + public function set scaleX(val:Number) : void + { + this._scaleX = val; + } + + public function get scaleY() : Number + { + return this._scaleY; + } + public function set scaleY(val:Number) : void + { + this._scaleY = val; + } + + public function get scaleZ() : Number + { + return this._scaleZ; + } + public function set scaleZ(val:Number) : void + { + this._scaleZ = val; + } + + public function setPositionXYZ(x:Number, y:Number, z:Number) : void + { + this._x = x; + this._y = y; + this._z = z; + } + + public function setRotationXYZ(x:Number, y:Number, z:Number) : void + { + this._rotationX = x; + this._rotationY = y; + this._rotationZ = z; + } + + public function setPositionFromVector3(position:Vector3D) : void + { + this._x = position.x; + this._y = position.y; + this._z = position.z; + } + + public function copyPositionTo(position:Vector3D) : void + { + position.setTo(this._x, this._y, this._z); + } + + + public function get matrix():Matrix3D + { + tA.composeMatrixFromSource(this); + return (new Matrix3D(Vector.([tA.ma, tA.me, tA.mi, 0, tA.mb, tA.mf, tA.mj, 0, tA.mc, tA.mg, tA.mk, 0, tA.md, tA.mh, tA.ml, 1]))); + } + public function get transformation() : Matrix4 + { + tA.composeMatrixFromSource(this); + return new Matrix4(tA.ma, tA.mb, tA.mc, tA.md, tA.me, tA.mf, tA.mg, tA.mh, tA.mi, tA.mj, tA.mk, tA.ml); + } + + public function set matrix(_arg_1:Matrix3D):void + { + var _local_2:Vector. = _arg_1.decompose(); + var _local_3:Vector3D = _local_2[0]; + var _local_4:Vector3D = _local_2[1]; + var _local_5:Vector3D = _local_2[2]; + this._x = _local_3.x; + this._y = _local_3.y; + this._z = _local_3.z; + this._rotationX = _local_4.x; + this._rotationY = _local_4.y; + this._rotationZ = _local_4.z; + this._scaleX = _local_5.x; + this._scaleY = _local_5.y; + this._scaleZ = _local_5.z; + } + + public function get concatenatedMatrix():Matrix3D + { + tA.composeMatrixFromSource(this); + var _local_1:Object3D = this; + while (_local_1._parent != null) + { + _local_1 = _local_1._parent; + tB.composeMatrixFromSource(_local_1); + tA.appendMatrix(tB); + }; + return (new Matrix3D(Vector.([tA.ma, tA.me, tA.mi, 0, tA.mb, tA.mf, tA.mj, 0, tA.mc, tA.mg, tA.mk, 0, tA.md, tA.mh, tA.ml, 1]))); + } + + public function localToGlobal(_arg_1:Vector3D):Vector3D + { + tA.composeMatrixFromSource(this); + var _local_2:Object3D = this; + while (_local_2._parent != null) + { + _local_2 = _local_2._parent; + tB.composeMatrixFromSource(_local_2); + tA.appendMatrix(tB); + }; + var _local_3:Vector3D = new Vector3D(); + _local_3.x = ((((tA.ma * _arg_1.x) + (tA.mb * _arg_1.y)) + (tA.mc * _arg_1.z)) + tA.md); + _local_3.y = ((((tA.me * _arg_1.x) + (tA.mf * _arg_1.y)) + (tA.mg * _arg_1.z)) + tA.mh); + _local_3.z = ((((tA.mi * _arg_1.x) + (tA.mj * _arg_1.y)) + (tA.mk * _arg_1.z)) + tA.ml); + return (_local_3); + } + + public function globalToLocal(_arg_1:Vector3D):Vector3D + { + tA.composeMatrixFromSource(this); + var _local_2:Object3D = this; + while (_local_2._parent != null) + { + _local_2 = _local_2._parent; + tB.composeMatrixFromSource(_local_2); + tA.appendMatrix(tB); + }; + tA.invertMatrix(); + var _local_3:Vector3D = new Vector3D(); + _local_3.x = ((((tA.ma * _arg_1.x) + (tA.mb * _arg_1.y)) + (tA.mc * _arg_1.z)) + tA.md); + _local_3.y = ((((tA.me * _arg_1.x) + (tA.mf * _arg_1.y)) + (tA.mg * _arg_1.z)) + tA.mh); + _local_3.z = ((((tA.mi * _arg_1.x) + (tA.mj * _arg_1.y)) + (tA.mk * _arg_1.z)) + tA.ml); + return (_local_3); + } + + public function get parent():Object3DContainer + { + return (this._parent); + } + + alternativa3d function setParent(_arg_1:Object3DContainer):void + { + this._parent = _arg_1; + } + + public function calculateBounds():void + { + this.boundMinX = 1E22; + this.boundMinY = 1E22; + this.boundMinZ = 1E22; + this.boundMaxX = -1E22; + this.boundMaxY = -1E22; + this.boundMaxZ = -1E22; + this.updateBounds(this, null); + if (this.boundMinX > this.boundMaxX) + { + this.boundMinX = -1E22; + this.boundMinY = -1E22; + this.boundMinZ = -1E22; + this.boundMaxX = 1E22; + this.boundMaxY = 1E22; + this.boundMaxZ = 1E22; + }; + } + + public function addEventListener(_arg_1:String, _arg_2:Function, _arg_3:Boolean=false, _arg_4:int=0, _arg_5:Boolean=false):void + { + var _local_6:Object; + if (_arg_2 == null) + { + throw (new TypeError("Parameter listener must be non-null.")); + }; + if (_arg_3) + { + if (this.captureListeners == null) + { + this.captureListeners = new Object(); + }; + _local_6 = this.captureListeners; + } else + { + if (this.bubbleListeners == null) + { + this.bubbleListeners = new Object(); + }; + _local_6 = this.bubbleListeners; + }; + var _local_7:Vector. = _local_6[_arg_1]; + if (_local_7 == null) + { + _local_7 = new Vector.(); + _local_6[_arg_1] = _local_7; + }; + if (_local_7.indexOf(_arg_2) < 0) + { + _local_7.push(_arg_2); + }; + } + + public function removeEventListener(_arg_1:String, _arg_2:Function, _arg_3:Boolean=false):void + { + var _local_5:Vector.; + var _local_6:int; + var _local_7:int; + var _local_8:int; + var _local_9:*; + if (_arg_2 == null) + { + throw (new TypeError("Parameter listener must be non-null.")); + }; + var _local_4:Object = ((_arg_3) ? this.captureListeners : this.bubbleListeners); + if (_local_4 != null) + { + _local_5 = _local_4[_arg_1]; + if (_local_5 != null) + { + _local_6 = _local_5.indexOf(_arg_2); + if (_local_6 >= 0) + { + _local_7 = _local_5.length; + _local_8 = (_local_6 + 1); + while (_local_8 < _local_7) + { + _local_5[_local_6] = _local_5[_local_8]; + _local_8++; + _local_6++; + }; + if (_local_7 > 1) + { + _local_5.length = (_local_7 - 1); + } else + { + delete _local_4[_arg_1]; + for (_local_9 in _local_4) + { + break; + }; + if ((!(_local_9))) + { + if (_local_4 == this.captureListeners) + { + this.captureListeners = null; + } else + { + this.bubbleListeners = null; + }; + }; + }; + }; + }; + }; + } + + public function hasEventListener(_arg_1:String):Boolean + { + return (((!(this.captureListeners == null)) && (this.captureListeners[_arg_1])) || ((!(this.bubbleListeners == null)) && (this.bubbleListeners[_arg_1]))); + } + + public function willTrigger(_arg_1:String):Boolean + { + var _local_2:Object3D = this; + while (_local_2 != null) + { + if ((((!(_local_2.captureListeners == null)) && (_local_2.captureListeners[_arg_1])) || ((!(_local_2.bubbleListeners == null)) && (_local_2.bubbleListeners[_arg_1])))) + { + return (true); + }; + _local_2 = _local_2._parent; + }; + return (false); + } + + public function dispatchEvent(_arg_1:Event):Boolean + { + var _local_4:Object3D; + var _local_6:Vector.; + var _local_7:int; + var _local_8:int; + var _local_9:Vector.; + if (_arg_1 == null) + { + throw (new TypeError("Parameter event must be non-null.")); + }; + if ((_arg_1 is MouseEvent3D)) + { + MouseEvent3D(_arg_1)._target = this; + }; + var _local_2:Vector. = new Vector.(); + var _local_3:int; + _local_4 = this; + while (_local_4 != null) + { + _local_2[_local_3] = _local_4; + _local_3++; + _local_4 = _local_4._parent; + }; + var _local_5:int; + while (_local_5 < _local_3) + { + _local_4 = _local_2[_local_5]; + if ((_arg_1 is MouseEvent3D)) + { + MouseEvent3D(_arg_1)._currentTarget = _local_4; + }; + if (this.bubbleListeners != null) + { + _local_6 = this.bubbleListeners[_arg_1.type]; + if (_local_6 != null) + { + _local_8 = _local_6.length; + _local_9 = new Vector.(); + _local_7 = 0; + while (_local_7 < _local_8) + { + _local_9[_local_7] = _local_6[_local_7]; + _local_7++; + }; + _local_7 = 0; + while (_local_7 < _local_8) + { + (_local_9[_local_7] as Function).call(null, _arg_1); + _local_7++; + }; + }; + }; + if ((!(_arg_1.bubbles))) break; + _local_5++; + }; + return (true); + } + + public function calculateResolution(_arg_1:int, _arg_2:int, _arg_3:int=1, _arg_4:Matrix3D=null):Number + { + return (1); + } + + public function intersectRay(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Dictionary=null, _arg_4:Camera3D=null):RayIntersectionData + { + return (null); + } + + alternativa3d function checkIntersection(_arg_1:Number, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Dictionary):Boolean + { + return (false); + } + + alternativa3d function boundCheckIntersection(_arg_1:Number, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Number, _arg_9:Number, _arg_10:Number, _arg_11:Number, _arg_12:Number, _arg_13:Number):Boolean + { + var _local_17:Number; + var _local_18:Number; + var _local_19:Number; + var _local_20:Number; + var _local_14:Number = (_arg_1 + (_arg_4 * _arg_7)); + var _local_15:Number = (_arg_2 + (_arg_5 * _arg_7)); + var _local_16:Number = (_arg_3 + (_arg_6 * _arg_7)); + if ((((((((_arg_1 >= _arg_8) && (_arg_1 <= _arg_11)) && (_arg_2 >= _arg_9)) && (_arg_2 <= _arg_12)) && (_arg_3 >= _arg_10)) && (_arg_3 <= _arg_13)) || ((((((_local_14 >= _arg_8) && (_local_14 <= _arg_11)) && (_local_15 >= _arg_9)) && (_local_15 <= _arg_12)) && (_local_16 >= _arg_10)) && (_local_16 <= _arg_13)))) + { + return (true); + }; + if ((((((((_arg_1 < _arg_8) && (_local_14 < _arg_8)) || ((_arg_1 > _arg_11) && (_local_14 > _arg_11))) || ((_arg_2 < _arg_9) && (_local_15 < _arg_9))) || ((_arg_2 > _arg_12) && (_local_15 > _arg_12))) || ((_arg_3 < _arg_10) && (_local_16 < _arg_10))) || ((_arg_3 > _arg_13) && (_local_16 > _arg_13)))) + { + return (false); + }; + var _local_21:Number = 1E-6; + if (_arg_4 > _local_21) + { + _local_17 = ((_arg_8 - _arg_1) / _arg_4); + _local_18 = ((_arg_11 - _arg_1) / _arg_4); + } else + { + if (_arg_4 < -(_local_21)) + { + _local_17 = ((_arg_11 - _arg_1) / _arg_4); + _local_18 = ((_arg_8 - _arg_1) / _arg_4); + } else + { + _local_17 = 0; + _local_18 = _arg_7; + }; + }; + if (_arg_5 > _local_21) + { + _local_19 = ((_arg_9 - _arg_2) / _arg_5); + _local_20 = ((_arg_12 - _arg_2) / _arg_5); + } else + { + if (_arg_5 < -(_local_21)) + { + _local_19 = ((_arg_12 - _arg_2) / _arg_5); + _local_20 = ((_arg_9 - _arg_2) / _arg_5); + } else + { + _local_19 = 0; + _local_20 = _arg_7; + }; + }; + if (((_local_19 >= _local_18) || (_local_20 <= _local_17))) + { + return (false); + }; + if (_local_19 < _local_17) + { + if (_local_20 < _local_18) + { + _local_18 = _local_20; + }; + } else + { + _local_17 = _local_19; + if (_local_20 < _local_18) + { + _local_18 = _local_20; + }; + }; + if (_arg_6 > _local_21) + { + _local_19 = ((_arg_10 - _arg_3) / _arg_6); + _local_20 = ((_arg_13 - _arg_3) / _arg_6); + } else + { + if (_arg_6 < -(_local_21)) + { + _local_19 = ((_arg_13 - _arg_3) / _arg_6); + _local_20 = ((_arg_10 - _arg_3) / _arg_6); + } else + { + _local_19 = 0; + _local_20 = _arg_7; + }; + }; + if (((_local_19 >= _local_18) || (_local_20 <= _local_17))) + { + return (false); + }; + return (true); + } + + public function clone():Object3D + { + var _local_1:Object3D = new Object3D(); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + protected function clonePropertiesFrom(_arg_1:Object3D):void + { + this.name = _arg_1.name; + this.visible = _arg_1.visible; + this.alpha = _arg_1.alpha; + this.blendMode = _arg_1.blendMode; + this.mouseEnabled = _arg_1.mouseEnabled; + this.doubleClickEnabled = _arg_1.doubleClickEnabled; + this.useHandCursor = _arg_1.useHandCursor; + this.depthMapAlphaThreshold = _arg_1.depthMapAlphaThreshold; + this.shadowMapAlphaThreshold = _arg_1.shadowMapAlphaThreshold; + this.softAttenuation = _arg_1.softAttenuation; + this.useShadowMap = _arg_1.useShadowMap; + this.useLight = _arg_1.useLight; + this.transformId = _arg_1.transformId; + this.distance = _arg_1.distance; + if (_arg_1.colorTransform != null) + { + this.colorTransform = new ColorTransform(); + this.colorTransform.concat(_arg_1.colorTransform); + }; + if (_arg_1.filters != null) + { + this.filters = new Array().concat(_arg_1.filters); + }; + this._x = _arg_1._x; + this._y = _arg_1._y; + this._z = _arg_1._z; + this._rotationX = _arg_1._rotationX; + this._rotationY = _arg_1._rotationY; + this._rotationZ = _arg_1._rotationZ; + this._scaleX = _arg_1._scaleX; + this._scaleY = _arg_1._scaleY; + this._scaleZ = _arg_1._scaleZ; + this.boundMinX = _arg_1.boundMinX; + this.boundMinY = _arg_1.boundMinY; + this.boundMinZ = _arg_1.boundMinZ; + this.boundMaxX = _arg_1.boundMaxX; + this.boundMaxY = _arg_1.boundMaxY; + this.boundMaxZ = _arg_1.boundMaxZ; + } + + public function toString():String + { + var _local_1:String = getQualifiedClassName(this); + return (((("[" + _local_1.substr((_local_1.indexOf("::") + 2))) + " ") + this.name) + "]"); + } + + alternativa3d function draw(_arg_1:Camera3D):void + { + } + + alternativa3d function getVG(_arg_1:Camera3D):VG + { + return (null); + } + + alternativa3d function updateBounds(_arg_1:Object3D, _arg_2:Object3D=null):void + { + } + + alternativa3d function concat(_arg_1:Object3DContainer):void + { + this.concatenatedAlpha = (_arg_1.concatenatedAlpha * this.alpha); + this.concatenatedBlendMode = ((_arg_1.concatenatedBlendMode != "normal") ? _arg_1.concatenatedBlendMode : this.blendMode); + if (_arg_1.concatenatedColorTransform != null) + { + if (this.colorTransform != null) + { + this.concatenatedColorTransform = new ColorTransform(); + this.concatenatedColorTransform.redMultiplier = _arg_1.concatenatedColorTransform.redMultiplier; + this.concatenatedColorTransform.greenMultiplier = _arg_1.concatenatedColorTransform.greenMultiplier; + this.concatenatedColorTransform.blueMultiplier = _arg_1.concatenatedColorTransform.blueMultiplier; + this.concatenatedColorTransform.redOffset = _arg_1.concatenatedColorTransform.redOffset; + this.concatenatedColorTransform.greenOffset = _arg_1.concatenatedColorTransform.greenOffset; + this.concatenatedColorTransform.blueOffset = _arg_1.concatenatedColorTransform.blueOffset; + this.concatenatedColorTransform.concat(this.colorTransform); + } else + { + this.concatenatedColorTransform = _arg_1.concatenatedColorTransform; + }; + } else + { + this.concatenatedColorTransform = this.colorTransform; + }; + if (this.concatenatedColorTransform != null) + { + this.colorConst[0] = this.concatenatedColorTransform.redMultiplier; + this.colorConst[1] = this.concatenatedColorTransform.greenMultiplier; + this.colorConst[2] = this.concatenatedColorTransform.blueMultiplier; + this.colorConst[3] = this.concatenatedAlpha; + this.colorConst[4] = (this.concatenatedColorTransform.redOffset / 0xFF); + this.colorConst[5] = (this.concatenatedColorTransform.greenOffset / 0xFF); + this.colorConst[6] = (this.concatenatedColorTransform.blueOffset / 0xFF); + } else + { + this.colorConst[3] = this.concatenatedAlpha; + }; + } + + alternativa3d function boundIntersectRay(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Number):Boolean + { + var _local_9:Number; + var _local_10:Number; + var _local_11:Number; + var _local_12:Number; + if (((((((_arg_1.x >= _arg_3) && (_arg_1.x <= _arg_6)) && (_arg_1.y >= _arg_4)) && (_arg_1.y <= _arg_7)) && (_arg_1.z >= _arg_5)) && (_arg_1.z <= _arg_8))) + { + return (true); + }; + if ((((((((_arg_1.x < _arg_3) && (_arg_2.x <= 0)) || ((_arg_1.x > _arg_6) && (_arg_2.x >= 0))) || ((_arg_1.y < _arg_4) && (_arg_2.y <= 0))) || ((_arg_1.y > _arg_7) && (_arg_2.y >= 0))) || ((_arg_1.z < _arg_5) && (_arg_2.z <= 0))) || ((_arg_1.z > _arg_8) && (_arg_2.z >= 0)))) + { + return (false); + }; + var _local_13:Number = 1E-6; + if (_arg_2.x > _local_13) + { + _local_9 = ((_arg_3 - _arg_1.x) / _arg_2.x); + _local_10 = ((_arg_6 - _arg_1.x) / _arg_2.x); + } else + { + if (_arg_2.x < -(_local_13)) + { + _local_9 = ((_arg_6 - _arg_1.x) / _arg_2.x); + _local_10 = ((_arg_3 - _arg_1.x) / _arg_2.x); + } else + { + _local_9 = 0; + _local_10 = 1E22; + }; + }; + if (_arg_2.y > _local_13) + { + _local_11 = ((_arg_4 - _arg_1.y) / _arg_2.y); + _local_12 = ((_arg_7 - _arg_1.y) / _arg_2.y); + } else + { + if (_arg_2.y < -(_local_13)) + { + _local_11 = ((_arg_7 - _arg_1.y) / _arg_2.y); + _local_12 = ((_arg_4 - _arg_1.y) / _arg_2.y); + } else + { + _local_11 = 0; + _local_12 = 1E22; + }; + }; + if (((_local_11 >= _local_10) || (_local_12 <= _local_9))) + { + return (false); + }; + if (_local_11 < _local_9) + { + if (_local_12 < _local_10) + { + _local_10 = _local_12; + }; + } else + { + _local_9 = _local_11; + if (_local_12 < _local_10) + { + _local_10 = _local_12; + }; + }; + if (_arg_2.z > _local_13) + { + _local_11 = ((_arg_5 - _arg_1.z) / _arg_2.z); + _local_12 = ((_arg_8 - _arg_1.z) / _arg_2.z); + } else + { + if (_arg_2.z < -(_local_13)) + { + _local_11 = ((_arg_8 - _arg_1.z) / _arg_2.z); + _local_12 = ((_arg_5 - _arg_1.z) / _arg_2.z); + } else + { + _local_11 = 0; + _local_12 = 1E22; + }; + }; + if (((_local_11 >= _local_10) || (_local_12 <= _local_9))) + { + return (false); + }; + return (true); + } + + alternativa3d function collectPlanes(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Vector3D, _arg_4:Vector3D, _arg_5:Vector3D, _arg_6:Vector., _arg_7:Dictionary=null):void + { + } + + alternativa3d function calculateSphere(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Vector3D, _arg_4:Vector3D, _arg_5:Vector3D, _arg_6:Vector3D=null):Vector3D + { + this.calculateInverseMatrix(); + var _local_7:Number = ((((this.ima * _arg_1.x) + (this.imb * _arg_1.y)) + (this.imc * _arg_1.z)) + this.imd); + var _local_8:Number = ((((this.ime * _arg_1.x) + (this.imf * _arg_1.y)) + (this.img * _arg_1.z)) + this.imh); + var _local_9:Number = ((((this.imi * _arg_1.x) + (this.imj * _arg_1.y)) + (this.imk * _arg_1.z)) + this.iml); + var _local_10:Number = ((((this.ima * _arg_2.x) + (this.imb * _arg_2.y)) + (this.imc * _arg_2.z)) + this.imd); + var _local_11:Number = ((((this.ime * _arg_2.x) + (this.imf * _arg_2.y)) + (this.img * _arg_2.z)) + this.imh); + var _local_12:Number = ((((this.imi * _arg_2.x) + (this.imj * _arg_2.y)) + (this.imk * _arg_2.z)) + this.iml); + var _local_13:Number = ((((this.ima * _arg_3.x) + (this.imb * _arg_3.y)) + (this.imc * _arg_3.z)) + this.imd); + var _local_14:Number = ((((this.ime * _arg_3.x) + (this.imf * _arg_3.y)) + (this.img * _arg_3.z)) + this.imh); + var _local_15:Number = ((((this.imi * _arg_3.x) + (this.imj * _arg_3.y)) + (this.imk * _arg_3.z)) + this.iml); + var _local_16:Number = ((((this.ima * _arg_4.x) + (this.imb * _arg_4.y)) + (this.imc * _arg_4.z)) + this.imd); + var _local_17:Number = ((((this.ime * _arg_4.x) + (this.imf * _arg_4.y)) + (this.img * _arg_4.z)) + this.imh); + var _local_18:Number = ((((this.imi * _arg_4.x) + (this.imj * _arg_4.y)) + (this.imk * _arg_4.z)) + this.iml); + var _local_19:Number = ((((this.ima * _arg_5.x) + (this.imb * _arg_5.y)) + (this.imc * _arg_5.z)) + this.imd); + var _local_20:Number = ((((this.ime * _arg_5.x) + (this.imf * _arg_5.y)) + (this.img * _arg_5.z)) + this.imh); + var _local_21:Number = ((((this.imi * _arg_5.x) + (this.imj * _arg_5.y)) + (this.imk * _arg_5.z)) + this.iml); + var _local_22:Number = (_local_10 - _local_7); + var _local_23:Number = (_local_11 - _local_8); + var _local_24:Number = (_local_12 - _local_9); + var _local_25:Number = (((_local_22 * _local_22) + (_local_23 * _local_23)) + (_local_24 * _local_24)); + _local_22 = (_local_13 - _local_7); + _local_23 = (_local_14 - _local_8); + _local_24 = (_local_15 - _local_9); + var _local_26:Number = (((_local_22 * _local_22) + (_local_23 * _local_23)) + (_local_24 * _local_24)); + if (_local_26 > _local_25) + { + _local_25 = _local_26; + }; + _local_22 = (_local_16 - _local_7); + _local_23 = (_local_17 - _local_8); + _local_24 = (_local_18 - _local_9); + _local_26 = (((_local_22 * _local_22) + (_local_23 * _local_23)) + (_local_24 * _local_24)); + if (_local_26 > _local_25) + { + _local_25 = _local_26; + }; + _local_22 = (_local_19 - _local_7); + _local_23 = (_local_20 - _local_8); + _local_24 = (_local_21 - _local_9); + _local_26 = (((_local_22 * _local_22) + (_local_23 * _local_23)) + (_local_24 * _local_24)); + if (_local_26 > _local_25) + { + _local_25 = _local_26; + }; + if (_arg_6 == null) + { + _arg_6 = staticSphere; + }; + _arg_6.x = _local_7; + _arg_6.y = _local_8; + _arg_6.z = _local_9; + _arg_6.w = Math.sqrt(_local_25); + return (_arg_6); + } + + alternativa3d function boundIntersectSphere(_arg_1:Vector3D, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number):Boolean + { + return (((((((_arg_1.x + _arg_1.w) > _arg_2) && ((_arg_1.x - _arg_1.w) < _arg_5)) && ((_arg_1.y + _arg_1.w) > _arg_3)) && ((_arg_1.y - _arg_1.w) < _arg_6)) && ((_arg_1.z + _arg_1.w) > _arg_4)) && ((_arg_1.z - _arg_1.w) < _arg_7)); + } + + alternativa3d function split(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Vector3D, _arg_4:Number):Vector. + { + return (new Vector.(2)); + } + + alternativa3d function testSplit(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Vector3D, _arg_4:Number):int + { + var _local_5:Vector3D = this.calculatePlane(_arg_1, _arg_2, _arg_3); + if (_local_5.x >= 0) + { + if (_local_5.y >= 0) + { + if (_local_5.z >= 0) + { + if ((((this.boundMaxX * _local_5.x) + (this.boundMaxY * _local_5.y)) + (this.boundMaxZ * _local_5.z)) <= (_local_5.w + _arg_4)) + { + return (-1); + }; + if ((((this.boundMinX * _local_5.x) + (this.boundMinY * _local_5.y)) + (this.boundMinZ * _local_5.z)) >= (_local_5.w - _arg_4)) + { + return (1); + }; + } else + { + if ((((this.boundMaxX * _local_5.x) + (this.boundMaxY * _local_5.y)) + (this.boundMinZ * _local_5.z)) <= (_local_5.w + _arg_4)) + { + return (-1); + }; + if ((((this.boundMinX * _local_5.x) + (this.boundMinY * _local_5.y)) + (this.boundMaxZ * _local_5.z)) >= (_local_5.w - _arg_4)) + { + return (1); + }; + }; + } else + { + if (_local_5.z >= 0) + { + if ((((this.boundMaxX * _local_5.x) + (this.boundMinY * _local_5.y)) + (this.boundMaxZ * _local_5.z)) <= (_local_5.w + _arg_4)) + { + return (-1); + }; + if ((((this.boundMinX * _local_5.x) + (this.boundMaxY * _local_5.y)) + (this.boundMinZ * _local_5.z)) >= (_local_5.w - _arg_4)) + { + return (1); + }; + } else + { + if ((((this.boundMaxX * _local_5.x) + (this.boundMinY * _local_5.y)) + (this.boundMinZ * _local_5.z)) <= (_local_5.w + _arg_4)) + { + return (-1); + }; + if ((((this.boundMinX * _local_5.x) + (this.boundMaxY * _local_5.y)) + (this.boundMaxZ * _local_5.z)) >= (_local_5.w - _arg_4)) + { + return (1); + }; + }; + }; + } else + { + if (_local_5.y >= 0) + { + if (_local_5.z >= 0) + { + if ((((this.boundMinX * _local_5.x) + (this.boundMaxY * _local_5.y)) + (this.boundMaxZ * _local_5.z)) <= (_local_5.w + _arg_4)) + { + return (-1); + }; + if ((((this.boundMaxX * _local_5.x) + (this.boundMinY * _local_5.y)) + (this.boundMinZ * _local_5.z)) >= (_local_5.w - _arg_4)) + { + return (1); + }; + } else + { + if ((((this.boundMinX * _local_5.x) + (this.boundMaxY * _local_5.y)) + (this.boundMinZ * _local_5.z)) <= (_local_5.w + _arg_4)) + { + return (-1); + }; + if ((((this.boundMaxX * _local_5.x) + (this.boundMinY * _local_5.y)) + (this.boundMaxZ * _local_5.z)) >= (_local_5.w - _arg_4)) + { + return (1); + }; + }; + } else + { + if (_local_5.z >= 0) + { + if ((((this.boundMinX * _local_5.x) + (this.boundMinY * _local_5.y)) + (this.boundMaxZ * _local_5.z)) <= (_local_5.w + _arg_4)) + { + return (-1); + }; + if ((((this.boundMaxX * _local_5.x) + (this.boundMaxY * _local_5.y)) + (this.boundMinZ * _local_5.z)) >= (_local_5.w - _arg_4)) + { + return (1); + }; + } else + { + if ((((this.boundMinX * _local_5.x) + (this.boundMinY * _local_5.y)) + (this.boundMinZ * _local_5.z)) <= (_local_5.w + _arg_4)) + { + return (-1); + }; + if ((((this.boundMaxX * _local_5.x) + (this.boundMaxY * _local_5.y)) + (this.boundMaxZ * _local_5.z)) >= (_local_5.w - _arg_4)) + { + return (1); + }; + }; + }; + }; + return (0); + } + + alternativa3d function calculatePlane(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Vector3D):Vector3D + { + var _local_4:Vector3D = new Vector3D(); + var _local_5:Number = (_arg_2.x - _arg_1.x); + var _local_6:Number = (_arg_2.y - _arg_1.y); + var _local_7:Number = (_arg_2.z - _arg_1.z); + var _local_8:Number = (_arg_3.x - _arg_1.x); + var _local_9:Number = (_arg_3.y - _arg_1.y); + var _local_10:Number = (_arg_3.z - _arg_1.z); + _local_4.x = ((_local_10 * _local_6) - (_local_9 * _local_7)); + _local_4.y = ((_local_8 * _local_7) - (_local_10 * _local_5)); + _local_4.z = ((_local_9 * _local_5) - (_local_8 * _local_6)); + var _local_11:Number = (((_local_4.x * _local_4.x) + (_local_4.y * _local_4.y)) + (_local_4.z * _local_4.z)); + if (_local_11 > 0.0001) + { + _local_11 = Math.sqrt(_local_11); + _local_4.x = (_local_4.x / _local_11); + _local_4.y = (_local_4.y / _local_11); + _local_4.z = (_local_4.z / _local_11); + }; + _local_4.w = (((_arg_1.x * _local_4.x) + (_arg_1.y * _local_4.y)) + (_arg_1.z * _local_4.z)); + return (_local_4); + } + + alternativa3d function composeMatrix():void + { + var _local_1:Number = Math.cos(this._rotationX); + var _local_2:Number = Math.sin(this._rotationX); + var _local_3:Number = Math.cos(this._rotationY); + var _local_4:Number = Math.sin(this._rotationY); + var _local_5:Number = Math.cos(this._rotationZ); + var _local_6:Number = Math.sin(this._rotationZ); + var _local_7:Number = (_local_5 * _local_4); + var _local_8:Number = (_local_6 * _local_4); + var _local_9:Number = (_local_3 * this._scaleX); + var _local_10:Number = (_local_2 * this._scaleY); + var _local_11:Number = (_local_1 * this._scaleY); + var _local_12:Number = (_local_1 * this._scaleZ); + var _local_13:Number = (_local_2 * this._scaleZ); + this.ma = (_local_5 * _local_9); + this.mb = ((_local_7 * _local_10) - (_local_6 * _local_11)); + this.mc = ((_local_7 * _local_12) + (_local_6 * _local_13)); + this.md = this._x; + this.me = (_local_6 * _local_9); + this.mf = ((_local_8 * _local_10) + (_local_5 * _local_11)); + this.mg = ((_local_8 * _local_12) - (_local_5 * _local_13)); + this.mh = this._y; + this.mi = (-(_local_4) * this._scaleX); + this.mj = (_local_3 * _local_10); + this.mk = (_local_3 * _local_12); + this.ml = this._z; + } + + alternativa3d function composeMatrixFromSource(_arg_1:Object3D):void + { + var _local_2:Number = Math.cos(_arg_1.rotationX); + var _local_3:Number = Math.sin(_arg_1.rotationX); + var _local_4:Number = Math.cos(_arg_1.rotationY); + var _local_5:Number = Math.sin(_arg_1.rotationY); + var _local_6:Number = Math.cos(_arg_1.rotationZ); + var _local_7:Number = Math.sin(_arg_1.rotationZ); + var _local_8:Number = (_local_6 * _local_5); + var _local_9:Number = (_local_7 * _local_5); + var _local_10:Number = (_local_4 * _arg_1.scaleX); + var _local_11:Number = (_local_3 * _arg_1.scaleY); + var _local_12:Number = (_local_2 * _arg_1.scaleY); + var _local_13:Number = (_local_2 * _arg_1.scaleZ); + var _local_14:Number = (_local_3 * _arg_1.scaleZ); + this.ma = (_local_6 * _local_10); + this.mb = ((_local_8 * _local_11) - (_local_7 * _local_12)); + this.mc = ((_local_8 * _local_13) + (_local_7 * _local_14)); + this.md = _arg_1.x; + this.me = (_local_7 * _local_10); + this.mf = ((_local_9 * _local_11) + (_local_6 * _local_12)); + this.mg = ((_local_9 * _local_13) - (_local_6 * _local_14)); + this.mh = _arg_1.y; + this.mi = (-(_local_5) * _arg_1.scaleX); + this.mj = (_local_4 * _local_11); + this.mk = (_local_4 * _local_13); + this.ml = _arg_1.z; + } + + alternativa3d function appendMatrix(_arg_1:Object3D):void + { + var _local_2:Number = this.ma; + var _local_3:Number = this.mb; + var _local_4:Number = this.mc; + var _local_5:Number = this.md; + var _local_6:Number = this.me; + var _local_7:Number = this.mf; + var _local_8:Number = this.mg; + var _local_9:Number = this.mh; + var _local_10:Number = this.mi; + var _local_11:Number = this.mj; + var _local_12:Number = this.mk; + var _local_13:Number = this.ml; + this.ma = (((_arg_1.ma * _local_2) + (_arg_1.mb * _local_6)) + (_arg_1.mc * _local_10)); + this.mb = (((_arg_1.ma * _local_3) + (_arg_1.mb * _local_7)) + (_arg_1.mc * _local_11)); + this.mc = (((_arg_1.ma * _local_4) + (_arg_1.mb * _local_8)) + (_arg_1.mc * _local_12)); + this.md = ((((_arg_1.ma * _local_5) + (_arg_1.mb * _local_9)) + (_arg_1.mc * _local_13)) + _arg_1.md); + this.me = (((_arg_1.me * _local_2) + (_arg_1.mf * _local_6)) + (_arg_1.mg * _local_10)); + this.mf = (((_arg_1.me * _local_3) + (_arg_1.mf * _local_7)) + (_arg_1.mg * _local_11)); + this.mg = (((_arg_1.me * _local_4) + (_arg_1.mf * _local_8)) + (_arg_1.mg * _local_12)); + this.mh = ((((_arg_1.me * _local_5) + (_arg_1.mf * _local_9)) + (_arg_1.mg * _local_13)) + _arg_1.mh); + this.mi = (((_arg_1.mi * _local_2) + (_arg_1.mj * _local_6)) + (_arg_1.mk * _local_10)); + this.mj = (((_arg_1.mi * _local_3) + (_arg_1.mj * _local_7)) + (_arg_1.mk * _local_11)); + this.mk = (((_arg_1.mi * _local_4) + (_arg_1.mj * _local_8)) + (_arg_1.mk * _local_12)); + this.ml = ((((_arg_1.mi * _local_5) + (_arg_1.mj * _local_9)) + (_arg_1.mk * _local_13)) + _arg_1.ml); + } + + alternativa3d function composeAndAppend(_arg_1:Object3D):void + { + var _local_2:Number = Math.cos(this._rotationX); + var _local_3:Number = Math.sin(this._rotationX); + var _local_4:Number = Math.cos(this._rotationY); + var _local_5:Number = Math.sin(this._rotationY); + var _local_6:Number = Math.cos(this._rotationZ); + var _local_7:Number = Math.sin(this._rotationZ); + var _local_8:Number = (_local_6 * _local_5); + var _local_9:Number = (_local_7 * _local_5); + var _local_10:Number = (_local_4 * this._scaleX); + var _local_11:Number = (_local_3 * this._scaleY); + var _local_12:Number = (_local_2 * this._scaleY); + var _local_13:Number = (_local_2 * this._scaleZ); + var _local_14:Number = (_local_3 * this._scaleZ); + var _local_15:Number = (_local_6 * _local_10); + var _local_16:Number = ((_local_8 * _local_11) - (_local_7 * _local_12)); + var _local_17:Number = ((_local_8 * _local_13) + (_local_7 * _local_14)); + var _local_18:Number = this._x; + var _local_19:Number = (_local_7 * _local_10); + var _local_20:Number = ((_local_9 * _local_11) + (_local_6 * _local_12)); + var _local_21:Number = ((_local_9 * _local_13) - (_local_6 * _local_14)); + var _local_22:Number = this._y; + var _local_23:Number = (-(_local_5) * this._scaleX); + var _local_24:Number = (_local_4 * _local_11); + var _local_25:Number = (_local_4 * _local_13); + var _local_26:Number = this._z; + this.ma = (((_arg_1.ma * _local_15) + (_arg_1.mb * _local_19)) + (_arg_1.mc * _local_23)); + this.mb = (((_arg_1.ma * _local_16) + (_arg_1.mb * _local_20)) + (_arg_1.mc * _local_24)); + this.mc = (((_arg_1.ma * _local_17) + (_arg_1.mb * _local_21)) + (_arg_1.mc * _local_25)); + this.md = ((((_arg_1.ma * _local_18) + (_arg_1.mb * _local_22)) + (_arg_1.mc * _local_26)) + _arg_1.md); + this.me = (((_arg_1.me * _local_15) + (_arg_1.mf * _local_19)) + (_arg_1.mg * _local_23)); + this.mf = (((_arg_1.me * _local_16) + (_arg_1.mf * _local_20)) + (_arg_1.mg * _local_24)); + this.mg = (((_arg_1.me * _local_17) + (_arg_1.mf * _local_21)) + (_arg_1.mg * _local_25)); + this.mh = ((((_arg_1.me * _local_18) + (_arg_1.mf * _local_22)) + (_arg_1.mg * _local_26)) + _arg_1.mh); + this.mi = (((_arg_1.mi * _local_15) + (_arg_1.mj * _local_19)) + (_arg_1.mk * _local_23)); + this.mj = (((_arg_1.mi * _local_16) + (_arg_1.mj * _local_20)) + (_arg_1.mk * _local_24)); + this.mk = (((_arg_1.mi * _local_17) + (_arg_1.mj * _local_21)) + (_arg_1.mk * _local_25)); + this.ml = ((((_arg_1.mi * _local_18) + (_arg_1.mj * _local_22)) + (_arg_1.mk * _local_26)) + _arg_1.ml); + } + + alternativa3d function copyAndAppend(_arg_1:Object3D, _arg_2:Object3D):void + { + this.ma = (((_arg_2.ma * _arg_1.ma) + (_arg_2.mb * _arg_1.me)) + (_arg_2.mc * _arg_1.mi)); + this.mb = (((_arg_2.ma * _arg_1.mb) + (_arg_2.mb * _arg_1.mf)) + (_arg_2.mc * _arg_1.mj)); + this.mc = (((_arg_2.ma * _arg_1.mc) + (_arg_2.mb * _arg_1.mg)) + (_arg_2.mc * _arg_1.mk)); + this.md = ((((_arg_2.ma * _arg_1.md) + (_arg_2.mb * _arg_1.mh)) + (_arg_2.mc * _arg_1.ml)) + _arg_2.md); + this.me = (((_arg_2.me * _arg_1.ma) + (_arg_2.mf * _arg_1.me)) + (_arg_2.mg * _arg_1.mi)); + this.mf = (((_arg_2.me * _arg_1.mb) + (_arg_2.mf * _arg_1.mf)) + (_arg_2.mg * _arg_1.mj)); + this.mg = (((_arg_2.me * _arg_1.mc) + (_arg_2.mf * _arg_1.mg)) + (_arg_2.mg * _arg_1.mk)); + this.mh = ((((_arg_2.me * _arg_1.md) + (_arg_2.mf * _arg_1.mh)) + (_arg_2.mg * _arg_1.ml)) + _arg_2.mh); + this.mi = (((_arg_2.mi * _arg_1.ma) + (_arg_2.mj * _arg_1.me)) + (_arg_2.mk * _arg_1.mi)); + this.mj = (((_arg_2.mi * _arg_1.mb) + (_arg_2.mj * _arg_1.mf)) + (_arg_2.mk * _arg_1.mj)); + this.mk = (((_arg_2.mi * _arg_1.mc) + (_arg_2.mj * _arg_1.mg)) + (_arg_2.mk * _arg_1.mk)); + this.ml = ((((_arg_2.mi * _arg_1.md) + (_arg_2.mj * _arg_1.mh)) + (_arg_2.mk * _arg_1.ml)) + _arg_2.ml); + } + + alternativa3d function invertMatrix():void + { + var _local_1:Number = this.ma; + var _local_2:Number = this.mb; + var _local_3:Number = this.mc; + var _local_4:Number = this.md; + var _local_5:Number = this.me; + var _local_6:Number = this.mf; + var _local_7:Number = this.mg; + var _local_8:Number = this.mh; + var _local_9:Number = this.mi; + var _local_10:Number = this.mj; + var _local_11:Number = this.mk; + var _local_12:Number = this.ml; + var _local_13:Number = (1 / (((((((-(_local_3) * _local_6) * _local_9) + ((_local_2 * _local_7) * _local_9)) + ((_local_3 * _local_5) * _local_10)) - ((_local_1 * _local_7) * _local_10)) - ((_local_2 * _local_5) * _local_11)) + ((_local_1 * _local_6) * _local_11))); + this.ma = (((-(_local_7) * _local_10) + (_local_6 * _local_11)) * _local_13); + this.mb = (((_local_3 * _local_10) - (_local_2 * _local_11)) * _local_13); + this.mc = (((-(_local_3) * _local_6) + (_local_2 * _local_7)) * _local_13); + this.md = ((((((((_local_4 * _local_7) * _local_10) - ((_local_3 * _local_8) * _local_10)) - ((_local_4 * _local_6) * _local_11)) + ((_local_2 * _local_8) * _local_11)) + ((_local_3 * _local_6) * _local_12)) - ((_local_2 * _local_7) * _local_12)) * _local_13); + this.me = (((_local_7 * _local_9) - (_local_5 * _local_11)) * _local_13); + this.mf = (((-(_local_3) * _local_9) + (_local_1 * _local_11)) * _local_13); + this.mg = (((_local_3 * _local_5) - (_local_1 * _local_7)) * _local_13); + this.mh = ((((((((_local_3 * _local_8) * _local_9) - ((_local_4 * _local_7) * _local_9)) + ((_local_4 * _local_5) * _local_11)) - ((_local_1 * _local_8) * _local_11)) - ((_local_3 * _local_5) * _local_12)) + ((_local_1 * _local_7) * _local_12)) * _local_13); + this.mi = (((-(_local_6) * _local_9) + (_local_5 * _local_10)) * _local_13); + this.mj = (((_local_2 * _local_9) - (_local_1 * _local_10)) * _local_13); + this.mk = (((-(_local_2) * _local_5) + (_local_1 * _local_6)) * _local_13); + this.ml = ((((((((_local_4 * _local_6) * _local_9) - ((_local_2 * _local_8) * _local_9)) - ((_local_4 * _local_5) * _local_10)) + ((_local_1 * _local_8) * _local_10)) + ((_local_2 * _local_5) * _local_12)) - ((_local_1 * _local_6) * _local_12)) * _local_13); + } + + alternativa3d function calculateInverseMatrix():void + { + var _local_1:Number = (1 / (((((((-(this.mc) * this.mf) * this.mi) + ((this.mb * this.mg) * this.mi)) + ((this.mc * this.me) * this.mj)) - ((this.ma * this.mg) * this.mj)) - ((this.mb * this.me) * this.mk)) + ((this.ma * this.mf) * this.mk))); + this.ima = (((-(this.mg) * this.mj) + (this.mf * this.mk)) * _local_1); + this.imb = (((this.mc * this.mj) - (this.mb * this.mk)) * _local_1); + this.imc = (((-(this.mc) * this.mf) + (this.mb * this.mg)) * _local_1); + this.imd = ((((((((this.md * this.mg) * this.mj) - ((this.mc * this.mh) * this.mj)) - ((this.md * this.mf) * this.mk)) + ((this.mb * this.mh) * this.mk)) + ((this.mc * this.mf) * this.ml)) - ((this.mb * this.mg) * this.ml)) * _local_1); + this.ime = (((this.mg * this.mi) - (this.me * this.mk)) * _local_1); + this.imf = (((-(this.mc) * this.mi) + (this.ma * this.mk)) * _local_1); + this.img = (((this.mc * this.me) - (this.ma * this.mg)) * _local_1); + this.imh = ((((((((this.mc * this.mh) * this.mi) - ((this.md * this.mg) * this.mi)) + ((this.md * this.me) * this.mk)) - ((this.ma * this.mh) * this.mk)) - ((this.mc * this.me) * this.ml)) + ((this.ma * this.mg) * this.ml)) * _local_1); + this.imi = (((-(this.mf) * this.mi) + (this.me * this.mj)) * _local_1); + this.imj = (((this.mb * this.mi) - (this.ma * this.mj)) * _local_1); + this.imk = (((-(this.mb) * this.me) + (this.ma * this.mf)) * _local_1); + this.iml = ((((((((this.md * this.mf) * this.mi) - ((this.mb * this.mh) * this.mi)) - ((this.md * this.me) * this.mj)) + ((this.ma * this.mh) * this.mj)) + ((this.mb * this.me) * this.ml)) - ((this.ma * this.mf) * this.ml)) * _local_1); + } + + alternativa3d function cullingInCamera(_arg_1:Camera3D, _arg_2:int):int + { + var _local_4:Vertex; + var _local_5:Number; + var _local_6:Number; + var _local_7:Number; + var _local_8:Boolean; + var _local_9:Boolean; + var _local_10:Number; + var _local_11:Number; + var _local_12:int; + var _local_13:Vertex; + if (_arg_1.occludedAll) + { + return (-1); + }; + var _local_3:int = _arg_1.numOccluders; + if (((_arg_2 > 0) || (_local_3 > 0))) + { + _local_4 = boundVertexList; + _local_4.x = this.boundMinX; + _local_4.y = this.boundMinY; + _local_4.z = this.boundMinZ; + _local_4 = _local_4.next; + _local_4.x = this.boundMaxX; + _local_4.y = this.boundMinY; + _local_4.z = this.boundMinZ; + _local_4 = _local_4.next; + _local_4.x = this.boundMinX; + _local_4.y = this.boundMaxY; + _local_4.z = this.boundMinZ; + _local_4 = _local_4.next; + _local_4.x = this.boundMaxX; + _local_4.y = this.boundMaxY; + _local_4.z = this.boundMinZ; + _local_4 = _local_4.next; + _local_4.x = this.boundMinX; + _local_4.y = this.boundMinY; + _local_4.z = this.boundMaxZ; + _local_4 = _local_4.next; + _local_4.x = this.boundMaxX; + _local_4.y = this.boundMinY; + _local_4.z = this.boundMaxZ; + _local_4 = _local_4.next; + _local_4.x = this.boundMinX; + _local_4.y = this.boundMaxY; + _local_4.z = this.boundMaxZ; + _local_4 = _local_4.next; + _local_4.x = this.boundMaxX; + _local_4.y = this.boundMaxY; + _local_4.z = this.boundMaxZ; + _local_4 = boundVertexList; + while (_local_4 != null) + { + _local_5 = _local_4.x; + _local_6 = _local_4.y; + _local_7 = _local_4.z; + _local_4.cameraX = ((((this.ma * _local_5) + (this.mb * _local_6)) + (this.mc * _local_7)) + this.md); + _local_4.cameraY = ((((this.me * _local_5) + (this.mf * _local_6)) + (this.mg * _local_7)) + this.mh); + _local_4.cameraZ = ((((this.mi * _local_5) + (this.mj * _local_6)) + (this.mk * _local_7)) + this.ml); + _local_4 = _local_4.next; + }; + }; + if (_arg_2 > 0) + { + if ((_arg_2 & 0x01)) + { + _local_10 = _arg_1.nearClipping; + _local_4 = boundVertexList; + _local_8 = false; + _local_9 = false; + while (_local_4 != null) + { + if (_local_4.cameraZ > _local_10) + { + _local_8 = true; + if (_local_9) break; + } else + { + _local_9 = true; + if (_local_8) break; + }; + _local_4 = _local_4.next; + }; + if (_local_9) + { + if ((!(_local_8))) + { + return (-1); + }; + } else + { + _arg_2 = (_arg_2 & 0x3E); + }; + }; + if ((_arg_2 & 0x02)) + { + _local_11 = _arg_1.farClipping; + _local_4 = boundVertexList; + _local_8 = false; + _local_9 = false; + while (_local_4 != null) + { + if (_local_4.cameraZ < _local_11) + { + _local_8 = true; + if (_local_9) break; + } else + { + _local_9 = true; + if (_local_8) break; + }; + _local_4 = _local_4.next; + }; + if (_local_9) + { + if ((!(_local_8))) + { + return (-1); + }; + } else + { + _arg_2 = (_arg_2 & 0x3D); + }; + }; + if ((_arg_2 & 0x04)) + { + _local_4 = boundVertexList; + _local_8 = false; + _local_9 = false; + while (_local_4 != null) + { + if (-(_local_4.cameraX) < _local_4.cameraZ) + { + _local_8 = true; + if (_local_9) break; + } else + { + _local_9 = true; + if (_local_8) break; + }; + _local_4 = _local_4.next; + }; + if (_local_9) + { + if ((!(_local_8))) + { + return (-1); + }; + } else + { + _arg_2 = (_arg_2 & 0x3B); + }; + }; + if ((_arg_2 & 0x08)) + { + _local_4 = boundVertexList; + _local_8 = false; + _local_9 = false; + while (_local_4 != null) + { + if (_local_4.cameraX < _local_4.cameraZ) + { + _local_8 = true; + if (_local_9) break; + } else + { + _local_9 = true; + if (_local_8) break; + }; + _local_4 = _local_4.next; + }; + if (_local_9) + { + if ((!(_local_8))) + { + return (-1); + }; + } else + { + _arg_2 = (_arg_2 & 0x37); + }; + }; + if ((_arg_2 & 0x10)) + { + _local_4 = boundVertexList; + _local_8 = false; + _local_9 = false; + while (_local_4 != null) + { + if (-(_local_4.cameraY) < _local_4.cameraZ) + { + _local_8 = true; + if (_local_9) break; + } else + { + _local_9 = true; + if (_local_8) break; + }; + _local_4 = _local_4.next; + }; + if (_local_9) + { + if ((!(_local_8))) + { + return (-1); + }; + } else + { + _arg_2 = (_arg_2 & 0x2F); + }; + }; + if ((_arg_2 & 0x20)) + { + _local_4 = boundVertexList; + _local_8 = false; + _local_9 = false; + while (_local_4 != null) + { + if (_local_4.cameraY < _local_4.cameraZ) + { + _local_8 = true; + if (_local_9) break; + } else + { + _local_9 = true; + if (_local_8) break; + }; + _local_4 = _local_4.next; + }; + if (_local_9) + { + if ((!(_local_8))) + { + return (-1); + }; + } else + { + _arg_2 = (_arg_2 & 0x1F); + }; + }; + }; + if (_local_3 > 0) + { + _local_12 = 0; + while (_local_12 < _local_3) + { + _local_13 = _arg_1.occluders[_local_12]; + while (_local_13 != null) + { + _local_4 = boundVertexList; + while (_local_4 != null) + { + if ((((_local_13.cameraX * _local_4.cameraX) + (_local_13.cameraY * _local_4.cameraY)) + (_local_13.cameraZ * _local_4.cameraZ)) >= 0) break; + _local_4 = _local_4.next; + }; + if (_local_4 != null) break; + _local_13 = _local_13.next; + }; + if (_local_13 == null) + { + return (-1); + }; + _local_12++; + }; + }; + this.culling = _arg_2; + return (_arg_2); + } + + alternativa3d function removeFromParent():void + { + if (this._parent != null) + { + this._parent.removeChild(this); + }; + } + + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/Object3DContainer.as b/src/alternativa/engine3d/core/Object3DContainer.as new file mode 100644 index 0000000..5e11ef6 --- /dev/null +++ b/src/alternativa/engine3d/core/Object3DContainer.as @@ -0,0 +1,835 @@ +package alternativa.engine3d.core +{ + import __AS3__.vec.Vector; + import flash.geom.Vector3D; + import flash.utils.Dictionary; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class Object3DContainer extends Object3D + { + + public var mouseChildren:Boolean = true; + public var childrenList:Object3D; + alternativa3d var lightList:Light3D; + alternativa3d var visibleChildren:Vector. = new Vector.(); + alternativa3d var numVisibleChildren:int = 0; + + + public function get children() : Vector. + { + var objects:Vector. = new Vector.(); + + var child:Object3D = childrenList; + + while(child != null) + { + objects.push(child); + + child = child.next; + } + + return objects; + } + + public function addChild(_arg_1:Object3D):Object3D + { + if (_arg_1 == null) + { + throw (new TypeError("Parameter child must be non-null.")); + }; + if (_arg_1 == this) + { + throw (new ArgumentError("An object cannot be added as a child of itself.")); + }; + var _local_2:Object3DContainer = _parent; + while (_local_2 != null) + { + if (_local_2 == _arg_1) + { + throw (new ArgumentError("An object cannot be added as a child to one of it's children (or children's children, etc.).")); + }; + _local_2 = _local_2._parent; + }; + if (_arg_1._parent != null) + { + _arg_1._parent.removeChild(_arg_1); + }; + this.addToList(_arg_1); + return (_arg_1); + } + + public function removeChild(_arg_1:Object3D):Object3D + { + var _local_2:Object3D; + var _local_3:Object3D; + if (_arg_1 == null) + { + throw (new TypeError("Parameter child must be non-null.")); + }; + if (_arg_1._parent != this) + { + throw (new ArgumentError("The supplied Object3D must be a child of the caller.")); + }; + _local_3 = this.childrenList; + while (_local_3 != null) + { + if (_local_3 == _arg_1) + { + if (_local_2 != null) + { + _local_2.next = _local_3.next; + } else + { + this.childrenList = _local_3.next; + }; + _local_3.next = null; + _local_3.setParent(null); + return (_arg_1); + }; + _local_2 = _local_3; + _local_3 = _local_3.next; + }; + throw (new ArgumentError("Cannot remove child.")); + } + + public function addChildAt(_arg_1:Object3D, _arg_2:int):Object3D + { + if (_arg_1 == null) + { + throw (new TypeError("Parameter child must be non-null.")); + }; + if (_arg_1 == this) + { + throw (new ArgumentError("An object cannot be added as a child of itself.")); + }; + if (_arg_2 < 0) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + var _local_3:Object3DContainer = _parent; + while (_local_3 != null) + { + if (_local_3 == _arg_1) + { + throw (new ArgumentError("An object cannot be added as a child to one of it's children (or children's children, etc.).")); + }; + _local_3 = _local_3._parent; + }; + var _local_4:Object3D = this.childrenList; + var _local_5:int; + while (_local_5 < _arg_2) + { + if (_local_4 == null) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + _local_4 = _local_4.next; + _local_5++; + }; + if (_arg_1._parent != null) + { + _arg_1._parent.removeChild(_arg_1); + }; + this.addToList(_arg_1, _local_4); + return (_arg_1); + } + + public function removeChildAt(_arg_1:int):Object3D + { + if (_arg_1 < 0) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + var _local_2:Object3D = this.childrenList; + var _local_3:int; + while (_local_3 < _arg_1) + { + if (_local_2 == null) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + _local_2 = _local_2.next; + _local_3++; + }; + if (_local_2 == null) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + this.removeChild(_local_2); + return (_local_2); + } + + public function getChildAt(_arg_1:int):Object3D + { + if (_arg_1 < 0) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + var _local_2:Object3D = this.childrenList; + var _local_3:int; + while (_local_3 < _arg_1) + { + if (_local_2 == null) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + _local_2 = _local_2.next; + _local_3++; + }; + if (_local_2 == null) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + return (_local_2); + } + + public function getChildIndex(_arg_1:Object3D):int + { + if (_arg_1 == null) + { + throw (new TypeError("Parameter child must be non-null.")); + }; + if (_arg_1._parent != this) + { + throw (new ArgumentError("The supplied Object3D must be a child of the caller.")); + }; + var _local_2:int; + var _local_3:Object3D = this.childrenList; + while (_local_3 != null) + { + if (_local_3 == _arg_1) + { + return (_local_2); + }; + _local_2++; + _local_3 = _local_3.next; + }; + throw (new ArgumentError("Cannot get child index.")); + } + + public function setChildIndex(_arg_1:Object3D, _arg_2:int):void + { + if (_arg_1 == null) + { + throw (new TypeError("Parameter child must be non-null.")); + }; + if (_arg_1._parent != this) + { + throw (new ArgumentError("The supplied Object3D must be a child of the caller.")); + }; + if (_arg_2 < 0) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + var _local_3:Object3D = this.childrenList; + var _local_4:int; + while (_local_4 < _arg_2) + { + if (_local_3 == null) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + _local_3 = _local_3.next; + _local_4++; + }; + this.removeChild(_arg_1); + this.addToList(_arg_1, _local_3); + } + + public function swapChildren(_arg_1:Object3D, _arg_2:Object3D):void + { + var _local_3:Object3D; + if (((_arg_1 == null) || (_arg_2 == null))) + { + throw (new TypeError("Parameter child must be non-null.")); + }; + if (((!(_arg_1._parent == this)) || (!(_arg_2._parent == this)))) + { + throw (new ArgumentError("The supplied Object3D must be a child of the caller.")); + }; + if (_arg_1 != _arg_2) + { + if (_arg_1.next == _arg_2) + { + this.removeChild(_arg_2); + this.addToList(_arg_2, _arg_1); + } else + { + if (_arg_2.next == _arg_1) + { + this.removeChild(_arg_1); + this.addToList(_arg_1, _arg_2); + } else + { + _local_3 = _arg_1.next; + this.removeChild(_arg_1); + this.addToList(_arg_1, _arg_2); + this.removeChild(_arg_2); + this.addToList(_arg_2, _local_3); + }; + }; + }; + } + + public function swapChildrenAt(_arg_1:int, _arg_2:int):void + { + var _local_3:int; + var _local_4:Object3D; + var _local_5:Object3D; + var _local_6:Object3D; + if (((_arg_1 < 0) || (_arg_2 < 0))) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + if (_arg_1 != _arg_2) + { + _local_4 = this.childrenList; + _local_3 = 0; + while (_local_3 < _arg_1) + { + if (_local_4 == null) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + _local_4 = _local_4.next; + _local_3++; + }; + if (_local_4 == null) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + _local_5 = this.childrenList; + _local_3 = 0; + while (_local_3 < _arg_2) + { + if (_local_5 == null) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + _local_5 = _local_5.next; + _local_3++; + }; + if (_local_5 == null) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + if (_local_4 != _local_5) + { + if (_local_4.next == _local_5) + { + this.removeChild(_local_5); + this.addToList(_local_5, _local_4); + } else + { + if (_local_5.next == _local_4) + { + this.removeChild(_local_4); + this.addToList(_local_4, _local_5); + } else + { + _local_6 = _local_4.next; + this.removeChild(_local_4); + this.addToList(_local_4, _local_5); + this.removeChild(_local_5); + this.addToList(_local_5, _local_6); + }; + }; + }; + }; + } + + public function getChildByName(_arg_1:String):Object3D + { + if (_arg_1 == null) + { + throw (new TypeError("Parameter name must be non-null.")); + }; + var _local_2:Object3D = this.childrenList; + while (_local_2 != null) + { + if (_local_2.name == _arg_1) + { + return (_local_2); + }; + _local_2 = _local_2.next; + }; + return (null); + } + + public function contains(_arg_1:Object3D):Boolean + { + if (_arg_1 == null) + { + throw (new TypeError("Parameter child must be non-null.")); + }; + if (_arg_1 == this) + { + return (true); + }; + var _local_2:Object3D = this.childrenList; + while (_local_2 != null) + { + if ((_local_2 is Object3DContainer)) + { + if ((_local_2 as Object3DContainer).contains(_arg_1)) + { + return (true); + }; + } else + { + if (_local_2 == _arg_1) + { + return (true); + }; + }; + _local_2 = _local_2.next; + }; + return (false); + } + + public function get numChildren():int + { + var _local_1:int; + var _local_2:Object3D = this.childrenList; + while (_local_2 != null) + { + _local_1++; + _local_2 = _local_2.next; + }; + return (_local_1); + } + + override public function intersectRay(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Dictionary=null, _arg_4:Camera3D=null):RayIntersectionData + { + var _local_5:Vector3D; + var _local_6:Vector3D; + var _local_7:RayIntersectionData; + var _local_10:RayIntersectionData; + if (((!(_arg_3 == null)) && (_arg_3[this]))) + { + return (null); + }; + if ((!(boundIntersectRay(_arg_1, _arg_2, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ)))) + { + return (null); + }; + var _local_8:Number = 1E22; + var _local_9:Object3D = this.childrenList; + while (_local_9 != null) + { + _local_9.composeMatrix(); + _local_9.invertMatrix(); + if (_local_5 == null) + { + _local_5 = new Vector3D(); + _local_6 = new Vector3D(); + }; + _local_5.x = ((((_local_9.ma * _arg_1.x) + (_local_9.mb * _arg_1.y)) + (_local_9.mc * _arg_1.z)) + _local_9.md); + _local_5.y = ((((_local_9.me * _arg_1.x) + (_local_9.mf * _arg_1.y)) + (_local_9.mg * _arg_1.z)) + _local_9.mh); + _local_5.z = ((((_local_9.mi * _arg_1.x) + (_local_9.mj * _arg_1.y)) + (_local_9.mk * _arg_1.z)) + _local_9.ml); + _local_6.x = (((_local_9.ma * _arg_2.x) + (_local_9.mb * _arg_2.y)) + (_local_9.mc * _arg_2.z)); + _local_6.y = (((_local_9.me * _arg_2.x) + (_local_9.mf * _arg_2.y)) + (_local_9.mg * _arg_2.z)); + _local_6.z = (((_local_9.mi * _arg_2.x) + (_local_9.mj * _arg_2.y)) + (_local_9.mk * _arg_2.z)); + _local_10 = _local_9.intersectRay(_local_5, _local_6, _arg_3, _arg_4); + if (((!(_local_10 == null)) && (_local_10.time < _local_8))) + { + _local_8 = _local_10.time; + _local_7 = _local_10; + }; + _local_9 = _local_9.next; + }; + return (_local_7); + } + + override alternativa3d function checkIntersection(_arg_1:Number, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Dictionary):Boolean + { + var _local_10:Number; + var _local_11:Number; + var _local_12:Number; + var _local_13:Number; + var _local_14:Number; + var _local_15:Number; + var _local_9:Object3D = this.childrenList; + while (_local_9 != null) + { + if (((!(_arg_8 == null)) && (!(_arg_8[_local_9])))) + { + _local_9.composeMatrix(); + _local_9.invertMatrix(); + _local_10 = ((((_local_9.ma * _arg_1) + (_local_9.mb * _arg_2)) + (_local_9.mc * _arg_3)) + _local_9.md); + _local_11 = ((((_local_9.me * _arg_1) + (_local_9.mf * _arg_2)) + (_local_9.mg * _arg_3)) + _local_9.mh); + _local_12 = ((((_local_9.mi * _arg_1) + (_local_9.mj * _arg_2)) + (_local_9.mk * _arg_3)) + _local_9.ml); + _local_13 = (((_local_9.ma * _arg_4) + (_local_9.mb * _arg_5)) + (_local_9.mc * _arg_6)); + _local_14 = (((_local_9.me * _arg_4) + (_local_9.mf * _arg_5)) + (_local_9.mg * _arg_6)); + _local_15 = (((_local_9.mi * _arg_4) + (_local_9.mj * _arg_5)) + (_local_9.mk * _arg_6)); + if (((boundCheckIntersection(_local_10, _local_11, _local_12, _local_13, _local_14, _local_15, _arg_7, _local_9.boundMinX, _local_9.boundMinY, _local_9.boundMinZ, _local_9.boundMaxX, _local_9.boundMaxY, _local_9.boundMaxZ)) && (_local_9.checkIntersection(_local_10, _local_11, _local_12, _local_13, _local_14, _local_15, _arg_7, _arg_8)))) + { + return (true); + }; + }; + _local_9 = _local_9.next; + }; + return (false); + } + + override alternativa3d function collectPlanes(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Vector3D, _arg_4:Vector3D, _arg_5:Vector3D, _arg_6:Vector., _arg_7:Dictionary=null):void + { + if (((!(_arg_7 == null)) && (_arg_7[this]))) + { + return; + }; + var _local_8:Vector3D = calculateSphere(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5); + if ((!(boundIntersectSphere(_local_8, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ)))) + { + return; + }; + var _local_9:Object3D = this.childrenList; + while (_local_9 != null) + { + _local_9.composeAndAppend(this); + _local_9.collectPlanes(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7); + _local_9 = _local_9.next; + }; + } + + override public function clone():Object3D + { + var _local_1:Object3DContainer = new Object3DContainer(); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + override protected function clonePropertiesFrom(_arg_1:Object3D):void + { + var _local_4:Object3D; + var _local_5:Object3D; + super.clonePropertiesFrom(_arg_1); + var _local_2:Object3DContainer = (_arg_1 as Object3DContainer); + this.mouseChildren = _local_2.mouseChildren; + var _local_3:Object3D = _local_2.childrenList; + while (_local_3 != null) + { + _local_5 = _local_3.clone(); + if (this.childrenList != null) + { + _local_4.next = _local_5; + } else + { + this.childrenList = _local_5; + }; + _local_4 = _local_5; + _local_5.setParent(this); + _local_3 = _local_3.next; + }; + } + + override alternativa3d function draw(_arg_1:Camera3D):void + { + var _local_2:int; + this.numVisibleChildren = 0; + var _local_3:Object3D = this.childrenList; + while (_local_3 != null) + { + if (_local_3.visible) + { + _local_3.composeAndAppend(this); + if (_local_3.cullingInCamera(_arg_1, culling) >= 0) + { + _local_3.concat(this); + this.visibleChildren[this.numVisibleChildren] = _local_3; + this.numVisibleChildren++; + }; + }; + _local_3 = _local_3.next; + }; + if (this.numVisibleChildren > 0) + { + if (((_arg_1.debug) && ((_local_2 = _arg_1.checkInDebug(this)) > 0))) + { + if ((_local_2 & Debug.BOUNDS)) + { + Debug.drawBounds(_arg_1, this, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ); + }; + }; + this.drawVisibleChildren(_arg_1); + }; + } + + alternativa3d function drawVisibleChildren(_arg_1:Camera3D):void + { + var _local_3:Object3D; + var _local_2:int = (this.numVisibleChildren - 1); + while (_local_2 >= 0) + { + _local_3 = this.visibleChildren[_local_2]; + _local_3.draw(_arg_1); + this.visibleChildren[_local_2] = null; + _local_2--; + }; + } + + override alternativa3d function getVG(_arg_1:Camera3D):VG + { + var _local_2:VG; + var _local_3:VG; + var _local_5:VG; + var _local_4:Object3D = this.childrenList; + while (_local_4 != null) + { + if (_local_4.visible) + { + _local_4.composeAndAppend(this); + if (_local_4.cullingInCamera(_arg_1, culling) >= 0) + { + _local_4.concat(this); + _local_5 = _local_4.getVG(_arg_1); + if (_local_5 != null) + { + if (_local_2 != null) + { + _local_3.next = _local_5; + } else + { + _local_2 = _local_5; + _local_3 = _local_5; + }; + while (_local_3.next != null) + { + _local_3 = _local_3.next; + }; + }; + }; + }; + _local_4 = _local_4.next; + }; + return (_local_2); + } + + override alternativa3d function updateBounds(_arg_1:Object3D, _arg_2:Object3D=null):void + { + var _local_3:Object3D = this.childrenList; + while (_local_3 != null) + { + if (_arg_2 != null) + { + _local_3.composeAndAppend(_arg_2); + } else + { + _local_3.composeMatrix(); + }; + _local_3.updateBounds(_arg_1, _local_3); + _local_3 = _local_3.next; + }; + } + + override alternativa3d function split(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Vector3D, _arg_4:Number):Vector. + { + var _local_10:Object3D; + var _local_11:Object3D; + var _local_13:Object3D; + var _local_14:Vector3D; + var _local_15:Vector3D; + var _local_16:Vector3D; + var _local_17:int; + var _local_18:Vector.; + var _local_19:Number; + var _local_5:Vector. = new Vector.(2); + var _local_6:Vector3D = calculatePlane(_arg_1, _arg_2, _arg_3); + var _local_7:Object3D = this.childrenList; + this.childrenList = null; + var _local_8:Object3DContainer = (this.clone() as Object3DContainer); + var _local_9:Object3DContainer = (this.clone() as Object3DContainer); + var _local_12:Object3D = _local_7; + while (_local_12 != null) + { + _local_13 = _local_12.next; + _local_12.next = null; + _local_12.setParent(null); + _local_12.composeMatrix(); + _local_12.calculateInverseMatrix(); + _local_14 = new Vector3D(((((_local_12.ima * _arg_1.x) + (_local_12.imb * _arg_1.y)) + (_local_12.imc * _arg_1.z)) + _local_12.imd), ((((_local_12.ime * _arg_1.x) + (_local_12.imf * _arg_1.y)) + (_local_12.img * _arg_1.z)) + _local_12.imh), ((((_local_12.imi * _arg_1.x) + (_local_12.imj * _arg_1.y)) + (_local_12.imk * _arg_1.z)) + _local_12.iml)); + _local_15 = new Vector3D(((((_local_12.ima * _arg_2.x) + (_local_12.imb * _arg_2.y)) + (_local_12.imc * _arg_2.z)) + _local_12.imd), ((((_local_12.ime * _arg_2.x) + (_local_12.imf * _arg_2.y)) + (_local_12.img * _arg_2.z)) + _local_12.imh), ((((_local_12.imi * _arg_2.x) + (_local_12.imj * _arg_2.y)) + (_local_12.imk * _arg_2.z)) + _local_12.iml)); + _local_16 = new Vector3D(((((_local_12.ima * _arg_3.x) + (_local_12.imb * _arg_3.y)) + (_local_12.imc * _arg_3.z)) + _local_12.imd), ((((_local_12.ime * _arg_3.x) + (_local_12.imf * _arg_3.y)) + (_local_12.img * _arg_3.z)) + _local_12.imh), ((((_local_12.imi * _arg_3.x) + (_local_12.imj * _arg_3.y)) + (_local_12.imk * _arg_3.z)) + _local_12.iml)); + _local_17 = _local_12.testSplit(_local_14, _local_15, _local_16, _arg_4); + if (_local_17 < 0) + { + if (_local_10 != null) + { + _local_10.next = _local_12; + } else + { + _local_8.childrenList = _local_12; + }; + _local_10 = _local_12; + _local_12.setParent(_local_8); + } else + { + if (_local_17 > 0) + { + if (_local_11 != null) + { + _local_11.next = _local_12; + } else + { + _local_9.childrenList = _local_12; + }; + _local_11 = _local_12; + _local_12.setParent(_local_9); + } else + { + _local_18 = _local_12.split(_local_14, _local_15, _local_16, _arg_4); + _local_19 = _local_12.distance; + if (_local_18[0] != null) + { + _local_12 = _local_18[0]; + if (_local_10 != null) + { + _local_10.next = _local_12; + } else + { + _local_8.childrenList = _local_12; + }; + _local_10 = _local_12; + _local_12.setParent(_local_8); + _local_12.distance = _local_19; + }; + if (_local_18[1] != null) + { + _local_12 = _local_18[1]; + if (_local_11 != null) + { + _local_11.next = _local_12; + } else + { + _local_9.childrenList = _local_12; + }; + _local_11 = _local_12; + _local_12.setParent(_local_9); + _local_12.distance = _local_19; + }; + }; + }; + _local_12 = _local_13; + }; + if (_local_10 != null) + { + _local_8.calculateBounds(); + _local_5[0] = _local_8; + }; + if (_local_11 != null) + { + _local_9.calculateBounds(); + _local_5[1] = _local_9; + }; + return (_local_5); + } + + alternativa3d function addToList(_arg_1:Object3D, _arg_2:Object3D=null):void + { + var _local_3:Object3D; + _arg_1.next = _arg_2; + _arg_1.setParent(this); + if (_arg_2 == this.childrenList) + { + this.childrenList = _arg_1; + } else + { + _local_3 = this.childrenList; + while (_local_3 != null) + { + if (_local_3.next == _arg_2) + { + _local_3.next = _arg_1; + return; + }; + _local_3 = _local_3.next; + }; + }; + } + + override alternativa3d function setParent(_arg_1:Object3DContainer):void + { + var _local_2:Object3DContainer; + var _local_3:Light3D; + if (_arg_1 == null) + { + _local_2 = _parent; + while (_local_2._parent != null) + { + _local_2 = _local_2._parent; + }; + if (_local_2.lightList != null) + { + this.transferLights(_local_2, this); + }; + } else + { + if (this.lightList != null) + { + _local_2 = _arg_1; + while (_local_2._parent != null) + { + _local_2 = _local_2._parent; + }; + _local_3 = this.lightList; + while (_local_3.nextLight != null) + { + _local_3 = _local_3.nextLight; + }; + _local_3.nextLight = _local_2.lightList; + _local_2.lightList = this.lightList; + this.lightList = null; + }; + }; + _parent = _arg_1; + } + + private function transferLights(_arg_1:Object3DContainer, _arg_2:Object3DContainer):void + { + var _local_4:Light3D; + var _local_5:Light3D; + var _local_6:Light3D; + var _local_3:Object3D = this.childrenList; + while (_local_3 != null) + { + if ((_local_3 is Light3D)) + { + _local_4 = (_local_3 as Light3D); + _local_5 = null; + _local_6 = _arg_1.lightList; + while (_local_6 != null) + { + if (_local_6 == _local_4) + { + if (_local_5 != null) + { + _local_5.nextLight = _local_6.nextLight; + } else + { + _arg_1.lightList = _local_6.nextLight; + }; + _local_6.nextLight = _arg_2.lightList; + _arg_2.lightList = _local_6; + break; + }; + _local_5 = _local_6; + _local_6 = _local_6.nextLight; + }; + } else + { + if ((_local_3 is Object3DContainer)) + { + (_local_3 as Object3DContainer).transferLights(_arg_1, _arg_2); + }; + }; + if (_arg_1.lightList == null) break; + _local_3 = _local_3.next; + }; + } + + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/PerformanceController.as b/src/alternativa/engine3d/core/PerformanceController.as new file mode 100644 index 0000000..d7b36f6 --- /dev/null +++ b/src/alternativa/engine3d/core/PerformanceController.as @@ -0,0 +1,597 @@ +package alternativa.engine3d.core +{ + import flash.net.SharedObject; + import __AS3__.vec.Vector; + import flash.display.Stage; + import flash.utils.setTimeout; + import flash.events.Event; + import flash.utils.clearInterval; + import flash.utils.getTimer; + import __AS3__.vec.*; + + public class PerformanceController + { + + public static const FOG:String = "fog"; + public static const DIRECTIONAL_LIGHT:String = "directionalLight"; + public static const SHADOW_MAP:String = "shadowMap"; + public static const SOFT_TRANSPARENCY:String = "softTransparency"; + public static const SHADOWS:String = "shadows"; + public static const ANTI_ALIAS:String = "antiAlias"; + public static const SSAO:String = "ssao"; + public static const DEFERRED_LIGHTING:String = "deferredLighting"; + private static var storage:SharedObject = SharedObject.getLocal("performance"); + + private var types:Vector. = new Vector.(); + private var speeds:Vector. = new Vector.(); + private var actives:Vector. = new Vector.(); + private var stage:Stage; + private var camera:Camera3D; + private var fpsThreshold:Number; + private var ratioThreshold:Number; + private var testTime:Number; + private var maxAttempts:uint; + private var key:String; + private var traceLog:Boolean; + private var mask:int; + private var id:uint; + private var idleId:uint; + private var timer:int; + private var frameCounter:int; + private var lowCounter:int; + private var state:int; + private var features:Vector.; + private var featuresCount:int; + private var index:int; + private var _block:Boolean = false; + private var afterIdle:Boolean; + + + public function addFeature(_arg_1:String, _arg_2:Number, _arg_3:Boolean):void + { + var _local_4:String; + if (this.camera != null) + { + throw (new Error("Cannot add feature during analysis.")); + }; + if (((((((((!(_arg_1 == FOG)) && (!(_arg_1 == SHADOWS))) && (!(_arg_1 == DIRECTIONAL_LIGHT))) && (!(_arg_1 == SHADOW_MAP))) && (!(_arg_1 == SOFT_TRANSPARENCY))) && (!(_arg_1 == ANTI_ALIAS))) && (!(_arg_1 == SSAO))) && (!(_arg_1 == DEFERRED_LIGHTING)))) + { + throw (new Error("Nonexistent feature.")); + }; + for each (_local_4 in this.types) + { + if (_local_4 == _arg_1) + { + throw (new Error("Feature already exists.")); + }; + }; + this.types.push(_arg_1); + this.speeds.push(_arg_2); + this.actives.push(_arg_3); + } + + public function get activated():Boolean + { + return (!(this.camera == null)); + } + + public function clearSharedObject():void + { + storage.clear(); + } + + public function start(_arg_1:Stage, _arg_2:Camera3D, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:uint, _arg_8:String, _arg_9:Boolean=false):void + { + var _local_10:int; + if (this.camera != null) + { + throw (new Error("Analysis already started.")); + }; + var _local_11:int = this.types.length; + this.stage = _arg_1; + this.camera = _arg_2; + this.fpsThreshold = _arg_3; + this.ratioThreshold = _arg_4; + this.testTime = _arg_6; + this.maxAttempts = _arg_7; + this.key = _arg_8; + this.traceLog = _arg_9; + this.mask = 0; + _local_10 = 0; + while (_local_10 < _local_11) + { + this.key = (this.key + ("_5_" + this.types[_local_10])); + if (this.actives[_local_10]) + { + this.mask = (this.mask | (1 << _local_10)); + }; + _local_10++; + }; + if (storage.data[this.key] != undefined) + { + this.mask = storage.data[this.key]; + } else + { + this.save(); + }; + this.features = new Vector.(); + this.featuresCount = 0; + _local_10 = 0; + while (_local_10 < _local_11) + { + if ((this.mask & (1 << _local_10)) > 0) + { + this.features[this.featuresCount] = new Feature(this.types[_local_10], this.speeds[_local_10]); + this.featuresCount++; + }; + _local_10++; + }; + this.index = (this.featuresCount - 1); + _local_10 = 0; + while (_local_10 < _local_11) + { + if ((this.mask & (1 << _local_10)) == 0) + { + this.features[this.featuresCount] = new Feature(this.types[_local_10], this.speeds[_local_10]); + this.featuresCount++; + this.disableFeature(this.types[_local_10]); + }; + _local_10++; + }; + this.afterIdle = false; + if (_arg_5 > 0) + { + this.idleId = setTimeout(this.onIdle, (_arg_5 * 1000)); + } else + { + this.onIdle(); + }; + this.traceFeatures("\nStart", true); + } + + public function stop():void + { + if (this.camera == null) + { + return; + }; + this.stage.removeEventListener(Event.ENTER_FRAME, this.onEnterFrame); + clearInterval(this.id); + clearInterval(this.idleId); + var _local_1:int = this.types.length; + var _local_2:int; + while (_local_2 < _local_1) + { + this.restoreFeature(this.types[_local_2]); + _local_2++; + }; + this.stage = null; + this.camera = null; + } + + public function get block():Boolean + { + return (this._block); + } + + public function set block(_arg_1:Boolean):void + { + if (this._block != _arg_1) + { + this._block = _arg_1; + this.traceFeatures(("\nBlock " + this._block), false); + if (((!(this.camera == null)) && (this.afterIdle))) + { + if (this._block) + { + this.stage.removeEventListener(Event.ENTER_FRAME, this.onEnterFrame); + clearInterval(this.id); + if (this.index < (this.featuresCount - 1)) + { + this.disableFeature(Feature(this.features[(this.index + 1)]).type); + }; + } else + { + this.stage.addEventListener(Event.ENTER_FRAME, this.onEnterFrame); + this.timer = getTimer(); + if (this.state == 0) + { + this.testCurrent(); + }; + }; + }; + }; + } + + private function onIdle():void + { + this.state = 0; + this.afterIdle = true; + if ((!(this._block))) + { + this.stage.addEventListener(Event.ENTER_FRAME, this.onEnterFrame); + this.timer = getTimer(); + this.testCurrent(); + }; + } + + private function onEnterFrame(_arg_1:Event):void + { + var _local_4:Number; + var _local_2:int = getTimer(); + var _local_3:Number = ((_local_2 - this.timer) / 1000); + this.timer = _local_2; + if (this.state == 1) + { + _local_4 = this.changeStrength(Feature(this.features[this.index]).type, (_local_3 * this.speeds[this.index])); + if (_local_4 >= 1) + { + if ((this.index + 1) < this.featuresCount) + { + this.testNext(); + } else + { + this.testCurrent(); + }; + }; + } else + { + if (this.state == -1) + { + _local_4 = this.changeStrength(Feature(this.features[this.index]).type, (-(_local_3) * this.speeds[this.index])); + if (_local_4 <= 0) + { + this.mask = (this.mask & (~(1 << this.types.indexOf(Feature(this.features[this.index]).type)))); + this.save(); + this.index--; + this.swap(); + this.traceFeatures(null, true); + this.testCurrent(); + }; + } else + { + this.frameCounter++; + if ((1 / _local_3) < this.fpsThreshold) + { + this.lowCounter++; + }; + }; + }; + } + + private function testNext():void + { + this.state = 0; + this.frameCounter = 0; + this.lowCounter = 0; + this.testFeature(Feature(this.features[(this.index + 1)]).type); + this.id = setTimeout(this.onTestNext, (this.testTime * 1000)); + this.traceFeatures(((("\nTest Next " + String((this.index + 1))) + " ") + this.features[(this.index + 1)].type), false); + } + + private function onTestNext():void + { + if ((this.lowCounter / this.frameCounter) < this.ratioThreshold) + { + this.index++; + this.mask = (this.mask | (1 << this.types.indexOf(Feature(this.features[this.index]).type))); + this.save(); + Feature(this.features[this.index]).attempts = 0; + this.state = 1; + this.traceFeatures("SUCCESS", true); + } else + { + this.swap(); + this.traceFeatures("FAIL", true); + if ((this.index + 1) < this.featuresCount) + { + this.testNext(); + } else + { + this.testCurrent(); + }; + }; + } + + private function testCurrent():void + { + this.state = 0; + this.frameCounter = 0; + this.lowCounter = 0; + this.id = setTimeout(this.onTestCurrent, (this.testTime * 1000)); + this.traceFeatures(((("\nTest Current " + this.index) + " ") + ((this.index >= 0) ? this.features[this.index].type : "none")), false); + } + + private function onTestCurrent():void + { + if ((this.lowCounter / this.frameCounter) < this.ratioThreshold) + { + this.traceFeatures("SUCCESS", true); + if ((this.index + 1) < this.featuresCount) + { + this.testNext(); + } else + { + this.testCurrent(); + }; + } else + { + if (this.index >= 0) + { + this.traceFeatures("FAIL", false); + this.state = -1; + } else + { + this.traceFeatures("FAIL", true); + this.testCurrent(); + }; + }; + } + + private function swap():void + { + var _local_1:Feature = Feature(this.features[(this.index + 1)]); + this.disableFeature(_local_1.type); + _local_1.attempts++; + var _local_2:int = (this.index + 1); + while (_local_2 < (this.featuresCount - 1)) + { + this.features[_local_2] = this.features[(_local_2 + 1)]; + _local_2++; + }; + if (_local_1.attempts < this.maxAttempts) + { + this.features[(this.featuresCount - 1)] = _local_1; + } else + { + this.featuresCount--; + this.features.length = this.featuresCount; + }; + } + + private function save():void + { + storage.data[this.key] = this.mask; + } + + private function traceFeatures(_arg_1:String=null, _arg_2:Boolean=false):void + { + var _local_3:int; + var _local_4:String; + if (this.traceLog) + { + if (_arg_1 != null) + { + }; + if (_arg_2) + { + _local_3 = 0; + while (_local_3 <= this.index) + { + _local_3++; + }; + _local_3 = (this.index + 1); + while (_local_3 < this.featuresCount) + { + _local_3++; + }; + _local_4 = " "; + _local_3 = 0; + while (_local_3 < this.types.length) + { + _local_4 = (_local_4 + (this.types[_local_3] + (((this.mask & (1 << _local_3)) > 0) ? "+ " : "- "))); + _local_3++; + }; + }; + }; + } + + private function disableFeature(_arg_1:String):void + { + switch (_arg_1) + { + case FOG: + this.camera.fogStrength = 0; + return; + case DIRECTIONAL_LIGHT: + this.camera.directionalLightStrength = 0; + return; + case SHADOW_MAP: + this.camera.shadowMapStrength = 0; + return; + case SOFT_TRANSPARENCY: + this.camera.softTransparencyStrength = 0; + return; + case SHADOWS: + this.camera.shadowsStrength = 0; + return; + case ANTI_ALIAS: + this.camera.view.antiAliasEnabled = false; + return; + case SSAO: + this.camera.ssaoStrength = 0; + return; + case DEFERRED_LIGHTING: + this.camera.deferredLightingStrength = 0; + return; + }; + } + + private function restoreFeature(_arg_1:String):void + { + switch (_arg_1) + { + case FOG: + this.camera.fogStrength = 1; + return; + case DIRECTIONAL_LIGHT: + this.camera.directionalLightStrength = 1; + return; + case SHADOW_MAP: + this.camera.shadowMapStrength = 1; + return; + case SOFT_TRANSPARENCY: + this.camera.softTransparencyStrength = 1; + return; + case SHADOWS: + this.camera.shadowsStrength = 1; + this.camera.shadowsDistanceMultiplier = 1; + return; + case ANTI_ALIAS: + this.camera.view.antiAliasEnabled = true; + return; + case SSAO: + this.camera.ssaoStrength = 1; + return; + case DEFERRED_LIGHTING: + this.camera.deferredLightingStrength = 1; + return; + }; + } + + private function testFeature(_arg_1:String):void + { + switch (_arg_1) + { + case FOG: + this.camera.fogStrength = 0.01; + return; + case DIRECTIONAL_LIGHT: + this.camera.directionalLightStrength = 0.01; + return; + case SHADOW_MAP: + this.camera.shadowMapStrength = 0.01; + return; + case SOFT_TRANSPARENCY: + this.camera.softTransparencyStrength = 0.01; + return; + case SHADOWS: + this.camera.shadowsStrength = 0.01; + return; + case ANTI_ALIAS: + this.camera.view.antiAliasEnabled = true; + return; + case SSAO: + this.camera.ssaoStrength = 0.01; + return; + case DEFERRED_LIGHTING: + this.camera.deferredLightingStrength = 0.01; + return; + }; + } + + private function changeStrength(_arg_1:String, _arg_2:Number):Number + { + var _local_3:Number = 0; + switch (_arg_1) + { + case FOG: + this.camera.fogStrength = (this.camera.fogStrength + _arg_2); + if (this.camera.fogStrength > 1) + { + this.camera.fogStrength = 1; + }; + if (this.camera.fogStrength < 0) + { + this.camera.fogStrength = 0; + }; + _local_3 = this.camera.fogStrength; + break; + case DIRECTIONAL_LIGHT: + this.camera.directionalLightStrength = (this.camera.directionalLightStrength + _arg_2); + if (this.camera.directionalLightStrength > 1) + { + this.camera.directionalLightStrength = 1; + }; + if (this.camera.directionalLightStrength < 0) + { + this.camera.directionalLightStrength = 0; + }; + _local_3 = this.camera.directionalLightStrength; + break; + case SHADOW_MAP: + this.camera.shadowMapStrength = (this.camera.shadowMapStrength + _arg_2); + if (this.camera.shadowMapStrength > 1) + { + this.camera.shadowMapStrength = 1; + }; + if (this.camera.shadowMapStrength < 0) + { + this.camera.shadowMapStrength = 0; + }; + _local_3 = this.camera.shadowMapStrength; + break; + case SOFT_TRANSPARENCY: + this.camera.softTransparencyStrength = (this.camera.softTransparencyStrength + _arg_2); + if (this.camera.softTransparencyStrength > 1) + { + this.camera.softTransparencyStrength = 1; + }; + if (this.camera.softTransparencyStrength < 0) + { + this.camera.softTransparencyStrength = 0; + }; + _local_3 = this.camera.softTransparencyStrength; + break; + case SHADOWS: + this.camera.shadowsStrength = (this.camera.shadowsStrength + _arg_2); + if (this.camera.shadowsStrength > 1) + { + this.camera.shadowsStrength = 1; + }; + if (this.camera.shadowsStrength < 0) + { + this.camera.shadowsStrength = 0; + }; + _local_3 = this.camera.shadowsStrength; + break; + case ANTI_ALIAS: + this.camera.view.antiAliasEnabled = (_arg_2 > 0); + _local_3 = ((this.camera.view.antiAliasEnabled) ? 1 : 0); + break; + case SSAO: + this.camera.ssaoStrength = (this.camera.ssaoStrength + _arg_2); + if (this.camera.ssaoStrength > 1) + { + this.camera.ssaoStrength = 1; + }; + if (this.camera.ssaoStrength < 0) + { + this.camera.ssaoStrength = 0; + }; + _local_3 = this.camera.ssaoStrength; + break; + case DEFERRED_LIGHTING: + this.camera.deferredLightingStrength = (this.camera.deferredLightingStrength + _arg_2); + if (this.camera.deferredLightingStrength > 1) + { + this.camera.deferredLightingStrength = 1; + }; + if (this.camera.deferredLightingStrength < 0) + { + this.camera.deferredLightingStrength = 0; + }; + _local_3 = this.camera.deferredLightingStrength; + break; + }; + return (_local_3); + } + + + } +}//package alternativa.engine3d.core + +class Feature +{ + + public var type:String; + public var speed:Number; + public var attempts:int = 0; + + public function Feature(_arg_1:String, _arg_2:Number) + { + this.type = _arg_1; + this.speed = _arg_2; + } + +} diff --git a/src/alternativa/engine3d/core/RayIntersectionData.as b/src/alternativa/engine3d/core/RayIntersectionData.as new file mode 100644 index 0000000..42528dd --- /dev/null +++ b/src/alternativa/engine3d/core/RayIntersectionData.as @@ -0,0 +1,23 @@ +package alternativa.engine3d.core +{ + import flash.geom.Vector3D; + import flash.geom.Point; + + public class RayIntersectionData + { + + public var object:Object3D; + public var face:Face; + public var point:Vector3D; + public var uv:Point; + public var time:Number; + + + public function toString():String + { + return (((((((((("[RayIntersectionData " + this.object) + ", ") + this.face) + ", ") + this.point) + ", ") + this.uv) + ", ") + this.time) + "]"); + } + + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/Shadow.as b/src/alternativa/engine3d/core/Shadow.as new file mode 100644 index 0000000..a69988f --- /dev/null +++ b/src/alternativa/engine3d/core/Shadow.as @@ -0,0 +1,759 @@ +package alternativa.engine3d.core +{ + import alternativa.gfx.core.ProgramResource; + import __AS3__.vec.Vector; + import alternativa.gfx.core.VertexBufferResource; + import alternativa.gfx.core.IndexBufferResource; + import flash.geom.Vector3D; + import alternativa.engine3d.objects.Mesh; + import alternativa.engine3d.lights.DirectionalLight; + import alternativa.gfx.core.TextureResource; + import flash.utils.ByteArray; + import alternativa.gfx.agal.FragmentShader; + import alternativa.gfx.agal.Shader; + import alternativa.gfx.core.Device; + import flash.display3D.Context3DVertexBufferFormat; + import flash.display3D.Context3DProgramType; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class Shadow + { + + private static var casterProgram:ProgramResource; + private static var casterConst:Vector. = Vector.([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]); + private static var volumeProgram:ProgramResource; + private static var volumeVertexBuffer:VertexBufferResource = new VertexBufferResource(Vector.([0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1]), 3); + private static var volumeIndexBuffer:IndexBufferResource = new IndexBufferResource(Vector.([0, 1, 3, 2, 3, 1, 7, 6, 4, 5, 4, 6, 4, 5, 0, 1, 0, 5, 3, 2, 7, 6, 7, 2, 0, 3, 4, 7, 4, 3, 5, 6, 1, 2, 1, 6])); + private static var volumeTransformConst:Vector. = new Vector.(20); + private static var volumeFragmentConst:Vector. = Vector.([1, 0, 1, 0.5]); + private static var receiverPrograms:Array = new Array(); + + public var mapSize:int; + public var blur:int; + public var attenuation:Number; + public var nearDistance:Number; + public var farDistance:Number; + public var color:int; + public var alpha:Number; + public var direction:Vector3D = new Vector3D(0, 0, -1); + public var offset:Number = 0; + public var backFadeRange:Number = 0; + private var casters:Vector. = new Vector.(); + private var castersCount:int = 0; + alternativa3d var receiversBuffers:Vector. = new Vector.(); + alternativa3d var receiversFirstIndexes:Vector. = new Vector.(); + alternativa3d var receiversNumsTriangles:Vector. = new Vector.(); + alternativa3d var receiversCount:int = 0; + private var dir:Vector3D = new Vector3D(); + private var light:DirectionalLight = new DirectionalLight(0); + private var boundVertexList:Vertex = Vertex.createList(8); + private var planeX:Number; + private var planeY:Number; + private var planeSize:Number; + private var minZ:Number; + alternativa3d var boundMinX:Number; + alternativa3d var boundMinY:Number; + alternativa3d var boundMinZ:Number; + alternativa3d var boundMaxX:Number; + alternativa3d var boundMaxY:Number; + alternativa3d var boundMaxZ:Number; + alternativa3d var cameraInside:Boolean; + private var transformConst:Vector. = new Vector.(12); + private var uvConst:Vector. = Vector.([0, 0, 0, 1, 0, 0, 0, 1]); + private var colorConst:Vector. = new Vector.(12); + private var clampConst:Vector. = Vector.([0, 0, 0, 1]); + alternativa3d var texture:TextureResource; + alternativa3d var textureScaleU:Number; + alternativa3d var textureScaleV:Number; + alternativa3d var textureOffsetU:Number; + alternativa3d var textureOffsetV:Number; + + public function Shadow(_arg_1:int, _arg_2:int, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:int=0, _arg_7:Number=1) + { + if (_arg_1 > ShadowAtlas.sizeLimit) + { + throw (new Error("Value of mapSize too big.")); + }; + var _local_8:Number = (Math.log(_arg_1) / Math.LN2); + if (_local_8 != int(_local_8)) + { + throw (new Error("Value of mapSize must be power of 2.")); + }; + this.mapSize = _arg_1; + this.blur = _arg_2; + this.attenuation = _arg_3; + this.nearDistance = _arg_4; + this.farDistance = _arg_5; + this.color = _arg_6; + this.alpha = _arg_7; + } + + alternativa3d static function getCasterProgram():ProgramResource + { + var _local_2:ByteArray; + var _local_3:FragmentShader; + var _local_1:ProgramResource = casterProgram; + if (_local_1 == null) + { + _local_2 = new ShadowCasterVertexShader().agalcode; + _local_3 = new FragmentShader(); + _local_3.mov(FragmentShader.oc, Shader.v0); + _local_1 = new ProgramResource(_local_2, _local_3.agalcode); + casterProgram = _local_1; + }; + return (_local_1); + } + + + public function addCaster(_arg_1:Mesh):void + { + this.casters[this.castersCount] = _arg_1; + this.castersCount++; + } + + public function removeCaster(_arg_1:Mesh):void + { + var _local_2:int; + while (_local_2 < this.castersCount) + { + if (this.casters[_local_2] == _arg_1) + { + this.castersCount--; + while (_local_2 < this.castersCount) + { + this.casters[_local_2] = this.casters[int((_local_2 + 1))]; + _local_2++; + }; + this.casters.length = this.castersCount; + return; + }; + _local_2++; + }; + } + + public function removeAllCasters():void + { + this.castersCount = 0; + this.casters.length = 0; + } + + alternativa3d function checkVisibility(_arg_1:Camera3D):Boolean + { + var _local_24:Object3D; + var _local_25:Object3D; + var _local_26:Vertex; + var _local_27:Number; + if (this.castersCount == 0) + { + return (false); + }; + if (this.direction != null) + { + this.dir.x = this.direction.x; + this.dir.y = this.direction.y; + this.dir.z = this.direction.z; + this.dir.normalize(); + } + else + { + this.dir.x = 0; + this.dir.y = 0; + this.dir.z = -1; + }; + this.light.rotationX = (Math.atan2(this.dir.z, Math.sqrt(((this.dir.x * this.dir.x) + (this.dir.y * this.dir.y)))) - (Math.PI / 2)); + this.light.rotationY = 0; + this.light.rotationZ = -(Math.atan2(this.dir.x, this.dir.y)); + this.light.composeMatrix(); + var _local_2:Number = this.light.ma; + var _local_3:Number = this.light.mb; + var _local_4:Number = this.light.mc; + var _local_5:Number = this.light.md; + var _local_6:Number = this.light.me; + var _local_7:Number = this.light.mf; + var _local_8:Number = this.light.mg; + var _local_9:Number = this.light.mh; + var _local_10:Number = this.light.mi; + var _local_11:Number = this.light.mj; + var _local_12:Number = this.light.mk; + var _local_13:Number = this.light.ml; + this.light.invertMatrix(); + this.light.ima = this.light.ma; + this.light.imb = this.light.mb; + this.light.imc = this.light.mc; + this.light.imd = this.light.md; + this.light.ime = this.light.me; + this.light.imf = this.light.mf; + this.light.img = this.light.mg; + this.light.imh = this.light.mh; + this.light.imi = this.light.mi; + this.light.imj = this.light.mj; + this.light.imk = this.light.mk; + this.light.iml = this.light.ml; + this.light.boundMinX = 1E22; + this.light.boundMinY = 1E22; + this.light.boundMinZ = 1E22; + this.light.boundMaxX = -1E22; + this.light.boundMaxY = -1E22; + this.light.boundMaxZ = -1E22; + var _local_14:int; + while (_local_14 < this.castersCount) + { + _local_24 = this.casters[_local_14]; + _local_24.composeMatrix(); + _local_25 = _local_24._parent; + while (_local_25 != null) + { + Object3D.tA.composeMatrixFromSource(_local_25); + _local_24.appendMatrix(Object3D.tA); + _local_25 = _local_25._parent; + }; + _local_24.appendMatrix(this.light); + _local_26 = this.boundVertexList; + _local_26.x = _local_24.boundMinX; + _local_26.y = _local_24.boundMinY; + _local_26.z = _local_24.boundMinZ; + _local_26 = _local_26.next; + _local_26.x = _local_24.boundMaxX; + _local_26.y = _local_24.boundMinY; + _local_26.z = _local_24.boundMinZ; + _local_26 = _local_26.next; + _local_26.x = _local_24.boundMinX; + _local_26.y = _local_24.boundMaxY; + _local_26.z = _local_24.boundMinZ; + _local_26 = _local_26.next; + _local_26.x = _local_24.boundMaxX; + _local_26.y = _local_24.boundMaxY; + _local_26.z = _local_24.boundMinZ; + _local_26 = _local_26.next; + _local_26.x = _local_24.boundMinX; + _local_26.y = _local_24.boundMinY; + _local_26.z = _local_24.boundMaxZ; + _local_26 = _local_26.next; + _local_26.x = _local_24.boundMaxX; + _local_26.y = _local_24.boundMinY; + _local_26.z = _local_24.boundMaxZ; + _local_26 = _local_26.next; + _local_26.x = _local_24.boundMinX; + _local_26.y = _local_24.boundMaxY; + _local_26.z = _local_24.boundMaxZ; + _local_26 = _local_26.next; + _local_26.x = _local_24.boundMaxX; + _local_26.y = _local_24.boundMaxY; + _local_26.z = _local_24.boundMaxZ; + _local_26 = this.boundVertexList; + while (_local_26 != null) + { + _local_26.cameraX = ((((_local_24.ma * _local_26.x) + (_local_24.mb * _local_26.y)) + (_local_24.mc * _local_26.z)) + _local_24.md); + _local_26.cameraY = ((((_local_24.me * _local_26.x) + (_local_24.mf * _local_26.y)) + (_local_24.mg * _local_26.z)) + _local_24.mh); + _local_26.cameraZ = ((((_local_24.mi * _local_26.x) + (_local_24.mj * _local_26.y)) + (_local_24.mk * _local_26.z)) + _local_24.ml); + if (_local_26.cameraX < this.light.boundMinX) + { + this.light.boundMinX = _local_26.cameraX; + }; + if (_local_26.cameraX > this.light.boundMaxX) + { + this.light.boundMaxX = _local_26.cameraX; + }; + if (_local_26.cameraY < this.light.boundMinY) + { + this.light.boundMinY = _local_26.cameraY; + }; + if (_local_26.cameraY > this.light.boundMaxY) + { + this.light.boundMaxY = _local_26.cameraY; + }; + if (_local_26.cameraZ < this.light.boundMinZ) + { + this.light.boundMinZ = _local_26.cameraZ; + }; + if (_local_26.cameraZ > this.light.boundMaxZ) + { + this.light.boundMaxZ = _local_26.cameraZ; + }; + _local_26 = _local_26.next; + }; + _local_14++; + }; + var _local_15:int = ((((this.mapSize - 1) - 1) - this.blur) - this.blur); + var _local_16:Number = (this.light.boundMaxX - this.light.boundMinX); + var _local_17:Number = (this.light.boundMaxY - this.light.boundMinY); + var _local_18:Number = ((_local_16 > _local_17) ? _local_16 : _local_17); + var _local_19:Number = (_local_18 / _local_15); + var _local_20:Number = ((1 + this.blur) * _local_19); + var _local_21:Number = ((1 + this.blur) * _local_19); + if (_local_16 > _local_17) + { + _local_21 = (_local_21 + (((Math.ceil(((_local_17 - 0.01) / (_local_19 + _local_19))) * (_local_19 + _local_19)) - _local_17) * 0.5)); + } + else + { + _local_20 = (_local_20 + (((Math.ceil(((_local_16 - 0.01) / (_local_19 + _local_19))) * (_local_19 + _local_19)) - _local_16) * 0.5)); + }; + this.light.boundMinX = (this.light.boundMinX - _local_20); + this.light.boundMaxX = (this.light.boundMaxX + _local_20); + this.light.boundMinY = (this.light.boundMinY - _local_21); + this.light.boundMaxY = (this.light.boundMaxY + _local_21); + this.light.boundMinZ = (this.light.boundMinZ + this.offset); + this.light.boundMaxZ = (this.light.boundMaxZ + this.attenuation); + this.planeSize = ((_local_18 * this.mapSize) / _local_15); + if (_local_16 > _local_17) + { + this.planeX = this.light.boundMinX; + this.planeY = (this.light.boundMinY - (((this.light.boundMaxX - this.light.boundMinX) - (this.light.boundMaxY - this.light.boundMinY)) * 0.5)); + } + else + { + this.planeX = (this.light.boundMinX - (((this.light.boundMaxY - this.light.boundMinY) - (this.light.boundMaxX - this.light.boundMinX)) * 0.5)); + this.planeY = this.light.boundMinY; + }; + var _local_22:Number = _arg_1.farClipping; + _arg_1.farClipping = (this.farDistance * _arg_1.shadowsDistanceMultiplier); + this.light.ma = _local_2; + this.light.mb = _local_3; + this.light.mc = _local_4; + this.light.md = _local_5; + this.light.me = _local_6; + this.light.mf = _local_7; + this.light.mg = _local_8; + this.light.mh = _local_9; + this.light.mi = _local_10; + this.light.mj = _local_11; + this.light.mk = _local_12; + this.light.ml = _local_13; + this.light.appendMatrix(_arg_1); + var _local_23:Boolean = this.cullingInCamera(_arg_1); + _arg_1.farClipping = _local_22; + if (_local_23) + { + if (((_arg_1.debug) && (_arg_1.checkInDebug(this.light) & Debug.BOUNDS))) + { + Debug.drawBounds(_arg_1, this.light, this.light.boundMinX, this.light.boundMinY, this.light.boundMinZ, this.light.boundMaxX, this.light.boundMaxY, this.light.boundMaxZ, 0xFF00FF); + }; + this.boundMinX = 1E22; + this.boundMinY = 1E22; + this.boundMinZ = 1E22; + this.boundMaxX = -1E22; + this.boundMaxY = -1E22; + this.boundMaxZ = -1E22; + _local_26 = this.boundVertexList; + while (_local_26 != null) + { + _local_26.cameraX = ((((_local_2 * _local_26.x) + (_local_3 * _local_26.y)) + (_local_4 * _local_26.z)) + _local_5); + _local_26.cameraY = ((((_local_6 * _local_26.x) + (_local_7 * _local_26.y)) + (_local_8 * _local_26.z)) + _local_9); + _local_26.cameraZ = ((((_local_10 * _local_26.x) + (_local_11 * _local_26.y)) + (_local_12 * _local_26.z)) + _local_13); + if (_local_26.cameraX < this.boundMinX) + { + this.boundMinX = _local_26.cameraX; + }; + if (_local_26.cameraX > this.boundMaxX) + { + this.boundMaxX = _local_26.cameraX; + }; + if (_local_26.cameraY < this.boundMinY) + { + this.boundMinY = _local_26.cameraY; + }; + if (_local_26.cameraY > this.boundMaxY) + { + this.boundMaxY = _local_26.cameraY; + }; + if (_local_26.cameraZ < this.boundMinZ) + { + this.boundMinZ = _local_26.cameraZ; + }; + if (_local_26.cameraZ > this.boundMaxZ) + { + this.boundMaxZ = _local_26.cameraZ; + }; + _local_26 = _local_26.next; + }; + this.cameraInside = false; + if (this.minZ <= _arg_1.nearClipping) + { + _local_27 = ((((this.light.ima * _arg_1.gmd) + (this.light.imb * _arg_1.gmh)) + (this.light.imc * _arg_1.gml)) + this.light.imd); + if ((((_local_27 - _arg_1.nearClipping) <= this.light.boundMaxX) && ((_local_27 + _arg_1.nearClipping) >= this.light.boundMinX))) + { + _local_27 = ((((this.light.ime * _arg_1.gmd) + (this.light.imf * _arg_1.gmh)) + (this.light.img * _arg_1.gml)) + this.light.imh); + if ((((_local_27 - _arg_1.nearClipping) <= this.light.boundMaxY) && ((_local_27 + _arg_1.nearClipping) >= this.light.boundMinY))) + { + _local_27 = ((((this.light.imi * _arg_1.gmd) + (this.light.imj * _arg_1.gmh)) + (this.light.imk * _arg_1.gml)) + this.light.iml); + if ((((_local_27 - _arg_1.nearClipping) <= this.light.boundMaxZ) && ((_local_27 + _arg_1.nearClipping) >= this.light.boundMinZ))) + { + this.cameraInside = true; + }; + }; + }; + }; + }; + return (_local_23); + } + + alternativa3d function renderCasters(_arg_1:Camera3D):void + { + var _local_10:Mesh; + var _local_2:Device = _arg_1.device; + var _local_3:Number = (2 / this.planeSize); + var _local_4:Number = (-2 / this.planeSize); + var _local_5:Number = (1 / ((this.light.boundMaxZ - this.attenuation) - (this.light.boundMinZ - this.offset))); + var _local_6:Number = (-(this.light.boundMinZ - this.offset) * _local_5); + var _local_7:Number = ((this.light.boundMinX + this.light.boundMaxX) * 0.5); + var _local_8:Number = ((this.light.boundMinY + this.light.boundMaxY) * 0.5); + var _local_9:int; + while (_local_9 < this.castersCount) + { + _local_10 = this.casters[_local_9]; + _local_10.prepareResources(); + casterConst[0] = (_local_10.ma * _local_3); + casterConst[1] = (_local_10.mb * _local_3); + casterConst[2] = (_local_10.mc * _local_3); + casterConst[3] = ((_local_10.md - _local_7) * _local_3); + casterConst[4] = (_local_10.me * _local_4); + casterConst[5] = (_local_10.mf * _local_4); + casterConst[6] = (_local_10.mg * _local_4); + casterConst[7] = ((_local_10.mh - _local_8) * _local_4); + casterConst[8] = (_local_10.mi * _local_5); + casterConst[9] = (_local_10.mj * _local_5); + casterConst[10] = (_local_10.mk * _local_5); + casterConst[11] = ((_local_10.ml * _local_5) + _local_6); + casterConst[12] = this.textureScaleU; + casterConst[13] = this.textureScaleV; + casterConst[16] = (((2 * this.textureOffsetU) - 1) + this.textureScaleU); + casterConst[17] = -(((2 * this.textureOffsetV) - 1) + this.textureScaleV); + _local_2.setVertexBufferAt(0, _local_10.vertexBuffer, 0, Context3DVertexBufferFormat.FLOAT_3); + _local_2.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 0, casterConst, 5, false); + _local_2.drawTriangles(_local_10.indexBuffer, 0, _local_10.numTriangles); + _local_9++; + }; + this.clampConst[0] = this.textureOffsetU; + this.clampConst[1] = this.textureOffsetV; + this.clampConst[2] = (this.textureOffsetU + this.textureScaleU); + this.clampConst[3] = (this.textureOffsetV + this.textureScaleV); + } + + alternativa3d function renderVolume(_arg_1:Camera3D):void + { + var _local_2:Device = _arg_1.device; + volumeTransformConst[0] = this.light.ma; + volumeTransformConst[1] = this.light.mb; + volumeTransformConst[2] = this.light.mc; + volumeTransformConst[3] = this.light.md; + volumeTransformConst[4] = this.light.me; + volumeTransformConst[5] = this.light.mf; + volumeTransformConst[6] = this.light.mg; + volumeTransformConst[7] = this.light.mh; + volumeTransformConst[8] = this.light.mi; + volumeTransformConst[9] = this.light.mj; + volumeTransformConst[10] = this.light.mk; + volumeTransformConst[11] = this.light.ml; + volumeTransformConst[12] = (this.light.boundMaxX - this.light.boundMinX); + volumeTransformConst[13] = (this.light.boundMaxY - this.light.boundMinY); + volumeTransformConst[14] = (this.light.boundMaxZ - this.light.boundMinZ); + volumeTransformConst[15] = 1; + volumeTransformConst[16] = this.light.boundMinX; + volumeTransformConst[17] = this.light.boundMinY; + volumeTransformConst[18] = this.light.boundMinZ; + volumeTransformConst[19] = 1; + _local_2.setProgram(this.getVolumeProgram()); + _local_2.setVertexBufferAt(0, volumeVertexBuffer, 0, Context3DVertexBufferFormat.FLOAT_3); + _local_2.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 11, volumeTransformConst, 5, false); + _local_2.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 16, _arg_1.projection, 1); + _local_2.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 17, _arg_1.correction, 1); + _local_2.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 13, volumeFragmentConst, 1); + _local_2.drawTriangles(volumeIndexBuffer, 0, 12); + } + + alternativa3d function renderReceivers(_arg_1:Camera3D):void + { + var _local_21:int; + var _local_2:Device = _arg_1.device; + var _local_3:Number = (this.light.boundMinZ - this.offset); + var _local_4:Number = ((this.light.boundMaxZ - this.attenuation) - _local_3); + var _local_5:Number = (this.light.ima / this.planeSize); + var _local_6:Number = (this.light.imb / this.planeSize); + var _local_7:Number = (this.light.imc / this.planeSize); + var _local_8:Number = ((this.light.imd - this.planeX) / this.planeSize); + var _local_9:Number = (this.light.ime / this.planeSize); + var _local_10:Number = (this.light.imf / this.planeSize); + var _local_11:Number = (this.light.img / this.planeSize); + var _local_12:Number = ((this.light.imh - this.planeY) / this.planeSize); + var _local_13:Number = (this.light.imi / _local_4); + var _local_14:Number = (this.light.imj / _local_4); + var _local_15:Number = (this.light.imk / _local_4); + var _local_16:Number = ((this.light.iml - _local_3) / _local_4); + this.transformConst[0] = (((_local_5 * _arg_1.gma) + (_local_6 * _arg_1.gme)) + (_local_7 * _arg_1.gmi)); + this.transformConst[1] = (((_local_5 * _arg_1.gmb) + (_local_6 * _arg_1.gmf)) + (_local_7 * _arg_1.gmj)); + this.transformConst[2] = (((_local_5 * _arg_1.gmc) + (_local_6 * _arg_1.gmg)) + (_local_7 * _arg_1.gmk)); + this.transformConst[3] = ((((_local_5 * _arg_1.gmd) + (_local_6 * _arg_1.gmh)) + (_local_7 * _arg_1.gml)) + _local_8); + this.transformConst[4] = (((_local_9 * _arg_1.gma) + (_local_10 * _arg_1.gme)) + (_local_11 * _arg_1.gmi)); + this.transformConst[5] = (((_local_9 * _arg_1.gmb) + (_local_10 * _arg_1.gmf)) + (_local_11 * _arg_1.gmj)); + this.transformConst[6] = (((_local_9 * _arg_1.gmc) + (_local_10 * _arg_1.gmg)) + (_local_11 * _arg_1.gmk)); + this.transformConst[7] = ((((_local_9 * _arg_1.gmd) + (_local_10 * _arg_1.gmh)) + (_local_11 * _arg_1.gml)) + _local_12); + this.transformConst[8] = (((_local_13 * _arg_1.gma) + (_local_14 * _arg_1.gme)) + (_local_15 * _arg_1.gmi)); + this.transformConst[9] = (((_local_13 * _arg_1.gmb) + (_local_14 * _arg_1.gmf)) + (_local_15 * _arg_1.gmj)); + this.transformConst[10] = (((_local_13 * _arg_1.gmc) + (_local_14 * _arg_1.gmg)) + (_local_15 * _arg_1.gmk)); + this.transformConst[11] = ((((_local_13 * _arg_1.gmd) + (_local_14 * _arg_1.gmh)) + (_local_15 * _arg_1.gml)) + _local_16); + this.uvConst[0] = this.textureScaleU; + this.uvConst[1] = this.textureScaleV; + this.uvConst[4] = this.textureOffsetU; + this.uvConst[5] = this.textureOffsetV; + var _local_17:Number = (this.nearDistance * _arg_1.shadowsDistanceMultiplier); + var _local_18:Number = (this.farDistance * _arg_1.shadowsDistanceMultiplier); + var _local_19:Number = (1 - ((this.minZ - _local_17) / (_local_18 - _local_17))); + if (_local_19 < 0) + { + _local_19 = 0; + }; + if (_local_19 > 1) + { + _local_19 = 1; + }; + this.colorConst[0] = 0; + this.colorConst[1] = 0x0100; + this.colorConst[2] = 1; + this.colorConst[3] = (this.attenuation / _local_4); + this.colorConst[4] = 0; + this.colorConst[5] = (this.backFadeRange / _local_4); + this.colorConst[6] = (this.offset / _local_4); + this.colorConst[7] = 1; + this.colorConst[8] = (((this.color >> 16) & 0xFF) / 0xFF); + this.colorConst[9] = (((this.color >> 8) & 0xFF) / 0xFF); + this.colorConst[10] = ((this.color & 0xFF) / 0xFF); + this.colorConst[11] = ((this.alpha * _local_19) * _arg_1.shadowsStrength); + _local_2.setProgram(this.getReceiverProgram(_arg_1.view.quality, this.cameraInside, _arg_1.view.correction)); + _local_2.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 11, _arg_1.transform, 3); + _local_2.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 14, _arg_1.projection, 1); + _local_2.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 15, this.transformConst, 3); + _local_2.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 18, _arg_1.correction, 1); + _local_2.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 19, this.uvConst, 2); + _local_2.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 13, this.colorConst, 3); + _local_2.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 16, this.clampConst, 1); + var _local_20:int; + while (_local_20 < this.receiversCount) + { + _local_21 = this.receiversBuffers[_local_20]; + _local_2.setVertexBufferAt(0, _arg_1.receiversVertexBuffers[_local_21], 0, Context3DVertexBufferFormat.FLOAT_3); + _local_2.drawTriangles(_arg_1.receiversIndexBuffers[_local_21], this.receiversFirstIndexes[_local_20], this.receiversNumsTriangles[_local_20]); + _arg_1.numShadows++; + _local_20++; + }; + this.receiversCount = 0; + } + + private function getVolumeProgram():ProgramResource + { + var _local_2:ByteArray; + var _local_3:FragmentShader; + var _local_1:ProgramResource = volumeProgram; + if (_local_1 == null) + { + _local_2 = new ShadowVolumeVertexShader().agalcode; + _local_3 = new FragmentShader(); + _local_3.mov(FragmentShader.oc, FragmentShader.fc[13]); + _local_1 = new ProgramResource(_local_2, _local_3.agalcode); + volumeProgram = _local_1; + }; + return (_local_1); + } + + private function getReceiverProgram(_arg_1:Boolean, _arg_2:Boolean, _arg_3:Boolean):ProgramResource + { + var _local_6:ByteArray; + var _local_7:ByteArray; + var _local_4:int = ((int(_arg_1) | (int(_arg_2) << 1)) | (int(_arg_3) << 2)); + var _local_5:ProgramResource = receiverPrograms[_local_4]; + if (_local_5 == null) + { + _local_6 = new ShadowReceiverVertexShader(_arg_3).agalcode; + _local_7 = new ShadowReceiverFragmentShader(_arg_1, _arg_2).agalcode; + _local_5 = new ProgramResource(_local_6, _local_7); + receiverPrograms[_local_4] = _local_5; + }; + return (_local_5); + } + + private function cullingInCamera(_arg_1:Camera3D):Boolean + { + var _local_3:Boolean; + var _local_4:Boolean; + var _local_2:Vertex = this.boundVertexList; + _local_2.x = this.light.boundMinX; + _local_2.y = this.light.boundMinY; + _local_2.z = this.light.boundMinZ; + _local_2 = _local_2.next; + _local_2.x = this.light.boundMaxX; + _local_2.y = this.light.boundMinY; + _local_2.z = this.light.boundMinZ; + _local_2 = _local_2.next; + _local_2.x = this.light.boundMinX; + _local_2.y = this.light.boundMaxY; + _local_2.z = this.light.boundMinZ; + _local_2 = _local_2.next; + _local_2.x = this.light.boundMaxX; + _local_2.y = this.light.boundMaxY; + _local_2.z = this.light.boundMinZ; + _local_2 = _local_2.next; + _local_2.x = this.light.boundMinX; + _local_2.y = this.light.boundMinY; + _local_2.z = this.light.boundMaxZ; + _local_2 = _local_2.next; + _local_2.x = this.light.boundMaxX; + _local_2.y = this.light.boundMinY; + _local_2.z = this.light.boundMaxZ; + _local_2 = _local_2.next; + _local_2.x = this.light.boundMinX; + _local_2.y = this.light.boundMaxY; + _local_2.z = this.light.boundMaxZ; + _local_2 = _local_2.next; + _local_2.x = this.light.boundMaxX; + _local_2.y = this.light.boundMaxY; + _local_2.z = this.light.boundMaxZ; + this.minZ = 1E22; + _local_2 = this.boundVertexList; + while (_local_2 != null) + { + _local_2.cameraX = ((((this.light.ma * _local_2.x) + (this.light.mb * _local_2.y)) + (this.light.mc * _local_2.z)) + this.light.md); + _local_2.cameraY = ((((this.light.me * _local_2.x) + (this.light.mf * _local_2.y)) + (this.light.mg * _local_2.z)) + this.light.mh); + _local_2.cameraZ = ((((this.light.mi * _local_2.x) + (this.light.mj * _local_2.y)) + (this.light.mk * _local_2.z)) + this.light.ml); + if (_local_2.cameraZ < this.minZ) + { + this.minZ = _local_2.cameraZ; + }; + _local_2 = _local_2.next; + }; + var _local_5:Number = _arg_1.nearClipping; + _local_2 = this.boundVertexList; + _local_3 = false; + _local_4 = false; + while (_local_2 != null) + { + if (_local_2.cameraZ > _local_5) + { + _local_3 = true; + if (_local_4) break; + } + else + { + _local_4 = true; + if (_local_3) break; + }; + _local_2 = _local_2.next; + }; + if (((_local_4) && (!(_local_3)))) + { + return (false); + }; + var _local_6:Number = _arg_1.farClipping; + _local_2 = this.boundVertexList; + _local_3 = false; + _local_4 = false; + while (_local_2 != null) + { + if (_local_2.cameraZ < _local_6) + { + _local_3 = true; + if (_local_4) break; + } + else + { + _local_4 = true; + if (_local_3) break; + }; + _local_2 = _local_2.next; + }; + if (((_local_4) && (!(_local_3)))) + { + return (false); + }; + _local_2 = this.boundVertexList; + _local_3 = false; + _local_4 = false; + while (_local_2 != null) + { + if (-(_local_2.cameraX) < _local_2.cameraZ) + { + _local_3 = true; + if (_local_4) break; + } + else + { + _local_4 = true; + if (_local_3) break; + }; + _local_2 = _local_2.next; + }; + if (((_local_4) && (!(_local_3)))) + { + return (false); + }; + _local_2 = this.boundVertexList; + _local_3 = false; + _local_4 = false; + while (_local_2 != null) + { + if (_local_2.cameraX < _local_2.cameraZ) + { + _local_3 = true; + if (_local_4) break; + } + else + { + _local_4 = true; + if (_local_3) break; + }; + _local_2 = _local_2.next; + }; + if (((_local_4) && (!(_local_3)))) + { + return (false); + }; + _local_2 = this.boundVertexList; + _local_3 = false; + _local_4 = false; + while (_local_2 != null) + { + if (-(_local_2.cameraY) < _local_2.cameraZ) + { + _local_3 = true; + if (_local_4) break; + } + else + { + _local_4 = true; + if (_local_3) break; + }; + _local_2 = _local_2.next; + }; + if (((_local_4) && (!(_local_3)))) + { + return (false); + }; + _local_2 = this.boundVertexList; + _local_3 = false; + _local_4 = false; + while (_local_2 != null) + { + if (_local_2.cameraY < _local_2.cameraZ) + { + _local_3 = true; + if (_local_4) break; + } + else + { + _local_4 = true; + if (_local_3) break; + }; + _local_2 = _local_2.next; + }; + if (((_local_4) && (!(_local_3)))) + { + return (false); + }; + return (true); + } + + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/ShadowAtlas.as b/src/alternativa/engine3d/core/ShadowAtlas.as new file mode 100644 index 0000000..c9e4e78 --- /dev/null +++ b/src/alternativa/engine3d/core/ShadowAtlas.as @@ -0,0 +1,139 @@ +package alternativa.engine3d.core +{ + import alternativa.gfx.core.VertexBufferResource; + import alternativa.gfx.core.IndexBufferResource; + import __AS3__.vec.Vector; + import alternativa.gfx.core.RenderTargetTextureResource; + import alternativa.gfx.core.Device; + import flash.display3D.Context3DVertexBufferFormat; + import flash.display3D.Context3DProgramType; + import flash.utils.ByteArray; + import alternativa.gfx.core.ProgramResource; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class ShadowAtlas + { + + alternativa3d static const sizeLimit:int = 0x0400; + private static var blurPrograms:Array = new Array(); + private static var blurVertexBuffer:VertexBufferResource = new VertexBufferResource(Vector.([-1, 1, 0, 0, 0, -1, -1, 0, 0, 1, 1, -1, 0, 1, 1, 1, 1, 0, 1, 0]), 5); + private static var blurIndexBuffer:IndexBufferResource = new IndexBufferResource(Vector.([0, 1, 3, 2, 3, 1])); + private static var blurConst:Vector. = Vector.([0, 0, 0, 1, 0, 0, 0, 1]); + + alternativa3d var shadows:Vector. = new Vector.(); + alternativa3d var shadowsCount:int = 0; + private var mapSize:int; + private var blur:int; + private var maps:Array = new Array(); + private var map1:RenderTargetTextureResource; + private var map2:RenderTargetTextureResource; + + public function ShadowAtlas(_arg_1:int, _arg_2:int) + { + this.mapSize = _arg_1; + this.blur = _arg_2; + } + + alternativa3d function renderCasters(_arg_1:Camera3D):void + { + var _local_9:Shadow; + var _local_2:Device = _arg_1.device; + var _local_3:int = int((sizeLimit / this.mapSize)); + var _local_4:int = int(Math.ceil((this.shadowsCount / _local_3))); + var _local_5:int = ((this.shadowsCount > _local_3) ? _local_3 : this.shadowsCount); + _local_4 = int((1 << Math.ceil((Math.log(_local_4) / Math.LN2)))); + _local_5 = int((1 << Math.ceil((Math.log(_local_5) / Math.LN2)))); + if (_local_4 > _local_3) + { + _local_4 = _local_3; + this.shadowsCount = (_local_4 * _local_5); + }; + var _local_6:int = ((_local_4 << 8) | _local_5); + this.map1 = this.maps[_local_6]; + var _local_7:int = ((1 << 16) | _local_6); + this.map2 = this.maps[_local_7]; + if (this.map1 == null) + { + this.map1 = new RenderTargetTextureResource((_local_5 * this.mapSize), (_local_4 * this.mapSize)); + this.map2 = new RenderTargetTextureResource((_local_5 * this.mapSize), (_local_4 * this.mapSize)); + this.maps[_local_6] = this.map1; + this.maps[_local_7] = this.map2; + }; + _local_2.setRenderToTexture(this.map1, true); + _local_2.clear(0, 0, 0, 0, 0); + var _local_8:int; + while (_local_8 < this.shadowsCount) + { + _local_9 = this.shadows[_local_8]; + _local_9.texture = this.map1; + _local_9.textureScaleU = (1 / _local_5); + _local_9.textureScaleV = (1 / _local_4); + _local_9.textureOffsetU = ((_local_8 % _local_5) / _local_5); + _local_9.textureOffsetV = (int((_local_8 / _local_5)) / _local_4); + _local_9.renderCasters(_arg_1); + _local_8++; + }; + } + + alternativa3d function renderBlur(_arg_1:Camera3D):void + { + var _local_2:Device = _arg_1.device; + if (this.blur > 0) + { + _local_2.setVertexBufferAt(0, blurVertexBuffer, 0, Context3DVertexBufferFormat.FLOAT_3); + _local_2.setVertexBufferAt(1, blurVertexBuffer, 3, Context3DVertexBufferFormat.FLOAT_2); + blurConst[0] = (1 / this.map1.width); + blurConst[1] = (1 / this.map1.height); + blurConst[3] = ((1 + this.blur) + this.blur); + blurConst[4] = (this.blur / this.map1.width); + blurConst[5] = (this.blur / this.map1.height); + _local_2.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 0, blurConst, 2); + _local_2.setRenderToTexture(this.map2, false); + _local_2.clear(0, 0, 0, 0); + _local_2.setProgram(this.getBlurProgram(1, this.blur)); + _local_2.setTextureAt(0, this.map1); + _local_2.drawTriangles(blurIndexBuffer, 0, 2); + _local_2.setRenderToTexture(this.map1, false); + _local_2.clear(0, 0, 0, 0); + _local_2.setProgram(this.getBlurProgram(2, this.blur)); + _local_2.setTextureAt(0, this.map2); + _local_2.drawTriangles(blurIndexBuffer, 0, 2); + }; + } + + alternativa3d function clear():void + { + var _local_2:Shadow; + var _local_1:int; + while (_local_1 < this.shadowsCount) + { + _local_2 = this.shadows[_local_1]; + _local_2.texture = null; + _local_1++; + }; + this.shadows.length = 0; + this.shadowsCount = 0; + } + + private function getBlurProgram(_arg_1:int, _arg_2:int):ProgramResource + { + var _local_5:ByteArray; + var _local_6:ByteArray; + var _local_3:int = ((_arg_1 << 16) + _arg_2); + var _local_4:ProgramResource = blurPrograms[_local_3]; + if (_local_4 == null) + { + _local_5 = new ShadowAtlasVertexShader().agalcode; + _local_6 = new ShadowAtlasFragmentShader(_arg_2, (_arg_1 == 1)).agalcode; + _local_4 = new ProgramResource(_local_5, _local_6); + blurPrograms[_local_3] = _local_4; + }; + return (_local_4); + } + + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/ShadowAtlasFragmentShader.as b/src/alternativa/engine3d/core/ShadowAtlasFragmentShader.as new file mode 100644 index 0000000..6469cbd --- /dev/null +++ b/src/alternativa/engine3d/core/ShadowAtlasFragmentShader.as @@ -0,0 +1,44 @@ +package alternativa.engine3d.core{ + import alternativa.gfx.agal.FragmentShader; + import alternativa.gfx.agal.SamplerDim; + import alternativa.gfx.agal.SamplerRepeat; + import alternativa.gfx.agal.SamplerFilter; + import alternativa.gfx.agal.SamplerMipMap; + + public class ShadowAtlasFragmentShader extends FragmentShader { + + public function ShadowAtlasFragmentShader(_arg_1:int, _arg_2:Boolean){ + var _local_3:int; + super(); + mov(ft1, v0); + tex(ft3, ft1, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + if (_arg_2) + { + sub(ft1.x, v0, fc[1]); + } else + { + sub(ft1.y, v0, fc[1]); + }; + _local_3 = -(_arg_1); + while (_local_3 <= _arg_1) + { + if (_local_3 != 0) + { + tex(ft2, ft1, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + add(ft3.w, ft3, ft2); + }; + if (_arg_2) + { + add(ft1.x, ft1, fc[0]); + } else + { + add(ft1.y, ft1, fc[0]); + }; + _local_3++; + }; + div(ft3.w, ft3, fc[0]); + mov(oc, ft3); + } + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/ShadowAtlasVertexShader.as b/src/alternativa/engine3d/core/ShadowAtlasVertexShader.as new file mode 100644 index 0000000..dea9fa8 --- /dev/null +++ b/src/alternativa/engine3d/core/ShadowAtlasVertexShader.as @@ -0,0 +1,12 @@ +package alternativa.engine3d.core{ + import alternativa.gfx.agal.VertexShader; + + public class ShadowAtlasVertexShader extends VertexShader { + + public function ShadowAtlasVertexShader(){ + mov(op, va0); + mov(v0, va1); + } + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/ShadowCasterVertexShader.as b/src/alternativa/engine3d/core/ShadowCasterVertexShader.as new file mode 100644 index 0000000..6337408 --- /dev/null +++ b/src/alternativa/engine3d/core/ShadowCasterVertexShader.as @@ -0,0 +1,18 @@ +package alternativa.engine3d.core{ + import alternativa.gfx.agal.VertexShader; + + public class ShadowCasterVertexShader extends VertexShader { + + public function ShadowCasterVertexShader(){ + dp4(vt0.x, va0, vc[0]); + dp4(vt0.y, va0, vc[1]); + dp4(vt0.zw, va0, vc[2]); + mul(vt0.xy, vt0, vc[3]); + add(vt0.xy, vt0, vc[4]); + mov(op.xyz, vt0); + mov(op.w, vc[3]); + mov(v0, vt0); + } + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/ShadowMap.as b/src/alternativa/engine3d/core/ShadowMap.as new file mode 100644 index 0000000..71e64f6 --- /dev/null +++ b/src/alternativa/engine3d/core/ShadowMap.as @@ -0,0 +1,560 @@ +package alternativa.engine3d.core +{ + import alternativa.gfx.core.VertexBufferResource; + import alternativa.gfx.core.IndexBufferResource; + import __AS3__.vec.Vector; + import flash.geom.Rectangle; + import alternativa.gfx.core.RenderTargetTextureResource; + import alternativa.gfx.core.BitmapTextureResource; + import alternativa.engine3d.lights.DirectionalLight; + import flash.display.BitmapData; + import alternativa.engine3d.materials.TextureMaterial; + import alternativa.engine3d.objects.Sprite3D; + import alternativa.engine3d.objects.Mesh; + import alternativa.engine3d.objects.BSP; + import alternativa.gfx.core.Device; + import flash.display3D.Context3DVertexBufferFormat; + import flash.display3D.Context3DProgramType; + import flash.utils.ByteArray; + import alternativa.gfx.core.ProgramResource; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class ShadowMap + { + + private static const sizeLimit:int = 0x0800; + private static const bigValue:Number = 0x0800; + public static const numSamples:int = 6; + + private var programs:Array = new Array(); + private var spriteVertexBuffer:VertexBufferResource = new VertexBufferResource(Vector.([0, 2, 4, 6]), 1); + private var spriteIndexBuffer:IndexBufferResource = new IndexBufferResource(Vector.([0, 1, 3, 1, 2, 3])); + alternativa3d var transform:Vector. = Vector.([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]); + alternativa3d var params:Vector. = Vector.([(-255 * bigValue), -(bigValue), bigValue, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1]); + private var coords:Vector. = Vector.([0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, (1 / 0xFF), 1]); + private var fragment:Vector. = Vector.([(1 / 0xFF), 0, 1, 1]); + private var alphaTestConst:Vector. = Vector.([0, 0, 0, 1]); + private var scissor:Rectangle = new Rectangle(); + alternativa3d var map:RenderTargetTextureResource; + alternativa3d var noise:BitmapTextureResource; + private var noiseSize:int = 64; + private var noiseAngle:Number = 1.0471975511966; + private var noiseRadius:Number = 1.3; + private var noiseRandom:Number = 0.3; + public var mapSize:int; + public var nearDistance:Number; + public var farDistance:Number; + public var bias:Number = 0; + public var biasMultiplier:Number = 30; + public var additionalSpace:Number = 0; + public var alphaThreshold:Number = 0.1; + private var defaultLight:DirectionalLight = new DirectionalLight(0x7F7F7F); + private var boundVertexList:Vertex = Vertex.createList(8); + private var light:DirectionalLight; + private var dirZ:Number; + private var planeX:Number; + private var planeY:Number; + private var planeSize:Number; + private var pixel:Number; + alternativa3d var boundMinX:Number; + alternativa3d var boundMinY:Number; + alternativa3d var boundMinZ:Number; + alternativa3d var boundMaxX:Number; + alternativa3d var boundMaxY:Number; + alternativa3d var boundMaxZ:Number; + + public function ShadowMap(_arg_1:int, _arg_2:Number, _arg_3:Number, _arg_4:Number=0, _arg_5:Number=0) + { + var _local_10:int; + var _local_11:Number; + var _local_12:int; + var _local_13:int; + var _local_14:int; + super(); + if (_arg_1 > sizeLimit) + { + throw (new Error("Value of mapSize too big.")); + }; + var _local_6:Number = (Math.log(_arg_1) / Math.LN2); + if (_local_6 != int(_local_6)) + { + throw (new Error("Value of mapSize must be power of 2.")); + }; + this.mapSize = _arg_1; + this.nearDistance = _arg_2; + this.farDistance = _arg_3; + this.bias = _arg_4; + this.additionalSpace = _arg_5; + this.defaultLight.rotationX = Math.PI; + this.map = new RenderTargetTextureResource(_arg_1, _arg_1); + var _local_7:Vector. = new Vector.(); + var _local_8:int; + var _local_9:int; + while (_local_9 < this.noiseSize) + { + _local_10 = 0; + while (_local_10 < this.noiseSize) + { + _local_11 = (Math.random() * this.noiseAngle); + _local_12 = (Math.sin(_local_11) * 0xFF); + _local_13 = (Math.cos(_local_11) * 0xFF); + _local_14 = ((this.noiseRandom + (Math.random() * (1 - this.noiseRandom))) * 0xFF); + _local_7[_local_8] = (((_local_12 << 16) | (_local_13 << 8)) | _local_14); + _local_8++; + _local_10++; + }; + _local_9++; + }; + this.noise = new BitmapTextureResource(new BitmapData(this.noiseSize, this.noiseSize, false, 0), false); + this.noise.bitmapData.setVector(this.noise.bitmapData.rect, _local_7); + } + + alternativa3d function calculateBounds(_arg_1:Camera3D):void + { + if (_arg_1.directionalLight != null) + { + this.light = _arg_1.directionalLight; + } + else + { + this.light = this.defaultLight; + }; + this.light.composeMatrix(); + this.dirZ = this.light.mk; + this.light.calculateInverseMatrix(); + var _local_2:Number = this.light.ima; + var _local_3:Number = this.light.imb; + var _local_4:Number = this.light.imc; + var _local_5:Number = this.light.imd; + var _local_6:Number = this.light.ime; + var _local_7:Number = this.light.imf; + var _local_8:Number = this.light.img; + var _local_9:Number = this.light.imh; + var _local_10:Number = this.light.imi; + var _local_11:Number = this.light.imj; + var _local_12:Number = this.light.imk; + var _local_13:Number = this.light.iml; + this.light.ima = (((_local_2 * _arg_1.gma) + (_local_3 * _arg_1.gme)) + (_local_4 * _arg_1.gmi)); + this.light.imb = (((_local_2 * _arg_1.gmb) + (_local_3 * _arg_1.gmf)) + (_local_4 * _arg_1.gmj)); + this.light.imc = (((_local_2 * _arg_1.gmc) + (_local_3 * _arg_1.gmg)) + (_local_4 * _arg_1.gmk)); + this.light.imd = ((((_local_2 * _arg_1.gmd) + (_local_3 * _arg_1.gmh)) + (_local_4 * _arg_1.gml)) + _local_5); + this.light.ime = (((_local_6 * _arg_1.gma) + (_local_7 * _arg_1.gme)) + (_local_8 * _arg_1.gmi)); + this.light.imf = (((_local_6 * _arg_1.gmb) + (_local_7 * _arg_1.gmf)) + (_local_8 * _arg_1.gmj)); + this.light.img = (((_local_6 * _arg_1.gmc) + (_local_7 * _arg_1.gmg)) + (_local_8 * _arg_1.gmk)); + this.light.imh = ((((_local_6 * _arg_1.gmd) + (_local_7 * _arg_1.gmh)) + (_local_8 * _arg_1.gml)) + _local_9); + this.light.imi = (((_local_10 * _arg_1.gma) + (_local_11 * _arg_1.gme)) + (_local_12 * _arg_1.gmi)); + this.light.imj = (((_local_10 * _arg_1.gmb) + (_local_11 * _arg_1.gmf)) + (_local_12 * _arg_1.gmj)); + this.light.imk = (((_local_10 * _arg_1.gmc) + (_local_11 * _arg_1.gmg)) + (_local_12 * _arg_1.gmk)); + this.light.iml = ((((_local_10 * _arg_1.gmd) + (_local_11 * _arg_1.gmh)) + (_local_12 * _arg_1.gml)) + _local_13); + var _local_14:Vertex = this.boundVertexList; + _local_14.x = -(_arg_1.nearClipping); + _local_14.y = -(_arg_1.nearClipping); + _local_14.z = _arg_1.nearClipping; + _local_14 = _local_14.next; + _local_14.x = -(_arg_1.nearClipping); + _local_14.y = _arg_1.nearClipping; + _local_14.z = _arg_1.nearClipping; + _local_14 = _local_14.next; + _local_14.x = _arg_1.nearClipping; + _local_14.y = _arg_1.nearClipping; + _local_14.z = _arg_1.nearClipping; + _local_14 = _local_14.next; + _local_14.x = _arg_1.nearClipping; + _local_14.y = -(_arg_1.nearClipping); + _local_14.z = _arg_1.nearClipping; + _local_14 = _local_14.next; + _local_14.x = -(this.farDistance); + _local_14.y = -(this.farDistance); + _local_14.z = this.farDistance; + _local_14 = _local_14.next; + _local_14.x = -(this.farDistance); + _local_14.y = this.farDistance; + _local_14.z = this.farDistance; + _local_14 = _local_14.next; + _local_14.x = this.farDistance; + _local_14.y = this.farDistance; + _local_14.z = this.farDistance; + _local_14 = _local_14.next; + _local_14.x = this.farDistance; + _local_14.y = -(this.farDistance); + _local_14.z = this.farDistance; + this.light.boundMinX = 1E22; + this.light.boundMinY = 1E22; + this.light.boundMinZ = 1E22; + this.light.boundMaxX = -1E22; + this.light.boundMaxY = -1E22; + this.light.boundMaxZ = -1E22; + _local_14 = this.boundVertexList; + while (_local_14 != null) + { + _local_14.cameraX = ((((this.light.ima * _local_14.x) + (this.light.imb * _local_14.y)) + (this.light.imc * _local_14.z)) + this.light.imd); + _local_14.cameraY = ((((this.light.ime * _local_14.x) + (this.light.imf * _local_14.y)) + (this.light.img * _local_14.z)) + this.light.imh); + _local_14.cameraZ = ((((this.light.imi * _local_14.x) + (this.light.imj * _local_14.y)) + (this.light.imk * _local_14.z)) + this.light.iml); + if (_local_14.cameraX < this.light.boundMinX) + { + this.light.boundMinX = _local_14.cameraX; + }; + if (_local_14.cameraX > this.light.boundMaxX) + { + this.light.boundMaxX = _local_14.cameraX; + }; + if (_local_14.cameraY < this.light.boundMinY) + { + this.light.boundMinY = _local_14.cameraY; + }; + if (_local_14.cameraY > this.light.boundMaxY) + { + this.light.boundMaxY = _local_14.cameraY; + }; + if (_local_14.cameraZ < this.light.boundMinZ) + { + this.light.boundMinZ = _local_14.cameraZ; + }; + if (_local_14.cameraZ > this.light.boundMaxZ) + { + this.light.boundMaxZ = _local_14.cameraZ; + }; + _local_14 = _local_14.next; + }; + var _local_15:Vertex = this.boundVertexList; + var _local_16:Vertex = this.boundVertexList.next.next.next.next.next.next; + var _local_17:Vertex = this.boundVertexList.next.next.next.next; + var _local_18:Number = (_local_16.cameraX - _local_15.cameraX); + var _local_19:Number = (_local_16.cameraY - _local_15.cameraY); + var _local_20:Number = (_local_16.cameraZ - _local_15.cameraZ); + var _local_21:Number = (_local_17.cameraX - _local_16.cameraX); + var _local_22:Number = (_local_17.cameraY - _local_16.cameraY); + var _local_23:Number = (_local_17.cameraZ - _local_16.cameraZ); + var _local_24:Number = (((_local_18 * _local_18) + (_local_19 * _local_19)) + (_local_20 * _local_20)); + var _local_25:Number = (((_local_21 * _local_21) + (_local_22 * _local_22)) + (_local_23 * _local_23)); + var _local_26:int = Math.ceil(this.noiseRadius); + this.planeSize = ((_local_24 > _local_25) ? Math.sqrt(_local_24) : Math.sqrt(_local_25)); + this.pixel = (this.planeSize / ((this.mapSize - 1) - this.noiseRadius)); + this.planeSize = (this.planeSize + ((_local_26 * this.pixel) * 2)); + this.light.boundMinX = (this.light.boundMinX - (_local_26 * this.pixel)); + this.light.boundMaxX = (this.light.boundMaxX + (_local_26 * this.pixel)); + this.light.boundMinY = (this.light.boundMinY - (_local_26 * this.pixel)); + this.light.boundMaxY = (this.light.boundMaxY + (_local_26 * this.pixel)); + this.light.boundMinZ = (this.light.boundMinZ - this.additionalSpace); + _local_14 = this.boundVertexList; + _local_14.x = this.light.boundMinX; + _local_14.y = this.light.boundMinY; + _local_14.z = this.light.boundMinZ; + _local_14 = _local_14.next; + _local_14.x = this.light.boundMaxX; + _local_14.y = this.light.boundMinY; + _local_14.z = this.light.boundMinZ; + _local_14 = _local_14.next; + _local_14.x = this.light.boundMinX; + _local_14.y = this.light.boundMaxY; + _local_14.z = this.light.boundMinZ; + _local_14 = _local_14.next; + _local_14.x = this.light.boundMaxX; + _local_14.y = this.light.boundMaxY; + _local_14.z = this.light.boundMinZ; + _local_14 = _local_14.next; + _local_14.x = this.light.boundMinX; + _local_14.y = this.light.boundMinY; + _local_14.z = this.light.boundMaxZ; + _local_14 = _local_14.next; + _local_14.x = this.light.boundMaxX; + _local_14.y = this.light.boundMinY; + _local_14.z = this.light.boundMaxZ; + _local_14 = _local_14.next; + _local_14.x = this.light.boundMinX; + _local_14.y = this.light.boundMaxY; + _local_14.z = this.light.boundMaxZ; + _local_14 = _local_14.next; + _local_14.x = this.light.boundMaxX; + _local_14.y = this.light.boundMaxY; + _local_14.z = this.light.boundMaxZ; + this.boundMinX = 1E22; + this.boundMinY = 1E22; + this.boundMinZ = 1E22; + this.boundMaxX = -1E22; + this.boundMaxY = -1E22; + this.boundMaxZ = -1E22; + _local_14 = this.boundVertexList; + while (_local_14 != null) + { + _local_14.cameraX = ((((this.light.ma * _local_14.x) + (this.light.mb * _local_14.y)) + (this.light.mc * _local_14.z)) + this.light.md); + _local_14.cameraY = ((((this.light.me * _local_14.x) + (this.light.mf * _local_14.y)) + (this.light.mg * _local_14.z)) + this.light.mh); + _local_14.cameraZ = ((((this.light.mi * _local_14.x) + (this.light.mj * _local_14.y)) + (this.light.mk * _local_14.z)) + this.light.ml); + if (_local_14.cameraX < this.boundMinX) + { + this.boundMinX = _local_14.cameraX; + }; + if (_local_14.cameraX > this.boundMaxX) + { + this.boundMaxX = _local_14.cameraX; + }; + if (_local_14.cameraY < this.boundMinY) + { + this.boundMinY = _local_14.cameraY; + }; + if (_local_14.cameraY > this.boundMaxY) + { + this.boundMaxY = _local_14.cameraY; + }; + if (_local_14.cameraZ < this.boundMinZ) + { + this.boundMinZ = _local_14.cameraZ; + }; + if (_local_14.cameraZ > this.boundMaxZ) + { + this.boundMaxZ = _local_14.cameraZ; + }; + _local_14 = _local_14.next; + }; + } + + alternativa3d function render(_arg_1:Camera3D, _arg_2:Vector., _arg_3:int):void + { + var _local_12:Object3D; + var _local_13:VertexBufferResource; + var _local_14:IndexBufferResource; + var _local_15:int; + var _local_16:Boolean; + var _local_17:TextureMaterial; + var _local_18:Sprite3D; + var _local_19:Number; + var _local_20:Number; + var _local_21:Number; + var _local_22:Number; + var _local_23:Number; + var _local_24:Number; + var _local_25:Number; + var _local_26:Number; + var _local_27:Number; + var _local_28:Number; + var _local_29:Number; + var _local_30:Number; + var _local_31:Number; + var _local_32:Number; + var _local_33:Mesh; + var _local_34:BSP; + var _local_4:Device = _arg_1.device; + this.planeX = (Math.floor((this.light.boundMinX / this.pixel)) * this.pixel); + this.planeY = (Math.floor((this.light.boundMinY / this.pixel)) * this.pixel); + this.scissor.width = (Math.ceil((this.light.boundMaxX / this.pixel)) - (this.planeX / this.pixel)); + this.scissor.height = (Math.ceil((this.light.boundMaxY / this.pixel)) - (this.planeY / this.pixel)); + var _local_5:Number = (2 / this.planeSize); + var _local_6:Number = (-2 / this.planeSize); + var _local_7:Number = (0xFF / (this.light.boundMaxZ - this.light.boundMinZ)); + var _local_8:Number = (-(this.planeX + (this.planeSize * 0.5)) * _local_5); + var _local_9:Number = (-(this.planeY + (this.planeSize * 0.5)) * _local_6); + var _local_10:Number = (-(this.light.boundMinZ) * _local_7); + if (this.mapSize != this.map.width) + { + this.map.dispose(); + this.map = new RenderTargetTextureResource(this.mapSize, this.mapSize); + }; + _local_4.setRenderToTexture(this.map, true); + _local_4.clear(1, 0, 0); + _local_4.setScissorRectangle(this.scissor); + this.transform[14] = (1 / 0xFF); + var _local_11:int; + while (_local_11 < _arg_3) + { + _local_12 = _arg_2[_local_11]; + _local_13 = null; + _local_14 = null; + _local_16 = false; + if ((_local_12 is Sprite3D)) + { + _local_18 = Sprite3D(_local_12); + _local_17 = TextureMaterial(_local_18.material); + _local_19 = _local_18.width; + _local_20 = _local_18.height; + if (_local_18.autoSize) + { + _local_31 = (_local_18.bottomRightU - _local_18.topLeftU); + _local_32 = (_local_18.bottomRightV - _local_18.topLeftV); + _local_19 = (_local_17.texture.width * _local_31); + _local_20 = (_local_17.texture.height * _local_32); + }; + _local_21 = Math.tan(Math.asin(-(this.dirZ))); + _local_19 = (_local_19 * _local_18.scaleX); + _local_20 = (_local_20 * _local_18.scaleY); + _local_22 = ((((this.light.ima * _local_12.md) + (this.light.imb * _local_12.mh)) + (this.light.imc * _local_12.ml)) + this.light.imd); + _local_23 = ((((this.light.ime * _local_12.md) + (this.light.imf * _local_12.mh)) + (this.light.img * _local_12.ml)) + this.light.imh); + _local_24 = ((((this.light.imi * _local_12.md) + (this.light.imj * _local_12.mh)) + (this.light.imk * _local_12.ml)) + this.light.iml); + _local_23 = (_local_23 + ((Math.sin(-(this.dirZ)) * _local_20) / 4)); + _local_24 = (_local_24 - ((Math.cos(-(this.dirZ)) * _local_20) / 4)); + _local_25 = (-(_local_19) * _local_18.originX); + _local_26 = (-(_local_20) * _local_18.originY); + _local_27 = (-(_local_26) / _local_21); + _local_28 = (_local_25 + _local_19); + _local_29 = (_local_26 + _local_20); + _local_30 = (-(_local_29) / _local_21); + _local_25 = (((_local_25 + _local_22) * _local_5) + _local_8); + _local_26 = (((_local_26 + _local_23) * _local_6) + _local_9); + _local_27 = (((_local_27 + _local_24) * _local_7) + _local_10); + _local_28 = (((_local_28 + _local_22) * _local_5) + _local_8); + _local_29 = (((_local_29 + _local_23) * _local_6) + _local_9); + _local_30 = (((_local_30 + _local_24) * _local_7) + _local_10); + _local_27 = (_local_27 - (((this.bias * this.biasMultiplier) * _local_7) / _local_21)); + _local_30 = (_local_30 - (((this.bias * this.biasMultiplier) * _local_7) / _local_21)); + this.coords[0] = _local_25; + this.coords[1] = _local_26; + this.coords[2] = _local_27; + this.coords[4] = 0; + this.coords[5] = 0; + this.coords[8] = _local_25; + this.coords[9] = _local_29; + this.coords[10] = _local_30; + this.coords[12] = 0; + this.coords[13] = 1; + this.coords[16] = _local_28; + this.coords[17] = _local_29; + this.coords[18] = _local_30; + this.coords[20] = 1; + this.coords[21] = 1; + this.coords[24] = _local_28; + this.coords[25] = _local_26; + this.coords[26] = _local_27; + this.coords[28] = 1; + this.coords[29] = 0; + _local_13 = this.spriteVertexBuffer; + _local_14 = this.spriteIndexBuffer; + _local_15 = 2; + _local_16 = true; + _local_4.setProgram(this.getProgram(true, true)); + _local_4.setVertexBufferAt(0, _local_13, 0, Context3DVertexBufferFormat.FLOAT_1); + _local_4.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 0, this.coords, 9, false); + } + else + { + this.transform[0] = ((((this.light.ima * _local_12.ma) + (this.light.imb * _local_12.me)) + (this.light.imc * _local_12.mi)) * _local_5); + this.transform[1] = ((((this.light.ima * _local_12.mb) + (this.light.imb * _local_12.mf)) + (this.light.imc * _local_12.mj)) * _local_5); + this.transform[2] = ((((this.light.ima * _local_12.mc) + (this.light.imb * _local_12.mg)) + (this.light.imc * _local_12.mk)) * _local_5); + this.transform[3] = ((((((this.light.ima * _local_12.md) + (this.light.imb * _local_12.mh)) + (this.light.imc * _local_12.ml)) + this.light.imd) * _local_5) + _local_8); + this.transform[4] = ((((this.light.ime * _local_12.ma) + (this.light.imf * _local_12.me)) + (this.light.img * _local_12.mi)) * _local_6); + this.transform[5] = ((((this.light.ime * _local_12.mb) + (this.light.imf * _local_12.mf)) + (this.light.img * _local_12.mj)) * _local_6); + this.transform[6] = ((((this.light.ime * _local_12.mc) + (this.light.imf * _local_12.mg)) + (this.light.img * _local_12.mk)) * _local_6); + this.transform[7] = ((((((this.light.ime * _local_12.md) + (this.light.imf * _local_12.mh)) + (this.light.img * _local_12.ml)) + this.light.imh) * _local_6) + _local_9); + this.transform[8] = ((((this.light.imi * _local_12.ma) + (this.light.imj * _local_12.me)) + (this.light.imk * _local_12.mi)) * _local_7); + this.transform[9] = ((((this.light.imi * _local_12.mb) + (this.light.imj * _local_12.mf)) + (this.light.imk * _local_12.mj)) * _local_7); + this.transform[10] = ((((this.light.imi * _local_12.mc) + (this.light.imj * _local_12.mg)) + (this.light.imk * _local_12.mk)) * _local_7); + this.transform[11] = ((((((this.light.imi * _local_12.md) + (this.light.imj * _local_12.mh)) + (this.light.imk * _local_12.ml)) + this.light.iml) * _local_7) + _local_10); + if ((_local_12 is Mesh)) + { + _local_33 = Mesh(_local_12); + _local_33.prepareResources(); + _local_13 = _local_33.vertexBuffer; + _local_14 = _local_33.indexBuffer; + _local_15 = _local_33.numTriangles; + _local_17 = (_local_33.faceList.material as TextureMaterial); + } + else + { + if ((_local_12 is BSP)) + { + _local_34 = BSP(_local_12); + _local_34.prepareResources(); + _local_13 = _local_34.vertexBuffer; + _local_14 = _local_34.indexBuffer; + _local_15 = _local_34.numTriangles; + _local_17 = (_local_34.faces[0].material as TextureMaterial); + } + else + { + _local_17 = null; + }; + }; + if (((!(_local_17 == null)) && (_local_17.transparent))) + { + _local_16 = true; + _local_4.setProgram(this.getProgram(true, false)); + _local_4.setVertexBufferAt(1, _local_13, 3, Context3DVertexBufferFormat.FLOAT_2); + } + else + { + _local_4.setProgram(this.getProgram(false, false)); + }; + _local_4.setVertexBufferAt(0, _local_13, 0, Context3DVertexBufferFormat.FLOAT_3); + _local_4.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 0, this.transform, 4, false); + }; + if (((!(_local_13 == null)) && (!(_local_14 == null)))) + { + _local_4.setTextureAt(4, null); + _local_4.setTextureAt(6, null); + if (_local_16) + { + _local_4.setTextureAt(0, _local_17.textureResource); + this.alphaTestConst[0] = _local_17.textureResource.correctionU; + this.alphaTestConst[1] = _local_17.textureResource.correctionV; + this.alphaTestConst[3] = ((_local_12 is Sprite3D) ? 0.99 : this.alphaThreshold); + _local_4.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 10, this.alphaTestConst, 1); + }; + _local_4.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 0, this.fragment, 1); + _local_4.drawTriangles(_local_14, 0, _local_15); + }; + if (_local_16) + { + _local_4.setTextureAt(0, null); + _local_4.setVertexBufferAt(1, null); + }; + _local_11++; + }; + _local_4.setScissorRectangle(null); + _local_5 = (1 / this.planeSize); + _local_6 = (1 / this.planeSize); + _local_8 = (-(this.planeX) * _local_5); + _local_9 = (-(this.planeY) * _local_6); + this.transform[0] = (this.light.ima * _local_5); + this.transform[1] = (this.light.imb * _local_5); + this.transform[2] = (this.light.imc * _local_5); + this.transform[3] = ((this.light.imd * _local_5) + _local_8); + this.transform[4] = (this.light.ime * _local_6); + this.transform[5] = (this.light.imf * _local_6); + this.transform[6] = (this.light.img * _local_6); + this.transform[7] = ((this.light.imh * _local_6) + _local_9); + this.transform[8] = (this.light.imi * _local_7); + this.transform[9] = (this.light.imj * _local_7); + this.transform[10] = (this.light.imk * _local_7); + this.transform[11] = (((this.light.iml * _local_7) + _local_10) - ((this.bias * this.biasMultiplier) * _local_7)); + this.transform[12] = this.nearDistance; + this.transform[13] = (this.farDistance - this.nearDistance); + this.transform[14] = -(_local_7); + this.params[4] = 0; + this.params[5] = 0; + this.params[6] = (this.noiseRadius / this.mapSize); + this.params[7] = (1 / numSamples); + this.params[8] = (_arg_1.view._width / this.noiseSize); + this.params[9] = (_arg_1.view._height / this.noiseSize); + this.params[11] = ((_arg_1.directionalLight != null) ? (_arg_1.directionalLightStrength * _arg_1.shadowMapStrength) : 0); + this.params[12] = Math.cos(this.noiseAngle); + this.params[13] = Math.sin(this.noiseAngle); + this.params[16] = -(Math.sin(this.noiseAngle)); + this.params[17] = Math.cos(this.noiseAngle); + } + + public function dispose():void + { + this.map.reset(); + this.noise.reset(); + } + + private function getProgram(_arg_1:Boolean, _arg_2:Boolean):ProgramResource + { + var _local_5:ByteArray; + var _local_6:ByteArray; + var _local_3:int = (int(_arg_1) | (int(_arg_2) << 1)); + var _local_4:ProgramResource = this.programs[_local_3]; + if (_local_4 == null) + { + _local_5 = new ShadowMapVertexShader(_arg_1, _arg_2).agalcode; + _local_6 = new ShadowMapFragmentShader(_arg_1).agalcode; + _local_4 = new ProgramResource(_local_5, _local_6); + this.programs[_local_3] = _local_4; + }; + return (_local_4); + } + + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/ShadowMapFragmentShader.as b/src/alternativa/engine3d/core/ShadowMapFragmentShader.as new file mode 100644 index 0000000..7f8f0d0 --- /dev/null +++ b/src/alternativa/engine3d/core/ShadowMapFragmentShader.as @@ -0,0 +1,29 @@ +package alternativa.engine3d.core +{ + import alternativa.gfx.agal.FragmentShader; + import alternativa.gfx.agal.SamplerDim; + import alternativa.gfx.agal.SamplerFilter; + import alternativa.gfx.agal.SamplerMipMap; + import alternativa.gfx.agal.SamplerRepeat; + + public class ShadowMapFragmentShader extends FragmentShader + { + + + public function ShadowMapFragmentShader(param1:Boolean) + { + super(); + if(param1) + { + tex(ft0,v1,fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.LINEAR).mipmap(SamplerMipMap.NONE)); + sub(ft0.w,ft0,v1); + kil(ft0.w); + } + frc(ft0,v0.z); + sub(ft0.x,v0.z,ft0); + mul(ft0.x,ft0,fc[0]); + mov(ft0.zw,fc[0]); + mov(oc,ft0); + } + } +} diff --git a/src/alternativa/engine3d/core/ShadowMapVertexShader.as b/src/alternativa/engine3d/core/ShadowMapVertexShader.as new file mode 100644 index 0000000..d0afde1 --- /dev/null +++ b/src/alternativa/engine3d/core/ShadowMapVertexShader.as @@ -0,0 +1,40 @@ +package alternativa.engine3d.core +{ + import alternativa.gfx.agal.VertexShader; + + public class ShadowMapVertexShader extends VertexShader + { + + + public function ShadowMapVertexShader(param1:Boolean, param2:Boolean) + { + super(); + if(param2) + { + mov(vt0,cc.rel(va0.x,0)); + mov(v0,vt0); + mul(vt0.z,vt0,vc[8]); + mov(op,vt0); + if(param1) + { + mov(vt0,vc[10]); + mul(v1,cc.rel(va0.x,1),vt0); + } + } + else + { + mov(vt0,vc[3]); + dp4(vt0.x,va0,vc[0]); + dp4(vt0.y,va0,vc[1]); + dp4(vt0.z,va0,vc[2]); + mov(v0,vt0); + mul(vt0.z,vt0,vc[3]); + mov(op,vt0); + if(param1) + { + mul(v1,va1,vc[10]); + } + } + } + } +} diff --git a/src/alternativa/engine3d/core/ShadowReceiverFragmentShader.as b/src/alternativa/engine3d/core/ShadowReceiverFragmentShader.as new file mode 100644 index 0000000..fda8ac9 --- /dev/null +++ b/src/alternativa/engine3d/core/ShadowReceiverFragmentShader.as @@ -0,0 +1,44 @@ +package alternativa.engine3d.core{ + import alternativa.gfx.agal.FragmentShader; + import alternativa.gfx.agal.SamplerFilter; + import alternativa.gfx.agal.SamplerMipMap; + import alternativa.gfx.agal.SamplerDim; + import alternativa.gfx.agal.SamplerRepeat; + + public class ShadowReceiverFragmentShader extends FragmentShader { + + public function ShadowReceiverFragmentShader(_arg_1:Boolean, _arg_2:Boolean){ + var _local_3:SamplerFilter = ((_arg_1) ? SamplerFilter.LINEAR : SamplerFilter.NEAREST); + var _local_4:SamplerMipMap = ((_arg_1) ? SamplerMipMap.LINEAR : SamplerMipMap.NEAREST); + if (_arg_2) + { + max(ft0, v0, fc[16]); + min(ft0.x, ft0, fc[16].z); + min(ft0.y, ft0, fc[16].w); + tex(ft0, ft0, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(_local_3).mipmap(_local_4)); + } else + { + tex(ft0, v0, fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(_local_3).mipmap(_local_4)); + }; + sub(ft1, v0.z, fc[14]); + div(ft2, ft1, fc[13]); + max(ft3, ft1, fc[13].x); + mul(ft3, ft3, fc[13].y); + min(ft3, ft3, fc[14]); + sub(ft4, fc[14], ft3); + mul(ft2, ft2, ft3); + mul(ft1, ft1, ft4); + add(ft2, ft1, ft2); + sub(ft2, fc[14], ft2); + mul(ft0, ft0, ft2); + sub(ft1, v0, fc[14]); + div(ft1, ft1, fc[14].y); + sat(ft1, ft1); + mul(ft0, ft0, ft1.z); + mov(ft0.xyz, fc[15]); + mul(ft0.w, ft0, fc[15]); + mov(oc, ft0); + } + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/ShadowReceiverVertexShader.as b/src/alternativa/engine3d/core/ShadowReceiverVertexShader.as new file mode 100644 index 0000000..5318b9b --- /dev/null +++ b/src/alternativa/engine3d/core/ShadowReceiverVertexShader.as @@ -0,0 +1,42 @@ +package alternativa.engine3d.core{ + import alternativa.gfx.agal.VertexShader; + + public class ShadowReceiverVertexShader extends VertexShader { + + public function ShadowReceiverVertexShader(_arg_1:Boolean){ + dp4(vt0.x, va0, vc[11]); + dp4(vt0.y, va0, vc[12]); + dp4(vt0.z, va0, vc[13]); + mov(vt0.w, va0); + dp4(vt1, vt0, vc[15]); + dp4(vt1.y, vt0, vc[16]); + mul(vt1.xy, vt1, vc[19]); + add(v0.xy, vt1, vc[20]); + dp4(v0.zw, vt0, vc[17]); + div(vt1.z, vc[14].w, vt0); + add(vt1.z, vt1, vc[14]); + mul(vt1.z, vt1, vc[14].x); + sub(vt1.z, vt1, vc[14].y); + div(vt1.z, vt1, vc[14].x); + sub(vt1.z, vt1, vc[14]); + div(vt1.z, vc[14].w, vt1); + mov(vt2, vc[20]); + nrm(vt2.xyz, vt0.xyz); + sub(vt1.z, vt0, vt1); + div(vt1.z, vt1, vt2); + mul(vt2, vt2, vt1.z); + sub(vt0, vt0, vt2); + if (_arg_1) + { + mul(vt0.xy, vt0, vc[18]); + mul(vt1.xy, vc[18].zw, vt0.z); + add(vt0.xy, vt0, vt1); + }; + mov(op.xw, vt0.xz); + neg(op.y, vt0); + mul(vt0.z, vt0, vc[14]); + add(op.z, vt0, vc[14].w); + } + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/ShadowVolumeVertexShader.as b/src/alternativa/engine3d/core/ShadowVolumeVertexShader.as new file mode 100644 index 0000000..2b4ff19 --- /dev/null +++ b/src/alternativa/engine3d/core/ShadowVolumeVertexShader.as @@ -0,0 +1,23 @@ +package alternativa.engine3d.core{ + import alternativa.gfx.agal.VertexShader; + + public class ShadowVolumeVertexShader extends VertexShader { + + public function ShadowVolumeVertexShader(){ + mul(vt1, va0, vc[14]); + add(vt1.xyz, vt1, vc[15]); + dp4(vt0.x, vt1, vc[11]); + dp4(vt0.y, vt1, vc[12]); + dp4(vt0.z, vt1, vc[13]); + mov(vt0.w, vt1); + mul(vt0.xy, vt0, vc[17]); + mul(vt1.xy, vc[17].zw, vt0.z); + add(vt0.xy, vt0, vt1); + mov(op.xw, vt0.xz); + neg(op.y, vt0); + mul(vt0.z, vt0, vc[16]); + add(op.z, vt0, vc[16].w); + } + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/Sorting.as b/src/alternativa/engine3d/core/Sorting.as new file mode 100644 index 0000000..6d8246b --- /dev/null +++ b/src/alternativa/engine3d/core/Sorting.as @@ -0,0 +1,18 @@ +package alternativa.engine3d.core +{ + public class Sorting + { + + public static const NONE:int = 0; + + public static const AVERAGE_Z:int = 1; + + public static const DYNAMIC_BSP:int = 2; + + + public function Sorting() + { + super(); + } + } +} diff --git a/src/alternativa/engine3d/core/VG.as b/src/alternativa/engine3d/core/VG.as new file mode 100644 index 0000000..cdbbb44 --- /dev/null +++ b/src/alternativa/engine3d/core/VG.as @@ -0,0 +1,1337 @@ +package alternativa.engine3d.core{ + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class VG { + + private static var collector:VG; + + alternativa3d var next:VG; + alternativa3d var faceStruct:Face; + alternativa3d var object:Object3D; + alternativa3d var sorting:int; + alternativa3d var debug:int = 0; + alternativa3d var space:int = 0; + alternativa3d var viewAligned:Boolean = false; + alternativa3d var boundMinX:Number; + alternativa3d var boundMinY:Number; + alternativa3d var boundMinZ:Number; + alternativa3d var boundMaxX:Number; + alternativa3d var boundMaxY:Number; + alternativa3d var boundMaxZ:Number; + alternativa3d var boundMin:Number; + alternativa3d var boundMax:Number; + alternativa3d var boundVertexList:Vertex = Vertex.createList(8); + alternativa3d var boundPlaneList:Vertex = Vertex.createList(6); + alternativa3d var numOccluders:int; + + + alternativa3d static function create(_arg_1:Object3D, _arg_2:Face, _arg_3:int, _arg_4:int, _arg_5:Boolean):VG{ + var _local_6:VG; + if (collector != null) + { + _local_6 = collector; + collector = collector.next; + _local_6.next = null; + } + else + { + _local_6 = new (VG)(); + }; + _local_6.object = _arg_1; + _local_6.faceStruct = _arg_2; + _local_6.sorting = _arg_3; + _local_6.debug = _arg_4; + _local_6.viewAligned = _arg_5; + return (_local_6); + } + + + alternativa3d function destroy():void{ + if (this.faceStruct != null) + { + this.destroyFaceStruct(this.faceStruct); + this.faceStruct = null; + }; + this.object = null; + this.numOccluders = 0; + this.debug = 0; + this.space = 0; + this.next = collector; + collector = this; + } + + private function destroyFaceStruct(_arg_1:Face):void{ + if (_arg_1.processNegative != null) + { + this.destroyFaceStruct(_arg_1.processNegative); + _arg_1.processNegative = null; + }; + if (_arg_1.processPositive != null) + { + this.destroyFaceStruct(_arg_1.processPositive); + _arg_1.processPositive = null; + }; + var _local_2:Face = _arg_1.processNext; + while (_local_2 != null) + { + _arg_1.processNext = null; + _arg_1 = _local_2; + _local_2 = _arg_1.processNext; + }; + } + + alternativa3d function calculateAABB(_arg_1:Number, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Number, _arg_9:Number, _arg_10:Number, _arg_11:Number, _arg_12:Number):void{ + this.boundMinX = 1E22; + this.boundMinY = 1E22; + this.boundMinZ = 1E22; + this.boundMaxX = -1E22; + this.boundMaxY = -1E22; + this.boundMaxZ = -1E22; + this.calculateAABBStruct(this.faceStruct, ++this.object.transformId, _arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9, _arg_10, _arg_11, _arg_12); + this.space = 1; + } + + alternativa3d function calculateOOBB(_arg_1:Object3D):void{ + var _local_2:Vertex; + var _local_3:Vertex; + var _local_4:Vertex; + var _local_5:Vertex; + var _local_6:Vertex; + var _local_7:Vertex; + var _local_8:Vertex; + var _local_9:Vertex; + var _local_10:Vertex; + var _local_11:Vertex; + var _local_12:Vertex; + var _local_13:Number; + var _local_14:Number; + var _local_15:Number; + var _local_16:Number; + var _local_17:Number; + var _local_18:Number; + var _local_19:Number; + var _local_20:Number; + var _local_21:Number; + var _local_22:Number; + var _local_23:Number; + var _local_24:Number; + var _local_25:Number; + var _local_26:Vertex; + var _local_27:Vertex; + var _local_28:Vertex; + var _local_29:Vertex; + if (this.space == 1) + { + this.transformStruct(this.faceStruct, ++this.object.transformId, _arg_1.ma, _arg_1.mb, _arg_1.mc, _arg_1.md, _arg_1.me, _arg_1.mf, _arg_1.mg, _arg_1.mh, _arg_1.mi, _arg_1.mj, _arg_1.mk, _arg_1.ml); + }; + if (!this.viewAligned) + { + this.boundMinX = 1E22; + this.boundMinY = 1E22; + this.boundMinZ = 1E22; + this.boundMaxX = -1E22; + this.boundMaxY = -1E22; + this.boundMaxZ = -1E22; + this.calculateOOBBStruct(this.faceStruct, ++this.object.transformId, this.object.ima, this.object.imb, this.object.imc, this.object.imd, this.object.ime, this.object.imf, this.object.img, this.object.imh, this.object.imi, this.object.imj, this.object.imk, this.object.iml); + if ((this.boundMaxX - this.boundMinX) < 1) + { + this.boundMaxX = (this.boundMinX + 1); + }; + if ((this.boundMaxY - this.boundMinY) < 1) + { + this.boundMaxY = (this.boundMinY + 1); + }; + if ((this.boundMaxZ - this.boundMinZ) < 1) + { + this.boundMaxZ = (this.boundMinZ + 1); + }; + _local_2 = this.boundVertexList; + _local_2.x = this.boundMinX; + _local_2.y = this.boundMinY; + _local_2.z = this.boundMinZ; + _local_3 = _local_2.next; + _local_3.x = this.boundMaxX; + _local_3.y = this.boundMinY; + _local_3.z = this.boundMinZ; + _local_4 = _local_3.next; + _local_4.x = this.boundMinX; + _local_4.y = this.boundMaxY; + _local_4.z = this.boundMinZ; + _local_5 = _local_4.next; + _local_5.x = this.boundMaxX; + _local_5.y = this.boundMaxY; + _local_5.z = this.boundMinZ; + _local_6 = _local_5.next; + _local_6.x = this.boundMinX; + _local_6.y = this.boundMinY; + _local_6.z = this.boundMaxZ; + _local_7 = _local_6.next; + _local_7.x = this.boundMaxX; + _local_7.y = this.boundMinY; + _local_7.z = this.boundMaxZ; + _local_8 = _local_7.next; + _local_8.x = this.boundMinX; + _local_8.y = this.boundMaxY; + _local_8.z = this.boundMaxZ; + _local_9 = _local_8.next; + _local_9.x = this.boundMaxX; + _local_9.y = this.boundMaxY; + _local_9.z = this.boundMaxZ; + _local_10 = _local_2; + while (_local_10 != null) + { + _local_10.cameraX = ((((this.object.ma * _local_10.x) + (this.object.mb * _local_10.y)) + (this.object.mc * _local_10.z)) + this.object.md); + _local_10.cameraY = ((((this.object.me * _local_10.x) + (this.object.mf * _local_10.y)) + (this.object.mg * _local_10.z)) + this.object.mh); + _local_10.cameraZ = ((((this.object.mi * _local_10.x) + (this.object.mj * _local_10.y)) + (this.object.mk * _local_10.z)) + this.object.ml); + _local_10 = _local_10.next; + }; + _local_11 = this.boundPlaneList; + _local_12 = _local_11.next; + _local_13 = _local_2.cameraX; + _local_14 = _local_2.cameraY; + _local_15 = _local_2.cameraZ; + _local_16 = (_local_3.cameraX - _local_13); + _local_17 = (_local_3.cameraY - _local_14); + _local_18 = (_local_3.cameraZ - _local_15); + _local_19 = (_local_6.cameraX - _local_13); + _local_20 = (_local_6.cameraY - _local_14); + _local_21 = (_local_6.cameraZ - _local_15); + _local_22 = ((_local_21 * _local_17) - (_local_20 * _local_18)); + _local_23 = ((_local_19 * _local_18) - (_local_21 * _local_16)); + _local_24 = ((_local_20 * _local_16) - (_local_19 * _local_17)); + _local_25 = (1 / Math.sqrt((((_local_22 * _local_22) + (_local_23 * _local_23)) + (_local_24 * _local_24)))); + _local_22 = (_local_22 * _local_25); + _local_23 = (_local_23 * _local_25); + _local_24 = (_local_24 * _local_25); + _local_11.cameraX = _local_22; + _local_11.cameraY = _local_23; + _local_11.cameraZ = _local_24; + _local_11.offset = (((_local_13 * _local_22) + (_local_14 * _local_23)) + (_local_15 * _local_24)); + _local_12.cameraX = -(_local_22); + _local_12.cameraY = -(_local_23); + _local_12.cameraZ = -(_local_24); + _local_12.offset = (((-(_local_4.cameraX) * _local_22) - (_local_4.cameraY * _local_23)) - (_local_4.cameraZ * _local_24)); + _local_26 = _local_12.next; + _local_27 = _local_26.next; + _local_13 = _local_2.cameraX; + _local_14 = _local_2.cameraY; + _local_15 = _local_2.cameraZ; + _local_16 = (_local_6.cameraX - _local_13); + _local_17 = (_local_6.cameraY - _local_14); + _local_18 = (_local_6.cameraZ - _local_15); + _local_19 = (_local_4.cameraX - _local_13); + _local_20 = (_local_4.cameraY - _local_14); + _local_21 = (_local_4.cameraZ - _local_15); + _local_22 = ((_local_21 * _local_17) - (_local_20 * _local_18)); + _local_23 = ((_local_19 * _local_18) - (_local_21 * _local_16)); + _local_24 = ((_local_20 * _local_16) - (_local_19 * _local_17)); + _local_25 = (1 / Math.sqrt((((_local_22 * _local_22) + (_local_23 * _local_23)) + (_local_24 * _local_24)))); + _local_22 = (_local_22 * _local_25); + _local_23 = (_local_23 * _local_25); + _local_24 = (_local_24 * _local_25); + _local_26.cameraX = _local_22; + _local_26.cameraY = _local_23; + _local_26.cameraZ = _local_24; + _local_26.offset = (((_local_13 * _local_22) + (_local_14 * _local_23)) + (_local_15 * _local_24)); + _local_27.cameraX = -(_local_22); + _local_27.cameraY = -(_local_23); + _local_27.cameraZ = -(_local_24); + _local_27.offset = (((-(_local_3.cameraX) * _local_22) - (_local_3.cameraY * _local_23)) - (_local_3.cameraZ * _local_24)); + _local_28 = _local_27.next; + _local_29 = _local_28.next; + _local_13 = _local_6.cameraX; + _local_14 = _local_6.cameraY; + _local_15 = _local_6.cameraZ; + _local_16 = (_local_7.cameraX - _local_13); + _local_17 = (_local_7.cameraY - _local_14); + _local_18 = (_local_7.cameraZ - _local_15); + _local_19 = (_local_8.cameraX - _local_13); + _local_20 = (_local_8.cameraY - _local_14); + _local_21 = (_local_8.cameraZ - _local_15); + _local_22 = ((_local_21 * _local_17) - (_local_20 * _local_18)); + _local_23 = ((_local_19 * _local_18) - (_local_21 * _local_16)); + _local_24 = ((_local_20 * _local_16) - (_local_19 * _local_17)); + _local_25 = (1 / Math.sqrt((((_local_22 * _local_22) + (_local_23 * _local_23)) + (_local_24 * _local_24)))); + _local_22 = (_local_22 * _local_25); + _local_23 = (_local_23 * _local_25); + _local_24 = (_local_24 * _local_25); + _local_28.cameraX = _local_22; + _local_28.cameraY = _local_23; + _local_28.cameraZ = _local_24; + _local_28.offset = (((_local_13 * _local_22) + (_local_14 * _local_23)) + (_local_15 * _local_24)); + _local_29.cameraX = -(_local_22); + _local_29.cameraY = -(_local_23); + _local_29.cameraZ = -(_local_24); + _local_29.offset = (((-(_local_2.cameraX) * _local_22) - (_local_2.cameraY * _local_23)) - (_local_2.cameraZ * _local_24)); + if (_local_11.offset < -(_local_12.offset)) + { + _local_12.cameraX = -(_local_12.cameraX); + _local_12.cameraY = -(_local_12.cameraY); + _local_12.cameraZ = -(_local_12.cameraZ); + _local_12.offset = -(_local_12.offset); + _local_11.cameraX = -(_local_11.cameraX); + _local_11.cameraY = -(_local_11.cameraY); + _local_11.cameraZ = -(_local_11.cameraZ); + _local_11.offset = -(_local_11.offset); + }; + if (_local_26.offset < -(_local_27.offset)) + { + _local_26.cameraX = -(_local_26.cameraX); + _local_26.cameraY = -(_local_26.cameraY); + _local_26.cameraZ = -(_local_26.cameraZ); + _local_26.offset = -(_local_26.offset); + _local_27.cameraX = -(_local_27.cameraX); + _local_27.cameraY = -(_local_27.cameraY); + _local_27.cameraZ = -(_local_27.cameraZ); + _local_27.offset = -(_local_27.offset); + }; + if (_local_29.offset < -(_local_28.offset)) + { + _local_29.cameraX = -(_local_29.cameraX); + _local_29.cameraY = -(_local_29.cameraY); + _local_29.cameraZ = -(_local_29.cameraZ); + _local_29.offset = -(_local_29.offset); + _local_28.cameraX = -(_local_28.cameraX); + _local_28.cameraY = -(_local_28.cameraY); + _local_28.cameraZ = -(_local_28.cameraZ); + _local_28.offset = -(_local_28.offset); + }; + }; + this.space = 2; + } + + private function calculateAABBStruct(_arg_1:Face, _arg_2:int, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Number, _arg_9:Number, _arg_10:Number, _arg_11:Number, _arg_12:Number, _arg_13:Number, _arg_14:Number):void{ + var _local_16:Wrapper; + var _local_17:Vertex; + var _local_18:Number; + var _local_19:Number; + var _local_20:Number; + var _local_15:Face = _arg_1; + while (_local_15 != null) + { + _local_16 = _local_15.wrapper; + while (_local_16 != null) + { + _local_17 = _local_16.vertex; + if (_local_17.transformId != _arg_2) + { + _local_18 = _local_17.cameraX; + _local_19 = _local_17.cameraY; + _local_20 = _local_17.cameraZ; + _local_17.cameraX = ((((_arg_3 * _local_18) + (_arg_4 * _local_19)) + (_arg_5 * _local_20)) + _arg_6); + _local_17.cameraY = ((((_arg_7 * _local_18) + (_arg_8 * _local_19)) + (_arg_9 * _local_20)) + _arg_10); + _local_17.cameraZ = ((((_arg_11 * _local_18) + (_arg_12 * _local_19)) + (_arg_13 * _local_20)) + _arg_14); + if (_local_17.cameraX < this.boundMinX) + { + this.boundMinX = _local_17.cameraX; + }; + if (_local_17.cameraX > this.boundMaxX) + { + this.boundMaxX = _local_17.cameraX; + }; + if (_local_17.cameraY < this.boundMinY) + { + this.boundMinY = _local_17.cameraY; + }; + if (_local_17.cameraY > this.boundMaxY) + { + this.boundMaxY = _local_17.cameraY; + }; + if (_local_17.cameraZ < this.boundMinZ) + { + this.boundMinZ = _local_17.cameraZ; + }; + if (_local_17.cameraZ > this.boundMaxZ) + { + this.boundMaxZ = _local_17.cameraZ; + }; + _local_17.transformId = _arg_2; + }; + _local_16 = _local_16.next; + }; + _local_15 = _local_15.processNext; + }; + if (_arg_1.processNegative != null) + { + this.calculateAABBStruct(_arg_1.processNegative, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9, _arg_10, _arg_11, _arg_12, _arg_13, _arg_14); + }; + if (_arg_1.processPositive != null) + { + this.calculateAABBStruct(_arg_1.processPositive, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9, _arg_10, _arg_11, _arg_12, _arg_13, _arg_14); + }; + } + + private function calculateOOBBStruct(_arg_1:Face, _arg_2:int, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Number, _arg_9:Number, _arg_10:Number, _arg_11:Number, _arg_12:Number, _arg_13:Number, _arg_14:Number):void{ + var _local_16:Wrapper; + var _local_17:Vertex; + var _local_15:Face = _arg_1; + while (_local_15 != null) + { + _local_16 = _local_15.wrapper; + while (_local_16 != null) + { + _local_17 = _local_16.vertex; + if (_local_17.transformId != _arg_2) + { + if (_local_17.x < this.boundMinX) + { + this.boundMinX = _local_17.x; + }; + if (_local_17.x > this.boundMaxX) + { + this.boundMaxX = _local_17.x; + }; + if (_local_17.y < this.boundMinY) + { + this.boundMinY = _local_17.y; + }; + if (_local_17.y > this.boundMaxY) + { + this.boundMaxY = _local_17.y; + }; + if (_local_17.z < this.boundMinZ) + { + this.boundMinZ = _local_17.z; + }; + if (_local_17.z > this.boundMaxZ) + { + this.boundMaxZ = _local_17.z; + }; + _local_17.transformId = _arg_2; + }; + _local_16 = _local_16.next; + }; + _local_15 = _local_15.processNext; + }; + if (_arg_1.processNegative != null) + { + this.calculateOOBBStruct(_arg_1.processNegative, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9, _arg_10, _arg_11, _arg_12, _arg_13, _arg_14); + }; + if (_arg_1.processPositive != null) + { + this.calculateOOBBStruct(_arg_1.processPositive, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9, _arg_10, _arg_11, _arg_12, _arg_13, _arg_14); + }; + } + + private function updateAABBStruct(_arg_1:Face, _arg_2:int):void{ + var _local_4:Wrapper; + var _local_5:Vertex; + var _local_3:Face = _arg_1; + while (_local_3 != null) + { + _local_4 = _local_3.wrapper; + while (_local_4 != null) + { + _local_5 = _local_4.vertex; + if (_local_5.transformId != _arg_2) + { + if (_local_5.cameraX < this.boundMinX) + { + this.boundMinX = _local_5.cameraX; + }; + if (_local_5.cameraX > this.boundMaxX) + { + this.boundMaxX = _local_5.cameraX; + }; + if (_local_5.cameraY < this.boundMinY) + { + this.boundMinY = _local_5.cameraY; + }; + if (_local_5.cameraY > this.boundMaxY) + { + this.boundMaxY = _local_5.cameraY; + }; + if (_local_5.cameraZ < this.boundMinZ) + { + this.boundMinZ = _local_5.cameraZ; + }; + if (_local_5.cameraZ > this.boundMaxZ) + { + this.boundMaxZ = _local_5.cameraZ; + }; + _local_5.transformId = _arg_2; + }; + _local_4 = _local_4.next; + }; + _local_3 = _local_3.processNext; + }; + if (_arg_1.processNegative != null) + { + this.updateAABBStruct(_arg_1.processNegative, _arg_2); + }; + if (_arg_1.processPositive != null) + { + this.updateAABBStruct(_arg_1.processPositive, _arg_2); + }; + } + + alternativa3d function split(_arg_1:Camera3D, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number):void{ + var _local_8:VG; + var _local_7:Face = this.faceStruct.create(); + this.splitFaceStruct(_arg_1, this.faceStruct, _local_7, _arg_2, _arg_3, _arg_4, _arg_5, (_arg_5 - _arg_6), (_arg_5 + _arg_6)); + if (_local_7.processNegative != null) + { + if (collector != null) + { + _local_8 = collector; + collector = collector.next; + _local_8.next = null; + } + else + { + _local_8 = new VG(); + }; + this.next = _local_8; + _local_8.faceStruct = _local_7.processNegative; + _local_7.processNegative = null; + _local_8.object = this.object; + _local_8.sorting = this.sorting; + _local_8.debug = this.debug; + _local_8.space = this.space; + _local_8.viewAligned = this.viewAligned; + _local_8.boundMinX = 1E22; + _local_8.boundMinY = 1E22; + _local_8.boundMinZ = 1E22; + _local_8.boundMaxX = -1E22; + _local_8.boundMaxY = -1E22; + _local_8.boundMaxZ = -1E22; + _local_8.updateAABBStruct(_local_8.faceStruct, ++this.object.transformId); + } + else + { + this.next = null; + }; + if (_local_7.processPositive != null) + { + this.faceStruct = _local_7.processPositive; + _local_7.processPositive = null; + this.boundMinX = 1E22; + this.boundMinY = 1E22; + this.boundMinZ = 1E22; + this.boundMaxX = -1E22; + this.boundMaxY = -1E22; + this.boundMaxZ = -1E22; + this.updateAABBStruct(this.faceStruct, ++this.object.transformId); + } + else + { + this.faceStruct = null; + }; + _local_7.next = Face.collector; + Face.collector = _local_7; + } + + alternativa3d function crop(_arg_1:Camera3D, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number):void{ + this.faceStruct = this.cropFaceStruct(_arg_1, this.faceStruct, _arg_2, _arg_3, _arg_4, _arg_5, (_arg_5 - _arg_6), (_arg_5 + _arg_6)); + if (this.faceStruct != null) + { + this.boundMinX = 1E22; + this.boundMinY = 1E22; + this.boundMinZ = 1E22; + this.boundMaxX = -1E22; + this.boundMaxY = -1E22; + this.boundMaxZ = -1E22; + this.updateAABBStruct(this.faceStruct, ++this.object.transformId); + }; + } + + private function splitFaceStruct(_arg_1:Camera3D, _arg_2:Face, _arg_3:Face, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Number, _arg_9:Number):void{ + var _local_10:Face; + var _local_11:Face; + var _local_12:Wrapper; + var _local_13:Vertex; + var _local_14:Vertex; + var _local_15:Face; + var _local_16:Face; + var _local_17:Face; + var _local_18:Face; + var _local_19:Face; + var _local_20:Face; + var _local_21:Face; + var _local_22:Face; + var _local_23:Face; + var _local_24:Face; + var _local_25:Wrapper; + var _local_26:Wrapper; + var _local_27:Wrapper; + var _local_28:Boolean; + var _local_29:Vertex; + var _local_30:Vertex; + var _local_31:Vertex; + var _local_32:Number; + var _local_33:Number; + var _local_34:Number; + var _local_35:Boolean; + var _local_36:Boolean; + var _local_37:Boolean; + var _local_38:Number; + var _local_39:Number; + if (_arg_2.processNegative != null) + { + this.splitFaceStruct(_arg_1, _arg_2.processNegative, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9); + _arg_2.processNegative = null; + _local_15 = _arg_3.processNegative; + _local_16 = _arg_3.processPositive; + }; + if (_arg_2.processPositive != null) + { + this.splitFaceStruct(_arg_1, _arg_2.processPositive, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9); + _arg_2.processPositive = null; + _local_17 = _arg_3.processNegative; + _local_18 = _arg_3.processPositive; + }; + if (_arg_2.wrapper != null) + { + _local_10 = _arg_2; + while (_local_10 != null) + { + _local_11 = _local_10.processNext; + _local_12 = _local_10.wrapper; + _local_29 = _local_12.vertex; + _local_12 = _local_12.next; + _local_30 = _local_12.vertex; + _local_12 = _local_12.next; + _local_31 = _local_12.vertex; + _local_12 = _local_12.next; + _local_32 = (((_local_29.cameraX * _arg_4) + (_local_29.cameraY * _arg_5)) + (_local_29.cameraZ * _arg_6)); + _local_33 = (((_local_30.cameraX * _arg_4) + (_local_30.cameraY * _arg_5)) + (_local_30.cameraZ * _arg_6)); + _local_34 = (((_local_31.cameraX * _arg_4) + (_local_31.cameraY * _arg_5)) + (_local_31.cameraZ * _arg_6)); + _local_35 = (((_local_32 < _arg_8) || (_local_33 < _arg_8)) || (_local_34 < _arg_8)); + _local_36 = (((_local_32 > _arg_9) || (_local_33 > _arg_9)) || (_local_34 > _arg_9)); + _local_37 = (((_local_32 < _arg_8) && (_local_33 < _arg_8)) && (_local_34 < _arg_8)); + while (_local_12 != null) + { + _local_13 = _local_12.vertex; + _local_38 = (((_local_13.cameraX * _arg_4) + (_local_13.cameraY * _arg_5)) + (_local_13.cameraZ * _arg_6)); + if (_local_38 < _arg_8) + { + _local_35 = true; + } + else + { + _local_37 = false; + if (_local_38 > _arg_9) + { + _local_36 = true; + }; + }; + _local_13.offset = _local_38; + _local_12 = _local_12.next; + }; + if ((!(_local_35))) + { + if (_local_21 != null) + { + _local_22.processNext = _local_10; + } + else + { + _local_21 = _local_10; + }; + _local_22 = _local_10; + } + else + { + if ((!(_local_36))) + { + if (_local_37) + { + if (_local_19 != null) + { + _local_20.processNext = _local_10; + } + else + { + _local_19 = _local_10; + }; + _local_20 = _local_10; + } + else + { + _local_29.offset = _local_32; + _local_30.offset = _local_33; + _local_31.offset = _local_34; + _local_23 = _local_10.create(); + _local_23.material = _local_10.material; + _arg_1.lastFace.next = _local_23; + _arg_1.lastFace = _local_23; + _local_25 = null; + _local_28 = ((!(_local_10.material == null)) && (_local_10.material.useVerticesNormals)); + _local_12 = _local_10.wrapper; + while (_local_12 != null) + { + _local_30 = _local_12.vertex; + if (_local_30.offset >= _arg_8) + { + _local_14 = _local_30.create(); + _arg_1.lastVertex.next = _local_14; + _arg_1.lastVertex = _local_14; + _local_14.x = _local_30.x; + _local_14.y = _local_30.y; + _local_14.z = _local_30.z; + _local_14.u = _local_30.u; + _local_14.v = _local_30.v; + _local_14.cameraX = _local_30.cameraX; + _local_14.cameraY = _local_30.cameraY; + _local_14.cameraZ = _local_30.cameraZ; + if (_local_28) + { + _local_14.normalX = _local_30.normalX; + _local_14.normalY = _local_30.normalY; + _local_14.normalZ = _local_30.normalZ; + }; + _local_30 = _local_14; + }; + _local_27 = _local_12.create(); + _local_27.vertex = _local_30; + if (_local_25 != null) + { + _local_25.next = _local_27; + } + else + { + _local_23.wrapper = _local_27; + }; + _local_25 = _local_27; + _local_12 = _local_12.next; + }; + if (_local_19 != null) + { + _local_20.processNext = _local_23; + } + else + { + _local_19 = _local_23; + }; + _local_20 = _local_23; + _local_10.processNext = null; + }; + } + else + { + _local_29.offset = _local_32; + _local_30.offset = _local_33; + _local_31.offset = _local_34; + _local_23 = _local_10.create(); + _local_23.material = _local_10.material; + _arg_1.lastFace.next = _local_23; + _arg_1.lastFace = _local_23; + _local_24 = _local_10.create(); + _local_24.material = _local_10.material; + _arg_1.lastFace.next = _local_24; + _arg_1.lastFace = _local_24; + _local_25 = null; + _local_26 = null; + _local_12 = _local_10.wrapper.next.next; + while (_local_12.next != null) + { + _local_12 = _local_12.next; + }; + _local_29 = _local_12.vertex; + _local_32 = _local_29.offset; + _local_28 = ((!(_local_10.material == null)) && (_local_10.material.useVerticesNormals)); + _local_12 = _local_10.wrapper; + while (_local_12 != null) + { + _local_30 = _local_12.vertex; + _local_33 = _local_30.offset; + if ((((_local_32 < _arg_8) && (_local_33 > _arg_9)) || ((_local_32 > _arg_9) && (_local_33 < _arg_8)))) + { + _local_39 = ((_arg_7 - _local_32) / (_local_33 - _local_32)); + _local_13 = _local_30.create(); + _arg_1.lastVertex.next = _local_13; + _arg_1.lastVertex = _local_13; + _local_13.x = (_local_29.x + ((_local_30.x - _local_29.x) * _local_39)); + _local_13.y = (_local_29.y + ((_local_30.y - _local_29.y) * _local_39)); + _local_13.z = (_local_29.z + ((_local_30.z - _local_29.z) * _local_39)); + _local_13.u = (_local_29.u + ((_local_30.u - _local_29.u) * _local_39)); + _local_13.v = (_local_29.v + ((_local_30.v - _local_29.v) * _local_39)); + _local_13.cameraX = (_local_29.cameraX + ((_local_30.cameraX - _local_29.cameraX) * _local_39)); + _local_13.cameraY = (_local_29.cameraY + ((_local_30.cameraY - _local_29.cameraY) * _local_39)); + _local_13.cameraZ = (_local_29.cameraZ + ((_local_30.cameraZ - _local_29.cameraZ) * _local_39)); + if (_local_28) + { + _local_13.normalX = (_local_29.normalX + ((_local_30.normalX - _local_29.normalX) * _local_39)); + _local_13.normalY = (_local_29.normalY + ((_local_30.normalY - _local_29.normalY) * _local_39)); + _local_13.normalZ = (_local_29.normalZ + ((_local_30.normalZ - _local_29.normalZ) * _local_39)); + }; + _local_27 = _local_12.create(); + _local_27.vertex = _local_13; + if (_local_25 != null) + { + _local_25.next = _local_27; + } + else + { + _local_23.wrapper = _local_27; + }; + _local_25 = _local_27; + _local_14 = _local_30.create(); + _arg_1.lastVertex.next = _local_14; + _arg_1.lastVertex = _local_14; + _local_14.x = _local_13.x; + _local_14.y = _local_13.y; + _local_14.z = _local_13.z; + _local_14.u = _local_13.u; + _local_14.v = _local_13.v; + _local_14.cameraX = _local_13.cameraX; + _local_14.cameraY = _local_13.cameraY; + _local_14.cameraZ = _local_13.cameraZ; + if (_local_28) + { + _local_14.normalX = _local_13.normalX; + _local_14.normalY = _local_13.normalY; + _local_14.normalZ = _local_13.normalZ; + }; + _local_27 = _local_12.create(); + _local_27.vertex = _local_14; + if (_local_26 != null) + { + _local_26.next = _local_27; + } + else + { + _local_24.wrapper = _local_27; + }; + _local_26 = _local_27; + }; + if (_local_30.offset < _arg_8) + { + _local_27 = _local_12.create(); + _local_27.vertex = _local_30; + if (_local_25 != null) + { + _local_25.next = _local_27; + } + else + { + _local_23.wrapper = _local_27; + }; + _local_25 = _local_27; + } + else + { + if (_local_30.offset > _arg_9) + { + _local_27 = _local_12.create(); + _local_27.vertex = _local_30; + if (_local_26 != null) + { + _local_26.next = _local_27; + } + else + { + _local_24.wrapper = _local_27; + }; + _local_26 = _local_27; + } + else + { + _local_27 = _local_12.create(); + _local_27.vertex = _local_30; + if (_local_26 != null) + { + _local_26.next = _local_27; + } + else + { + _local_24.wrapper = _local_27; + }; + _local_26 = _local_27; + _local_14 = _local_30.create(); + _arg_1.lastVertex.next = _local_14; + _arg_1.lastVertex = _local_14; + _local_14.x = _local_30.x; + _local_14.y = _local_30.y; + _local_14.z = _local_30.z; + _local_14.u = _local_30.u; + _local_14.v = _local_30.v; + _local_14.cameraX = _local_30.cameraX; + _local_14.cameraY = _local_30.cameraY; + _local_14.cameraZ = _local_30.cameraZ; + if (_local_28) + { + _local_14.normalX = _local_30.normalX; + _local_14.normalY = _local_30.normalY; + _local_14.normalZ = _local_30.normalZ; + }; + _local_27 = _local_12.create(); + _local_27.vertex = _local_14; + if (_local_25 != null) + { + _local_25.next = _local_27; + } + else + { + _local_23.wrapper = _local_27; + }; + _local_25 = _local_27; + }; + }; + _local_29 = _local_30; + _local_32 = _local_33; + _local_12 = _local_12.next; + }; + if (_local_19 != null) + { + _local_20.processNext = _local_23; + } + else + { + _local_19 = _local_23; + }; + _local_20 = _local_23; + if (_local_21 != null) + { + _local_22.processNext = _local_24; + } + else + { + _local_21 = _local_24; + }; + _local_22 = _local_24; + _local_10.processNext = null; + }; + }; + _local_10 = _local_11; + }; + }; + if (((!(_local_19 == null)) || ((!(_local_15 == null)) && (!(_local_17 == null))))) + { + if (_local_19 == null) + { + _local_19 = _arg_2.create(); + _arg_1.lastFace.next = _local_19; + _arg_1.lastFace = _local_19; + } + else + { + _local_20.processNext = null; + }; + if (this.sorting == 3) + { + _local_19.normalX = _arg_2.normalX; + _local_19.normalY = _arg_2.normalY; + _local_19.normalZ = _arg_2.normalZ; + _local_19.offset = _arg_2.offset; + }; + _local_19.processNegative = _local_15; + _local_19.processPositive = _local_17; + _arg_3.processNegative = _local_19; + } + else + { + _arg_3.processNegative = ((_local_15 != null) ? _local_15 : _local_17); + }; + if (((!(_local_21 == null)) || ((!(_local_16 == null)) && (!(_local_18 == null))))) + { + if (_local_21 == null) + { + _local_21 = _arg_2.create(); + _arg_1.lastFace.next = _local_21; + _arg_1.lastFace = _local_21; + } + else + { + _local_22.processNext = null; + }; + if (this.sorting == 3) + { + _local_21.normalX = _arg_2.normalX; + _local_21.normalY = _arg_2.normalY; + _local_21.normalZ = _arg_2.normalZ; + _local_21.offset = _arg_2.offset; + }; + _local_21.processNegative = _local_16; + _local_21.processPositive = _local_18; + _arg_3.processPositive = _local_21; + } + else + { + _arg_3.processPositive = ((_local_16 != null) ? _local_16 : _local_18); + }; + } + + private function cropFaceStruct(_arg_1:Camera3D, _arg_2:Face, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Number):Face{ + var _local_9:Face; + var _local_10:Face; + var _local_11:Wrapper; + var _local_12:Vertex; + var _local_13:Face; + var _local_14:Face; + var _local_15:Face; + var _local_16:Face; + var _local_17:Vertex; + var _local_18:Vertex; + var _local_19:Vertex; + var _local_20:Number; + var _local_21:Number; + var _local_22:Number; + var _local_23:Boolean; + var _local_24:Boolean; + var _local_25:Number; + var _local_26:Face; + var _local_27:Wrapper; + var _local_28:Wrapper; + var _local_29:Boolean; + var _local_30:Number; + if (_arg_2.processNegative != null) + { + _local_13 = this.cropFaceStruct(_arg_1, _arg_2.processNegative, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8); + _arg_2.processNegative = null; + }; + if (_arg_2.processPositive != null) + { + _local_14 = this.cropFaceStruct(_arg_1, _arg_2.processPositive, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8); + _arg_2.processPositive = null; + }; + if (_arg_2.wrapper != null) + { + _local_9 = _arg_2; + while (_local_9 != null) + { + _local_10 = _local_9.processNext; + _local_11 = _local_9.wrapper; + _local_17 = _local_11.vertex; + _local_11 = _local_11.next; + _local_18 = _local_11.vertex; + _local_11 = _local_11.next; + _local_19 = _local_11.vertex; + _local_11 = _local_11.next; + _local_20 = (((_local_17.cameraX * _arg_3) + (_local_17.cameraY * _arg_4)) + (_local_17.cameraZ * _arg_5)); + _local_21 = (((_local_18.cameraX * _arg_3) + (_local_18.cameraY * _arg_4)) + (_local_18.cameraZ * _arg_5)); + _local_22 = (((_local_19.cameraX * _arg_3) + (_local_19.cameraY * _arg_4)) + (_local_19.cameraZ * _arg_5)); + _local_23 = (((_local_20 < _arg_7) || (_local_21 < _arg_7)) || (_local_22 < _arg_7)); + _local_24 = (((_local_20 > _arg_8) || (_local_21 > _arg_8)) || (_local_22 > _arg_8)); + while (_local_11 != null) + { + _local_12 = _local_11.vertex; + _local_25 = (((_local_12.cameraX * _arg_3) + (_local_12.cameraY * _arg_4)) + (_local_12.cameraZ * _arg_5)); + if (_local_25 < _arg_7) + { + _local_23 = true; + } + else + { + if (_local_25 > _arg_8) + { + _local_24 = true; + }; + }; + _local_12.offset = _local_25; + _local_11 = _local_11.next; + }; + if ((!(_local_24))) + { + _local_9.processNext = null; + } + else + { + if ((!(_local_23))) + { + if (_local_15 != null) + { + _local_16.processNext = _local_9; + } + else + { + _local_15 = _local_9; + }; + _local_16 = _local_9; + } + else + { + _local_17.offset = _local_20; + _local_18.offset = _local_21; + _local_19.offset = _local_22; + _local_26 = _local_9.create(); + _local_26.material = _local_9.material; + _arg_1.lastFace.next = _local_26; + _arg_1.lastFace = _local_26; + _local_27 = null; + _local_11 = _local_9.wrapper.next.next; + while (_local_11.next != null) + { + _local_11 = _local_11.next; + }; + _local_17 = _local_11.vertex; + _local_20 = _local_17.offset; + _local_29 = ((!(_local_9.material == null)) && (_local_9.material.useVerticesNormals)); + _local_11 = _local_9.wrapper; + while (_local_11 != null) + { + _local_18 = _local_11.vertex; + _local_21 = _local_18.offset; + if ((((_local_20 < _arg_7) && (_local_21 > _arg_8)) || ((_local_20 > _arg_8) && (_local_21 < _arg_7)))) + { + _local_30 = ((_arg_6 - _local_20) / (_local_21 - _local_20)); + _local_12 = _local_18.create(); + _arg_1.lastVertex.next = _local_12; + _arg_1.lastVertex = _local_12; + _local_12.x = (_local_17.x + ((_local_18.x - _local_17.x) * _local_30)); + _local_12.y = (_local_17.y + ((_local_18.y - _local_17.y) * _local_30)); + _local_12.z = (_local_17.z + ((_local_18.z - _local_17.z) * _local_30)); + _local_12.u = (_local_17.u + ((_local_18.u - _local_17.u) * _local_30)); + _local_12.v = (_local_17.v + ((_local_18.v - _local_17.v) * _local_30)); + _local_12.cameraX = (_local_17.cameraX + ((_local_18.cameraX - _local_17.cameraX) * _local_30)); + _local_12.cameraY = (_local_17.cameraY + ((_local_18.cameraY - _local_17.cameraY) * _local_30)); + _local_12.cameraZ = (_local_17.cameraZ + ((_local_18.cameraZ - _local_17.cameraZ) * _local_30)); + if (_local_29) + { + _local_12.normalX = (_local_17.normalX + ((_local_18.normalX - _local_17.normalX) * _local_30)); + _local_12.normalY = (_local_17.normalY + ((_local_18.normalY - _local_17.normalY) * _local_30)); + _local_12.normalZ = (_local_17.normalZ + ((_local_18.normalZ - _local_17.normalZ) * _local_30)); + }; + _local_28 = _local_11.create(); + _local_28.vertex = _local_12; + if (_local_27 != null) + { + _local_27.next = _local_28; + } + else + { + _local_26.wrapper = _local_28; + }; + _local_27 = _local_28; + }; + if (_local_21 >= _arg_7) + { + _local_28 = _local_11.create(); + _local_28.vertex = _local_18; + if (_local_27 != null) + { + _local_27.next = _local_28; + } + else + { + _local_26.wrapper = _local_28; + }; + _local_27 = _local_28; + }; + _local_17 = _local_18; + _local_20 = _local_21; + _local_11 = _local_11.next; + }; + if (_local_15 != null) + { + _local_16.processNext = _local_26; + } + else + { + _local_15 = _local_26; + }; + _local_16 = _local_26; + _local_9.processNext = null; + }; + }; + _local_9 = _local_10; + }; + }; + if (((!(_local_15 == null)) || ((!(_local_13 == null)) && (!(_local_14 == null))))) + { + if (_local_15 == null) + { + _local_15 = _arg_2.create(); + _arg_1.lastFace.next = _local_15; + _arg_1.lastFace = _local_15; + } + else + { + _local_16.processNext = null; + }; + if (this.sorting == 3) + { + _local_15.normalX = _arg_2.normalX; + _local_15.normalY = _arg_2.normalY; + _local_15.normalZ = _arg_2.normalZ; + _local_15.offset = _arg_2.offset; + }; + _local_15.processNegative = _local_13; + _local_15.processPositive = _local_14; + return (_local_15); + }; + return ((_local_13 != null) ? _local_13 : _local_14); + } + + alternativa3d function transformStruct(_arg_1:Face, _arg_2:int, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Number, _arg_9:Number, _arg_10:Number, _arg_11:Number, _arg_12:Number, _arg_13:Number, _arg_14:Number):void{ + var _local_16:Wrapper; + var _local_17:Vertex; + var _local_18:Number; + var _local_19:Number; + var _local_20:Number; + var _local_15:Face = _arg_1; + while (_local_15 != null) + { + _local_16 = _local_15.wrapper; + while (_local_16 != null) + { + _local_17 = _local_16.vertex; + if (_local_17.transformId != _arg_2) + { + _local_18 = _local_17.cameraX; + _local_19 = _local_17.cameraY; + _local_20 = _local_17.cameraZ; + _local_17.cameraX = ((((_arg_3 * _local_18) + (_arg_4 * _local_19)) + (_arg_5 * _local_20)) + _arg_6); + _local_17.cameraY = ((((_arg_7 * _local_18) + (_arg_8 * _local_19)) + (_arg_9 * _local_20)) + _arg_10); + _local_17.cameraZ = ((((_arg_11 * _local_18) + (_arg_12 * _local_19)) + (_arg_13 * _local_20)) + _arg_14); + _local_17.transformId = _arg_2; + }; + _local_16 = _local_16.next; + }; + _local_15 = _local_15.processNext; + }; + if (_arg_1.processNegative != null) + { + this.transformStruct(_arg_1.processNegative, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9, _arg_10, _arg_11, _arg_12, _arg_13, _arg_14); + }; + if (_arg_1.processPositive != null) + { + this.transformStruct(_arg_1.processPositive, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8, _arg_9, _arg_10, _arg_11, _arg_12, _arg_13, _arg_14); + }; + } + + alternativa3d function draw(_arg_1:Camera3D, _arg_2:Number, _arg_3:Object3D):void{ + var _local_4:Face; + var _local_5:Face; + var _local_6:Face; + var _local_7:Face; + if (this.space == 1) + { + this.transformStruct(this.faceStruct, ++this.object.transformId, _arg_3.ma, _arg_3.mb, _arg_3.mc, _arg_3.md, _arg_3.me, _arg_3.mf, _arg_3.mg, _arg_3.mh, _arg_3.mi, _arg_3.mj, _arg_3.mk, _arg_3.ml); + }; + if (this.viewAligned) + { + _local_4 = this.faceStruct; + if (this.debug > 0) + { + if ((this.debug & Debug.EDGES)) + { + Debug.drawEdges(_arg_1, _local_4, ((this.space != 2) ? 0xFFFFFF : 0xFF9900)); + }; + if ((this.debug & Debug.BOUNDS)) + { + if (this.space == 1) + { + Debug.drawBounds(_arg_1, _arg_3, this.boundMinX, this.boundMinY, this.boundMinZ, this.boundMaxX, this.boundMaxY, this.boundMaxZ, 0x99FF00); + }; + }; + }; + _arg_1.addTransparent(_local_4, this.object); + } + else + { + switch (this.sorting) + { + case 0: + _local_4 = this.faceStruct; + break; + case 1: + _local_4 = ((this.faceStruct.processNext != null) ? _arg_1.sortByAverageZ(this.faceStruct) : this.faceStruct); + break; + case 2: + _local_4 = ((this.faceStruct.processNext != null) ? _arg_1.sortByDynamicBSP(this.faceStruct, _arg_2) : this.faceStruct); + break; + case 3: + _local_4 = this.collectNode(this.faceStruct); + break; + }; + if (this.debug > 0) + { + if ((this.debug & Debug.EDGES)) + { + Debug.drawEdges(_arg_1, _local_4, 0xFFFFFF); + }; + if ((this.debug & Debug.BOUNDS)) + { + if (this.space == 1) + { + Debug.drawBounds(_arg_1, _arg_3, this.boundMinX, this.boundMinY, this.boundMinZ, this.boundMaxX, this.boundMaxY, this.boundMaxZ, 0x99FF00); + } + else + { + if (this.space == 2) + { + Debug.drawBounds(_arg_1, this.object, this.boundMinX, this.boundMinY, this.boundMinZ, this.boundMaxX, this.boundMaxY, this.boundMaxZ, 0xFF9900); + }; + }; + }; + }; + _local_7 = _local_4; + while (_local_7 != null) + { + _local_5 = _local_7.processNext; + if (((_local_5 == null) || (!(_local_5.material == _local_4.material)))) + { + _local_7.processNext = null; + if (_local_4.material != null) + { + _local_4.processNegative = _local_6; + _local_6 = _local_4; + } + else + { + while (_local_4 != null) + { + _local_7 = _local_4.processNext; + _local_4.processNext = null; + _local_4 = _local_7; + }; + }; + _local_4 = _local_5; + }; + _local_7 = _local_5; + }; + _local_4 = _local_6; + while (_local_4 != null) + { + _local_5 = _local_4.processNegative; + _local_4.processNegative = null; + _arg_1.addTransparent(_local_4, this.object); + _local_4 = _local_5; + }; + }; + this.faceStruct = null; + } + + private function collectNode(_arg_1:Face, _arg_2:Face=null):Face{ + var _local_3:Face; + var _local_4:Face; + var _local_5:Face; + if (_arg_1.offset < 0) + { + _local_4 = _arg_1.processNegative; + _local_5 = _arg_1.processPositive; + } + else + { + _local_4 = _arg_1.processPositive; + _local_5 = _arg_1.processNegative; + }; + _arg_1.processNegative = null; + _arg_1.processPositive = null; + if (_local_5 != null) + { + _arg_2 = this.collectNode(_local_5, _arg_2); + }; + if (_arg_1.wrapper != null) + { + _local_3 = _arg_1; + while (_local_3.processNext != null) + { + _local_3 = _local_3.processNext; + }; + _local_3.processNext = _arg_2; + _arg_2 = _arg_1; + }; + if (_local_4 != null) + { + _arg_2 = this.collectNode(_local_4, _arg_2); + }; + return (_arg_2); + } + + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/core/Vertex.as b/src/alternativa/engine3d/core/Vertex.as new file mode 100644 index 0000000..c1ad3cf --- /dev/null +++ b/src/alternativa/engine3d/core/Vertex.as @@ -0,0 +1,133 @@ +package alternativa.engine3d.core +{ + import alternativa.engine3d.alternativa3d; + import alternativa.engine3d.objects.VertexBinding; + import flash.geom.Vector3D; + use namespace alternativa3d; + + public class Vertex + { + + alternativa3d static var collector:Vertex; + + + public var x:Number = 0; + + alternativa3d var vertexbinding:VertexBinding; + + public var y:Number = 0; + + public var z:Number = 0; + + public var u:Number = 0; + + public var v:Number = 0; + + public var normalX:Number; + + public var normalY:Number; + + public var normalZ:Number; + + alternativa3d var cameraX:Number; + + alternativa3d var cameraY:Number; + + alternativa3d var cameraZ:Number; + + alternativa3d var offset:Number = 1; + + alternativa3d var transformId:int = 0; + + alternativa3d var drawId:int = 0; + + alternativa3d var index:int; + + alternativa3d var next:Vertex; + + alternativa3d var value:Vertex; + + public var id:Object; + + public function Vertex() + { + super(); + } + + public function copyToVector3D(vec:Vector3D) : Vector3D + { + vec.x = this.x; + vec.y = this.y; + vec.z = this.z; + return vec; + } + + alternativa3d static function createList(param1:int) : Vertex + { + var _loc3_:Vertex = null; + var _loc2_:Vertex = collector; + if(_loc2_ != null) + { + _loc3_ = _loc2_; + while(param1 > 1) + { + _loc3_.transformId = 0; + _loc3_.drawId = 0; + if(_loc3_.next == null) + { + while(param1 > 1) + { + _loc3_.next = new Vertex(); + _loc3_ = _loc3_.next; + param1--; + } + break; + } + _loc3_ = _loc3_.next; + param1--; + } + collector = _loc3_.next; + _loc3_.transformId = 0; + _loc3_.drawId = 0; + _loc3_.next = null; + } + else + { + _loc2_ = new Vertex(); + _loc3_ = _loc2_; + while(param1 > 1) + { + _loc3_.next = new Vertex(); + _loc3_ = _loc3_.next; + param1--; + } + } + return _loc2_; + } + + alternativa3d function create() : Vertex + { + var _loc1_:Vertex = null; + if(collector != null) + { + _loc1_ = collector; + collector = _loc1_.next; + _loc1_.next = null; + _loc1_.transformId = 0; + _loc1_.drawId = 0; + return _loc1_; + } + return new Vertex(); + } + + public function toString() : String + { + return "[Vertex " + this.id + " " + this.x.toFixed(2) + ", " + this.y.toFixed(2) + ", " + this.z.toFixed(2) + ", " + this.u.toFixed(3) + ", " + this.v.toFixed(3) + "]"; + } + + public function destroy() : * + { + delete this[this]; + } + } +} diff --git a/src/alternativa/engine3d/core/View.as b/src/alternativa/engine3d/core/View.as new file mode 100644 index 0000000..8c0a158 --- /dev/null +++ b/src/alternativa/engine3d/core/View.as @@ -0,0 +1,847 @@ +package alternativa.engine3d.core{ + import flash.geom.Point; + import __AS3__.vec.Vector; + import alternativa.gfx.core.Device; + import flash.geom.Rectangle; + import flash.display.Sprite; + import flash.events.MouseEvent; + import flash.display.Bitmap; + import flash.ui.ContextMenuItem; + import alternativa.Alternativa3D; + import flash.events.ContextMenuEvent; + import flash.net.navigateToURL; + import flash.net.URLRequest; + import flash.ui.ContextMenu; + import flash.events.Event; + import flash.events.KeyboardEvent; + import flash.display3D.Context3DRenderMode; + import flash.ui.Keyboard; + import flash.utils.setTimeout; + import flash.display3D.Context3DClearMask; + import flash.ui.Mouse; + import flash.display.DisplayObject; + import flash.display.StageAlign; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class View extends Canvas { + + private static const mouse:Point = new Point(); + private static const coords:Point = new Point(); + private static const branch:Vector. = new Vector.(); + private static const overedBranch:Vector. = new Vector.(); + private static const changedBranch:Vector. = new Vector.(); + private static const functions:Vector. = new Vector.(); + private static var staticDevice:Device; + private static var views:Vector. = new Vector.(); + private static var configured:Boolean = false; + private static var cleared:Boolean = true; + + private var presented:Boolean = false; + private var globalCoords:Point; + alternativa3d var rect:Rectangle = new Rectangle(); + alternativa3d var correction:Boolean = false; + alternativa3d var device:Device; + alternativa3d var quality:Boolean; + alternativa3d var constrained:Boolean; + alternativa3d var camera:Camera3D; + alternativa3d var _width:Number; + alternativa3d var _height:Number; + alternativa3d var canvas:Sprite = new Sprite(); + private var lastEvent:MouseEvent; + private var target:Object3D; + private var pressedTarget:Object3D; + private var clickedTarget:Object3D; + private var overedTarget:Object3D; + private var altKey:Boolean; + private var ctrlKey:Boolean; + private var shiftKey:Boolean; + private var delta:int; + private var buttonDown:Boolean; + private var area:Sprite; + private var logo:Logo; + private var bitmap:Bitmap; + private var _logoAlign:String = "BR"; + private var _logoHorizontalMargin:Number = 0; + private var _logoVerticalMargin:Number = 0; + public var enableErrorChecking:Boolean = false; + public var zBufferPrecision:int = 16; + public var antiAliasEnabled:Boolean = true; + public var offsetX:Number = 0; + public var offsetY:Number = 0; + + public function View(width:Number, height:Number, constrainedMode:Boolean=false){ + super(); + this._width = width; + this._height = height; + this.constrained = constrainedMode; + mouseEnabled = true; + mouseChildren = true; + doubleClickEnabled = true; + buttonMode = true; + useHandCursor = false; + tabEnabled = false; + tabChildren = false; + /*var item:ContextMenuItem = new ContextMenuItem(("Powered by Alternativa3D " + Alternativa3D.version)); + item.addEventListener(ContextMenuEvent.MENU_ITEM_SELECT, function (_arg_1:ContextMenuEvent):void{ + try + { + navigateToURL(new URLRequest("http://alternativaplatform.com"), "_blank"); + } + catch(e:Error) + { + }; + }); + var menu:ContextMenu = new ContextMenu(); + menu.customItems = [item]; + contextMenu = menu;*/ + this.area = new Sprite(); + this.area.graphics.beginFill(0xFF0000); + this.area.graphics.drawRect(0, 0, width, height); + this.area.mouseEnabled = false; + this.area.visible = false; + hitArea = this.area; + super.addChild(hitArea); + this.canvas.mouseEnabled = false; + super.addChild(this.canvas); + //this.showLogo(); + addEventListener(Event.ADDED_TO_STAGE, this.onAddToStage); + } + + private function onAddToStage(_arg_1:Event):void{ + stage.addEventListener(KeyboardEvent.KEY_DOWN, this.onKeyDown); + stage.addEventListener(KeyboardEvent.KEY_UP, this.onKeyUp); + removeEventListener(Event.ADDED_TO_STAGE, this.onAddToStage); + addEventListener(Event.REMOVED_FROM_STAGE, this.onRemoveFromStage); + if (staticDevice == null) + { + staticDevice = new Device(stage, Context3DRenderMode.AUTO, ((this.constrained) ? "baselineConstrained" : "baseline")); + }; + views.push(this); + this.device = staticDevice; + } + + private function onRemoveFromStage(_arg_1:Event):void{ + stage.removeEventListener(KeyboardEvent.KEY_DOWN, this.onKeyDown); + stage.removeEventListener(KeyboardEvent.KEY_UP, this.onKeyUp); + addEventListener(Event.ADDED_TO_STAGE, this.onAddToStage); + removeEventListener(Event.REMOVED_FROM_STAGE, this.onRemoveFromStage); + this.canvas.graphics.clear(); + var _local_2:int = views.indexOf(this); + while (_local_2 < (views.length - 1)) + { + views[_local_2] = views[int((_local_2 + 1))]; + _local_2++; + }; + views.pop(); + if (views.length == 0) + { + staticDevice.dispose(); + staticDevice = null; + }; + this.device = null; + } + + private function onKeyDown(_arg_1:KeyboardEvent):void{ + this.altKey = _arg_1.altKey; + this.ctrlKey = _arg_1.ctrlKey; + this.shiftKey = _arg_1.shiftKey; + if (((((this.ctrlKey) && (this.shiftKey)) && (_arg_1.keyCode == Keyboard.F1)) && (this.bitmap == null))) + { + this.bitmap = new Bitmap(Logo.image); + this.bitmap.x = Math.round(((this._width - this.bitmap.width) / 2)); + this.bitmap.y = Math.round(((this._height - this.bitmap.height) / 2)); + super.addChild(this.bitmap); + setTimeout(this.removeBitmap, 0x0800); + }; + } + + private function removeBitmap():void{ + if (this.bitmap != null) + { + super.removeChild(this.bitmap); + this.bitmap = null; + }; + } + + private function onKeyUp(_arg_1:KeyboardEvent):void{ + this.altKey = _arg_1.altKey; + this.ctrlKey = _arg_1.ctrlKey; + this.shiftKey = _arg_1.shiftKey; + } + + private function onMouse(_arg_1:MouseEvent):void{ + this.altKey = _arg_1.altKey; + this.ctrlKey = _arg_1.ctrlKey; + this.shiftKey = _arg_1.shiftKey; + this.buttonDown = _arg_1.buttonDown; + this.delta = _arg_1.delta; + this.lastEvent = _arg_1; + } + + private function onMouseDown(_arg_1:MouseEvent):void{ + this.onMouse(_arg_1); + this.defineTarget(_arg_1); + if (this.target != null) + { + this.propagateEvent(MouseEvent3D.MOUSE_DOWN, this.target, this.branchToVector(this.target, branch)); + }; + this.pressedTarget = this.target; + this.target = null; + } + + private function onMouseWheel(_arg_1:MouseEvent):void{ + this.onMouse(_arg_1); + this.defineTarget(_arg_1); + if (this.target != null) + { + this.propagateEvent(MouseEvent3D.MOUSE_WHEEL, this.target, this.branchToVector(this.target, branch)); + }; + this.target = null; + } + + private function onClick(_arg_1:MouseEvent):void{ + this.onMouse(_arg_1); + this.defineTarget(_arg_1); + if (this.target != null) + { + this.propagateEvent(MouseEvent3D.MOUSE_UP, this.target, this.branchToVector(this.target, branch)); + if (this.pressedTarget == this.target) + { + this.clickedTarget = this.target; + this.propagateEvent(MouseEvent3D.CLICK, this.target, this.branchToVector(this.target, branch)); + }; + }; + this.pressedTarget = null; + this.target = null; + } + + private function onDoubleClick(_arg_1:MouseEvent):void{ + this.onMouse(_arg_1); + this.defineTarget(_arg_1); + if (this.target != null) + { + this.propagateEvent(MouseEvent3D.MOUSE_UP, this.target, this.branchToVector(this.target, branch)); + if (this.pressedTarget == this.target) + { + this.propagateEvent((((this.clickedTarget == this.target) && (this.target.doubleClickEnabled)) ? MouseEvent3D.DOUBLE_CLICK : MouseEvent3D.CLICK), this.target, this.branchToVector(this.target, branch)); + }; + }; + this.clickedTarget = null; + this.pressedTarget = null; + this.target = null; + } + + private function onMouseMove(_arg_1:MouseEvent):void{ + this.onMouse(_arg_1); + this.defineTarget(_arg_1); + if (this.target != null) + { + this.propagateEvent(MouseEvent3D.MOUSE_MOVE, this.target, this.branchToVector(this.target, branch)); + }; + if (this.overedTarget != this.target) + { + this.processOverOut(); + }; + this.target = null; + } + + private function onMouseOut(_arg_1:MouseEvent):void{ + this.onMouse(_arg_1); + this.lastEvent = null; + this.target = null; + if (this.overedTarget != this.target) + { + this.processOverOut(); + }; + this.target = null; + } + + alternativa3d function configure():void{ + var _local_3:Number; + var _local_4:Number; + var _local_5:Number; + var _local_6:Number; + var _local_7:int; + var _local_8:View; + var _local_1:int = ((stage.quality == "LOW") ? 0 : ((stage.quality == "MEDIUM") ? 2 : 4)); + var _local_2:int = (((this.antiAliasEnabled) && (!(this.constrained))) ? _local_1 : 0); + this.quality = (_local_1 > 0); + if ((!(configured))) + { + _local_3 = 1000000; + _local_4 = 1000000; + _local_5 = -1000000; + _local_6 = -1000000; + _local_7 = 0; + while (_local_7 < views.length) + { + _local_8 = views[_local_7]; + coords.x = 0; + coords.y = 0; + _local_8.globalCoords = _local_8.localToGlobal(coords); + if (_local_8.globalCoords.x < _local_3) + { + _local_3 = _local_8.globalCoords.x; + }; + if (_local_8.globalCoords.y < _local_4) + { + _local_4 = _local_8.globalCoords.y; + }; + if ((_local_8.globalCoords.x + _local_8._width) > _local_5) + { + _local_5 = (_local_8.globalCoords.x + _local_8._width); + }; + if ((_local_8.globalCoords.y + _local_8._height) > _local_6) + { + _local_6 = (_local_8.globalCoords.y + _local_8._height); + }; + _local_7++; + }; + this.device.x = _local_3; + this.device.y = _local_4; + this.device.width = (_local_5 - _local_3); + this.device.height = (_local_6 - _local_4); + this.device.antiAlias = _local_2; + this.device.enableDepthAndStencil = true; + this.device.enableErrorChecking = this.enableErrorChecking; + configured = true; + }; + if (this.globalCoords == null) + { + this.globalCoords = localToGlobal(new Point(0, 0)); + }; + this.rect.x = (int(this.globalCoords.x) - this.device.x); + this.rect.y = (int(this.globalCoords.y) - this.device.y); + this.rect.width = int(this._width); + this.rect.height = int(this._height); + this.correction = false; + this.canvas.x = (this._width / 2); + this.canvas.y = (this._height / 2); + this.canvas.graphics.clear(); + } + + alternativa3d function clearArea():void{ + if ((!(cleared))) + { + this.device.clear((((stage.color >> 16) & 0xFF) / 0xFF), (((stage.color >> 8) & 0xFF) / 0xFF), ((stage.color & 0xFF) / 0xFF)); + cleared = true; + } + else + { + this.device.clear((((stage.color >> 16) & 0xFF) / 0xFF), (((stage.color >> 8) & 0xFF) / 0xFF), ((stage.color & 0xFF) / 0xFF), 1, 1, 0, (Context3DClearMask.DEPTH | Context3DClearMask.STENCIL)); + }; + if (((((!(this.rect.x == 0)) || (!(this.rect.y == 0))) || (!(this.rect.width == this.device.width))) || (!(this.rect.height == this.device.height)))) + { + this.device.setScissorRectangle(this.rect); + this.correction = true; + }; + } + + alternativa3d function present():void{ + var _local_1:int; + var _local_2:View; + this.presented = true; + this.device.setScissorRectangle(null); + this.correction = false; + _local_1 = 0; + while (_local_1 < views.length) + { + _local_2 = views[_local_1]; + if ((!(_local_2.presented))) break; + _local_1++; + }; + if (_local_1 == views.length) + { + this.device.present(); + configured = false; + cleared = false; + _local_1 = 0; + while (_local_1 < views.length) + { + _local_2 = views[_local_1]; + _local_2.presented = false; + _local_1++; + }; + }; + } + + alternativa3d function onRender(_arg_1:Camera3D):void{ + } + + private function processOverOut():void{ + var _local_3:int; + var _local_4:int; + var _local_5:int; + var _local_6:Object3D; + this.branchToVector(this.target, branch); + this.branchToVector(this.overedTarget, overedBranch); + var _local_1:int = branch.length; + var _local_2:int = overedBranch.length; + if (this.overedTarget != null) + { + this.propagateEvent(MouseEvent3D.MOUSE_OUT, this.overedTarget, overedBranch, true, this.target); + _local_3 = 0; + _local_4 = 0; + while (_local_4 < _local_2) + { + _local_6 = overedBranch[_local_4]; + _local_5 = 0; + while (_local_5 < _local_1) + { + if (_local_6 == branch[_local_5]) break; + _local_5++; + }; + if (_local_5 == _local_1) + { + changedBranch[_local_3] = _local_6; + _local_3++; + }; + _local_4++; + }; + if (_local_3 > 0) + { + changedBranch.length = _local_3; + this.propagateEvent(MouseEvent3D.ROLL_OUT, this.overedTarget, changedBranch, false, this.target); + }; + }; + if (this.target != null) + { + _local_3 = 0; + _local_4 = 0; + while (_local_4 < _local_1) + { + _local_6 = branch[_local_4]; + _local_5 = 0; + while (_local_5 < _local_2) + { + if (_local_6 == overedBranch[_local_5]) break; + _local_5++; + }; + if (_local_5 == _local_2) + { + changedBranch[_local_3] = _local_6; + _local_3++; + }; + _local_4++; + }; + if (_local_3 > 0) + { + changedBranch.length = _local_3; + this.propagateEvent(MouseEvent3D.ROLL_OVER, this.target, changedBranch, false, this.overedTarget); + }; + this.propagateEvent(MouseEvent3D.MOUSE_OVER, this.target, branch, true, this.overedTarget); + useHandCursor = this.target.useHandCursor; + } + else + { + useHandCursor = false; + }; + Mouse.cursor = Mouse.cursor; + this.overedTarget = this.target; + } + + private function branchToVector(_arg_1:Object3D, _arg_2:Vector.):Vector.{ + var _local_3:int; + while (_arg_1 != null) + { + _arg_2[_local_3] = _arg_1; + _local_3++; + _arg_1 = _arg_1._parent; + }; + _arg_2.length = _local_3; + return (_arg_2); + } + + private function propagateEvent(_arg_1:String, _arg_2:Object3D, _arg_3:Vector., _arg_4:Boolean=true, _arg_5:Object3D=null):void{ + var _local_7:Object3D; + var _local_8:Vector.; + var _local_9:int; + var _local_10:int; + var _local_11:int; + var _local_12:MouseEvent3D; + var _local_6:int = _arg_3.length; + _local_10 = (_local_6 - 1); + while (_local_10 > 0) + { + _local_7 = _arg_3[_local_10]; + if (_local_7.captureListeners != null) + { + _local_8 = _local_7.captureListeners[_arg_1]; + if (_local_8 != null) + { + if (_local_12 == null) + { + _local_12 = new MouseEvent3D(_arg_1, _arg_4, _arg_5, this.altKey, this.ctrlKey, this.shiftKey, this.buttonDown, this.delta); + _local_12._target = _arg_2; + _local_12.calculateLocalRay(mouseX, mouseY, _arg_2, this.camera); + }; + _local_12._currentTarget = _local_7; + _local_12._eventPhase = 1; + _local_9 = _local_8.length; + _local_11 = 0; + while (_local_11 < _local_9) + { + functions[_local_11] = _local_8[_local_11]; + _local_11++; + }; + _local_11 = 0; + while (_local_11 < _local_9) + { + (functions[_local_11] as Function).call(null, _local_12); + if (_local_12.stopImmediate) + { + return; + }; + _local_11++; + }; + if (_local_12.stop) + { + return; + }; + }; + }; + _local_10--; + }; + _local_10 = 0; + while (_local_10 < _local_6) + { + _local_7 = _arg_3[_local_10]; + if (_local_7.bubbleListeners != null) + { + _local_8 = _local_7.bubbleListeners[_arg_1]; + if (_local_8 != null) + { + if (_local_12 == null) + { + _local_12 = new MouseEvent3D(_arg_1, _arg_4, _arg_5, this.altKey, this.ctrlKey, this.shiftKey, this.buttonDown, this.delta); + _local_12._target = _arg_2; + _local_12.calculateLocalRay(mouseX, mouseY, _arg_2, this.camera); + }; + _local_12._currentTarget = _local_7; + _local_12._eventPhase = ((_local_10 == 0) ? 2 : 3); + _local_9 = _local_8.length; + _local_11 = 0; + while (_local_11 < _local_9) + { + functions[_local_11] = _local_8[_local_11]; + _local_11++; + }; + _local_11 = 0; + while (_local_11 < _local_9) + { + (functions[_local_11] as Function).call(null, _local_12); + if (_local_12.stopImmediate) + { + return; + }; + _local_11++; + }; + if (_local_12.stop) + { + return; + }; + }; + }; + _local_10++; + }; + } + + private function defineTarget(_arg_1:MouseEvent):void{ + var _local_2:Object3D; + var _local_3:Object3D; + var _local_6:Canvas; + var _local_7:DisplayObject; + var _local_8:Object3D; + var _local_9:Object3D; + mouse.x = _arg_1.localX; + mouse.y = _arg_1.localY; + var _local_4:Array = ((stage != null) ? stage.getObjectsUnderPoint(localToGlobal(mouse)) : super.getObjectsUnderPoint(mouse)); + var _local_5:int = (_local_4.length - 1); + while (_local_5 >= 0) + { + _local_6 = null; + _local_7 = _local_4[_local_5]; + while (_local_7.parent != stage) + { + _local_6 = (_local_7 as Canvas); + if (_local_6 != null) break; + _local_7 = _local_7.parent; + }; + if (_local_6 != null) + { + if (_local_3 != null) + { + _local_8 = null; + _local_9 = _local_3; + while (_local_9 != null) + { + if (((_local_9 is Object3DContainer) && (!(Object3DContainer(_local_9).mouseChildren)))) + { + _local_8 = null; + }; + if (((_local_8 == null) && (_local_9.mouseEnabled))) + { + _local_8 = _local_9; + }; + _local_9 = _local_9._parent; + }; + if (_local_8 != null) + { + if (this.target != null) + { + _local_9 = _local_8; + while (_local_9 != null) + { + if (_local_9 == this.target) + { + _local_2 = _local_3; + this.target = _local_8; + break; + }; + _local_9 = _local_9._parent; + }; + } + else + { + _local_2 = _local_3; + this.target = _local_8; + }; + if (_local_2 == this.target) break; + }; + }; + }; + _local_5--; + }; + } + + override public function getObjectsUnderPoint(_arg_1:Point):Array{ + return (null); + } + + public function showLogo():void{ + if (this.logo == null) + { + this.logo = new Logo(); + super.addChild(this.logo); + this.resizeLogo(); + }; + } + + public function hideLogo():void{ + if (this.logo != null) + { + super.removeChild(this.logo); + this.logo = null; + }; + } + + public function get logoAlign():String{ + return (this._logoAlign); + } + + public function set logoAlign(_arg_1:String):void{ + this._logoAlign = _arg_1; + this.resizeLogo(); + } + + public function get logoHorizontalMargin():Number{ + return (this._logoHorizontalMargin); + } + + public function set logoHorizontalMargin(_arg_1:Number):void{ + this._logoHorizontalMargin = _arg_1; + this.resizeLogo(); + } + + public function get logoVerticalMargin():Number{ + return (this._logoVerticalMargin); + } + + public function set logoVerticalMargin(_arg_1:Number):void{ + this._logoVerticalMargin = _arg_1; + this.resizeLogo(); + } + + private function resizeLogo():void{ + if (this.logo != null) + { + if ((((this._logoAlign == StageAlign.TOP_LEFT) || (this._logoAlign == StageAlign.LEFT)) || (this._logoAlign == StageAlign.BOTTOM_LEFT))) + { + this.logo.x = Math.round(this._logoHorizontalMargin); + }; + if (((this._logoAlign == StageAlign.TOP) || (this._logoAlign == StageAlign.BOTTOM))) + { + this.logo.x = Math.round(((this._width - this.logo.width) / 2)); + }; + if ((((this._logoAlign == StageAlign.TOP_RIGHT) || (this._logoAlign == StageAlign.RIGHT)) || (this._logoAlign == StageAlign.BOTTOM_RIGHT))) + { + this.logo.x = Math.round(((this._width - this._logoHorizontalMargin) - this.logo.width)); + }; + if ((((this._logoAlign == StageAlign.TOP_LEFT) || (this._logoAlign == StageAlign.TOP)) || (this._logoAlign == StageAlign.TOP_RIGHT))) + { + this.logo.y = Math.round(this._logoVerticalMargin); + }; + if (((this._logoAlign == StageAlign.LEFT) || (this._logoAlign == StageAlign.RIGHT))) + { + this.logo.y = Math.round(((this._height - this.logo.height) / 2)); + }; + if ((((this._logoAlign == StageAlign.BOTTOM_LEFT) || (this._logoAlign == StageAlign.BOTTOM)) || (this._logoAlign == StageAlign.BOTTOM_RIGHT))) + { + this.logo.y = Math.round(((this._height - this._logoVerticalMargin) - this.logo.height)); + }; + }; + } + + public function clear():void{ + if (((!(this.device == null)) && (this.device.ready))) + { + this.device.clear((((stage.color >> 16) & 0xFF) / 0xFF), (((stage.color >> 8) & 0xFF) / 0xFF), ((stage.color & 0xFF) / 0xFF)); + }; + this.canvas.graphics.clear(); + } + + override public function get width():Number{ + return (this._width); + } + + override public function set width(_arg_1:Number):void{ + this._width = _arg_1; + this.area.width = _arg_1; + this.resizeLogo(); + } + + override public function get height():Number{ + return (this._height); + } + + override public function set height(_arg_1:Number):void{ + this._height = _arg_1; + this.area.height = _arg_1; + this.resizeLogo(); + } + + override public function addChild(_arg_1:DisplayObject):DisplayObject{ + throw (new Error("Unsupported operation.")); + } + + override public function removeChild(_arg_1:DisplayObject):DisplayObject{ + throw (new Error("Unsupported operation.")); + } + + override public function addChildAt(_arg_1:DisplayObject, _arg_2:int):DisplayObject{ + throw (new Error("Unsupported operation.")); + } + + override public function removeChildAt(_arg_1:int):DisplayObject{ + throw (new Error("Unsupported operation.")); + } + + override public function getChildAt(_arg_1:int):DisplayObject{ + throw (new Error("Unsupported operation.")); + } + + override public function getChildIndex(_arg_1:DisplayObject):int{ + throw (new Error("Unsupported operation.")); + } + + override public function setChildIndex(_arg_1:DisplayObject, _arg_2:int):void{ + throw (new Error("Unsupported operation.")); + } + + override public function swapChildren(_arg_1:DisplayObject, _arg_2:DisplayObject):void{ + throw (new Error("Unsupported operation.")); + } + + override public function swapChildrenAt(_arg_1:int, _arg_2:int):void{ + throw (new Error("Unsupported operation.")); + } + + override public function getChildByName(_arg_1:String):DisplayObject{ + throw (new Error("Unsupported operation.")); + } + + override public function get numChildren():int{ + return (0); + } + + + } +}//package alternativa.engine3d.core + +import flash.display.Sprite; +import flash.display.BitmapData; +import flash.geom.Matrix; +import flash.events.MouseEvent; +import flash.net.navigateToURL; +import flash.net.URLRequest; +import __AS3__.vec.*; + +class Logo extends Sprite { + + public static const image:BitmapData = createBMP(); + + private var border:int = 5; + private var over:Boolean = false; + private var press:Boolean; + + public function Logo(){ + graphics.beginFill(0xFF0000, 0); + graphics.drawRect(0, 0, ((image.width + this.border) + this.border), ((image.height + this.border) + this.border)); + graphics.drawRect(this.border, this.border, image.width, image.height); + graphics.beginBitmapFill(image, new Matrix(1, 0, 0, 1, this.border, this.border), false, true); + graphics.drawRect(this.border, this.border, image.width, image.height); + tabEnabled = false; + buttonMode = true; + useHandCursor = true; + addEventListener(MouseEvent.MOUSE_DOWN, this.onMouseDown); + addEventListener(MouseEvent.CLICK, this.onClick); + addEventListener(MouseEvent.DOUBLE_CLICK, this.onDoubleClick); + addEventListener(MouseEvent.MOUSE_MOVE, this.onMouseMove); + addEventListener(MouseEvent.MOUSE_OVER, this.onMouseMove); + addEventListener(MouseEvent.MOUSE_OUT, this.onMouseOut); + addEventListener(MouseEvent.MOUSE_WHEEL, this.onMouseWheel); + } + + private static function createBMP():BitmapData{ + var _local_1:BitmapData = new BitmapData(103, 22, true, 0); + _local_1.setVector(_local_1.rect, Vector.([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x3E000000, 0xA1000000, 0x95000000, 0x2C000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x96000000, 0xFF000000, 0x96000000, 0, 0, 0, 0, 0x96000000, 0xFF000000, 0x96000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2E000000, 0x97000000, 4282199055, 4288505883, 4287716373, 4280949511, 0x89000000, 0xE000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF000000, 4294892416, 0xFF000000, 0, 0, 0, 0, 0xFF000000, 4294892416, 0xFF000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x67000000, 4279504646, 4287917866, 4294285341, 4294478345, 4294478346, 4293626391, 4285810708, 4278387201, 0x4D000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0x96000000, 0xFF000000, 0x96000000, 0x96000000, 0xFF000000, 0x96000000, 0x96000000, 0xFF000000, 0x96000000, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0, 0, 0x96000000, 0xFF000000, 0x96000000, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 0, 0, 0, 0, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0x96000000, 0xFF000000, 0x96000000, 0, 0x96000000, 0xFF000000, 0x96000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x83000000, 4280753934, 4291530288, 4294412558, 4294411013, 4294411784, 4294411784, 4294411271, 4294411790, 4289816858, 4279635461, 0x66000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x96000000, 0xFF000000, 4294892416, 4294892416, 4294892416, 0xFF000000, 0x96000000, 0xFF000000, 4294892416, 4294892416, 4294892416, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 4294892416, 4294892416, 4294892416, 0xFF000000, 0x96000000, 0x96000000, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 4294892416, 4294892416, 4294892416, 0xFF000000, 0x96000000, 0xFF000000, 4294892416, 4294892416, 4294892416, 4294892416, 0xFF000000, 0, 0, 0, 0, 0xFF000000, 4294892416, 4294892416, 4294892416, 4294892416, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 0, 0xFF000000, 4294892416, 0xFF000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x8B000000, 4283252258, 4293301553, 4294409478, 4294409991, 4294410761, 4294476552, 4294476296, 4294410249, 4294344200, 4294343945, 4291392799, 4280752908, 0x79000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0, 0, 0, 0, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 4294892416, 0xFF000000, 0, 0xFF000000, 4294892416, 0xFF000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x88000000, 4283186471, 4293692972, 4294276097, 4294343176, 4294409225, 4294475017, 4293554194, 4293817874, 4294408967, 4294342921, 4294342664, 4294341895, 4292640548, 4281936662, 0x83000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF000000, 4294892416, 0xFF000000, 0, 0xFF000000, 4294892416, 0xFF000000, 4294892416, 0xFF000000, 0, 0xFF000000, 4294892416, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 4294892416, 0xFF000000, 4294892416, 4294892416, 4294892416, 0xFF000000, 4294892416, 0xFF000000, 0x96000000, 0xFF000000, 4294892416, 0xFF000000, 4294892416, 4294892416, 4294892416, 0xFF000000, 4294892416, 0xFF000000, 0, 0xFF000000, 4294892416, 0xFF000000, 0, 0, 0, 0, 0xFF000000, 4294892416, 0xFF000000, 0, 0xFF000000, 4294892416, 0xFF000000, 4294892416, 0xFF000000, 0, 0xFF000000, 4294892416, 0xFF000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x79000000, 4282068512, 4293561399, 4294208769, 4294210313, 4294407689, 4294210313, 4290530057, 4281734151, 4282851341, 4291913754, 4294275848, 4294275591, 4294275592, 4294208517, 4293164329, 4282133785, 0x7C000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 4294892416, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 0xFF000000, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 0, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 0xFF000000, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 0, 0, 0, 0, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x61000000, 4280293393, 4292577349, 4294272769, 4294208264, 4294471177, 4293617417, 4286918406, 4279502337, 0x72000000, 0x79000000, 4280422919, 4289945382, 4294009867, 4293875462, 4293743369, 4293610244, 4292440624, 4280950288, 0x69000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF000000, 4294892416, 4294892416, 4294892416, 4294892416, 0xFF000000, 0x96000000, 0xFF000000, 4294892416, 4294892416, 4294892416, 0xFF000000, 0x96000000, 0x96000000, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 4294892416, 4294892416, 0xFF000000, 0xFF000000, 4294892416, 4294892416, 4294892416, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 0, 0x96000000, 0xFF000000, 4294892416, 4294892416, 4294892416, 0xFF000000, 0x96000000, 0xFF000000, 4294892416, 4294892416, 4294892416, 0xFF000000, 0x96000000, 0, 0, 0, 0, 0x96000000, 0xFF000000, 4294892416, 4294892416, 4294892416, 0xFF000000, 0x96000000, 0xFF000000, 4294892416, 4294892416, 4294892416, 4294892416, 0xFF000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2F000000, 4279044359, 4291067728, 4294075141, 4294075143, 4294338057, 4293352968, 4284490243, 0xFF020100, 0x4D000000, 0, 0, 0x58000000, 4278781187, 4288236848, 4293610511, 4293609221, 4293610249, 4293609989, 4291261239, 4279241478, 0x4D000000, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF000000, 4294892416, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0, 0, 0x96000000, 0xFF000000, 0x96000000, 0x96000000, 0xFF000000, 0xFF000000, 0x96000000, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0x96000000, 0xFF000000, 0x96000000, 0, 0, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0, 0, 0, 0, 0, 0, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 4294892416, 0xFF000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x98000000, 4287849288, 4294009360, 4293941509, 4294007817, 4293679113, 4284620803, 0xAA000000, 0x31000000, 0, 0, 0, 0, 0x3B000000, 0xA4000000, 4288172857, 4293610511, 4293543429, 4293543943, 4293611019, 4289621050, 4278649858, 0x25000000, 0, 0, 0, 0, 0, 0, 0, 0xFF000000, 4294892416, 0xFF000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF000000, 4294892416, 4294892416, 4294892416, 0xFF000000, 0x96000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x79000000, 4283380775, 4294011945, 4293873409, 4293939977, 4293808649, 4285867012, 0xFF070200, 0x41000000, 0, 0, 0, 0, 0, 0, 0x38000000, 0xFF010100, 4288764223, 4293609227, 4293543175, 4293542917, 4293677843, 4287124784, 0x96000000, 0, 0, 0, 0, 0, 0, 0, 0x96000000, 0xFF000000, 0x96000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x30000000, 4279569674, 4292243009, 4293609217, 4293676041, 4293937929, 4288687621, 0xFF110400, 0x5C000000, 0, 0, 0, 0, 0, 0, 0, 0x1B000000, 0x84000000, 4278781188, 4290602054, 4293410821, 4293477384, 4293476868, 4293745950, 4283773466, 0x82000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x99000000, 4287714107, 4293543949, 4293542919, 4293673225, 4291834377, 4280879106, 0x7C000000, 0, 0, 0, 0, 0, 0, 0, 0x75000000, 4279898124, 4286467380, 4278846980, 4280686612, 4292961598, 4293343745, 4293411081, 4293476100, 4292566822, 4280357128, 0x44000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x96000000, 0xFF000000, 0x96000000, 0x96000000, 0xFF000000, 0x96000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x96000000, 0xFF000000, 0x96000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0, 0, 0, 0, 0x96000000, 0xFF000000, 0x96000000, 0, 0, 0x48000000, 4281539862, 4293417771, 4293343234, 4293277193, 4292947466, 4284880134, 0x94000000, 0, 0, 0, 0, 0, 0, 0x3B000000, 0xA4000000, 4282917657, 4291648314, 4293346067, 4288303409, 0xA3000000, 4284299053, 4293479197, 4293343493, 4293409801, 4293410569, 4288759582, 0xAD000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF000000, 0xFFE42300, 0xFFE42300, 0xFFE42300, 0xFF000000, 0x96000000, 0, 0, 0, 0xFF000000, 0xFFE42300, 0xFF000000, 0, 0, 0xB1000000, 4289023795, 4293211656, 4293144328, 4293143305, 4290389514, 4279108353, 0x20000000, 0, 0, 0, 0x14000000, 0x5C000000, 0xB2000000, 4281076999, 4287967257, 4293213977, 4293078532, 4293078275, 4293412634, 4284428061, 0xB2000000, 4289023285, 4293277192, 4293343240, 4293277191, 4293412372, 4282850829, 0x66000000, 0, 0, 0, 0, 0, 0, 0, 0x96000000, 0xFF000000, 0x96000000, 0, 0, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0, 0, 0x96000000, 0xFF000000, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0, 0, 0, 0x96000000, 0xFF000000, 0x96000000, 0, 0x96000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0x96000000, 0xFF000000, 0x96000000, 0, 0, 0, 0x96000000, 0xFF000000, 0x96000000, 0, 0x96000000, 0xFF000000, 0x96000000, 0, 0, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFE42300, 0xFF000000, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFE42300, 0xFF000000, 0, 0x39000000, 4281604366, 4293149982, 4293077253, 4293078025, 4292684810, 4282912516, 0x76000000, 0x63000000, 0x6A000000, 0x7F000000, 0xBF000000, 4279371011, 4283635982, 4288752661, 4292621844, 4293078537, 4293078022, 4293078537, 4293210121, 4293144583, 4290726433, 4278518273, 4280422668, 4292691489, 4293210117, 4293276937, 4293276680, 4290592536, 4278649601, 0x8000000, 0, 0, 0, 0, 0, 0x96000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0x96000000, 0, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFF000000, 0x96000000, 0x96000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFF000000, 0x96000000, 0, 0x96000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0x96000000, 0xFF000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0, 0, 0, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0x96000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0x96000000, 0, 0, 0xFF000000, 0xFFE42300, 0xFFE42300, 0xFF000000, 0x96000000, 0xFF000000, 0xFFE42300, 0xFFE42300, 0xFFE42300, 0xFFE42300, 0xFF000000, 0, 0xA2000000, 4287903514, 4293078538, 4293078280, 4293143817, 4290652684, 4281666563, 4281797635, 4283831561, 4284292110, 4285670934, 4289475868, 4291769878, 4293079566, 4293078281, 4293078023, 4293078280, 4293209609, 4293275145, 4292357130, 4287900432, 4280290309, 0x67000000, 0x91000000, 4286854178, 4293145355, 4293144584, 4293144328, 4293212431, 4283636492, 0x60000000, 0, 0, 0, 0, 0x96000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0x96000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0x96000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0x96000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0x96000000, 0, 0x96000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0x96000000, 0, 0x96000000, 0xFF000000, 0xFF000000, 0xFFE42300, 0xFF000000, 0xFFE42300, 0xFF000000, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0x1F000000, 4280027652, 4292426772, 4293078279, 4293079049, 4293144329, 4292751115, 4292555019, 4292948491, 4293079819, 4293146126, 4293211917, 4293210888, 4293145095, 4293210632, 4293144841, 4293210633, 4293275913, 4292685578, 4288618760, 4282584324, 0xB1000000, 0x48000000, 0, 0x28000000, 4279896839, 4292362526, 4293078022, 4293078793, 4293078536, 4290065172, 4278780673, 0xA000000, 0, 0, 0x96000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0x96000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0x96000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0x96000000, 0, 0, 0xFF000000, 0xFFE42300, 0xFF000000, 0xFFE42300, 0xFF000000, 0, 0xFF000000, 0xFFE42300, 0xFF000000, 0x6C000000, 4284620297, 4293211403, 4293210888, 4293211145, 4293276937, 4293277193, 4293277961, 4293344265, 4293410056, 4293344776, 4293344776, 4293345033, 4293410569, 4293475848, 4293344265, 4292819211, 4289276169, 4283437573, 0xFF080200, 0x6D000000, 0, 0, 0, 0, 0x96000000, 4287181084, 4293078538, 4293078025, 4293143560, 4293211664, 4283110665, 0x54000000, 0, 0, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0x96000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFE42300, 0xFF000000, 0xFFE42300, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFE42300, 0xFF000000, 0xB8000000, 4289148172, 4293345035, 4293345034, 4293411080, 4293476870, 4293477893, 4293544453, 4293611013, 4293677063, 4293677833, 4293677833, 4293612298, 4293218572, 4292102669, 4287771145, 4282651909, 0xFF080200, 0x72000000, 0xD000000, 0, 0, 0, 0, 0, 0x2E000000, 4280880904, 4292621585, 4293143048, 4292685067, 4290916111, 4284160266, 0x6C000000, 0, 0, 0xFF000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFF000000, 0x96000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFF000000, 0x96000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0, 0x96000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0x96000000, 0xFF000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFF000000, 0x96000000, 0xFF000000, 0xFFFFFFFF, 0xFF000000, 0xFFE42300, 0xFFE42300, 0xFFE42300, 0xFF000000, 0x96000000, 0xFF000000, 0xFFE42300, 0xFFE42300, 0xFFE42300, 0xFF000000, 0x96000000, 0x4F000000, 4280618243, 4284819723, 4287709972, 4289877530, 4293028892, 4293948702, 4293883680, 4293818144, 4292045341, 4289484568, 4288433169, 4286856717, 4282916870, 4279831042, 0xB5000000, 0x5B000000, 0xB000000, 0, 0, 0, 0, 0, 0, 0, 0, 0xC5000000, 4289014285, 4288159495, 4283372037, 4279370753, 0x81000000, 0x3000000, 0, 0, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0, 0x96000000, 0xFF000000, 0x96000000, 0x96000000, 0xFF000000, 0x96000000, 0xFF000000, 0x96000000, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0x96000000, 0xFF000000, 0x96000000, 0, 0x96000000, 0xFF000000, 0x96000000, 0, 0x96000000, 0xFF000000, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0, 0x96000000, 0xFF000000, 0x96000000, 0xFF000000, 0x96000000, 0xFF000000, 0x96000000, 0, 0, 0x96000000, 0xFF000000, 0x96000000, 0, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0, 0x96000000, 0xFF000000, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0, 0x96000000, 0xFF000000, 0xFF000000, 0xFF000000, 0x96000000, 0, 0, 0x28000000, 0x6D000000, 0x9B000000, 0xBD000000, 0xF0000000, 0xFE000000, 0xFE000000, 0xFE000000, 0xE3000000, 0xBD000000, 0xB1000000, 0x9F000000, 0x5B000000, 0x21000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x5C000000, 0xC5000000, 0xBA000000, 0x6C000000, 0x17000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])); + return (_local_1); + } + + + private function onMouseDown(_arg_1:MouseEvent):void{ + _arg_1.stopPropagation(); + } + + private function onClick(_arg_1:MouseEvent):void{ + _arg_1.stopPropagation(); + try + { + navigateToURL(new URLRequest("http://alternativaplatform.com"), "_blank"); + } + catch(e:Error) + { + }; + } + + private function onDoubleClick(_arg_1:MouseEvent):void{ + _arg_1.stopPropagation(); + } + + private function onMouseMove(_arg_1:MouseEvent):void{ + _arg_1.stopPropagation(); + } + + private function onMouseOut(_arg_1:MouseEvent):void{ + _arg_1.stopPropagation(); + } + + private function onMouseWheel(_arg_1:MouseEvent):void{ + _arg_1.stopPropagation(); + } + + +} diff --git a/src/alternativa/engine3d/core/Wrapper.as b/src/alternativa/engine3d/core/Wrapper.as new file mode 100644 index 0000000..0daaacd --- /dev/null +++ b/src/alternativa/engine3d/core/Wrapper.as @@ -0,0 +1,49 @@ +package alternativa.engine3d.core{ + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class Wrapper { + + alternativa3d static var collector:Wrapper; + + alternativa3d var next:Wrapper; + alternativa3d var vertex:Vertex; + + + alternativa3d static function create():Wrapper{ + var _local_1:Wrapper; + if (collector != null) + { + _local_1 = collector; + collector = collector.next; + _local_1.next = null; + return (_local_1); + }; + return (new (Wrapper)()); + } + + + alternativa3d function create():Wrapper{ + var _local_1:Wrapper; + if (collector != null) + { + _local_1 = collector; + collector = collector.next; + _local_1.next = null; + return (_local_1); + }; + return (new Wrapper()); + } + + public function destroy() : void + { + if(this.vertex != null) + { + this.vertex = null; + } + } + + + } +}//package alternativa.engine3d.core \ No newline at end of file diff --git a/src/alternativa/engine3d/lights/AmbientLight.as b/src/alternativa/engine3d/lights/AmbientLight.as new file mode 100644 index 0000000..e2d8718 --- /dev/null +++ b/src/alternativa/engine3d/lights/AmbientLight.as @@ -0,0 +1,45 @@ +package alternativa.engine3d.lights +{ + import alternativa.engine3d.alternativa3d; + import alternativa.engine3d.core.Camera3D; + import alternativa.engine3d.core.Debug; + import alternativa.engine3d.core.Light3D; + import alternativa.engine3d.core.Object3D; + import flash.display.Sprite; + use namespace alternativa3d; + public class AmbientLight extends Light3D + { + + + public function AmbientLight(param1:uint) + { + super(); + this.color = param1; + calculateBounds(); + } + + override public function clone() : Object3D + { + var _loc1_:AmbientLight = new AmbientLight(color); + _loc1_.clonePropertiesFrom(this); + return _loc1_; + } + + override alternativa3d function drawDebug(param1:Camera3D) : void + { + var _loc3_:Sprite = null; + var _loc2_:int = param1.checkInDebug(this); + if(_loc2_ > 0) + { + _loc3_ = param1.view.canvas; + if(_loc2_ & Debug.LIGHTS && ml > param1.nearClipping) + { + } + if(_loc2_ & Debug.BOUNDS) + { + Debug.drawBounds(param1,this,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ,10092288); + } + } + } + } +} diff --git a/src/alternativa/engine3d/lights/DirectionalLight.as b/src/alternativa/engine3d/lights/DirectionalLight.as new file mode 100644 index 0000000..24f749b --- /dev/null +++ b/src/alternativa/engine3d/lights/DirectionalLight.as @@ -0,0 +1,236 @@ +package alternativa.engine3d.lights +{ + import alternativa.engine3d.core.Light3D; + import alternativa.engine3d.core.Object3D; + import flash.display.Sprite; + import alternativa.engine3d.core.Debug; + import alternativa.engine3d.core.Camera3D; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class DirectionalLight extends Light3D + { + + public function DirectionalLight(_arg_1:uint) + { + this.color = _arg_1; + calculateBounds(); + } + + public function lookAt(_arg_1:Number, _arg_2:Number, _arg_3:Number):void + { + var _local_4:Number = (_arg_1 - this.x); + var _local_5:Number = (_arg_2 - this.y); + var _local_6:Number = (_arg_3 - this.z); + rotationX = (Math.atan2(_local_6, Math.sqrt(((_local_4 * _local_4) + (_local_5 * _local_5)))) - (Math.PI / 2)); + rotationY = 0; + rotationZ = -(Math.atan2(_local_4, _local_5)); + } + + override public function clone():Object3D + { + var _local_1:DirectionalLight = new DirectionalLight(color); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + override alternativa3d function drawDebug(_arg_1:Camera3D):void + { + var _local_3:Sprite; + var _local_4:Number; + var _local_5:Number; + var _local_6:Number; + var _local_7:int; + var _local_8:Number; + var _local_9:Number; + var _local_10:Number; + var _local_11:Number; + var _local_12:Number; + var _local_13:Number; + var _local_14:Number; + var _local_15:Number; + var _local_16:Number; + var _local_17:Number; + var _local_18:Number; + var _local_19:Number; + var _local_20:Number; + var _local_21:Number; + var _local_22:Number; + var _local_23:Number; + var _local_24:Number; + var _local_25:Number; + var _local_26:Number; + var _local_27:Number; + var _local_28:Number; + var _local_29:Number; + var _local_30:Number; + var _local_31:Number; + var _local_32:Number; + var _local_33:Number; + var _local_34:Number; + var _local_35:Number; + var _local_36:Number; + var _local_37:Number; + var _local_38:Number; + var _local_39:Number; + var _local_40:Number; + var _local_41:Number; + var _local_42:Number; + var _local_43:Number; + var _local_44:Number; + var _local_45:Number; + var _local_46:Number; + var _local_47:Number; + var _local_48:Number; + var _local_49:Number; + var _local_50:Number; + var _local_51:Number; + var _local_52:Number; + var _local_53:Number; + var _local_54:Number; + var _local_55:Number; + var _local_56:Number; + var _local_57:Number; + var _local_58:Number; + var _local_59:Number; + var _local_60:Number; + var _local_61:Number; + var _local_62:Number; + var _local_63:Number; + var _local_64:Number; + var _local_2:int = _arg_1.checkInDebug(this); + if (_local_2 > 0) + { + _local_3 = _arg_1.view.canvas; + if (((_local_2 & Debug.LIGHTS) && (ml > _arg_1.nearClipping))) + { + _local_4 = (((color >> 16) & 0xFF) * intensity); + _local_5 = (((color >> 8) & 0xFF) * intensity); + _local_6 = ((color & 0xFF) * intensity); + _local_7 = (((((_local_4 > 0xFF) ? 0xFF : _local_4) << 16) + (((_local_5 > 0xFF) ? 0xFF : _local_5) << 8)) + ((_local_6 > 0xFF) ? 0xFF : _local_6)); + _local_8 = ((md * _arg_1.viewSizeX) / _arg_1.focalLength); + _local_9 = ((mh * _arg_1.viewSizeY) / _arg_1.focalLength); + _local_10 = ml; + _local_11 = ((mc * _arg_1.viewSizeX) / _arg_1.focalLength); + _local_12 = ((mg * _arg_1.viewSizeY) / _arg_1.focalLength); + _local_13 = mk; + _local_14 = Math.sqrt((((_local_11 * _local_11) + (_local_12 * _local_12)) + (_local_13 * _local_13))); + _local_11 = (_local_11 / _local_14); + _local_12 = (_local_12 / _local_14); + _local_13 = (_local_13 / _local_14); + _local_15 = ((ma * _arg_1.viewSizeX) / _arg_1.focalLength); + _local_16 = ((me * _arg_1.viewSizeY) / _arg_1.focalLength); + _local_17 = mi; + _local_18 = ((_local_17 * _local_12) - (_local_16 * _local_13)); + _local_19 = ((_local_15 * _local_13) - (_local_17 * _local_11)); + _local_20 = ((_local_16 * _local_11) - (_local_15 * _local_12)); + _local_14 = Math.sqrt((((_local_18 * _local_18) + (_local_19 * _local_19)) + (_local_20 * _local_20))); + _local_18 = (_local_18 / _local_14); + _local_19 = (_local_19 / _local_14); + _local_20 = (_local_20 / _local_14); + _local_15 = ((mb * _arg_1.viewSizeX) / _arg_1.focalLength); + _local_16 = ((mf * _arg_1.viewSizeY) / _arg_1.focalLength); + _local_17 = mj; + _local_15 = ((_local_20 * _local_12) - (_local_19 * _local_13)); + _local_16 = ((_local_18 * _local_13) - (_local_20 * _local_11)); + _local_17 = ((_local_19 * _local_11) - (_local_18 * _local_12)); + _local_21 = (ml / _arg_1.focalLength); + _local_11 = (_local_11 * _local_21); + _local_12 = (_local_12 * _local_21); + _local_13 = (_local_13 * _local_21); + _local_15 = (_local_15 * _local_21); + _local_16 = (_local_16 * _local_21); + _local_17 = (_local_17 * _local_21); + _local_18 = (_local_18 * _local_21); + _local_19 = (_local_19 * _local_21); + _local_20 = (_local_20 * _local_21); + _local_22 = 16; + _local_23 = 24; + _local_24 = 4; + _local_25 = 8; + _local_26 = (_local_8 + (_local_11 * _local_23)); + _local_27 = (_local_9 + (_local_12 * _local_23)); + _local_28 = (_local_10 + (_local_13 * _local_23)); + _local_29 = ((_local_8 + (_local_15 * _local_24)) + (_local_18 * _local_24)); + _local_30 = ((_local_9 + (_local_16 * _local_24)) + (_local_19 * _local_24)); + _local_31 = ((_local_10 + (_local_17 * _local_24)) + (_local_20 * _local_24)); + _local_32 = ((_local_8 - (_local_15 * _local_24)) + (_local_18 * _local_24)); + _local_33 = ((_local_9 - (_local_16 * _local_24)) + (_local_19 * _local_24)); + _local_34 = ((_local_10 - (_local_17 * _local_24)) + (_local_20 * _local_24)); + _local_35 = ((_local_8 - (_local_15 * _local_24)) - (_local_18 * _local_24)); + _local_36 = ((_local_9 - (_local_16 * _local_24)) - (_local_19 * _local_24)); + _local_37 = ((_local_10 - (_local_17 * _local_24)) - (_local_20 * _local_24)); + _local_38 = ((_local_8 + (_local_15 * _local_24)) - (_local_18 * _local_24)); + _local_39 = ((_local_9 + (_local_16 * _local_24)) - (_local_19 * _local_24)); + _local_40 = ((_local_10 + (_local_17 * _local_24)) - (_local_20 * _local_24)); + _local_41 = (((_local_8 + (_local_11 * _local_22)) + (_local_15 * _local_24)) + (_local_18 * _local_24)); + _local_42 = (((_local_9 + (_local_12 * _local_22)) + (_local_16 * _local_24)) + (_local_19 * _local_24)); + _local_43 = (((_local_10 + (_local_13 * _local_22)) + (_local_17 * _local_24)) + (_local_20 * _local_24)); + _local_44 = (((_local_8 + (_local_11 * _local_22)) - (_local_15 * _local_24)) + (_local_18 * _local_24)); + _local_45 = (((_local_9 + (_local_12 * _local_22)) - (_local_16 * _local_24)) + (_local_19 * _local_24)); + _local_46 = (((_local_10 + (_local_13 * _local_22)) - (_local_17 * _local_24)) + (_local_20 * _local_24)); + _local_47 = (((_local_8 + (_local_11 * _local_22)) - (_local_15 * _local_24)) - (_local_18 * _local_24)); + _local_48 = (((_local_9 + (_local_12 * _local_22)) - (_local_16 * _local_24)) - (_local_19 * _local_24)); + _local_49 = (((_local_10 + (_local_13 * _local_22)) - (_local_17 * _local_24)) - (_local_20 * _local_24)); + _local_50 = (((_local_8 + (_local_11 * _local_22)) + (_local_15 * _local_24)) - (_local_18 * _local_24)); + _local_51 = (((_local_9 + (_local_12 * _local_22)) + (_local_16 * _local_24)) - (_local_19 * _local_24)); + _local_52 = (((_local_10 + (_local_13 * _local_22)) + (_local_17 * _local_24)) - (_local_20 * _local_24)); + _local_53 = (((_local_8 + (_local_11 * _local_22)) + (_local_15 * _local_25)) + (_local_18 * _local_25)); + _local_54 = (((_local_9 + (_local_12 * _local_22)) + (_local_16 * _local_25)) + (_local_19 * _local_25)); + _local_55 = (((_local_10 + (_local_13 * _local_22)) + (_local_17 * _local_25)) + (_local_20 * _local_25)); + _local_56 = (((_local_8 + (_local_11 * _local_22)) - (_local_15 * _local_25)) + (_local_18 * _local_25)); + _local_57 = (((_local_9 + (_local_12 * _local_22)) - (_local_16 * _local_25)) + (_local_19 * _local_25)); + _local_58 = (((_local_10 + (_local_13 * _local_22)) - (_local_17 * _local_25)) + (_local_20 * _local_25)); + _local_59 = (((_local_8 + (_local_11 * _local_22)) - (_local_15 * _local_25)) - (_local_18 * _local_25)); + _local_60 = (((_local_9 + (_local_12 * _local_22)) - (_local_16 * _local_25)) - (_local_19 * _local_25)); + _local_61 = (((_local_10 + (_local_13 * _local_22)) - (_local_17 * _local_25)) - (_local_20 * _local_25)); + _local_62 = (((_local_8 + (_local_11 * _local_22)) + (_local_15 * _local_25)) - (_local_18 * _local_25)); + _local_63 = (((_local_9 + (_local_12 * _local_22)) + (_local_16 * _local_25)) - (_local_19 * _local_25)); + _local_64 = (((_local_10 + (_local_13 * _local_22)) + (_local_17 * _local_25)) - (_local_20 * _local_25)); + if ((((((((((((((_local_28 > _arg_1.nearClipping) && (_local_31 > _arg_1.nearClipping)) && (_local_34 > _arg_1.nearClipping)) && (_local_37 > _arg_1.nearClipping)) && (_local_40 > _arg_1.nearClipping)) && (_local_43 > _arg_1.nearClipping)) && (_local_46 > _arg_1.nearClipping)) && (_local_49 > _arg_1.nearClipping)) && (_local_52 > _arg_1.nearClipping)) && (_local_55 > _arg_1.nearClipping)) && (_local_58 > _arg_1.nearClipping)) && (_local_61 > _arg_1.nearClipping)) && (_local_64 > _arg_1.nearClipping))) + { + _local_3.graphics.lineStyle(1, _local_7); + _local_3.graphics.moveTo(((_local_29 * _arg_1.focalLength) / _local_31), ((_local_30 * _arg_1.focalLength) / _local_31)); + _local_3.graphics.lineTo(((_local_32 * _arg_1.focalLength) / _local_34), ((_local_33 * _arg_1.focalLength) / _local_34)); + _local_3.graphics.lineTo(((_local_35 * _arg_1.focalLength) / _local_37), ((_local_36 * _arg_1.focalLength) / _local_37)); + _local_3.graphics.lineTo(((_local_38 * _arg_1.focalLength) / _local_40), ((_local_39 * _arg_1.focalLength) / _local_40)); + _local_3.graphics.lineTo(((_local_29 * _arg_1.focalLength) / _local_31), ((_local_30 * _arg_1.focalLength) / _local_31)); + _local_3.graphics.moveTo(((_local_41 * _arg_1.focalLength) / _local_43), ((_local_42 * _arg_1.focalLength) / _local_43)); + _local_3.graphics.lineTo(((_local_44 * _arg_1.focalLength) / _local_46), ((_local_45 * _arg_1.focalLength) / _local_46)); + _local_3.graphics.lineTo(((_local_47 * _arg_1.focalLength) / _local_49), ((_local_48 * _arg_1.focalLength) / _local_49)); + _local_3.graphics.lineTo(((_local_50 * _arg_1.focalLength) / _local_52), ((_local_51 * _arg_1.focalLength) / _local_52)); + _local_3.graphics.lineTo(((_local_41 * _arg_1.focalLength) / _local_43), ((_local_42 * _arg_1.focalLength) / _local_43)); + _local_3.graphics.moveTo(((_local_53 * _arg_1.focalLength) / _local_55), ((_local_54 * _arg_1.focalLength) / _local_55)); + _local_3.graphics.lineTo(((_local_56 * _arg_1.focalLength) / _local_58), ((_local_57 * _arg_1.focalLength) / _local_58)); + _local_3.graphics.lineTo(((_local_59 * _arg_1.focalLength) / _local_61), ((_local_60 * _arg_1.focalLength) / _local_61)); + _local_3.graphics.lineTo(((_local_62 * _arg_1.focalLength) / _local_64), ((_local_63 * _arg_1.focalLength) / _local_64)); + _local_3.graphics.lineTo(((_local_53 * _arg_1.focalLength) / _local_55), ((_local_54 * _arg_1.focalLength) / _local_55)); + _local_3.graphics.moveTo(((_local_26 * _arg_1.focalLength) / _local_28), ((_local_27 * _arg_1.focalLength) / _local_28)); + _local_3.graphics.lineTo(((_local_53 * _arg_1.focalLength) / _local_55), ((_local_54 * _arg_1.focalLength) / _local_55)); + _local_3.graphics.moveTo(((_local_26 * _arg_1.focalLength) / _local_28), ((_local_27 * _arg_1.focalLength) / _local_28)); + _local_3.graphics.lineTo(((_local_56 * _arg_1.focalLength) / _local_58), ((_local_57 * _arg_1.focalLength) / _local_58)); + _local_3.graphics.moveTo(((_local_26 * _arg_1.focalLength) / _local_28), ((_local_27 * _arg_1.focalLength) / _local_28)); + _local_3.graphics.lineTo(((_local_59 * _arg_1.focalLength) / _local_61), ((_local_60 * _arg_1.focalLength) / _local_61)); + _local_3.graphics.moveTo(((_local_26 * _arg_1.focalLength) / _local_28), ((_local_27 * _arg_1.focalLength) / _local_28)); + _local_3.graphics.lineTo(((_local_62 * _arg_1.focalLength) / _local_64), ((_local_63 * _arg_1.focalLength) / _local_64)); + _local_3.graphics.moveTo(((_local_29 * _arg_1.focalLength) / _local_31), ((_local_30 * _arg_1.focalLength) / _local_31)); + _local_3.graphics.lineTo(((_local_41 * _arg_1.focalLength) / _local_43), ((_local_42 * _arg_1.focalLength) / _local_43)); + _local_3.graphics.moveTo(((_local_32 * _arg_1.focalLength) / _local_34), ((_local_33 * _arg_1.focalLength) / _local_34)); + _local_3.graphics.lineTo(((_local_44 * _arg_1.focalLength) / _local_46), ((_local_45 * _arg_1.focalLength) / _local_46)); + _local_3.graphics.moveTo(((_local_35 * _arg_1.focalLength) / _local_37), ((_local_36 * _arg_1.focalLength) / _local_37)); + _local_3.graphics.lineTo(((_local_47 * _arg_1.focalLength) / _local_49), ((_local_48 * _arg_1.focalLength) / _local_49)); + _local_3.graphics.moveTo(((_local_38 * _arg_1.focalLength) / _local_40), ((_local_39 * _arg_1.focalLength) / _local_40)); + _local_3.graphics.lineTo(((_local_50 * _arg_1.focalLength) / _local_52), ((_local_51 * _arg_1.focalLength) / _local_52)); + }; + }; + if ((_local_2 & Debug.BOUNDS)) + { + Debug.drawBounds(_arg_1, this, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ, 0x99FF00); + }; + }; + } + + + } +}//package alternativa.engine3d.lights \ No newline at end of file diff --git a/src/alternativa/engine3d/lights/OmniLight.as b/src/alternativa/engine3d/lights/OmniLight.as new file mode 100644 index 0000000..773332c --- /dev/null +++ b/src/alternativa/engine3d/lights/OmniLight.as @@ -0,0 +1,190 @@ +package alternativa.engine3d.lights +{ + import alternativa.engine3d.alternativa3d; + import alternativa.engine3d.core.Camera3D; + import alternativa.engine3d.core.Debug; + import alternativa.engine3d.core.Light3D; + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.core.Vertex; + import flash.display.Sprite; + use namespace alternativa3d; + public class OmniLight extends Light3D + { + + + public var attenuationBegin:Number; + + public var attenuationEnd:Number; + + public function OmniLight(param1:uint, param2:Number, param3:Number) + { + super(); + this.color = param1; + this.attenuationBegin = param2; + this.attenuationEnd = param3; + calculateBounds(); + } + + override public function clone() : Object3D + { + var _loc1_:OmniLight = new OmniLight(color,this.attenuationBegin,this.attenuationEnd); + _loc1_.clonePropertiesFrom(this); + return _loc1_; + } + + override alternativa3d function drawDebug(param1:Camera3D) : void + { + var _loc3_:Sprite = null; + var _loc4_:Number = NaN; + var _loc5_:Number = NaN; + var _loc6_:Number = NaN; + var _loc7_:int = 0; + var _loc8_:Number = NaN; + var _loc9_:Number = NaN; + var _loc10_:Number = NaN; + var _loc11_:Number = NaN; + var _loc12_:Number = NaN; + var _loc13_:Number = NaN; + var _loc2_:int = param1.checkInDebug(this); + if(_loc2_ > 0) + { + _loc3_ = param1.view.canvas; + if(_loc2_ & Debug.LIGHTS && ml > param1.nearClipping) + { + _loc4_ = (color >> 16 & 255) * intensity; + _loc5_ = (color >> 8 & 255) * intensity; + _loc6_ = (color & 255) * intensity; + _loc7_ = ((_loc4_ > 255?255:_loc4_) << 16) + ((_loc5_ > 255?255:_loc5_) << 8) + (_loc6_ > 255?255:_loc6_); + _loc8_ = ma * param1.viewSizeX / param1.focalLength; + _loc9_ = me * param1.viewSizeY / param1.focalLength; + _loc10_ = Math.sqrt(_loc8_ * _loc8_ + _loc9_ * _loc9_ + mi * mi); + _loc8_ = mb * param1.viewSizeX / param1.focalLength; + _loc9_ = mf * param1.viewSizeY / param1.focalLength; + _loc10_ = _loc10_ + Math.sqrt(_loc8_ * _loc8_ + _loc9_ * _loc9_ + mj * mj); + _loc8_ = mc * param1.viewSizeX / param1.focalLength; + _loc9_ = mg * param1.viewSizeY / param1.focalLength; + _loc10_ = _loc10_ + Math.sqrt(_loc8_ * _loc8_ + _loc9_ * _loc9_ + mk * mk); + _loc10_ = _loc10_ / 3; + _loc11_ = Math.round(md * param1.viewSizeX / ml); + _loc12_ = Math.round(mh * param1.viewSizeY / ml); + _loc13_ = 8; + _loc3_.graphics.lineStyle(1,_loc7_); + _loc3_.graphics.moveTo(_loc11_ - _loc13_,_loc12_); + _loc3_.graphics.lineTo(_loc11_ + _loc13_,_loc12_); + _loc3_.graphics.moveTo(_loc11_,_loc12_ - _loc13_); + _loc3_.graphics.lineTo(_loc11_,_loc12_ + _loc13_); + _loc3_.graphics.moveTo(_loc11_ - _loc13_ * 0.7,_loc12_ - _loc13_ * 0.7); + _loc3_.graphics.lineTo(_loc11_ + _loc13_ * 0.7,_loc12_ + _loc13_ * 0.7); + _loc3_.graphics.moveTo(_loc11_ - _loc13_ * 0.7,_loc12_ + _loc13_ * 0.7); + _loc3_.graphics.lineTo(_loc11_ + _loc13_ * 0.7,_loc12_ - _loc13_ * 0.7); + _loc3_.graphics.drawCircle(_loc11_,_loc12_,this.attenuationBegin * _loc10_ * param1.focalLength / ml); + _loc3_.graphics.lineStyle(1,_loc7_,0.5); + _loc3_.graphics.drawCircle(_loc11_,_loc12_,this.attenuationEnd * _loc10_ * param1.focalLength / ml); + } + if(_loc2_ & Debug.BOUNDS) + { + Debug.drawBounds(param1,this,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ,10092288); + } + } + } + + override alternativa3d function updateBounds(param1:Object3D, param2:Object3D = null) : void + { + var _loc3_:Vertex = null; + if(param2 != null) + { + _loc3_ = boundVertexList; + _loc3_.x = -this.attenuationEnd; + _loc3_.y = -this.attenuationEnd; + _loc3_.z = -this.attenuationEnd; + _loc3_ = _loc3_.next; + _loc3_.x = this.attenuationEnd; + _loc3_.y = -this.attenuationEnd; + _loc3_.z = -this.attenuationEnd; + _loc3_ = _loc3_.next; + _loc3_.x = -this.attenuationEnd; + _loc3_.y = this.attenuationEnd; + _loc3_.z = -this.attenuationEnd; + _loc3_ = _loc3_.next; + _loc3_.x = this.attenuationEnd; + _loc3_.y = this.attenuationEnd; + _loc3_.z = -this.attenuationEnd; + _loc3_ = _loc3_.next; + _loc3_.x = -this.attenuationEnd; + _loc3_.y = -this.attenuationEnd; + _loc3_.z = this.attenuationEnd; + _loc3_ = _loc3_.next; + _loc3_.x = this.attenuationEnd; + _loc3_.y = -this.attenuationEnd; + _loc3_.z = this.attenuationEnd; + _loc3_ = _loc3_.next; + _loc3_.x = -this.attenuationEnd; + _loc3_.y = this.attenuationEnd; + _loc3_.z = this.attenuationEnd; + _loc3_ = _loc3_.next; + _loc3_.x = this.attenuationEnd; + _loc3_.y = this.attenuationEnd; + _loc3_.z = this.attenuationEnd; + _loc3_ = boundVertexList; + while(_loc3_ != null) + { + _loc3_.cameraX = param2.ma * _loc3_.x + param2.mb * _loc3_.y + param2.mc * _loc3_.z + param2.md; + _loc3_.cameraY = param2.me * _loc3_.x + param2.mf * _loc3_.y + param2.mg * _loc3_.z + param2.mh; + _loc3_.cameraZ = param2.mi * _loc3_.x + param2.mj * _loc3_.y + param2.mk * _loc3_.z + param2.ml; + if(_loc3_.cameraX < param1.boundMinX) + { + param1.boundMinX = _loc3_.cameraX; + } + if(_loc3_.cameraX > param1.boundMaxX) + { + param1.boundMaxX = _loc3_.cameraX; + } + if(_loc3_.cameraY < param1.boundMinY) + { + param1.boundMinY = _loc3_.cameraY; + } + if(_loc3_.cameraY > param1.boundMaxY) + { + param1.boundMaxY = _loc3_.cameraY; + } + if(_loc3_.cameraZ < param1.boundMinZ) + { + param1.boundMinZ = _loc3_.cameraZ; + } + if(_loc3_.cameraZ > param1.boundMaxZ) + { + param1.boundMaxZ = _loc3_.cameraZ; + } + _loc3_ = _loc3_.next; + } + } + else + { + if(-this.attenuationEnd < param1.boundMinX) + { + param1.boundMinX = -this.attenuationEnd; + } + if(this.attenuationEnd > param1.boundMaxX) + { + param1.boundMaxX = this.attenuationEnd; + } + if(-this.attenuationEnd < param1.boundMinY) + { + param1.boundMinY = -this.attenuationEnd; + } + if(this.attenuationEnd > param1.boundMaxY) + { + param1.boundMaxY = this.attenuationEnd; + } + if(-this.attenuationEnd < param1.boundMinZ) + { + param1.boundMinZ = -this.attenuationEnd; + } + if(this.attenuationEnd > param1.boundMaxZ) + { + param1.boundMaxZ = this.attenuationEnd; + } + } + } + } +} diff --git a/src/alternativa/engine3d/lights/SpotLight.as b/src/alternativa/engine3d/lights/SpotLight.as new file mode 100644 index 0000000..88fae49 --- /dev/null +++ b/src/alternativa/engine3d/lights/SpotLight.as @@ -0,0 +1,335 @@ +package alternativa.engine3d.lights +{ + import alternativa.engine3d.alternativa3d; + import alternativa.engine3d.core.Camera3D; + import alternativa.engine3d.core.Debug; + import alternativa.engine3d.core.Light3D; + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.core.Vertex; + import flash.display.Sprite; + use namespace alternativa3d; + public class SpotLight extends Light3D + { + + + public var attenuationBegin:Number; + + public var attenuationEnd:Number; + + public var hotspot:Number; + + public var falloff:Number; + + public function SpotLight(param1:uint, param2:Number, param3:Number, param4:Number, param5:Number) + { + super(); + this.color = param1; + this.attenuationBegin = param2; + this.attenuationEnd = param3; + this.hotspot = param4; + this.falloff = param5; + calculateBounds(); + } + + public function lookAt(param1:Number, param2:Number, param3:Number) : void + { + var _loc4_:Number = NaN; + _loc4_ = param1 - this.x; + var _loc5_:Number = param2 - this.y; + var _loc6_:Number = param3 - this.z; + rotationX = Math.atan2(_loc6_,Math.sqrt(_loc4_ * _loc4_ + _loc5_ * _loc5_)) - Math.PI / 2; + rotationY = 0; + rotationZ = -Math.atan2(_loc4_,_loc5_); + } + + override public function clone() : Object3D + { + var _loc1_:SpotLight = new SpotLight(color,this.attenuationBegin,this.attenuationEnd,this.hotspot,this.falloff); + _loc1_.clonePropertiesFrom(this); + return _loc1_; + } + + override alternativa3d function drawDebug(param1:Camera3D) : void + { + var _loc3_:Sprite = null; + var _loc4_:Number = NaN; + var _loc5_:Number = NaN; + var _loc6_:Number = NaN; + var _loc7_:int = 0; + var _loc8_:Number = NaN; + var _loc9_:Number = NaN; + var _loc10_:Number = NaN; + var _loc11_:Number = NaN; + var _loc12_:Number = NaN; + var _loc13_:Number = NaN; + var _loc14_:Number = NaN; + var _loc15_:Number = NaN; + var _loc16_:Number = NaN; + var _loc17_:Number = NaN; + var _loc18_:Number = NaN; + var _loc19_:Number = NaN; + var _loc20_:Number = NaN; + var _loc21_:Number = NaN; + var _loc22_:Number = NaN; + var _loc23_:Number = NaN; + var _loc24_:Number = NaN; + var _loc25_:Number = NaN; + var _loc26_:Number = NaN; + var _loc27_:Number = NaN; + var _loc28_:Number = NaN; + var _loc29_:Number = NaN; + var _loc30_:Number = NaN; + var _loc31_:Number = NaN; + var _loc32_:Number = NaN; + var _loc33_:Number = NaN; + var _loc34_:Number = NaN; + var _loc35_:Number = NaN; + var _loc36_:Number = NaN; + var _loc37_:Number = NaN; + var _loc38_:Number = NaN; + var _loc39_:Number = NaN; + var _loc40_:Number = NaN; + var _loc41_:Number = NaN; + var _loc42_:Number = NaN; + var _loc43_:Number = NaN; + var _loc44_:Number = NaN; + var _loc45_:Number = NaN; + var _loc46_:Number = NaN; + var _loc47_:Number = NaN; + var _loc2_:int = param1.checkInDebug(this); + if(_loc2_ > 0) + { + _loc3_ = param1.view.canvas; + if(_loc2_ & Debug.LIGHTS && ml > param1.nearClipping) + { + _loc4_ = (color >> 16 & 255) * intensity; + _loc5_ = (color >> 8 & 255) * intensity; + _loc6_ = (color & 255) * intensity; + _loc7_ = ((_loc4_ > 255?255:_loc4_) << 16) + ((_loc5_ > 255?255:_loc5_) << 8) + (_loc6_ > 255?255:_loc6_); + _loc8_ = 0; + _loc9_ = md * param1.viewSizeX / param1.focalLength; + _loc10_ = mh * param1.viewSizeY / param1.focalLength; + _loc11_ = ml; + _loc12_ = mc * param1.viewSizeX / param1.focalLength; + _loc13_ = mg * param1.viewSizeY / param1.focalLength; + _loc14_ = mk; + _loc15_ = Math.sqrt(_loc12_ * _loc12_ + _loc13_ * _loc13_ + _loc14_ * _loc14_); + _loc8_ = _loc8_ + _loc15_; + _loc12_ = _loc12_ / _loc15_; + _loc13_ = _loc13_ / _loc15_; + _loc14_ = _loc14_ / _loc15_; + _loc16_ = ma * param1.viewSizeX / param1.focalLength; + _loc17_ = me * param1.viewSizeY / param1.focalLength; + _loc18_ = mi; + _loc8_ = _loc8_ + Math.sqrt(_loc16_ * _loc16_ + _loc17_ * _loc17_ + _loc18_ * _loc18_); + _loc19_ = _loc18_ * _loc13_ - _loc17_ * _loc14_; + _loc20_ = _loc16_ * _loc14_ - _loc18_ * _loc12_; + _loc21_ = _loc17_ * _loc12_ - _loc16_ * _loc13_; + _loc15_ = Math.sqrt(_loc19_ * _loc19_ + _loc20_ * _loc20_ + _loc21_ * _loc21_); + _loc19_ = _loc19_ / _loc15_; + _loc20_ = _loc20_ / _loc15_; + _loc21_ = _loc21_ / _loc15_; + _loc16_ = mb * param1.viewSizeX / param1.focalLength; + _loc17_ = mf * param1.viewSizeY / param1.focalLength; + _loc18_ = mj; + _loc8_ = _loc8_ + Math.sqrt(_loc16_ * _loc16_ + _loc17_ * _loc17_ + _loc18_ * _loc18_); + _loc8_ = _loc8_ / 3; + _loc16_ = _loc21_ * _loc13_ - _loc20_ * _loc14_; + _loc17_ = _loc19_ * _loc14_ - _loc21_ * _loc12_; + _loc18_ = _loc20_ * _loc12_ - _loc19_ * _loc13_; + _loc22_ = Math.cos(this.hotspot / 2); + _loc23_ = Math.sin(this.hotspot / 2); + _loc24_ = _loc9_ + (_loc12_ * _loc22_ + _loc16_ * _loc23_) * _loc8_ * this.attenuationBegin; + _loc25_ = _loc10_ + (_loc13_ * _loc22_ + _loc17_ * _loc23_) * _loc8_ * this.attenuationBegin; + _loc26_ = _loc11_ + (_loc14_ * _loc22_ + _loc18_ * _loc23_) * _loc8_ * this.attenuationBegin; + _loc27_ = _loc9_ + (_loc12_ * _loc22_ + (_loc16_ + _loc19_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin; + _loc28_ = _loc10_ + (_loc13_ * _loc22_ + (_loc17_ + _loc20_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin; + _loc29_ = _loc11_ + (_loc14_ * _loc22_ + (_loc18_ + _loc21_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin; + _loc30_ = _loc9_ + (_loc12_ * _loc22_ + _loc19_ * _loc23_) * _loc8_ * this.attenuationBegin; + _loc31_ = _loc10_ + (_loc13_ * _loc22_ + _loc20_ * _loc23_) * _loc8_ * this.attenuationBegin; + _loc32_ = _loc11_ + (_loc14_ * _loc22_ + _loc21_ * _loc23_) * _loc8_ * this.attenuationBegin; + _loc33_ = _loc9_ + (_loc12_ * _loc22_ - (_loc16_ - _loc19_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin; + _loc34_ = _loc10_ + (_loc13_ * _loc22_ - (_loc17_ - _loc20_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin; + _loc35_ = _loc11_ + (_loc14_ * _loc22_ - (_loc18_ - _loc21_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin; + _loc36_ = _loc9_ + (_loc12_ * _loc22_ - _loc16_ * _loc23_) * _loc8_ * this.attenuationBegin; + _loc37_ = _loc10_ + (_loc13_ * _loc22_ - _loc17_ * _loc23_) * _loc8_ * this.attenuationBegin; + _loc38_ = _loc11_ + (_loc14_ * _loc22_ - _loc18_ * _loc23_) * _loc8_ * this.attenuationBegin; + _loc39_ = _loc9_ + (_loc12_ * _loc22_ - (_loc16_ + _loc19_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin; + _loc40_ = _loc10_ + (_loc13_ * _loc22_ - (_loc17_ + _loc20_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin; + _loc41_ = _loc11_ + (_loc14_ * _loc22_ - (_loc18_ + _loc21_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin; + _loc42_ = _loc9_ + (_loc12_ * _loc22_ - _loc19_ * _loc23_) * _loc8_ * this.attenuationBegin; + _loc43_ = _loc10_ + (_loc13_ * _loc22_ - _loc20_ * _loc23_) * _loc8_ * this.attenuationBegin; + _loc44_ = _loc11_ + (_loc14_ * _loc22_ - _loc21_ * _loc23_) * _loc8_ * this.attenuationBegin; + _loc45_ = _loc9_ + (_loc12_ * _loc22_ + (_loc16_ - _loc19_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin; + _loc46_ = _loc10_ + (_loc13_ * _loc22_ + (_loc17_ - _loc20_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin; + _loc47_ = _loc11_ + (_loc14_ * _loc22_ + (_loc18_ - _loc21_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin; + if(_loc26_ > param1.nearClipping && _loc29_ > param1.nearClipping && _loc32_ > param1.nearClipping && _loc35_ > param1.nearClipping && _loc38_ > param1.nearClipping && _loc41_ > param1.nearClipping && _loc44_ > param1.nearClipping && _loc47_ > param1.nearClipping) + { + _loc3_.graphics.lineStyle(1,_loc7_); + _loc3_.graphics.moveTo(_loc24_ * param1.focalLength / _loc26_,_loc25_ * param1.focalLength / _loc26_); + _loc3_.graphics.curveTo(_loc27_ * param1.focalLength / _loc29_,_loc28_ * param1.focalLength / _loc29_,_loc30_ * param1.focalLength / _loc32_,_loc31_ * param1.focalLength / _loc32_); + _loc3_.graphics.curveTo(_loc33_ * param1.focalLength / _loc35_,_loc34_ * param1.focalLength / _loc35_,_loc36_ * param1.focalLength / _loc38_,_loc37_ * param1.focalLength / _loc38_); + _loc3_.graphics.curveTo(_loc39_ * param1.focalLength / _loc41_,_loc40_ * param1.focalLength / _loc41_,_loc42_ * param1.focalLength / _loc44_,_loc43_ * param1.focalLength / _loc44_); + _loc3_.graphics.curveTo(_loc45_ * param1.focalLength / _loc47_,_loc46_ * param1.focalLength / _loc47_,_loc24_ * param1.focalLength / _loc26_,_loc25_ * param1.focalLength / _loc26_); + _loc3_.graphics.moveTo(_loc9_ * param1.focalLength / _loc11_,_loc10_ * param1.focalLength / _loc11_); + _loc3_.graphics.lineTo(_loc24_ * param1.focalLength / _loc26_,_loc25_ * param1.focalLength / _loc26_); + _loc3_.graphics.moveTo(_loc9_ * param1.focalLength / _loc11_,_loc10_ * param1.focalLength / _loc11_); + _loc3_.graphics.lineTo(_loc30_ * param1.focalLength / _loc32_,_loc31_ * param1.focalLength / _loc32_); + _loc3_.graphics.moveTo(_loc9_ * param1.focalLength / _loc11_,_loc10_ * param1.focalLength / _loc11_); + _loc3_.graphics.lineTo(_loc36_ * param1.focalLength / _loc38_,_loc37_ * param1.focalLength / _loc38_); + _loc3_.graphics.moveTo(_loc9_ * param1.focalLength / _loc11_,_loc10_ * param1.focalLength / _loc11_); + _loc3_.graphics.lineTo(_loc42_ * param1.focalLength / _loc44_,_loc43_ * param1.focalLength / _loc44_); + } + _loc22_ = Math.cos(this.falloff / 2); + _loc23_ = Math.sin(this.falloff / 2); + _loc24_ = _loc9_ + (_loc12_ * _loc22_ + _loc16_ * _loc23_) * _loc8_ * this.attenuationEnd; + _loc25_ = _loc10_ + (_loc13_ * _loc22_ + _loc17_ * _loc23_) * _loc8_ * this.attenuationEnd; + _loc26_ = _loc11_ + (_loc14_ * _loc22_ + _loc18_ * _loc23_) * _loc8_ * this.attenuationEnd; + _loc27_ = _loc9_ + (_loc12_ * _loc22_ + (_loc16_ + _loc19_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd; + _loc28_ = _loc10_ + (_loc13_ * _loc22_ + (_loc17_ + _loc20_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd; + _loc29_ = _loc11_ + (_loc14_ * _loc22_ + (_loc18_ + _loc21_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd; + _loc30_ = _loc9_ + (_loc12_ * _loc22_ + _loc19_ * _loc23_) * _loc8_ * this.attenuationEnd; + _loc31_ = _loc10_ + (_loc13_ * _loc22_ + _loc20_ * _loc23_) * _loc8_ * this.attenuationEnd; + _loc32_ = _loc11_ + (_loc14_ * _loc22_ + _loc21_ * _loc23_) * _loc8_ * this.attenuationEnd; + _loc33_ = _loc9_ + (_loc12_ * _loc22_ - (_loc16_ - _loc19_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd; + _loc34_ = _loc10_ + (_loc13_ * _loc22_ - (_loc17_ - _loc20_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd; + _loc35_ = _loc11_ + (_loc14_ * _loc22_ - (_loc18_ - _loc21_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd; + _loc36_ = _loc9_ + (_loc12_ * _loc22_ - _loc16_ * _loc23_) * _loc8_ * this.attenuationEnd; + _loc37_ = _loc10_ + (_loc13_ * _loc22_ - _loc17_ * _loc23_) * _loc8_ * this.attenuationEnd; + _loc38_ = _loc11_ + (_loc14_ * _loc22_ - _loc18_ * _loc23_) * _loc8_ * this.attenuationEnd; + _loc39_ = _loc9_ + (_loc12_ * _loc22_ - (_loc16_ + _loc19_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd; + _loc40_ = _loc10_ + (_loc13_ * _loc22_ - (_loc17_ + _loc20_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd; + _loc41_ = _loc11_ + (_loc14_ * _loc22_ - (_loc18_ + _loc21_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd; + _loc42_ = _loc9_ + (_loc12_ * _loc22_ - _loc19_ * _loc23_) * _loc8_ * this.attenuationEnd; + _loc43_ = _loc10_ + (_loc13_ * _loc22_ - _loc20_ * _loc23_) * _loc8_ * this.attenuationEnd; + _loc44_ = _loc11_ + (_loc14_ * _loc22_ - _loc21_ * _loc23_) * _loc8_ * this.attenuationEnd; + _loc45_ = _loc9_ + (_loc12_ * _loc22_ + (_loc16_ - _loc19_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd; + _loc46_ = _loc10_ + (_loc13_ * _loc22_ + (_loc17_ - _loc20_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd; + _loc47_ = _loc11_ + (_loc14_ * _loc22_ + (_loc18_ - _loc21_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd; + if(_loc26_ > param1.nearClipping && _loc29_ > param1.nearClipping && _loc32_ > param1.nearClipping && _loc35_ > param1.nearClipping && _loc38_ > param1.nearClipping && _loc41_ > param1.nearClipping && _loc44_ > param1.nearClipping && _loc47_ > param1.nearClipping) + { + _loc3_.graphics.lineStyle(1,_loc7_,0.5); + _loc3_.graphics.moveTo(_loc24_ * param1.focalLength / _loc26_,_loc25_ * param1.focalLength / _loc26_); + _loc3_.graphics.curveTo(_loc27_ * param1.focalLength / _loc29_,_loc28_ * param1.focalLength / _loc29_,_loc30_ * param1.focalLength / _loc32_,_loc31_ * param1.focalLength / _loc32_); + _loc3_.graphics.curveTo(_loc33_ * param1.focalLength / _loc35_,_loc34_ * param1.focalLength / _loc35_,_loc36_ * param1.focalLength / _loc38_,_loc37_ * param1.focalLength / _loc38_); + _loc3_.graphics.curveTo(_loc39_ * param1.focalLength / _loc41_,_loc40_ * param1.focalLength / _loc41_,_loc42_ * param1.focalLength / _loc44_,_loc43_ * param1.focalLength / _loc44_); + _loc3_.graphics.curveTo(_loc45_ * param1.focalLength / _loc47_,_loc46_ * param1.focalLength / _loc47_,_loc24_ * param1.focalLength / _loc26_,_loc25_ * param1.focalLength / _loc26_); + _loc3_.graphics.moveTo(_loc9_ * param1.focalLength / _loc11_,_loc10_ * param1.focalLength / _loc11_); + _loc3_.graphics.lineTo(_loc24_ * param1.focalLength / _loc26_,_loc25_ * param1.focalLength / _loc26_); + _loc3_.graphics.moveTo(_loc9_ * param1.focalLength / _loc11_,_loc10_ * param1.focalLength / _loc11_); + _loc3_.graphics.lineTo(_loc30_ * param1.focalLength / _loc32_,_loc31_ * param1.focalLength / _loc32_); + _loc3_.graphics.moveTo(_loc9_ * param1.focalLength / _loc11_,_loc10_ * param1.focalLength / _loc11_); + _loc3_.graphics.lineTo(_loc36_ * param1.focalLength / _loc38_,_loc37_ * param1.focalLength / _loc38_); + _loc3_.graphics.moveTo(_loc9_ * param1.focalLength / _loc11_,_loc10_ * param1.focalLength / _loc11_); + _loc3_.graphics.lineTo(_loc42_ * param1.focalLength / _loc44_,_loc43_ * param1.focalLength / _loc44_); + } + } + if(_loc2_ & Debug.BOUNDS) + { + Debug.drawBounds(param1,this,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ,10092288); + } + } + } + + override alternativa3d function updateBounds(param1:Object3D, param2:Object3D = null) : void + { + var _loc5_:Vertex = null; + var _loc3_:Number = this.falloff < Math.PI?Number(Math.sin(this.falloff / 2) * this.attenuationEnd):Number(this.attenuationEnd); + var _loc4_:Number = this.falloff < Math.PI?Number(0):Number(Math.cos(this.falloff / 2) * this.attenuationEnd); + if(param2 != null) + { + _loc5_ = boundVertexList; + _loc5_.x = -_loc3_; + _loc5_.y = -_loc3_; + _loc5_.z = _loc4_; + _loc5_ = _loc5_.next; + _loc5_.x = _loc3_; + _loc5_.y = -_loc3_; + _loc5_.z = _loc4_; + _loc5_ = _loc5_.next; + _loc5_.x = -_loc3_; + _loc5_.y = _loc3_; + _loc5_.z = _loc4_; + _loc5_ = _loc5_.next; + _loc5_.x = _loc3_; + _loc5_.y = _loc3_; + _loc5_.z = _loc4_; + _loc5_ = _loc5_.next; + _loc5_.x = -_loc3_; + _loc5_.y = -_loc3_; + _loc5_.z = this.attenuationEnd; + _loc5_ = _loc5_.next; + _loc5_.x = _loc3_; + _loc5_.y = -_loc3_; + _loc5_.z = this.attenuationEnd; + _loc5_ = _loc5_.next; + _loc5_.x = -_loc3_; + _loc5_.y = _loc3_; + _loc5_.z = this.attenuationEnd; + _loc5_ = _loc5_.next; + _loc5_.x = _loc3_; + _loc5_.y = _loc3_; + _loc5_.z = this.attenuationEnd; + _loc5_ = boundVertexList; + while(_loc5_ != null) + { + _loc5_.cameraX = param2.ma * _loc5_.x + param2.mb * _loc5_.y + param2.mc * _loc5_.z + param2.md; + _loc5_.cameraY = param2.me * _loc5_.x + param2.mf * _loc5_.y + param2.mg * _loc5_.z + param2.mh; + _loc5_.cameraZ = param2.mi * _loc5_.x + param2.mj * _loc5_.y + param2.mk * _loc5_.z + param2.ml; + if(_loc5_.cameraX < param1.boundMinX) + { + param1.boundMinX = _loc5_.cameraX; + } + if(_loc5_.cameraX > param1.boundMaxX) + { + param1.boundMaxX = _loc5_.cameraX; + } + if(_loc5_.cameraY < param1.boundMinY) + { + param1.boundMinY = _loc5_.cameraY; + } + if(_loc5_.cameraY > param1.boundMaxY) + { + param1.boundMaxY = _loc5_.cameraY; + } + if(_loc5_.cameraZ < param1.boundMinZ) + { + param1.boundMinZ = _loc5_.cameraZ; + } + if(_loc5_.cameraZ > param1.boundMaxZ) + { + param1.boundMaxZ = _loc5_.cameraZ; + } + _loc5_ = _loc5_.next; + } + } + else + { + if(-_loc3_ < param1.boundMinX) + { + param1.boundMinX = -_loc3_; + } + if(_loc3_ > param1.boundMaxX) + { + param1.boundMaxX = _loc3_; + } + if(-_loc3_ < param1.boundMinY) + { + param1.boundMinY = -_loc3_; + } + if(_loc3_ > param1.boundMaxY) + { + param1.boundMaxY = _loc3_; + } + if(_loc4_ < param1.boundMinZ) + { + param1.boundMinZ = _loc4_; + } + if(this.attenuationEnd > param1.boundMaxZ) + { + param1.boundMaxZ = this.attenuationEnd; + } + } + } + } +} diff --git a/src/alternativa/engine3d/lights/TubeLight.as b/src/alternativa/engine3d/lights/TubeLight.as new file mode 100644 index 0000000..6d65eb4 --- /dev/null +++ b/src/alternativa/engine3d/lights/TubeLight.as @@ -0,0 +1,364 @@ +package alternativa.engine3d.lights +{ + import alternativa.engine3d.alternativa3d; + import alternativa.engine3d.core.Camera3D; + import alternativa.engine3d.core.Debug; + import alternativa.engine3d.core.Light3D; + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.core.Vertex; + import flash.display.Sprite; + use namespace alternativa3d; + public class TubeLight extends Light3D + { + + + public var length:Number; + + public var attenuationBegin:Number; + + public var attenuationEnd:Number; + + public var falloff:Number; + + public function TubeLight(param1:uint, param2:Number, param3:Number, param4:Number, param5:Number) + { + super(); + this.color = param1; + this.length = param2; + this.attenuationBegin = param3; + this.attenuationEnd = param4; + this.falloff = param5; + calculateBounds(); + } + + public function lookAt(param1:Number, param2:Number, param3:Number) : void + { + var _loc4_:Number = NaN; + _loc4_ = param1 - this.x; + var _loc5_:Number = param2 - this.y; + var _loc6_:Number = param3 - this.z; + rotationX = Math.atan2(_loc6_,Math.sqrt(_loc4_ * _loc4_ + _loc5_ * _loc5_)) - Math.PI / 2; + rotationY = 0; + rotationZ = -Math.atan2(_loc4_,_loc5_); + } + + override public function clone() : Object3D + { + var _loc1_:TubeLight = new TubeLight(color,this.length,this.attenuationBegin,this.attenuationEnd,this.falloff); + _loc1_.clonePropertiesFrom(this); + return _loc1_; + } + + override alternativa3d function drawDebug(param1:Camera3D) : void + { + var _loc3_:Sprite = null; + var _loc4_:Number = NaN; + var _loc5_:Number = NaN; + var _loc6_:Number = NaN; + var _loc7_:int = 0; + var _loc8_:Number = NaN; + var _loc9_:Number = NaN; + var _loc10_:Number = NaN; + var _loc11_:Number = NaN; + var _loc12_:Number = NaN; + var _loc13_:Number = NaN; + var _loc14_:Number = NaN; + var _loc15_:Number = NaN; + var _loc16_:Number = NaN; + var _loc17_:Number = NaN; + var _loc18_:Number = NaN; + var _loc19_:Number = NaN; + var _loc20_:Number = NaN; + var _loc21_:Number = NaN; + var _loc22_:Number = NaN; + var _loc23_:Number = NaN; + var _loc24_:Number = NaN; + var _loc25_:Number = NaN; + var _loc26_:Number = NaN; + var _loc27_:Number = NaN; + var _loc28_:Number = NaN; + var _loc29_:Number = NaN; + var _loc30_:Number = NaN; + var _loc31_:Number = NaN; + var _loc32_:Number = NaN; + var _loc33_:Number = NaN; + var _loc34_:Number = NaN; + var _loc35_:Number = NaN; + var _loc36_:Number = NaN; + var _loc37_:Number = NaN; + var _loc38_:Number = NaN; + var _loc39_:Number = NaN; + var _loc40_:Number = NaN; + var _loc41_:Number = NaN; + var _loc42_:Number = NaN; + var _loc43_:Number = NaN; + var _loc44_:Number = NaN; + var _loc45_:Number = NaN; + var _loc46_:Number = NaN; + var _loc47_:Number = NaN; + var _loc48_:Number = NaN; + var _loc49_:Number = NaN; + var _loc50_:Number = NaN; + var _loc51_:Number = NaN; + var _loc52_:Number = NaN; + var _loc53_:Number = NaN; + var _loc54_:Number = NaN; + var _loc55_:Number = NaN; + var _loc2_:int = param1.checkInDebug(this); + if(_loc2_ > 0) + { + _loc3_ = param1.view.canvas; + if(_loc2_ & Debug.LIGHTS && ml > param1.nearClipping) + { + _loc4_ = (color >> 16 & 255) * intensity; + _loc5_ = (color >> 8 & 255) * intensity; + _loc6_ = (color & 255) * intensity; + _loc7_ = ((_loc4_ > 255?255:_loc4_) << 16) + ((_loc5_ > 255?255:_loc5_) << 8) + (_loc6_ > 255?255:_loc6_); + _loc8_ = md + ma * this.attenuationBegin; + _loc9_ = mh + me * this.attenuationBegin; + _loc10_ = ml + mi * this.attenuationBegin; + _loc11_ = md + (ma * this.attenuationBegin + mb * this.attenuationBegin) * 0.9; + _loc12_ = mh + (me * this.attenuationBegin + mf * this.attenuationBegin) * 0.9; + _loc13_ = ml + (mi * this.attenuationBegin + mj * this.attenuationBegin) * 0.9; + _loc14_ = md + mb * this.attenuationBegin; + _loc15_ = mh + mf * this.attenuationBegin; + _loc16_ = ml + mj * this.attenuationBegin; + _loc17_ = md - (ma * this.attenuationBegin - mb * this.attenuationBegin) * 0.9; + _loc18_ = mh - (me * this.attenuationBegin - mf * this.attenuationBegin) * 0.9; + _loc19_ = ml - (mi * this.attenuationBegin - mj * this.attenuationBegin) * 0.9; + _loc20_ = md - ma * this.attenuationBegin; + _loc21_ = mh - me * this.attenuationBegin; + _loc22_ = ml - mi * this.attenuationBegin; + _loc23_ = md - (ma * this.attenuationBegin + mb * this.attenuationBegin) * 0.9; + _loc24_ = mh - (me * this.attenuationBegin + mf * this.attenuationBegin) * 0.9; + _loc25_ = ml - (mi * this.attenuationBegin + mj * this.attenuationBegin) * 0.9; + _loc26_ = md - mb * this.attenuationBegin; + _loc27_ = mh - mf * this.attenuationBegin; + _loc28_ = ml - mj * this.attenuationBegin; + _loc29_ = md + (ma * this.attenuationBegin - mb * this.attenuationBegin) * 0.9; + _loc30_ = mh + (me * this.attenuationBegin - mf * this.attenuationBegin) * 0.9; + _loc31_ = ml + (mi * this.attenuationBegin - mj * this.attenuationBegin) * 0.9; + _loc32_ = md + mc * this.length + ma * this.attenuationBegin; + _loc33_ = mh + mg * this.length + me * this.attenuationBegin; + _loc34_ = ml + mk * this.length + mi * this.attenuationBegin; + _loc35_ = md + mc * this.length + (ma * this.attenuationBegin + mb * this.attenuationBegin) * 0.9; + _loc36_ = mh + mg * this.length + (me * this.attenuationBegin + mf * this.attenuationBegin) * 0.9; + _loc37_ = ml + mk * this.length + (mi * this.attenuationBegin + mj * this.attenuationBegin) * 0.9; + _loc38_ = md + mc * this.length + mb * this.attenuationBegin; + _loc39_ = mh + mg * this.length + mf * this.attenuationBegin; + _loc40_ = ml + mk * this.length + mj * this.attenuationBegin; + _loc41_ = md + mc * this.length - (ma * this.attenuationBegin - mb * this.attenuationBegin) * 0.9; + _loc42_ = mh + mg * this.length - (me * this.attenuationBegin - mf * this.attenuationBegin) * 0.9; + _loc43_ = ml + mk * this.length - (mi * this.attenuationBegin - mj * this.attenuationBegin) * 0.9; + _loc44_ = md + mc * this.length - ma * this.attenuationBegin; + _loc45_ = mh + mg * this.length - me * this.attenuationBegin; + _loc46_ = ml + mk * this.length - mi * this.attenuationBegin; + _loc47_ = md + mc * this.length - (ma * this.attenuationBegin + mb * this.attenuationBegin) * 0.9; + _loc48_ = mh + mg * this.length - (me * this.attenuationBegin + mf * this.attenuationBegin) * 0.9; + _loc49_ = ml + mk * this.length - (mi * this.attenuationBegin + mj * this.attenuationBegin) * 0.9; + _loc50_ = md + mc * this.length - mb * this.attenuationBegin; + _loc51_ = mh + mg * this.length - mf * this.attenuationBegin; + _loc52_ = ml + mk * this.length - mj * this.attenuationBegin; + _loc53_ = md + mc * this.length + (ma * this.attenuationBegin - mb * this.attenuationBegin) * 0.9; + _loc54_ = mh + mg * this.length + (me * this.attenuationBegin - mf * this.attenuationBegin) * 0.9; + _loc55_ = ml + mk * this.length + (mi * this.attenuationBegin - mj * this.attenuationBegin) * 0.9; + if(_loc10_ > param1.nearClipping && _loc13_ > param1.nearClipping && _loc16_ > param1.nearClipping && _loc19_ > param1.nearClipping && _loc22_ > param1.nearClipping && _loc25_ > param1.nearClipping && _loc28_ > param1.nearClipping && _loc31_ > param1.nearClipping && _loc34_ > param1.nearClipping && _loc37_ > param1.nearClipping && _loc40_ > param1.nearClipping && _loc43_ > param1.nearClipping && _loc46_ > param1.nearClipping && _loc49_ > param1.nearClipping && _loc52_ > param1.nearClipping && _loc55_ > param1.nearClipping) + { + _loc3_.graphics.lineStyle(1,_loc7_); + _loc3_.graphics.moveTo(_loc8_ * param1.viewSizeX / _loc10_,_loc9_ * param1.viewSizeY / _loc10_); + _loc3_.graphics.curveTo(_loc11_ * param1.viewSizeX / _loc13_,_loc12_ * param1.viewSizeY / _loc13_,_loc14_ * param1.viewSizeX / _loc16_,_loc15_ * param1.viewSizeY / _loc16_); + _loc3_.graphics.curveTo(_loc17_ * param1.viewSizeX / _loc19_,_loc18_ * param1.viewSizeY / _loc19_,_loc20_ * param1.viewSizeX / _loc22_,_loc21_ * param1.viewSizeY / _loc22_); + _loc3_.graphics.curveTo(_loc23_ * param1.viewSizeX / _loc25_,_loc24_ * param1.viewSizeY / _loc25_,_loc26_ * param1.viewSizeX / _loc28_,_loc27_ * param1.viewSizeY / _loc28_); + _loc3_.graphics.curveTo(_loc29_ * param1.viewSizeX / _loc31_,_loc30_ * param1.viewSizeY / _loc31_,_loc8_ * param1.viewSizeX / _loc10_,_loc9_ * param1.viewSizeY / _loc10_); + _loc3_.graphics.moveTo(_loc32_ * param1.viewSizeX / _loc34_,_loc33_ * param1.viewSizeY / _loc34_); + _loc3_.graphics.curveTo(_loc35_ * param1.viewSizeX / _loc37_,_loc36_ * param1.viewSizeY / _loc37_,_loc38_ * param1.viewSizeX / _loc40_,_loc39_ * param1.viewSizeY / _loc40_); + _loc3_.graphics.curveTo(_loc41_ * param1.viewSizeX / _loc43_,_loc42_ * param1.viewSizeY / _loc43_,_loc44_ * param1.viewSizeX / _loc46_,_loc45_ * param1.viewSizeY / _loc46_); + _loc3_.graphics.curveTo(_loc47_ * param1.viewSizeX / _loc49_,_loc48_ * param1.viewSizeY / _loc49_,_loc50_ * param1.viewSizeX / _loc52_,_loc51_ * param1.viewSizeY / _loc52_); + _loc3_.graphics.curveTo(_loc53_ * param1.viewSizeX / _loc55_,_loc54_ * param1.viewSizeY / _loc55_,_loc32_ * param1.viewSizeX / _loc34_,_loc33_ * param1.viewSizeY / _loc34_); + _loc3_.graphics.moveTo(_loc8_ * param1.viewSizeX / _loc10_,_loc9_ * param1.viewSizeY / _loc10_); + _loc3_.graphics.lineTo(_loc32_ * param1.viewSizeX / _loc34_,_loc33_ * param1.viewSizeY / _loc34_); + _loc3_.graphics.moveTo(_loc14_ * param1.viewSizeX / _loc16_,_loc15_ * param1.viewSizeY / _loc16_); + _loc3_.graphics.lineTo(_loc38_ * param1.viewSizeX / _loc40_,_loc39_ * param1.viewSizeY / _loc40_); + _loc3_.graphics.moveTo(_loc20_ * param1.viewSizeX / _loc22_,_loc21_ * param1.viewSizeY / _loc22_); + _loc3_.graphics.lineTo(_loc44_ * param1.viewSizeX / _loc46_,_loc45_ * param1.viewSizeY / _loc46_); + _loc3_.graphics.moveTo(_loc26_ * param1.viewSizeX / _loc28_,_loc27_ * param1.viewSizeY / _loc28_); + _loc3_.graphics.lineTo(_loc50_ * param1.viewSizeX / _loc52_,_loc51_ * param1.viewSizeY / _loc52_); + } + _loc8_ = md - mc * this.falloff + ma * this.attenuationEnd; + _loc9_ = mh - mg * this.falloff + me * this.attenuationEnd; + _loc10_ = ml - mk * this.falloff + mi * this.attenuationEnd; + _loc11_ = md - mc * this.falloff + (ma * this.attenuationEnd + mb * this.attenuationEnd) * 0.9; + _loc12_ = mh - mg * this.falloff + (me * this.attenuationEnd + mf * this.attenuationEnd) * 0.9; + _loc13_ = ml - mk * this.falloff + (mi * this.attenuationEnd + mj * this.attenuationEnd) * 0.9; + _loc14_ = md - mc * this.falloff + mb * this.attenuationEnd; + _loc15_ = mh - mg * this.falloff + mf * this.attenuationEnd; + _loc16_ = ml - mk * this.falloff + mj * this.attenuationEnd; + _loc17_ = md - mc * this.falloff - (ma * this.attenuationEnd - mb * this.attenuationEnd) * 0.9; + _loc18_ = mh - mg * this.falloff - (me * this.attenuationEnd - mf * this.attenuationEnd) * 0.9; + _loc19_ = ml - mk * this.falloff - (mi * this.attenuationEnd - mj * this.attenuationEnd) * 0.9; + _loc20_ = md - mc * this.falloff - ma * this.attenuationEnd; + _loc21_ = mh - mg * this.falloff - me * this.attenuationEnd; + _loc22_ = ml - mk * this.falloff - mi * this.attenuationEnd; + _loc23_ = md - mc * this.falloff - (ma * this.attenuationEnd + mb * this.attenuationEnd) * 0.9; + _loc24_ = mh - mg * this.falloff - (me * this.attenuationEnd + mf * this.attenuationEnd) * 0.9; + _loc25_ = ml - mk * this.falloff - (mi * this.attenuationEnd + mj * this.attenuationEnd) * 0.9; + _loc26_ = md - mc * this.falloff - mb * this.attenuationEnd; + _loc27_ = mh - mg * this.falloff - mf * this.attenuationEnd; + _loc28_ = ml - mk * this.falloff - mj * this.attenuationEnd; + _loc29_ = md - mc * this.falloff + (ma * this.attenuationEnd - mb * this.attenuationEnd) * 0.9; + _loc30_ = mh - mg * this.falloff + (me * this.attenuationEnd - mf * this.attenuationEnd) * 0.9; + _loc31_ = ml - mk * this.falloff + (mi * this.attenuationEnd - mj * this.attenuationEnd) * 0.9; + _loc32_ = md + mc * (this.length + this.falloff) + ma * this.attenuationEnd; + _loc33_ = mh + mg * (this.length + this.falloff) + me * this.attenuationEnd; + _loc34_ = ml + mk * (this.length + this.falloff) + mi * this.attenuationEnd; + _loc35_ = md + mc * (this.length + this.falloff) + (ma * this.attenuationEnd + mb * this.attenuationEnd) * 0.9; + _loc36_ = mh + mg * (this.length + this.falloff) + (me * this.attenuationEnd + mf * this.attenuationEnd) * 0.9; + _loc37_ = ml + mk * (this.length + this.falloff) + (mi * this.attenuationEnd + mj * this.attenuationEnd) * 0.9; + _loc38_ = md + mc * (this.length + this.falloff) + mb * this.attenuationEnd; + _loc39_ = mh + mg * (this.length + this.falloff) + mf * this.attenuationEnd; + _loc40_ = ml + mk * (this.length + this.falloff) + mj * this.attenuationEnd; + _loc41_ = md + mc * (this.length + this.falloff) - (ma * this.attenuationEnd - mb * this.attenuationEnd) * 0.9; + _loc42_ = mh + mg * (this.length + this.falloff) - (me * this.attenuationEnd - mf * this.attenuationEnd) * 0.9; + _loc43_ = ml + mk * (this.length + this.falloff) - (mi * this.attenuationEnd - mj * this.attenuationEnd) * 0.9; + _loc44_ = md + mc * (this.length + this.falloff) - ma * this.attenuationEnd; + _loc45_ = mh + mg * (this.length + this.falloff) - me * this.attenuationEnd; + _loc46_ = ml + mk * (this.length + this.falloff) - mi * this.attenuationEnd; + _loc47_ = md + mc * (this.length + this.falloff) - (ma * this.attenuationEnd + mb * this.attenuationEnd) * 0.9; + _loc48_ = mh + mg * (this.length + this.falloff) - (me * this.attenuationEnd + mf * this.attenuationEnd) * 0.9; + _loc49_ = ml + mk * (this.length + this.falloff) - (mi * this.attenuationEnd + mj * this.attenuationEnd) * 0.9; + _loc50_ = md + mc * (this.length + this.falloff) - mb * this.attenuationEnd; + _loc51_ = mh + mg * (this.length + this.falloff) - mf * this.attenuationEnd; + _loc52_ = ml + mk * (this.length + this.falloff) - mj * this.attenuationEnd; + _loc53_ = md + mc * (this.length + this.falloff) + (ma * this.attenuationEnd - mb * this.attenuationEnd) * 0.9; + _loc54_ = mh + mg * (this.length + this.falloff) + (me * this.attenuationEnd - mf * this.attenuationEnd) * 0.9; + _loc55_ = ml + mk * (this.length + this.falloff) + (mi * this.attenuationEnd - mj * this.attenuationEnd) * 0.9; + if(_loc10_ > param1.nearClipping && _loc13_ > param1.nearClipping && _loc16_ > param1.nearClipping && _loc19_ > param1.nearClipping && _loc22_ > param1.nearClipping && _loc25_ > param1.nearClipping && _loc28_ > param1.nearClipping && _loc31_ > param1.nearClipping && _loc34_ > param1.nearClipping && _loc37_ > param1.nearClipping && _loc40_ > param1.nearClipping && _loc43_ > param1.nearClipping && _loc46_ > param1.nearClipping && _loc49_ > param1.nearClipping && _loc52_ > param1.nearClipping && _loc55_ > param1.nearClipping) + { + _loc3_.graphics.lineStyle(1,_loc7_); + _loc3_.graphics.moveTo(_loc8_ * param1.viewSizeX / _loc10_,_loc9_ * param1.viewSizeY / _loc10_); + _loc3_.graphics.curveTo(_loc11_ * param1.viewSizeX / _loc13_,_loc12_ * param1.viewSizeY / _loc13_,_loc14_ * param1.viewSizeX / _loc16_,_loc15_ * param1.viewSizeY / _loc16_); + _loc3_.graphics.curveTo(_loc17_ * param1.viewSizeX / _loc19_,_loc18_ * param1.viewSizeY / _loc19_,_loc20_ * param1.viewSizeX / _loc22_,_loc21_ * param1.viewSizeY / _loc22_); + _loc3_.graphics.curveTo(_loc23_ * param1.viewSizeX / _loc25_,_loc24_ * param1.viewSizeY / _loc25_,_loc26_ * param1.viewSizeX / _loc28_,_loc27_ * param1.viewSizeY / _loc28_); + _loc3_.graphics.curveTo(_loc29_ * param1.viewSizeX / _loc31_,_loc30_ * param1.viewSizeY / _loc31_,_loc8_ * param1.viewSizeX / _loc10_,_loc9_ * param1.viewSizeY / _loc10_); + _loc3_.graphics.moveTo(_loc32_ * param1.viewSizeX / _loc34_,_loc33_ * param1.viewSizeY / _loc34_); + _loc3_.graphics.curveTo(_loc35_ * param1.viewSizeX / _loc37_,_loc36_ * param1.viewSizeY / _loc37_,_loc38_ * param1.viewSizeX / _loc40_,_loc39_ * param1.viewSizeY / _loc40_); + _loc3_.graphics.curveTo(_loc41_ * param1.viewSizeX / _loc43_,_loc42_ * param1.viewSizeY / _loc43_,_loc44_ * param1.viewSizeX / _loc46_,_loc45_ * param1.viewSizeY / _loc46_); + _loc3_.graphics.curveTo(_loc47_ * param1.viewSizeX / _loc49_,_loc48_ * param1.viewSizeY / _loc49_,_loc50_ * param1.viewSizeX / _loc52_,_loc51_ * param1.viewSizeY / _loc52_); + _loc3_.graphics.curveTo(_loc53_ * param1.viewSizeX / _loc55_,_loc54_ * param1.viewSizeY / _loc55_,_loc32_ * param1.viewSizeX / _loc34_,_loc33_ * param1.viewSizeY / _loc34_); + _loc3_.graphics.moveTo(_loc8_ * param1.viewSizeX / _loc10_,_loc9_ * param1.viewSizeY / _loc10_); + _loc3_.graphics.lineTo(_loc32_ * param1.viewSizeX / _loc34_,_loc33_ * param1.viewSizeY / _loc34_); + _loc3_.graphics.moveTo(_loc14_ * param1.viewSizeX / _loc16_,_loc15_ * param1.viewSizeY / _loc16_); + _loc3_.graphics.lineTo(_loc38_ * param1.viewSizeX / _loc40_,_loc39_ * param1.viewSizeY / _loc40_); + _loc3_.graphics.moveTo(_loc20_ * param1.viewSizeX / _loc22_,_loc21_ * param1.viewSizeY / _loc22_); + _loc3_.graphics.lineTo(_loc44_ * param1.viewSizeX / _loc46_,_loc45_ * param1.viewSizeY / _loc46_); + _loc3_.graphics.moveTo(_loc26_ * param1.viewSizeX / _loc28_,_loc27_ * param1.viewSizeY / _loc28_); + _loc3_.graphics.lineTo(_loc50_ * param1.viewSizeX / _loc52_,_loc51_ * param1.viewSizeY / _loc52_); + } + } + if(_loc2_ & Debug.BOUNDS) + { + Debug.drawBounds(param1,this,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ,10092288); + } + } + } + + override alternativa3d function updateBounds(param1:Object3D, param2:Object3D = null) : void + { + var _loc3_:Vertex = null; + if(param2 != null) + { + _loc3_ = boundVertexList; + _loc3_.x = -this.attenuationEnd; + _loc3_.y = -this.attenuationEnd; + _loc3_.z = -this.falloff; + _loc3_ = _loc3_.next; + _loc3_.x = this.attenuationEnd; + _loc3_.y = -this.attenuationEnd; + _loc3_.z = -this.falloff; + _loc3_ = _loc3_.next; + _loc3_.x = -this.attenuationEnd; + _loc3_.y = this.attenuationEnd; + _loc3_.z = -this.falloff; + _loc3_ = _loc3_.next; + _loc3_.x = this.attenuationEnd; + _loc3_.y = this.attenuationEnd; + _loc3_.z = -this.falloff; + _loc3_ = _loc3_.next; + _loc3_.x = -this.attenuationEnd; + _loc3_.y = -this.attenuationEnd; + _loc3_.z = this.length + this.falloff; + _loc3_ = _loc3_.next; + _loc3_.x = this.attenuationEnd; + _loc3_.y = -this.attenuationEnd; + _loc3_.z = this.length + this.falloff; + _loc3_ = _loc3_.next; + _loc3_.x = -this.attenuationEnd; + _loc3_.y = this.attenuationEnd; + _loc3_.z = this.length + this.falloff; + _loc3_ = _loc3_.next; + _loc3_.x = this.attenuationEnd; + _loc3_.y = this.attenuationEnd; + _loc3_.z = this.length + this.falloff; + _loc3_ = boundVertexList; + while(_loc3_ != null) + { + _loc3_.cameraX = param2.ma * _loc3_.x + param2.mb * _loc3_.y + param2.mc * _loc3_.z + param2.md; + _loc3_.cameraY = param2.me * _loc3_.x + param2.mf * _loc3_.y + param2.mg * _loc3_.z + param2.mh; + _loc3_.cameraZ = param2.mi * _loc3_.x + param2.mj * _loc3_.y + param2.mk * _loc3_.z + param2.ml; + if(_loc3_.cameraX < param1.boundMinX) + { + param1.boundMinX = _loc3_.cameraX; + } + if(_loc3_.cameraX > param1.boundMaxX) + { + param1.boundMaxX = _loc3_.cameraX; + } + if(_loc3_.cameraY < param1.boundMinY) + { + param1.boundMinY = _loc3_.cameraY; + } + if(_loc3_.cameraY > param1.boundMaxY) + { + param1.boundMaxY = _loc3_.cameraY; + } + if(_loc3_.cameraZ < param1.boundMinZ) + { + param1.boundMinZ = _loc3_.cameraZ; + } + if(_loc3_.cameraZ > param1.boundMaxZ) + { + param1.boundMaxZ = _loc3_.cameraZ; + } + _loc3_ = _loc3_.next; + } + } + else + { + if(-this.attenuationEnd < param1.boundMinX) + { + param1.boundMinX = -this.attenuationEnd; + } + if(this.attenuationEnd > param1.boundMaxX) + { + param1.boundMaxX = this.attenuationEnd; + } + if(-this.attenuationEnd < param1.boundMinY) + { + param1.boundMinY = -this.attenuationEnd; + } + if(this.attenuationEnd > param1.boundMaxY) + { + param1.boundMaxY = this.attenuationEnd; + } + if(-this.falloff < param1.boundMinZ) + { + param1.boundMinZ = -this.falloff; + } + if(this.length + this.falloff > param1.boundMaxZ) + { + param1.boundMaxZ = this.length + this.falloff; + } + } + } + } +} diff --git a/src/alternativa/engine3d/loaders/MaterialLoader.as b/src/alternativa/engine3d/loaders/MaterialLoader.as new file mode 100644 index 0000000..1955fc9 --- /dev/null +++ b/src/alternativa/engine3d/loaders/MaterialLoader.as @@ -0,0 +1,264 @@ +package alternativa.engine3d.loaders +{ + import alternativa.engine3d.loaders.events.LoaderErrorEvent; + import alternativa.engine3d.loaders.events.LoaderEvent; + import alternativa.engine3d.loaders.events.LoaderProgressEvent; + import alternativa.engine3d.materials.TextureMaterial; + import flash.display.Bitmap; + import flash.display.BitmapData; + import flash.display.BitmapDataChannel; + import flash.display.BlendMode; + import flash.display.Loader; + import flash.events.ErrorEvent; + import flash.events.Event; + import flash.events.EventDispatcher; + import flash.events.IOErrorEvent; + import flash.events.ProgressEvent; + import flash.events.SecurityErrorEvent; + import flash.geom.Matrix; + import flash.geom.Point; + import flash.net.URLRequest; + import flash.system.LoaderContext; + + [Event(name="loaderError",type="alternativa.engine3d.loaders.events.LoaderErrorEvent")] + [Event(name="complete",type="flash.events.Event")] + [Event(name="partComplete",type="alternativa.engine3d.loaders.events.LoaderEvent")] + [Event(name="partOpen",type="alternativa.engine3d.loaders.events.LoaderEvent")] + public class MaterialLoader extends EventDispatcher + { + + private static var stub:BitmapData; + + + private var loader:Loader; + + private var context:LoaderContext; + + private var materials:Vector.; + + private var urls:Vector.; + + private var filesTotal:int; + + private var filesLoaded:int; + + private var diffuse:BitmapData; + + private var currentURL:String; + + private var index:int; + + public function MaterialLoader() + { + super(); + } + + public function load(param1:Vector., param2:LoaderContext = null) : void + { + var _loc5_:TextureMaterial = null; + this.context = param2; + this.materials = param1; + this.urls = new Vector.(); + var _loc3_:int = 0; + var _loc4_:int = 0; + while(_loc3_ < param1.length) + { + _loc5_ = param1[_loc3_]; + var _loc6_:* = _loc4_++; + this.urls[_loc6_] = _loc5_.diffuseMapURL; + ++this.filesTotal; + if(_loc5_.opacityMapURL != null) + { + var _loc7_:* = _loc4_++; + this.urls[_loc7_] = _loc5_.opacityMapURL; + ++this.filesTotal; + } + else + { + _loc7_ = _loc4_++; + this.urls[_loc7_] = null; + } + _loc3_++; + } + this.filesLoaded = 0; + this.index = -1; + this.loadNext(null); + } + + public function close() : void + { + this.destroyLoader(); + this.materials = null; + this.urls = null; + this.diffuse = null; + this.currentURL = null; + this.context = null; + } + + private function destroyLoader() : void + { + if(this.loader != null) + { + this.loader.unload(); + this.loader.contentLoaderInfo.removeEventListener(Event.OPEN,this.onPartOpen); + this.loader.contentLoaderInfo.removeEventListener(Event.COMPLETE,this.loadNext); + this.loader.contentLoaderInfo.removeEventListener(ProgressEvent.PROGRESS,this.onFileProgress); + this.loader.contentLoaderInfo.removeEventListener(IOErrorEvent.DISK_ERROR,this.loadNext); + this.loader.contentLoaderInfo.removeEventListener(IOErrorEvent.IO_ERROR,this.loadNext); + this.loader.contentLoaderInfo.removeEventListener(IOErrorEvent.NETWORK_ERROR,this.loadNext); + this.loader.contentLoaderInfo.removeEventListener(IOErrorEvent.VERIFY_ERROR,this.loadNext); + this.loader.contentLoaderInfo.removeEventListener(SecurityErrorEvent.SECURITY_ERROR,this.loadNext); + this.loader = null; + } + } + + private function loadNext(param1:Event) : void + { + var _loc2_:TextureMaterial = null; + if(this.index >= 0) + { + if(this.index % 2 == 0) + { + if(param1 is ErrorEvent) + { + this.diffuse = this.getStub(); + this.onFileError((param1 as ErrorEvent).text); + } + else + { + this.diffuse = (this.loader.content as Bitmap).bitmapData; + } + ++this.filesLoaded; + } + else + { + _loc2_ = this.materials[this.index - 1 >> 1]; + if(param1 == null) + { + _loc2_.texture = this.diffuse; + } + else + { + if(param1 is ErrorEvent) + { + _loc2_.texture = this.diffuse; + this.onFileError((param1 as ErrorEvent).text); + } + else + { + _loc2_.texture = this.merge(this.diffuse,(this.loader.content as Bitmap).bitmapData); + } + ++this.filesLoaded; + } + this.onPartComplete(this.index - 1 >> 1,_loc2_); + this.diffuse = null; + } + this.destroyLoader(); + } + if(++this.index >= this.urls.length) + { + this.close(); + if(hasEventListener(Event.COMPLETE)) + { + dispatchEvent(new Event(Event.COMPLETE)); + } + } + else + { + this.currentURL = this.urls[this.index]; + if(this.currentURL != null && (this.diffuse == null || this.diffuse != stub)) + { + this.loader = new Loader(); + if(this.index % 2 == 0) + { + this.loader.contentLoaderInfo.addEventListener(Event.OPEN,this.onPartOpen); + } + this.loader.contentLoaderInfo.addEventListener(Event.COMPLETE,this.loadNext); + this.loader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS,this.onFileProgress); + this.loader.contentLoaderInfo.addEventListener(IOErrorEvent.DISK_ERROR,this.loadNext); + this.loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,this.loadNext); + this.loader.contentLoaderInfo.addEventListener(IOErrorEvent.NETWORK_ERROR,this.loadNext); + this.loader.contentLoaderInfo.addEventListener(IOErrorEvent.VERIFY_ERROR,this.loadNext); + this.loader.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR,this.loadNext); + this.loader.load(new URLRequest(this.currentURL),this.context); + } + else + { + this.loadNext(null); + } + } + } + + private function onPartOpen(param1:Event) : void + { + if(hasEventListener(LoaderEvent.PART_OPEN)) + { + dispatchEvent(new LoaderEvent(LoaderEvent.PART_OPEN,this.urls.length >> 1,this.index >> 1,this.materials[this.index >> 1])); + } + } + + private function onPartComplete(param1:int, param2:TextureMaterial) : void + { + if(hasEventListener(LoaderEvent.PART_COMPLETE)) + { + dispatchEvent(new LoaderEvent(LoaderEvent.PART_COMPLETE,this.urls.length >> 1,param1,param2)); + } + } + + private function onFileProgress(param1:ProgressEvent) : void + { + if(hasEventListener(LoaderProgressEvent.LOADER_PROGRESS)) + { + dispatchEvent(new LoaderProgressEvent(LoaderProgressEvent.LOADER_PROGRESS,this.filesTotal,this.filesLoaded,(this.filesLoaded + param1.bytesLoaded / param1.bytesTotal) / this.filesTotal,param1.bytesLoaded,param1.bytesTotal)); + } + } + + private function onFileError(param1:String) : void + { + dispatchEvent(new LoaderErrorEvent(LoaderErrorEvent.LOADER_ERROR,this.currentURL,param1)); + } + + private function merge(param1:BitmapData, param2:BitmapData) : BitmapData + { + var _loc3_:BitmapData = new BitmapData(param1.width,param1.height); + _loc3_.copyPixels(param1,param1.rect,new Point()); + if(param1.width != param2.width || param1.height != param2.height) + { + param1.draw(param2,new Matrix(param1.width / param2.width,0,0,param1.height / param2.height),null,BlendMode.NORMAL,null,true); + param2.dispose(); + param2 = param1; + } + else + { + param1.dispose(); + } + _loc3_.copyChannel(param2,param2.rect,new Point(),BitmapDataChannel.RED,BitmapDataChannel.ALPHA); + param2.dispose(); + return _loc3_; + } + + private function getStub() : BitmapData + { + var _loc1_:uint = 0; + var _loc2_:uint = 0; + var _loc3_:uint = 0; + if(stub == null) + { + _loc1_ = 32; + stub = new BitmapData(_loc1_,_loc1_,false,0); + _loc2_ = 0; + while(_loc2_ < _loc1_) + { + _loc3_ = 0; + while(_loc3_ < _loc1_) + { + stub.setPixel(Boolean(_loc2_ % 2)?int(_loc3_):int(_loc3_ + 1),_loc2_,16711935); + _loc3_ = _loc3_ + 2; + } + _loc2_++; + } + } + return stub; + } + } +} diff --git a/src/alternativa/engine3d/loaders/Parser3DS.as b/src/alternativa/engine3d/loaders/Parser3DS.as new file mode 100644 index 0000000..a2a9835 --- /dev/null +++ b/src/alternativa/engine3d/loaders/Parser3DS.as @@ -0,0 +1,1031 @@ +package alternativa.engine3d.loaders +{ + import alternativa.engine3d.alternativa3d; + import alternativa.engine3d.core.Face; + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.core.Vertex; + import alternativa.engine3d.core.Wrapper; + import alternativa.engine3d.materials.FillMaterial; + import alternativa.engine3d.materials.Material; + import alternativa.engine3d.materials.TextureMaterial; + import alternativa.engine3d.objects.Mesh; + import flash.geom.Matrix; + import flash.geom.Vector3D; + import flash.utils.ByteArray; + import flash.utils.Endian; + + use namespace alternativa3d; + + public class Parser3DS + { + + private static const CHUNK_MAIN:int = 19789; + + private static const CHUNK_VERSION:int = 2; + + private static const CHUNK_SCENE:int = 15677; + + private static const CHUNK_ANIMATION:int = 45056; + + private static const CHUNK_OBJECT:int = 16384; + + private static const CHUNK_TRIMESH:int = 16640; + + private static const CHUNK_VERTICES:int = 16656; + + private static const CHUNK_FACES:int = 16672; + + private static const CHUNK_FACESMATERIAL:int = 16688; + + private static const CHUNK_FACESSMOOTH:int = 16720; + + private static const CHUNK_MAPPINGCOORDS:int = 16704; + + private static const CHUNK_TRANSFORMATION:int = 16736; + + private static const CHUNK_MATERIAL:int = 45055; + + + private var data:ByteArray; + + private var objectDatas:Object; + + private var animationDatas:Array; + + private var materialDatas:Object; + + public var objects:Vector.; + + public var parents:Vector.; + + public var materials:Vector.; + + public var textureMaterials:Vector.; + + public function Parser3DS() + { + super(); + } + + public function getObjectByName(param1:String) : Object3D + { + var _loc2_:Object3D = null; + for each(_loc2_ in this.objects) + { + if(_loc2_.name == param1) + { + return _loc2_; + } + } + return null; + } + + public function parse(param1:ByteArray, param2:String = "", param3:Number = 1) : void + { + if(param1.bytesAvailable < 6) + { + return; + } + this.data = param1; + param1.endian = Endian.LITTLE_ENDIAN; + this.parse3DSChunk(param1.position,param1.bytesAvailable); + this.objects = new Vector.(); + this.parents = new Vector.(); + this.materials = new Vector.(); + this.textureMaterials = new Vector.(); + this.buildContent(param2,param3); + param1 = null; + this.objectDatas = null; + this.animationDatas = null; + this.materialDatas = null; + } + + private function readChunkInfo(param1:int) : ChunkInfo + { + this.data.position = param1; + var _loc2_:ChunkInfo = new ChunkInfo(); + _loc2_.id = this.data.readUnsignedShort(); + _loc2_.size = this.data.readUnsignedInt(); + _loc2_.dataSize = _loc2_.size - 6; + _loc2_.dataPosition = this.data.position; + _loc2_.nextChunkPosition = param1 + _loc2_.size; + return _loc2_; + } + + private function parse3DSChunk(param1:int, param2:int) : void + { + if(param2 < 6) + { + return; + } + var _loc3_:ChunkInfo = this.readChunkInfo(param1); + this.data.position = param1; + switch(_loc3_.id) + { + case CHUNK_MAIN: + this.parseMainChunk(_loc3_.dataPosition,_loc3_.dataSize); + } + this.parse3DSChunk(_loc3_.nextChunkPosition,param2 - _loc3_.size); + } + + private function parseMainChunk(param1:int, param2:int) : void + { + if(param2 < 6) + { + return; + } + var _loc3_:ChunkInfo = this.readChunkInfo(param1); + switch(_loc3_.id) + { + case CHUNK_VERSION: + break; + case CHUNK_SCENE: + this.parse3DChunk(_loc3_.dataPosition,_loc3_.dataSize); + break; + case CHUNK_ANIMATION: + this.parseAnimationChunk(_loc3_.dataPosition,_loc3_.dataSize); + } + this.parseMainChunk(_loc3_.nextChunkPosition,param2 - _loc3_.size); + } + + private function parse3DChunk(param1:int, param2:int) : void + { + var _loc3_:ChunkInfo = null; + var _loc4_:MaterialData = null; + for(; param2 >= 6; param1 = _loc3_.nextChunkPosition,param2 = param2 - _loc3_.size) + { + _loc3_ = this.readChunkInfo(param1); + switch(_loc3_.id) + { + case CHUNK_MATERIAL: + _loc4_ = new MaterialData(); + this.parseMaterialChunk(_loc4_,_loc3_.dataPosition,_loc3_.dataSize); + continue; + case CHUNK_OBJECT: + this.parseObject(_loc3_); + continue; + default: + continue; + } + } + } + + private function parseObject(param1:ChunkInfo) : void + { + if(this.objectDatas == null) + { + this.objectDatas = new Object(); + } + var _loc2_:ObjectData = new ObjectData(); + _loc2_.name = this.getString(param1.dataPosition); + this.objectDatas[_loc2_.name] = _loc2_; + var _loc3_:int = _loc2_.name.length + 1; + this.parseObjectChunk(_loc2_,param1.dataPosition + _loc3_,param1.dataSize - _loc3_); + } + + private function parseObjectChunk(param1:ObjectData, param2:int, param3:int) : void + { + if(param3 < 6) + { + return; + } + var _loc4_:ChunkInfo = this.readChunkInfo(param2); + switch(_loc4_.id) + { + case CHUNK_TRIMESH: + this.parseMeshChunk(param1,_loc4_.dataPosition,_loc4_.dataSize); + break; + case 17920: + break; + case 18176: + } + this.parseObjectChunk(param1,_loc4_.nextChunkPosition,param3 - _loc4_.size); + } + + private function parseMeshChunk(param1:ObjectData, param2:int, param3:int) : void + { + if(param3 < 6) + { + return; + } + var _loc4_:ChunkInfo = this.readChunkInfo(param2); + switch(_loc4_.id) + { + case CHUNK_VERTICES: + this.parseVertices(param1); + break; + case CHUNK_MAPPINGCOORDS: + this.parseUVs(param1); + break; + case CHUNK_TRANSFORMATION: + this.parseMatrix(param1); + break; + case CHUNK_FACES: + this.parseFaces(param1,_loc4_); + } + this.parseMeshChunk(param1,_loc4_.nextChunkPosition,param3 - _loc4_.size); + } + + private function parseVertices(param1:ObjectData) : void + { + var _loc2_:int = this.data.readUnsignedShort(); + param1.vertices = new Vector.(); + var _loc3_:int = 0; + var _loc4_:int = 0; + while(_loc3_ < _loc2_) + { + var _loc5_:* = _loc4_++; + param1.vertices[_loc5_] = this.data.readFloat(); + var _loc6_:* = _loc4_++; + param1.vertices[_loc6_] = this.data.readFloat(); + var _loc7_:* = _loc4_++; + param1.vertices[_loc7_] = this.data.readFloat(); + _loc3_++; + } + } + + private function parseUVs(param1:ObjectData) : void + { + var _loc2_:int = this.data.readUnsignedShort(); + param1.uvs = new Vector.(); + var _loc3_:int = 0; + var _loc4_:int = 0; + while(_loc3_ < _loc2_) + { + var _loc5_:* = _loc4_++; + param1.uvs[_loc5_] = this.data.readFloat(); + var _loc6_:* = _loc4_++; + param1.uvs[_loc6_] = this.data.readFloat(); + _loc3_++; + } + } + + private function parseMatrix(param1:ObjectData) : void + { + param1.a = this.data.readFloat(); + param1.e = this.data.readFloat(); + param1.i = this.data.readFloat(); + param1.b = this.data.readFloat(); + param1.f = this.data.readFloat(); + param1.j = this.data.readFloat(); + param1.c = this.data.readFloat(); + param1.g = this.data.readFloat(); + param1.k = this.data.readFloat(); + param1.d = this.data.readFloat(); + param1.h = this.data.readFloat(); + param1.l = this.data.readFloat(); + } + + private function parseFaces(param1:ObjectData, param2:ChunkInfo) : void + { + var _loc3_:int = this.data.readUnsignedShort(); + param1.faces = new Vector.(_loc3_ * 3); + param1.smoothingGroups = new Vector.(_loc3_); + var _loc4_:int = 0; + var _loc5_:int = 0; + while(_loc4_ < _loc3_) + { + var _loc7_:* = _loc5_++; + param1.faces[_loc7_] = this.data.readUnsignedShort(); + var _loc8_:* = _loc5_++; + param1.faces[_loc8_] = this.data.readUnsignedShort(); + var _loc9_:* = _loc5_++; + param1.faces[_loc9_] = this.data.readUnsignedShort(); + this.data.position = this.data.position + 2; + _loc4_++; + } + var _loc6_:int = 2 + 8 * _loc3_; + this.parseFacesChunk(param1,param2.dataPosition + _loc6_,param2.dataSize - _loc6_); + } + + private function parseFacesChunk(param1:ObjectData, param2:int, param3:int) : void + { + if(param3 < 6) + { + return; + } + var _loc4_:ChunkInfo = this.readChunkInfo(param2); + switch(_loc4_.id) + { + case CHUNK_FACESMATERIAL: + this.parseSurface(param1); + break; + case CHUNK_FACESSMOOTH: + this.parseSmoothingGroups(param1); + } + this.parseFacesChunk(param1,_loc4_.nextChunkPosition,param3 - _loc4_.size); + } + + private function parseSurface(param1:ObjectData) : void + { + if(param1.surfaces == null) + { + param1.surfaces = new Object(); + } + var _loc2_:Vector. = new Vector.(); + param1.surfaces[this.getString(this.data.position)] = _loc2_; + var _loc3_:int = this.data.readUnsignedShort(); + var _loc4_:int = 0; + while(_loc4_ < _loc3_) + { + _loc2_[_loc4_] = this.data.readUnsignedShort(); + _loc4_++; + } + } + + private function parseSmoothingGroups(param1:ObjectData) : void + { + var _loc2_:int = param1.faces.length / 3; + var _loc3_:int = 0; + while(_loc3_ < _loc2_) + { + param1.smoothingGroups[_loc3_] = this.data.readUnsignedInt(); + _loc3_++; + } + } + + private function parseAnimationChunk(param1:int, param2:int) : void + { + var _loc3_:ChunkInfo = null; + var _loc4_:AnimationData = null; + for(; param2 >= 6; param1 = _loc3_.nextChunkPosition,param2 = param2 - _loc3_.size) + { + _loc3_ = this.readChunkInfo(param1); + switch(_loc3_.id) + { + case 45057: + case 45058: + case 45059: + case 45060: + case 45061: + case 45062: + case 45063: + if(this.animationDatas == null) + { + this.animationDatas = new Array(); + } + _loc4_ = new AnimationData(); + this.animationDatas.push(_loc4_); + this.parseObjectAnimationChunk(_loc4_,_loc3_.dataPosition,_loc3_.dataSize); + continue; + case 45064: + continue; + default: + continue; + } + } + } + + private function parseObjectAnimationChunk(param1:AnimationData, param2:int, param3:int) : void + { + if(param3 < 6) + { + return; + } + var _loc4_:ChunkInfo = this.readChunkInfo(param2); + switch(_loc4_.id) + { + case 45072: + param1.objectName = this.getString(this.data.position); + this.data.position = this.data.position + 4; + param1.parentIndex = this.data.readUnsignedShort(); + break; + case 45073: + param1.objectName = this.getString(this.data.position); + break; + case 45075: + param1.pivot = new Vector3D(this.data.readFloat(),this.data.readFloat(),this.data.readFloat()); + break; + case 45088: + this.data.position = this.data.position + 20; + param1.position = new Vector3D(this.data.readFloat(),this.data.readFloat(),this.data.readFloat()); + break; + case 45089: + this.data.position = this.data.position + 20; + param1.rotation = this.getRotationFrom3DSAngleAxis(this.data.readFloat(),this.data.readFloat(),this.data.readFloat(),this.data.readFloat()); + break; + case 45090: + this.data.position = this.data.position + 20; + param1.scale = new Vector3D(this.data.readFloat(),this.data.readFloat(),this.data.readFloat()); + } + this.parseObjectAnimationChunk(param1,_loc4_.nextChunkPosition,param3 - _loc4_.size); + } + + private function parseMaterialChunk(param1:MaterialData, param2:int, param3:int) : void + { + if(param3 < 6) + { + return; + } + var _loc4_:ChunkInfo = this.readChunkInfo(param2); + switch(_loc4_.id) + { + case 40960: + this.parseMaterialName(param1); + break; + case 40976: + break; + case 40992: + this.data.position = _loc4_.dataPosition + 6; + param1.color = (this.data.readUnsignedByte() << 16) + (this.data.readUnsignedByte() << 8) + this.data.readUnsignedByte(); + break; + case 41008: + break; + case 41024: + this.data.position = _loc4_.dataPosition + 6; + param1.glossiness = this.data.readUnsignedShort(); + break; + case 41025: + this.data.position = _loc4_.dataPosition + 6; + param1.specular = this.data.readUnsignedShort(); + break; + case 41040: + this.data.position = _loc4_.dataPosition + 6; + param1.transparency = this.data.readUnsignedShort(); + break; + case 41472: + param1.diffuseMap = new MapData(); + this.parseMapChunk(param1.name,param1.diffuseMap,_loc4_.dataPosition,_loc4_.dataSize); + break; + case 41786: + break; + case 41488: + param1.opacityMap = new MapData(); + this.parseMapChunk(param1.name,param1.opacityMap,_loc4_.dataPosition,_loc4_.dataSize); + break; + case 41520: + break; + case 41788: + break; + case 41476: + break; + case 41789: + break; + case 41504: + } + this.parseMaterialChunk(param1,_loc4_.nextChunkPosition,param3 - _loc4_.size); + } + + private function parseMaterialName(param1:MaterialData) : void + { + if(this.materialDatas == null) + { + this.materialDatas = new Object(); + } + param1.name = this.getString(this.data.position); + this.materialDatas[param1.name] = param1; + } + + private function parseMapChunk(param1:String, param2:MapData, param3:int, param4:int) : void + { + if(param4 < 6) + { + return; + } + var _loc5_:ChunkInfo = this.readChunkInfo(param3); + switch(_loc5_.id) + { + case 41728: + param2.filename = this.getString(_loc5_.dataPosition).toLowerCase(); + break; + case 41809: + break; + case 41812: + param2.scaleU = this.data.readFloat(); + break; + case 41814: + param2.scaleV = this.data.readFloat(); + break; + case 41816: + param2.offsetU = this.data.readFloat(); + break; + case 41818: + param2.offsetV = this.data.readFloat(); + break; + case 41820: + param2.rotation = this.data.readFloat(); + } + this.parseMapChunk(param1,param2,_loc5_.nextChunkPosition,param4 - _loc5_.size); + } + + private function buildContent(param1:String, param2:Number) : void + { + var _loc3_:* = null; + var _loc4_:* = null; + var _loc5_:ObjectData = null; + var _loc6_:Object3D = null; + var _loc7_:MaterialData = null; + var _loc8_:MapData = null; + var _loc9_:Matrix = null; + var _loc10_:Number = NaN; + var _loc11_:TextureMaterial = null; + var _loc12_:FillMaterial = null; + var _loc13_:int = 0; + var _loc14_:int = 0; + var _loc15_:AnimationData = null; + var _loc16_:int = 0; + var _loc17_:int = 0; + var _loc18_:AnimationData = null; + var _loc19_:ObjectData = null; + var _loc20_:String = null; + for(_loc3_ in this.materialDatas) + { + _loc7_ = this.materialDatas[_loc3_]; + _loc8_ = _loc7_.diffuseMap; + if(_loc8_ != null) + { + _loc9_ = new Matrix(); + _loc10_ = _loc8_.rotation * Math.PI / 180; + _loc9_.translate(-_loc8_.offsetU,_loc8_.offsetV); + _loc9_.translate(-0.5,-0.5); + _loc9_.rotate(-_loc10_); + _loc9_.scale(_loc8_.scaleU,_loc8_.scaleV); + _loc9_.translate(0.5,0.5); + _loc7_.matrix = _loc9_; + _loc11_ = new TextureMaterial(); + _loc11_.name = _loc3_; + _loc11_.diffuseMapURL = param1 + _loc8_.filename; + _loc11_.opacityMapURL = _loc7_.opacityMap != null?param1 + _loc7_.opacityMap.filename:null; + _loc7_.material = _loc11_; + _loc11_.name = _loc7_.name; + this.textureMaterials.push(_loc11_); + } + else + { + _loc12_ = new FillMaterial(_loc7_.color); + _loc7_.material = _loc12_; + _loc12_.name = _loc7_.name; + } + this.materials.push(_loc7_.material); + } + if(this.animationDatas != null) + { + if(this.objectDatas != null) + { + _loc14_ = this.animationDatas.length; + _loc13_ = 0; + while(_loc13_ < _loc14_) + { + _loc15_ = this.animationDatas[_loc13_]; + _loc4_ = _loc15_.objectName; + _loc5_ = this.objectDatas[_loc4_]; + if(_loc5_ != null) + { + _loc16_ = _loc13_ + 1; + _loc17_ = 1; + while(_loc16_ < _loc14_) + { + _loc18_ = this.animationDatas[_loc16_]; + if(!_loc18_.isInstance && _loc4_ == _loc18_.objectName) + { + _loc19_ = new ObjectData(); + _loc20_ = _loc4_ + _loc17_++; + _loc19_.name = _loc20_; + this.objectDatas[_loc20_] = _loc19_; + _loc18_.objectName = _loc20_; + _loc19_.vertices = _loc5_.vertices; + _loc19_.uvs = _loc5_.uvs; + _loc19_.faces = _loc5_.faces; + _loc19_.smoothingGroups = _loc5_.smoothingGroups; + _loc19_.surfaces = _loc5_.surfaces; + _loc19_.a = _loc5_.a; + _loc19_.b = _loc5_.b; + _loc19_.c = _loc5_.c; + _loc19_.d = _loc5_.d; + _loc19_.e = _loc5_.e; + _loc19_.f = _loc5_.f; + _loc19_.g = _loc5_.g; + _loc19_.h = _loc5_.h; + _loc19_.i = _loc5_.i; + _loc19_.j = _loc5_.j; + _loc19_.k = _loc5_.k; + _loc19_.l = _loc5_.l; + } + _loc16_++; + } + } + if(_loc5_ != null && _loc5_.vertices != null) + { + _loc6_ = new Mesh(); + this.buildMesh(_loc6_ as Mesh,_loc5_,_loc15_,param2); + } + else + { + _loc6_ = new Object3D(); + } + _loc6_.name = _loc4_; + _loc15_.object = _loc6_; + if(_loc15_.position != null) + { + _loc6_.x = _loc15_.position.x * param2; + _loc6_.y = _loc15_.position.y * param2; + _loc6_.z = _loc15_.position.z * param2; + } + if(_loc15_.rotation != null) + { + _loc6_.rotationX = _loc15_.rotation.x; + _loc6_.rotationY = _loc15_.rotation.y; + _loc6_.rotationZ = _loc15_.rotation.z; + } + if(_loc15_.scale != null) + { + _loc6_.scaleX = _loc15_.scale.x; + _loc6_.scaleY = _loc15_.scale.y; + _loc6_.scaleZ = _loc15_.scale.z; + } + _loc13_++; + } + _loc13_ = 0; + while(_loc13_ < _loc14_) + { + _loc15_ = this.animationDatas[_loc13_]; + this.objects.push(_loc15_.object); + this.parents.push(_loc15_.parentIndex == 65535?null:AnimationData(this.animationDatas[_loc15_.parentIndex]).object); + _loc13_++; + } + } + } + else + { + for(_loc4_ in this.objectDatas) + { + _loc5_ = this.objectDatas[_loc4_]; + if(_loc5_.vertices != null) + { + _loc6_ = new Mesh(); + _loc6_.name = _loc4_; + this.buildMesh(_loc6_ as Mesh,_loc5_,null,param2); + this.objects.push(_loc6_); + this.parents.push(null); + } + } + } + } + + private function buildMesh(param1:Mesh, param2:ObjectData, param3:AnimationData, param4:Number) : void + { + var _loc9_:int = 0; + var _loc10_:int = 0; + var _loc11_:Face = null; + var _loc12_:Vertex = null; + var _loc14_:int = 0; + var _loc15_:Number = NaN; + var _loc16_:Number = NaN; + var _loc17_:Number = NaN; + var _loc18_:Number = NaN; + var _loc19_:Number = NaN; + var _loc20_:Number = NaN; + var _loc21_:Number = NaN; + var _loc22_:Number = NaN; + var _loc23_:Number = NaN; + var _loc24_:Number = NaN; + var _loc25_:Number = NaN; + var _loc26_:Number = NaN; + var _loc27_:Number = NaN; + var _loc28_:Boolean = false; + var _loc29_:Number = NaN; + var _loc30_:Number = NaN; + var _loc31_:Number = NaN; + var _loc32_:Face = null; + var _loc33_:* = null; + var _loc34_:Vector. = null; + var _loc35_:MaterialData = null; + var _loc36_:Material = null; + var _loc37_:Wrapper = null; + var _loc38_:Number = NaN; + var _loc39_:Number = NaN; + var _loc5_:Vector. = new Vector.(); + var _loc6_:Vector. = new Vector.(); + var _loc7_:int = 0; + var _loc8_:int = 0; + var _loc13_:Boolean = false; + if(param3 != null) + { + _loc15_ = param2.a; + _loc16_ = param2.b; + _loc17_ = param2.c; + _loc18_ = param2.d; + _loc19_ = param2.e; + _loc20_ = param2.f; + _loc21_ = param2.g; + _loc22_ = param2.h; + _loc23_ = param2.i; + _loc24_ = param2.j; + _loc25_ = param2.k; + _loc26_ = param2.l; + _loc27_ = 1 / (-_loc17_ * _loc20_ * _loc23_ + _loc16_ * _loc21_ * _loc23_ + _loc17_ * _loc19_ * _loc24_ - _loc15_ * _loc21_ * _loc24_ - _loc16_ * _loc19_ * _loc25_ + _loc15_ * _loc20_ * _loc25_); + param2.a = (-_loc21_ * _loc24_ + _loc20_ * _loc25_) * _loc27_; + param2.b = (_loc17_ * _loc24_ - _loc16_ * _loc25_) * _loc27_; + param2.c = (-_loc17_ * _loc20_ + _loc16_ * _loc21_) * _loc27_; + param2.d = (_loc18_ * _loc21_ * _loc24_ - _loc17_ * _loc22_ * _loc24_ - _loc18_ * _loc20_ * _loc25_ + _loc16_ * _loc22_ * _loc25_ + _loc17_ * _loc20_ * _loc26_ - _loc16_ * _loc21_ * _loc26_) * _loc27_; + param2.e = (_loc21_ * _loc23_ - _loc19_ * _loc25_) * _loc27_; + param2.f = (-_loc17_ * _loc23_ + _loc15_ * _loc25_) * _loc27_; + param2.g = (_loc17_ * _loc19_ - _loc15_ * _loc21_) * _loc27_; + param2.h = (_loc17_ * _loc22_ * _loc23_ - _loc18_ * _loc21_ * _loc23_ + _loc18_ * _loc19_ * _loc25_ - _loc15_ * _loc22_ * _loc25_ - _loc17_ * _loc19_ * _loc26_ + _loc15_ * _loc21_ * _loc26_) * _loc27_; + param2.i = (-_loc20_ * _loc23_ + _loc19_ * _loc24_) * _loc27_; + param2.j = (_loc16_ * _loc23_ - _loc15_ * _loc24_) * _loc27_; + param2.k = (-_loc16_ * _loc19_ + _loc15_ * _loc20_) * _loc27_; + param2.l = (_loc18_ * _loc20_ * _loc23_ - _loc16_ * _loc22_ * _loc23_ - _loc18_ * _loc19_ * _loc24_ + _loc15_ * _loc22_ * _loc24_ + _loc16_ * _loc19_ * _loc26_ - _loc15_ * _loc20_ * _loc26_) * _loc27_; + if(param3.pivot != null) + { + param2.d = param2.d - param3.pivot.x; + param2.h = param2.h - param3.pivot.y; + param2.l = param2.l - param3.pivot.z; + } + _loc13_ = true; + } + if(param2.vertices != null) + { + _loc28_ = param2.uvs != null && param2.uvs.length > 0; + _loc9_ = 0; + _loc10_ = 0; + _loc14_ = param2.vertices.length; + while(_loc9_ < _loc14_) + { + _loc12_ = new Vertex(); + if(_loc13_) + { + _loc29_ = param2.vertices[_loc9_++]; + _loc30_ = param2.vertices[_loc9_++]; + _loc31_ = param2.vertices[_loc9_++]; + _loc12_.x = param2.a * _loc29_ + param2.b * _loc30_ + param2.c * _loc31_ + param2.d; + _loc12_.y = param2.e * _loc29_ + param2.f * _loc30_ + param2.g * _loc31_ + param2.h; + _loc12_.z = param2.i * _loc29_ + param2.j * _loc30_ + param2.k * _loc31_ + param2.l; + } + else + { + _loc12_.x = param2.vertices[_loc9_++]; + _loc12_.y = param2.vertices[_loc9_++]; + _loc12_.z = param2.vertices[_loc9_++]; + } + _loc12_.x = _loc12_.x * param4; + _loc12_.y = _loc12_.y * param4; + _loc12_.z = _loc12_.z * param4; + if(_loc28_) + { + _loc12_.u = param2.uvs[_loc10_++]; + _loc12_.v = 1 - param2.uvs[_loc10_++]; + } + _loc12_.transformId = -1; + var _loc40_:* = _loc7_++; + _loc5_[_loc40_] = _loc12_; + _loc12_.next = param1.vertexList; + param1.vertexList = _loc12_; + } + } + if(param2.faces != null) + { + _loc9_ = 0; + _loc10_ = 0; + _loc14_ = param2.faces.length; + while(_loc9_ < _loc14_) + { + _loc11_ = new Face(); + _loc11_.wrapper = new Wrapper(); + _loc11_.wrapper.next = new Wrapper(); + _loc11_.wrapper.next.next = new Wrapper(); + _loc11_.wrapper.vertex = _loc5_[param2.faces[_loc9_++]]; + _loc11_.wrapper.next.vertex = _loc5_[param2.faces[_loc9_++]]; + _loc11_.wrapper.next.next.vertex = _loc5_[param2.faces[_loc9_++]]; + _loc11_.smoothingGroups = param2.smoothingGroups[_loc10_++]; + _loc40_ = _loc8_++; + _loc6_[_loc40_] = _loc11_; + if(_loc32_ != null) + { + _loc32_.next = _loc11_; + } + else + { + param1.faceList = _loc11_; + } + _loc32_ = _loc11_; + } + } + if(param2.surfaces != null) + { + for(_loc33_ in param2.surfaces) + { + _loc34_ = param2.surfaces[_loc33_]; + _loc35_ = this.materialDatas[_loc33_]; + _loc36_ = _loc35_.material; + _loc9_ = 0; + while(_loc9_ < _loc34_.length) + { + _loc11_ = _loc6_[_loc34_[_loc9_]]; + _loc11_.material = _loc36_; + if(_loc35_.matrix != null) + { + _loc37_ = _loc11_.wrapper; + while(_loc37_ != null) + { + _loc12_ = _loc37_.vertex; + if(_loc12_.transformId < 0) + { + _loc38_ = _loc12_.u; + _loc39_ = _loc12_.v; + _loc12_.u = _loc35_.matrix.a * _loc38_ + _loc35_.matrix.b * _loc39_ + _loc35_.matrix.tx; + _loc12_.v = _loc35_.matrix.c * _loc38_ + _loc35_.matrix.d * _loc39_ + _loc35_.matrix.ty; + _loc12_.transformId = 0; + } + _loc37_ = _loc37_.next; + } + } + _loc9_++; + } + } + } + param1.calculateFacesNormals(true); + param1.calculateBounds(); + } + + private function getString(param1:int) : String + { + var _loc2_:int = 0; + this.data.position = param1; + var _loc3_:String = ""; + while((_loc2_ = this.data.readByte()) != 0) + { + _loc3_ = _loc3_ + String.fromCharCode(_loc2_); + } + return _loc3_; + } + + private function getRotationFrom3DSAngleAxis(param1:Number, param2:Number, param3:Number, param4:Number) : Vector3D + { + var _loc10_:Number = NaN; + var _loc5_:Vector3D = new Vector3D(); + var _loc6_:Number = Math.sin(param1); + var _loc7_:Number = Math.cos(param1); + var _loc8_:Number = 1 - _loc7_; + var _loc9_:Number = param2 * param4 * _loc8_ + param3 * _loc6_; + if(_loc9_ >= 1) + { + _loc10_ = param1 / 2; + _loc5_.z = -2 * Math.atan2(param2 * Math.sin(_loc10_),Math.cos(_loc10_)); + _loc5_.y = -Math.PI / 2; + _loc5_.x = 0; + return _loc5_; + } + if(_loc9_ <= -1) + { + _loc10_ = param1 / 2; + _loc5_.z = 2 * Math.atan2(param2 * Math.sin(_loc10_),Math.cos(_loc10_)); + _loc5_.y = Math.PI / 2; + _loc5_.x = 0; + return _loc5_; + } + _loc5_.z = -Math.atan2(param4 * _loc6_ - param2 * param3 * _loc8_,1 - (param4 * param4 + param3 * param3) * _loc8_); + _loc5_.y = -Math.asin(param2 * param4 * _loc8_ + param3 * _loc6_); + _loc5_.x = -Math.atan2(param2 * _loc6_ - param4 * param3 * _loc8_,1 - (param2 * param2 + param3 * param3) * _loc8_); + return _loc5_; + } + } +} + +import alternativa.engine3d.materials.Material; +import flash.geom.Matrix; + +class MaterialData +{ + + + public var name:String; + + public var color:int; + + public var specular:int; + + public var glossiness:int; + + public var transparency:int; + + public var diffuseMap:MapData; + + public var opacityMap:MapData; + + public var matrix:Matrix; + + public var material:Material; + + function MaterialData() + { + super(); + } +} + +class MapData +{ + + + public var filename:String; + + public var scaleU:Number = 1; + + public var scaleV:Number = 1; + + public var offsetU:Number = 0; + + public var offsetV:Number = 0; + + public var rotation:Number = 0; + + function MapData() + { + super(); + } +} + +class ObjectData +{ + + + public var name:String; + + public var vertices:Vector.; + + public var uvs:Vector.; + + public var faces:Vector.; + + public var smoothingGroups:Vector.; + + public var surfaces:Object; + + public var a:Number; + + public var b:Number; + + public var c:Number; + + public var d:Number; + + public var e:Number; + + public var f:Number; + + public var g:Number; + + public var h:Number; + + public var i:Number; + + public var j:Number; + + public var k:Number; + + public var l:Number; + + function ObjectData() + { + super(); + } +} + +import alternativa.engine3d.core.Object3D; +import flash.geom.Vector3D; + +class AnimationData +{ + + + public var objectName:String; + + public var object:Object3D; + + public var parentIndex:int; + + public var pivot:Vector3D; + + public var position:Vector3D; + + public var rotation:Vector3D; + + public var scale:Vector3D; + + public var isInstance:Boolean; + + function AnimationData() + { + super(); + } +} + +class ChunkInfo +{ + + + public var id:int; + + public var size:int; + + public var dataSize:int; + + public var dataPosition:int; + + public var nextChunkPosition:int; + + function ChunkInfo() + { + super(); + } +} diff --git a/src/alternativa/engine3d/loaders/ParserCollada.as b/src/alternativa/engine3d/loaders/ParserCollada.as new file mode 100644 index 0000000..c215cae --- /dev/null +++ b/src/alternativa/engine3d/loaders/ParserCollada.as @@ -0,0 +1,524 @@ +package alternativa.engine3d.loaders +{ + import alternativa.engine3d.alternativa3d; + import alternativa.engine3d.animation.AnimationClip; + import alternativa.engine3d.animation.keys.Track; + import alternativa.engine3d.containers.LODContainer; + import alternativa.engine3d.core.Light3D; + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.core.Object3DContainer; + import alternativa.engine3d.loaders.collada.DaeDocument; + import alternativa.engine3d.loaders.collada.DaeMaterial; + import alternativa.engine3d.loaders.collada.DaeNode; + import alternativa.engine3d.loaders.collada.DaeObject; + import alternativa.engine3d.materials.Material; + import alternativa.engine3d.materials.TextureMaterial; + import flash.utils.Dictionary; + + use namespace alternativa3d; + + public class ParserCollada + { + + public static const STATIC_OBJECT:uint = 0; + + public static const STATIC_GEOMETRY:uint = 1; + + public static const SPLITTER:uint = 2; + + + public var objects:Vector.; + + public var parents:Vector.; + + public var hierarchy:Vector.; + + public var lights:Vector.; + + public var materials:Vector.; + + public var textureMaterials:Vector.; + + public var animations:Vector.; + + private var layers:Dictionary; + + private var bspContainerChildrenTypes:Dictionary; + + public function ParserCollada() + { + super(); + } + + public static function parseAnimation(param1:XML) : AnimationClip + { + var _loc2_:DaeDocument = new DaeDocument(param1); + var _loc3_:AnimationClip = new AnimationClip(); + collectAnimation(_loc3_,_loc2_.scene.nodes); + return _loc3_.numTracks > 0?_loc3_:null; + } + + private static function collectAnimation(param1:AnimationClip, param2:Vector.) : void + { + var _loc5_:DaeNode = null; + var _loc6_:AnimationClip = null; + var _loc7_:int = 0; + var _loc8_:int = 0; + var _loc9_:Track = null; + var _loc3_:int = 0; + var _loc4_:int = param2.length; + while(_loc3_ < _loc4_) + { + _loc5_ = param2[_loc3_]; + _loc6_ = _loc5_.parseAnimation(); + if(_loc6_ != null) + { + _loc7_ = 0; + _loc8_ = _loc6_.numTracks; + while(_loc7_ < _loc8_) + { + _loc9_ = _loc6_.getTrackAt(_loc7_); + param1.addTrack(_loc9_); + _loc7_++; + } + } + else + { + param1.addTrack(_loc5_.createStaticTransformTrack()); + } + collectAnimation(param1,_loc5_.nodes); + _loc3_++; + } + } + + public function clean() : void + { + this.objects = null; + this.parents = null; + this.hierarchy = null; + this.lights = null; + this.animations = null; + this.materials = null; + this.textureMaterials = null; + this.layers = null; + this.bspContainerChildrenTypes = null; + } + + public function getObjectLayer(param1:Object3D) : String + { + return this.layers[param1]; + } + + public function getBspContainerChildType(param1:Object3D) : uint + { + return this.bspContainerChildrenTypes[param1]; + } + + private function init(param1:XML) : DaeDocument + { + this.clean(); + this.objects = new Vector.(); + this.parents = new Vector.(); + this.hierarchy = new Vector.(); + this.lights = new Vector.(); + this.animations = new Vector.(); + this.materials = new Vector.(); + this.textureMaterials = new Vector.(); + this.layers = new Dictionary(); + this.bspContainerChildrenTypes = new Dictionary(); + return new DaeDocument(param1); + } + + public function parse(param1:XML, param2:String = null, param3:Boolean = false) : void + { + var _loc4_:DaeDocument = this.init(param1); + if(_loc4_.scene != null) + { + this.parseNodes(_loc4_.scene.nodes,null,false); + this.parseMaterials(_loc4_.materials,param2,param3); + } + } + + private function hasSignifiantChildren(param1:DaeNode, param2:Boolean) : Boolean + { + var _loc6_:DaeNode = null; + var _loc3_:Vector. = param1.nodes; + var _loc4_:int = 0; + var _loc5_:int = _loc3_.length; + while(_loc4_ < _loc5_) + { + _loc6_ = _loc3_[_loc4_]; + _loc6_.parse(); + if(_loc6_.skins != null) + { + return true; + } + if(_loc6_.skinOrTopmostJoint == false) + { + if(param2 == false) + { + return true; + } + } + if(this.hasSignifiantChildren(_loc6_,true)) + { + return true; + } + _loc4_++; + } + return false; + } + + private function addObject(param1:DaeObject, param2:Object3D, param3:String) : Object3D + { + var _loc6_:LODContainer = null; + var _loc7_:Number = NaN; + var _loc4_:Object3D = param1.object as Object3D; + this.objects.push(_loc4_); + this.parents.push(param2); + if(param2 == null) + { + this.hierarchy.push(_loc4_); + } + var _loc5_:Object3DContainer = param2 as Object3DContainer; + if(_loc5_ != null) + { + _loc5_.addChild(_loc4_); + _loc6_ = _loc5_ as LODContainer; + if(_loc6_ != null) + { + _loc7_ = param1.lodDistance; + if(_loc7_ != 0) + { + _loc6_.setChildDistance(_loc4_,_loc7_); + } + } + } + if(_loc4_ is Light3D) + { + this.lights.push(Light3D(_loc4_)); + } + if(param1.animation != null) + { + this.animations.push(param1.animation); + } + if(param3) + { + this.layers[_loc4_] = param3; + } + if(param1.isStaticGeometry) + { + this.bspContainerChildrenTypes[_loc4_] = STATIC_GEOMETRY; + } + else if(param1.isSplitter) + { + this.bspContainerChildrenTypes[_loc4_] = SPLITTER; + } + return _loc4_; + } + + private function addObjects(param1:Vector., param2:Object3D, param3:String) : Object3D + { + var _loc4_:Object3D = this.addObject(param1[0],param2,param3); + var _loc5_:int = 1; + var _loc6_:int = param1.length; + while(_loc5_ < _loc6_) + { + this.addObject(param1[_loc5_],param2,param3); + _loc5_++; + } + return _loc4_; + } + + private function parseNodes(param1:Vector., param2:Object3DContainer, param3:Boolean = false) : void + { + var _loc6_:DaeNode = null; + var _loc7_:Object3DContainer = null; + var _loc8_:Boolean = false; + var _loc9_:Object3D = null; + var _loc4_:int = 0; + var _loc5_:int = param1.length; + while(_loc4_ < _loc5_) + { + _loc6_ = param1[_loc4_]; + _loc6_.parse(); + _loc7_ = null; + _loc8_ = false; + if(_loc6_.skins != null) + { + this.addObjects(_loc6_.skins,param2,_loc6_.layer); + } + else if(param3 == false && _loc6_.skinOrTopmostJoint == false) + { + if(_loc6_.objects != null) + { + _loc7_ = this.addObjects(_loc6_.objects,param2,_loc6_.layer) as Object3DContainer; + } + else + { + _loc8_ = true; + } + } + if(_loc7_ == null) + { + if(this.hasSignifiantChildren(_loc6_,param3 || _loc6_.skinOrTopmostJoint)) + { + _loc7_ = new Object3DContainer(); + _loc7_.name = _loc6_.name; + this.addObject(_loc6_.applyAnimation(_loc6_.applyTransformations(_loc7_)),param2,_loc6_.layer); + this.parseNodes(_loc6_.nodes,_loc7_,param3 || _loc6_.skinOrTopmostJoint); + _loc7_.calculateBounds(); + } + else if(_loc8_) + { + _loc9_ = new Object3D(); + _loc9_.name = _loc6_.name; + this.addObject(_loc6_.applyAnimation(_loc6_.applyTransformations(_loc9_)),param2,_loc6_.layer); + } + } + else + { + this.parseNodes(_loc6_.nodes,_loc7_,param3 || _loc6_.skinOrTopmostJoint); + _loc7_.calculateBounds(); + } + _loc4_++; + } + } + + private function trimPath(param1:String) : String + { + var _loc2_:int = param1.lastIndexOf("/"); + return _loc2_ < 0?param1:param1.substr(_loc2_ + 1); + } + + private function parseMaterials(param1:Object, param2:String, param3:Boolean) : void + { + var _loc4_:TextureMaterial = null; + var _loc5_:DaeMaterial = null; + var _loc6_:String = null; + var _loc7_:int = 0; + for each(_loc5_ in param1) + { + if(_loc5_.used) + { + _loc5_.parse(); + this.materials.push(_loc5_.material); + _loc4_ = _loc5_.material as TextureMaterial; + if(_loc4_ != null) + { + this.textureMaterials.push(_loc4_); + } + } + } + if(param3) + { + for each(_loc4_ in this.textureMaterials) + { + if(_loc4_.diffuseMapURL != null) + { + _loc4_.diffuseMapURL = this.trimPath(this.fixURL(_loc4_.diffuseMapURL)); + } + if(_loc4_.opacityMapURL != null) + { + _loc4_.opacityMapURL = this.trimPath(this.fixURL(_loc4_.opacityMapURL)); + } + } + } + else + { + for each(_loc4_ in this.textureMaterials) + { + if(_loc4_.diffuseMapURL != null) + { + _loc4_.diffuseMapURL = this.fixURL(_loc4_.diffuseMapURL); + } + if(_loc4_.opacityMapURL != null) + { + _loc4_.opacityMapURL = this.fixURL(_loc4_.opacityMapURL); + } + } + } + if(param2 != null) + { + param2 = this.fixURL(param2); + _loc7_ = param2.lastIndexOf("/"); + _loc6_ = _loc7_ < 0?"":param2.substr(0,_loc7_); + for each(_loc4_ in this.textureMaterials) + { + if(_loc4_.diffuseMapURL != null) + { + _loc4_.diffuseMapURL = this.resolveURL(_loc4_.diffuseMapURL,_loc6_); + } + if(_loc4_.opacityMapURL != null) + { + _loc4_.opacityMapURL = this.resolveURL(_loc4_.opacityMapURL,_loc6_); + } + } + } + } + + private function fixURL(param1:String) : String + { + var _loc2_:int = param1.indexOf("://"); + _loc2_ = _loc2_ < 0?int(0):int(_loc2_ + 3); + var _loc3_:int = param1.indexOf("?",_loc2_); + _loc3_ = _loc3_ < 0?int(param1.indexOf("#",_loc2_)):int(_loc3_); + var _loc4_:String = param1.substring(_loc2_,_loc3_ < 0?Number(2147483647):Number(_loc3_)); + _loc4_ = _loc4_.replace(/\\/g,"/"); + var _loc5_:int = param1.indexOf("file://"); + if(_loc5_ >= 0) + { + if(param1.charAt(_loc2_) == "/") + { + return "file://" + _loc4_ + (_loc3_ >= 0?param1.substring(_loc3_):""); + } + return "file:///" + _loc4_ + (_loc3_ >= 0?param1.substring(_loc3_):""); + } + return param1.substring(0,_loc2_) + _loc4_ + (_loc3_ >= 0?param1.substring(_loc3_):""); + } + + private function mergePath(param1:String, param2:String, param3:Boolean = false) : String + { + var _loc8_:String = null; + var _loc9_:String = null; + var _loc4_:Array = param2.split("/"); + var _loc5_:Array = param1.split("/"); + var _loc6_:int = 0; + var _loc7_:int = _loc5_.length; + while(_loc6_ < _loc7_) + { + _loc8_ = _loc5_[_loc6_]; + if(_loc8_ == "..") + { + _loc9_ = _loc4_.pop(); + while(_loc9_ == "." || _loc9_ == "" && _loc9_ != null) + { + _loc9_ = _loc4_.pop(); + } + if(param3) + { + if(_loc9_ == "..") + { + _loc4_.push("..",".."); + } + else if(_loc9_ == null) + { + _loc4_.push(".."); + } + } + } + else + { + _loc4_.push(_loc8_); + } + _loc6_++; + } + return _loc4_.join("/"); + } + + private function resolveURL(param1:String, param2:String) : String + { + var _loc5_:int = 0; + var _loc6_:String = null; + var _loc7_:String = null; + var _loc8_:String = null; + var _loc9_:int = 0; + var _loc10_:int = 0; + var _loc11_:int = 0; + var _loc12_:String = null; + var _loc13_:String = null; + if(param2 == "") + { + return param1; + } + if(param1.charAt(0) == "." && param1.charAt(1) == "/") + { + return param2 + param1.substr(1); + } + if(param1.charAt(0) == "/") + { + return param1; + } + if(param1.charAt(0) == "." && param1.charAt(1) == ".") + { + _loc5_ = param1.indexOf("?"); + _loc5_ = _loc5_ < 0?int(param1.indexOf("#")):int(_loc5_); + if(_loc5_ < 0) + { + _loc7_ = ""; + _loc6_ = param1; + } + else + { + _loc7_ = param1.substring(_loc5_); + _loc6_ = param1.substring(0,_loc5_); + } + _loc9_ = param2.indexOf("/"); + _loc10_ = param2.indexOf(":"); + _loc11_ = param2.indexOf("//"); + if(_loc11_ < 0 || _loc11_ > _loc9_) + { + if(_loc10_ >= 0 && _loc10_ < _loc9_) + { + _loc12_ = param2.substring(0,_loc10_ + 1); + _loc8_ = param2.substring(_loc10_ + 1); + if(_loc8_.charAt(0) == "/") + { + return _loc12_ + "/" + this.mergePath(_loc6_,_loc8_.substring(1),false) + _loc7_; + } + return _loc12_ + this.mergePath(_loc6_,_loc8_,false) + _loc7_; + } + if(param2.charAt(0) == "/") + { + return "/" + this.mergePath(_loc6_,param2.substring(1),false) + _loc7_; + } + return this.mergePath(_loc6_,param2,true) + _loc7_; + } + _loc9_ = param2.indexOf("/",_loc11_ + 2); + if(_loc9_ >= 0) + { + _loc13_ = param2.substring(0,_loc9_ + 1); + _loc8_ = param2.substring(_loc9_ + 1); + return _loc13_ + this.mergePath(_loc6_,_loc8_,false) + _loc7_; + } + _loc13_ = param2; + return _loc13_ + "/" + this.mergePath(_loc6_,"",false); + } + var _loc3_:int = param1.indexOf(":"); + var _loc4_:int = param1.indexOf("/"); + if(_loc3_ >= 0 && (_loc3_ < _loc4_ || _loc4_ < 0)) + { + return param1; + } + return param2 + "/" + param1; + } + + public function getObjectByName(param1:String) : Object3D + { + var _loc2_:Object3D = null; + for each(_loc2_ in this.objects) + { + if(_loc2_.name == param1) + { + return _loc2_; + } + } + return null; + } + + public function getAnimationByObject(param1:Object) : AnimationClip + { + var _loc2_:AnimationClip = null; + var _loc3_:Array = null; + for each(_loc2_ in this.animations) + { + _loc3_ = _loc2_._objects; + if(_loc3_.indexOf(param1) >= 0) + { + return _loc2_; + } + } + return null; + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeAlternativa3DObject.as b/src/alternativa/engine3d/loaders/collada/DaeAlternativa3DObject.as new file mode 100644 index 0000000..59efb69 --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeAlternativa3DObject.as @@ -0,0 +1,305 @@ +package alternativa.engine3d.loaders.collada +{ + import alternativa.engine3d.alternativa3d; + import alternativa.engine3d.containers.BSPContainer; + import alternativa.engine3d.containers.ConflictContainer; + import alternativa.engine3d.containers.DistanceSortContainer; + import alternativa.engine3d.containers.KDContainer; + import alternativa.engine3d.containers.LODContainer; + import alternativa.engine3d.core.Clipping; + import alternativa.engine3d.core.Object3DContainer; + import alternativa.engine3d.core.Sorting; + import alternativa.engine3d.materials.Material; + import alternativa.engine3d.objects.Mesh; + import alternativa.engine3d.objects.Sprite3D; + + use namespace collada; + use namespace alternativa3d; + use namespace daeAlternativa3DLibrary; + use namespace daeAlternativa3DMesh; + + public class DaeAlternativa3DObject extends DaeElement + { + + + public var isSplitter:Boolean = false; + + public var isBaseGeometry:Boolean = false; + + public function DaeAlternativa3DObject(param1:XML, param2:DaeDocument) + { + super(param1,param2); + } + + override protected function parseImplementation() : Boolean + { + var _loc1_:String = null; + var _loc2_:XML = null; + var _loc3_:XML = null; + if(data.localName() == "mesh") + { + _loc2_ = data.baseGeometry[0]; + if(_loc2_ != null) + { + _loc1_ = _loc2_.toString(); + this.isBaseGeometry = _loc1_ == "true" || parseInt(_loc1_) != 0; + } + _loc3_ = data.splitter[0]; + if(_loc3_ != null) + { + _loc1_ = _loc3_.toString(); + this.isSplitter = _loc1_ == "true" || parseInt(_loc1_) != 0; + } + } + return true; + } + + public function parseContainer(param1:String) : Object3DContainer + { + var _loc2_:Object3DContainer = null; + var _loc3_:XML = null; + switch(data.localName()) + { + case "object3d": + _loc2_ = new Object3DContainer(); + _loc2_.name = param1; + return this.setParams(_loc2_); + case "distanceSort": + _loc2_ = new DistanceSortContainer(); + _loc2_.name = param1; + return this.setParams(_loc2_); + case "conflict": + _loc2_ = new ConflictContainer(); + _loc2_.name = param1; + return this.setParams(_loc2_); + case "kdTree": + _loc2_ = new KDContainer(); + _loc2_.name = param1; + return this.setParams(_loc2_); + case "bspTree": + _loc2_ = new BSPContainer(); + _loc3_ = data.clipping[0]; + if(_loc3_ != null) + { + (_loc2_ as BSPContainer).clipping = this.getClippingValue(_loc3_); + } + _loc2_.name = param1; + return this.setParams(_loc2_); + default: + return null; + } + } + + private function getClippingValue(param1:XML) : int + { + switch(param1.toString()) + { + case "BOUND_CULLING": + return Clipping.BOUND_CULLING; + case "FACE_CULLING": + return Clipping.FACE_CULLING; + case "FACE_CLIPPING": + return Clipping.FACE_CLIPPING; + default: + return Clipping.BOUND_CULLING; + } + } + + private function getSortingValue(param1:XML) : int + { + switch(param1.toString()) + { + case "STATIC_BSP": + return 3; + case "DYNAMIC_BSP": + return Sorting.DYNAMIC_BSP; + case "NONE": + return Sorting.NONE; + case "AVERAGE_Z": + return Sorting.AVERAGE_Z; + default: + return Sorting.NONE; + } + } + + public function parseSprite3D(param1:String, param2:Material = null) : Sprite3D + { + var _loc3_:Sprite3D = null; + var _loc4_:XML = null; + var _loc5_:XML = null; + var _loc6_:XML = null; + if(data.localName() == "sprite") + { + _loc3_ = new Sprite3D(100,100,param2); + _loc3_.name = param1; + _loc4_ = data.sorting[0]; + _loc5_ = data.clipping[0]; + if(_loc4_ != null) + { + _loc3_.sorting = this.getSortingValue(_loc4_); + } + if(_loc5_ != null) + { + _loc3_.clipping = this.getClippingValue(_loc5_); + } + _loc6_ = data.rotation[0]; + if(_loc6_ != null) + { + _loc3_.rotation = parseInt(_loc6_.toString()) * Math.PI / 180; + } + return this.setParams(_loc3_); + } + return null; + } + + public function applyA3DMeshProperties(param1:Mesh) : void + { + var _loc2_:XML = null; + var _loc3_:XML = null; + var _loc4_:XML = null; + var _loc5_:Boolean = false; + if(data.localName() == "mesh") + { + _loc2_ = data.sorting[0]; + _loc3_ = data.clipping[0]; + _loc4_ = data.optimizeBSP[0]; + if(_loc3_ != null) + { + param1.clipping = this.getClippingValue(_loc3_); + } + _loc5_ = _loc4_ != null ? Boolean(_loc4_.toString() != "false") : Boolean(true); + if(_loc2_ != null) + { + param1.sorting = this.getSortingValue(_loc2_); + if(_loc5_) + { + param1.transformId = 1; + } + } + this.setParams(param1); + } + } + + public function parseLOD(param1:String, param2:DaeNode) : LODContainer + { + var _loc3_:LODContainer = null; + var _loc4_:XMLList = null; + var _loc5_:int = 0; + var _loc6_:int = 0; + var _loc7_:XML = null; + var _loc8_:DaeNode = null; + var _loc9_:DaeObject = null; + if(data.localName() == "lod") + { + _loc3_ = new LODContainer(); + _loc3_.name = param1; + _loc4_ = data.level; + _loc5_ = _loc4_.length(); + _loc6_ = 0; + while(_loc6_ < _loc5_) + { + _loc7_ = _loc4_[_loc6_]; + _loc8_ = document.findNode(_loc7_.@url[0]); + if(_loc8_.scene == null) + { + param2.nodes.push(_loc8_); + } + _loc9_ = null; + if(_loc8_ != null) + { + if(_loc8_.rootJoint != null) + { + _loc8_ = _loc8_.rootJoint; + _loc8_.parse(); + if(_loc8_.skins != null) + { + _loc9_ = _loc8_.skins[0]; + } + } + else + { + _loc8_.parse(); + if(_loc8_.objects != null) + { + _loc9_ = _loc8_.objects[0]; + } + } + } + else + { + document.logger.logNotFoundError(_loc7_.@url[0]); + } + if(_loc9_ != null) + { + _loc9_.lodDistance = parseNumber(_loc7_.@distance[0]); + } + _loc6_++; + } + return this.setParams(_loc3_); + } + return null; + } + + private function setParams(param1:*) : * + { + var param:XML = null; + var name:String = null; + var value:String = null; + var num:Number = NaN; + var object:* = param1; + var params:XMLList = data.param; + var i:int = 0; + var count:int = params.length(); + for(; i < count; i++) + { + param = params[i]; + try + { + name = param.@name[0].toString(); + value = param.text().toString(); + if(value == "true") + { + object[name] = true; + } + else if(value == "false") + { + object[name] = false; + } + else if(value.charAt(0) == "\"" && value.charAt(value.length - 1) == "\"" || value.charAt(0) == "\'" && value.charAt(value.length - 1) == "\'") + { + object[name] = value; + } + else + { + if(value.indexOf(".") >= 0) + { + num = parseFloat(value); + } + else if(value.indexOf(",") >= 0) + { + value = value.replace(/,/,"."); + num = parseFloat(value); + } + else + { + num = parseInt(value); + } + if(isNaN(num)) + { + object[name] = value; + } + else + { + object[name] = num; + } + } + } + catch(e:Error) + { + continue; + } + } + return object; + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeArray.as b/src/alternativa/engine3d/loaders/collada/DaeArray.as new file mode 100644 index 0000000..7d4fc41 --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeArray.as @@ -0,0 +1,40 @@ +package alternativa.engine3d.loaders.collada +{ + use namespace collada; + + public class DaeArray extends DaeElement + { + + + public var array:Array; + + public function DaeArray(param1:XML, param2:DaeDocument) + { + super(param1,param2); + } + + public function get type() : String + { + return String(data.localName()); + } + + override protected function parseImplementation() : Boolean + { + var _loc2_:int = 0; + this.array = parseStringArray(data); + var _loc1_:XML = data.@count[0]; + if(_loc1_ != null) + { + _loc2_ = parseInt(_loc1_.toString(),10); + if(this.array.length < _loc2_) + { + document.logger.logNotEnoughDataError(data.@count[0]); + return false; + } + this.array.length = _loc2_; + return true; + } + return false; + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeCamera.as b/src/alternativa/engine3d/loaders/collada/DaeCamera.as new file mode 100644 index 0000000..3a2dc0d --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeCamera.as @@ -0,0 +1,74 @@ +package alternativa.engine3d.loaders.collada +{ + import alternativa.engine3d.core.Camera3D; + + use namespace collada; + + public class DaeCamera extends DaeElement + { + + + public function DaeCamera(param1:XML, param2:DaeDocument) + { + super(param1,param2); + } + + private function setXFov(param1:Camera3D, param2:Number) : void + { + } + + public function parseCamera() : Camera3D + { + var _loc3_:Number = NaN; + var _loc4_:XML = null; + var _loc5_:XML = null; + var _loc6_:XML = null; + var _loc7_:XML = null; + var _loc8_:XML = null; + var _loc9_:Number = NaN; + var _loc1_:Camera3D = new Camera3D(); + var _loc2_:XML = data.optics.technique_common.perspective[0]; + if(_loc2_) + { + _loc3_ = Math.PI / 180; + _loc4_ = _loc2_.xfov[0]; + _loc5_ = _loc2_.yfov[0]; + _loc6_ = _loc2_.aspect_ratio[0]; + if(_loc6_ == null) + { + if(_loc4_ != null) + { + this.setXFov(_loc1_,parseNumber(_loc4_) * _loc3_); + } + else if(_loc5_ != null) + { + this.setXFov(_loc1_,parseNumber(_loc5_) * _loc3_); + } + } + else + { + _loc9_ = parseNumber(_loc6_); + if(_loc4_ != null) + { + this.setXFov(_loc1_,parseNumber(_loc4_) * _loc3_); + } + else if(_loc5_ != null) + { + this.setXFov(_loc1_,_loc9_ * parseNumber(_loc5_) * _loc3_); + } + } + _loc7_ = _loc2_.znear[0]; + _loc8_ = _loc2_.zfar[0]; + if(_loc7_ != null) + { + _loc1_.nearClipping = parseNumber(_loc7_); + } + if(_loc8_ != null) + { + _loc1_.farClipping = parseNumber(_loc8_); + } + } + return _loc1_; + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeChannel.as b/src/alternativa/engine3d/loaders/collada/DaeChannel.as new file mode 100644 index 0000000..3f3795f --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeChannel.as @@ -0,0 +1,238 @@ +package alternativa.engine3d.loaders.collada +{ + import alternativa.engine3d.alternativa3d; + import alternativa.engine3d.animation.keys.NumberKey; + import alternativa.engine3d.animation.keys.NumberTrack; + import alternativa.engine3d.animation.keys.Track; + + use namespace alternativa3d; + + public class DaeChannel extends DaeElement + { + + public static const PARAM_UNDEFINED:String = "undefined"; + + public static const PARAM_TRANSLATE_X:String = "x"; + + public static const PARAM_TRANSLATE_Y:String = "y"; + + public static const PARAM_TRANSLATE_Z:String = "z"; + + public static const PARAM_SCALE_X:String = "scaleX"; + + public static const PARAM_SCALE_Y:String = "scaleY"; + + public static const PARAM_SCALE_Z:String = "scaleZ"; + + public static const PARAM_ROTATION_X:String = "rotationX"; + + public static const PARAM_ROTATION_Y:String = "rotationY"; + + public static const PARAM_ROTATION_Z:String = "rotationZ"; + + public static const PARAM_TRANSLATE:String = "translate"; + + public static const PARAM_SCALE:String = "scale"; + + public static const PARAM_MATRIX:String = "matrix"; + + + public var tracks:Vector.; + + public var animatedParam:String = "undefined"; + + public var animName:String; + + public function DaeChannel(param1:XML, param2:DaeDocument) + { + super(param1,param2); + } + + public function get node() : DaeNode + { + var _loc2_:Array = null; + var _loc3_:DaeNode = null; + var _loc4_:int = 0; + var _loc5_:int = 0; + var _loc6_:String = null; + var _loc1_:XML = data.@target[0]; + if(_loc1_ != null) + { + _loc2_ = _loc1_.toString().split("/"); + _loc3_ = document.findNodeByID(_loc2_[0]); + if(_loc3_ != null) + { + _loc2_.pop(); + _loc4_ = 1; + _loc5_ = _loc2_.length; + while(_loc4_ < _loc5_) + { + _loc6_ = _loc2_[_loc4_]; + _loc3_ = _loc3_.getNodeBySid(_loc6_); + if(_loc3_ == null) + { + return null; + } + _loc4_++; + } + return _loc3_; + } + } + return null; + } + + override protected function parseImplementation() : Boolean + { + this.parseTransformationType(); + this.parseSampler(); + return true; + } + + private function parseTransformationType() : void + { + var _loc6_:XML = null; + var _loc12_:XML = null; + var _loc13_:XML = null; + var _loc14_:String = null; + var _loc15_:Array = null; + var _loc1_:XML = data.@target[0]; + if(_loc1_ == null) + { + return; + } + var _loc2_:Array = _loc1_.toString().split("/"); + var _loc3_:String = _loc2_.pop(); + var _loc4_:Array = _loc3_.split("."); + var _loc5_:int = _loc4_.length; + var _loc7_:DaeNode = this.node; + if(_loc7_ == null) + { + return; + } + this.animName = _loc7_.animName; + var _loc8_:XMLList = _loc7_.data.children(); + var _loc9_:int = 0; + var _loc10_:int = _loc8_.length(); + while(_loc9_ < _loc10_) + { + _loc12_ = _loc8_[_loc9_]; + _loc13_ = _loc12_.@sid[0]; + if(_loc13_ != null && _loc13_.toString() == _loc4_[0]) + { + _loc6_ = _loc12_; + break; + } + _loc9_++; + } + var _loc11_:String = _loc6_ != null ? _loc6_.localName() as String : null; + if(_loc5_ > 1) + { + _loc14_ = _loc4_[1]; + switch(_loc11_) + { + case "translate": + switch(_loc14_) + { + case "X": + this.animatedParam = PARAM_TRANSLATE_X; + break; + case "Y": + this.animatedParam = PARAM_TRANSLATE_Y; + break; + case "Z": + this.animatedParam = PARAM_TRANSLATE_Z; + } + break; + case "rotate": + _loc15_ = parseNumbersArray(_loc6_); + switch(_loc15_.indexOf(1)) + { + case 0: + this.animatedParam = PARAM_ROTATION_X; + break; + case 1: + this.animatedParam = PARAM_ROTATION_Y; + break; + case 2: + this.animatedParam = PARAM_ROTATION_Z; + } + break; + case "scale": + switch(_loc14_) + { + case "X": + this.animatedParam = PARAM_SCALE_X; + break; + case "Y": + this.animatedParam = PARAM_SCALE_Y; + break; + case "Z": + this.animatedParam = PARAM_SCALE_Z; + } + } + } + else + { + switch(_loc11_) + { + case "translate": + this.animatedParam = PARAM_TRANSLATE; + break; + case "scale": + this.animatedParam = PARAM_SCALE; + break; + case "matrix": + this.animatedParam = PARAM_MATRIX; + } + } + } + + private function parseSampler() : void + { + var _loc2_:NumberTrack = null; + var _loc3_:Number = NaN; + var _loc4_:NumberKey = null; + var _loc1_:DaeSampler = document.findSampler(data.@source[0]); + if(_loc1_ != null) + { + _loc1_.parse(); + if(this.animatedParam == PARAM_MATRIX) + { + this.tracks = Vector.([_loc1_.parseTransformationTrack(this.animName)]); + return; + } + if(this.animatedParam == PARAM_TRANSLATE) + { + this.tracks = _loc1_.parsePointsTracks(this.animName,"x","y","z"); + return; + } + if(this.animatedParam == PARAM_SCALE) + { + this.tracks = _loc1_.parsePointsTracks(this.animName,"scaleX","scaleY","scaleZ"); + return; + } + if(this.animatedParam == PARAM_ROTATION_X || this.animatedParam == PARAM_ROTATION_Y || this.animatedParam == PARAM_ROTATION_Z) + { + _loc2_ = _loc1_.parseNumbersTrack(this.animName,this.animatedParam); + _loc3_ = Math.PI / 180; + _loc4_ = _loc2_.keyList; + while(_loc4_ != null) + { + _loc4_._value *= _loc3_; + _loc4_ = _loc4_.next; + } + this.tracks = Vector.([_loc2_]); + return; + } + if(this.animatedParam == PARAM_TRANSLATE_X || this.animatedParam == PARAM_TRANSLATE_Y || this.animatedParam == PARAM_TRANSLATE_Z || this.animatedParam == PARAM_SCALE_X || this.animatedParam == PARAM_SCALE_Y || this.animatedParam == PARAM_SCALE_Z) + { + this.tracks = Vector.([_loc1_.parseNumbersTrack(this.animName,this.animatedParam)]); + } + } + else + { + document.logger.logNotFoundError(data.@source[0]); + } + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeController.as b/src/alternativa/engine3d/loaders/collada/DaeController.as new file mode 100644 index 0000000..86728a2 --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeController.as @@ -0,0 +1,578 @@ +package alternativa.engine3d.loaders.collada +{ + import alternativa.engine3d.alternativa3d; + import alternativa.engine3d.animation.AnimationClip; + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.core.Vertex; + import alternativa.engine3d.objects.Joint; + import alternativa.engine3d.objects.Skin; + import alternativa.engine3d.objects.VertexBinding; + import flash.utils.Dictionary; + + use namespace alternativa3d; + use namespace collada; + + public class DaeController extends DaeElement + { + + + private var jointsBindMatrices:Vector.>; + + private var vcounts:Array; + + private var indices:Array; + + private var jointsInput:DaeInput; + + private var weightsInput:DaeInput; + + private var inputsStride:int; + + public function DaeController(param1:XML, param2:DaeDocument) + { + super(param1,param2); + } + + override protected function parseImplementation() : Boolean + { + var _loc1_:XML = data.skin.vertex_weights[0]; + if(_loc1_ == null) + { + return false; + } + var _loc2_:XML = _loc1_.vcount[0]; + if(_loc2_ == null) + { + return false; + } + this.vcounts = parseIntsArray(_loc2_); + var _loc3_:XML = _loc1_.v[0]; + if(_loc3_ == null) + { + return false; + } + this.indices = parseIntsArray(_loc3_); + this.parseInputs(); + this.parseJointsBindMatrices(); + return true; + } + + private function parseInputs() : void + { + var _loc5_:DaeInput = null; + var _loc6_:String = null; + var _loc7_:int = 0; + var _loc1_:XMLList = data.skin.vertex_weights.input; + var _loc2_:int = 0; + var _loc3_:int = 0; + var _loc4_:int = _loc1_.length(); + for(; _loc3_ < _loc4_; _loc7_ = _loc5_.offset,_loc2_ = _loc7_ > _loc2_ ? int(_loc7_) : int(_loc2_),_loc3_++) + { + _loc5_ = new DaeInput(_loc1_[_loc3_],document); + _loc6_ = _loc5_.semantic; + if(_loc6_ == null) + { + continue; + } + switch(_loc6_) + { + case "JOINT": + if(this.jointsInput == null) + { + this.jointsInput = _loc5_; + } + break; + case "WEIGHT": + if(this.weightsInput == null) + { + this.weightsInput = _loc5_; + } + break; + } + } + this.inputsStride = _loc2_ + 1; + } + + private function parseJointsBindMatrices() : void + { + var jointsXML:XML = null; + var jointsSource:DaeSource = null; + var stride:int = 0; + var count:int = 0; + var i:int = 0; + var index:int = 0; + var matrix:Vector. = null; + var j:int = 0; + jointsXML = data.skin.joints.input.(@semantic == "INV_BIND_MATRIX")[0]; + if(jointsXML != null) + { + jointsSource = document.findSource(jointsXML.@source[0]); + if(jointsSource != null) + { + if(jointsSource.parse() && jointsSource.numbers != null && jointsSource.stride >= 16) + { + stride = jointsSource.stride; + count = jointsSource.numbers.length / stride; + this.jointsBindMatrices = new Vector.>(count); + i = 0; + while(i < count) + { + index = stride * i; + matrix = new Vector.(16); + this.jointsBindMatrices[i] = matrix; + j = 0; + while(j < 16) + { + matrix[j] = jointsSource.numbers[int(index + j)]; + j++; + } + i++; + } + } + } + else + { + document.logger.logNotFoundError(jointsXML.@source[0]); + } + } + } + + private function get geometry() : DaeGeometry + { + var _loc1_:DaeGeometry = document.findGeometry(data.skin.@source[0]); + if(_loc1_ == null) + { + document.logger.logNotFoundError(data.@source[0]); + } + return _loc1_; + } + + public function parseSkin(param1:Object, param2:Vector., param3:Vector.) : DaeObject + { + var _loc5_:Skin = null; + var _loc6_:DaeGeometry = null; + var _loc7_:Vector. = null; + var _loc8_:Vector. = null; + var _loc4_:XML = data.skin[0]; + if(_loc4_ != null) + { + _loc5_ = new Skin(); + _loc6_ = this.geometry; + if(_loc6_ != null) + { + _loc6_.parse(); + _loc7_ = _loc6_.fillInMesh(_loc5_,param1); + this.applyBindShapeMatrix(_loc5_); + _loc8_ = this.addJointsToSkin(_loc5_,param2,this.findNodes(param3)); + this.setJointsBindMatrices(_loc8_); + this.linkVerticesToJoints(_loc8_,_loc7_); + _loc5_.normalizeWeights(); + _loc6_.cleanVertices(_loc5_); + _loc5_.calculateFacesNormals(true); + _loc5_.calculateBounds(); + return new DaeObject(_loc5_,this.mergeJointsClips(_loc5_,_loc8_)); + } + _loc5_.calculateFacesNormals(true); + _loc5_.calculateBounds(); + return new DaeObject(_loc5_); + } + return null; + } + + private function mergeJointsClips(param1:Skin, param2:Vector.) : AnimationClip + { + var _loc7_:DaeObject = null; + var _loc8_:AnimationClip = null; + var _loc9_:Object3D = null; + var _loc10_:int = 0; + if(!this.hasJointsAnimation(param2)) + { + return null; + } + var _loc3_:AnimationClip = new AnimationClip(); + var _loc4_:Array = [param1]; + var _loc5_:int = 0; + var _loc6_:int = param2.length; + while(_loc5_ < _loc6_) + { + _loc7_ = param2[_loc5_]; + _loc8_ = _loc7_.animation; + if(_loc8_ != null) + { + _loc10_ = 0; + while(_loc10_ < _loc8_.numTracks) + { + _loc3_.addTrack(_loc8_.getTrackAt(_loc10_)); + _loc10_++; + } + } + else + { + _loc3_.addTrack(_loc7_.jointNode.createStaticTransformTrack()); + } + _loc9_ = _loc7_.object; + _loc9_.name = _loc7_.jointNode.animName; + _loc4_.push(_loc9_); + _loc5_++; + } + _loc3_._objects = _loc4_; + return _loc3_; + } + + private function hasJointsAnimation(param1:Vector.) : Boolean + { + var _loc4_:DaeObject = null; + var _loc2_:int = 0; + var _loc3_:int = param1.length; + while(_loc2_ < _loc3_) + { + _loc4_ = param1[_loc2_]; + if(_loc4_.animation != null) + { + return true; + } + _loc2_++; + } + return false; + } + + private function setJointsBindMatrices(param1:Vector.) : void + { + var _loc4_:DaeObject = null; + var _loc5_:Vector. = null; + var _loc6_:Joint = null; + var _loc2_:int = 0; + var _loc3_:int = this.jointsBindMatrices.length; + while(_loc2_ < _loc3_) + { + _loc4_ = param1[_loc2_]; + _loc5_ = this.jointsBindMatrices[_loc2_]; + _loc6_ = _loc4_.object as Joint; + _loc6_.bma = _loc5_[0]; + _loc6_.bmb = _loc5_[1]; + _loc6_.bmc = _loc5_[2]; + _loc6_.bmd = _loc5_[3]; + _loc6_.bme = _loc5_[4]; + _loc6_.bmf = _loc5_[5]; + _loc6_.bmg = _loc5_[6]; + _loc6_.bmh = _loc5_[7]; + _loc6_.bmi = _loc5_[8]; + _loc6_.bmj = _loc5_[9]; + _loc6_.bmk = _loc5_[10]; + _loc6_.bml = _loc5_[11]; + _loc2_++; + } + } + + private function linkVertexToJoint(param1:Joint, param2:Vertex, param3:Number) : void + { + var _loc4_:VertexBinding = new VertexBinding(); + _loc4_.next = param1.vertexBindingList; + param1.vertexBindingList = _loc4_; + _loc4_.vertex = param2; + _loc4_.weight = param3; + while((param2 = param2.value) != null) + { + _loc4_ = new VertexBinding(); + _loc4_.next = param1.vertexBindingList; + param1.vertexBindingList = _loc4_; + _loc4_.vertex = param2; + _loc4_.weight = param3; + } + } + + private function linkVerticesToJoints(param1:Vector., param2:Vector.) : void + { + var _loc11_:Vertex = null; + var _loc12_:int = 0; + var _loc13_:int = 0; + var _loc14_:int = 0; + var _loc15_:int = 0; + var _loc16_:int = 0; + var _loc17_:Number = NaN; + var _loc3_:int = this.jointsInput.offset; + var _loc4_:int = this.weightsInput.offset; + var _loc5_:DaeSource = this.weightsInput.prepareSource(1); + var _loc6_:Vector. = _loc5_.numbers; + var _loc7_:int = _loc5_.stride; + var _loc8_:int = 0; + var _loc9_:int = 0; + var _loc10_:int = param2.length; + while(_loc9_ < _loc10_) + { + _loc11_ = param2[_loc9_]; + _loc12_ = this.vcounts[_loc9_]; + _loc13_ = 0; + while(_loc13_ < _loc12_) + { + _loc14_ = this.inputsStride * (_loc8_ + _loc13_); + _loc15_ = this.indices[int(_loc14_ + _loc3_)]; + if(_loc15_ >= 0) + { + _loc16_ = this.indices[int(_loc14_ + _loc4_)]; + _loc17_ = _loc6_[int(_loc7_ * _loc16_)]; + this.linkVertexToJoint(Joint(param1[_loc15_].object),_loc11_,_loc17_); + } + _loc13_++; + } + _loc8_ += _loc12_; + _loc9_++; + } + } + + private function addJointsToSkin(param1:Skin, param2:Vector., param3:Vector.) : Vector. + { + var _loc6_:int = 0; + var _loc9_:DaeNode = null; + var _loc10_:DaeObject = null; + var _loc4_:Dictionary = new Dictionary(); + var _loc5_:int = param3.length; + _loc6_ = 0; + while(_loc6_ < _loc5_) + { + _loc4_[param3[_loc6_]] = _loc6_; + _loc6_++; + } + var _loc7_:Vector. = new Vector.(_loc5_); + var _loc8_:int = param2.length; + _loc6_ = 0; + while(_loc6_ < _loc8_) + { + _loc9_ = param2[_loc6_]; + _loc10_ = this.addRootJointToSkin(param1,_loc9_,_loc7_,_loc4_); + this.addJointChildren(Joint(_loc10_.object),_loc7_,_loc9_,_loc4_); + _loc6_++; + } + return _loc7_; + } + + private function addRootJointToSkin(param1:Skin, param2:DaeNode, param3:Vector., param4:Dictionary) : DaeObject + { + var _loc5_:Joint = new Joint(); + _loc5_.name = param2.name; + param1.addJoint(_loc5_); + var _loc6_:DaeObject = param2.applyAnimation(param2.applyTransformations(_loc5_)); + _loc6_.jointNode = param2; + if(param2 in param4) + { + param3[param4[param2]] = _loc6_; + } + else + { + param3.push(_loc6_); + } + return _loc6_; + } + + private function addJointChildren(param1:Joint, param2:Vector., param3:DaeNode, param4:Dictionary) : void + { + var _loc5_:DaeObject = null; + var _loc9_:DaeNode = null; + var _loc10_:Joint = null; + var _loc6_:Vector. = param3.nodes; + var _loc7_:int = 0; + var _loc8_:int = _loc6_.length; + while(_loc7_ < _loc8_) + { + _loc9_ = _loc6_[_loc7_]; + if(_loc9_ in param4) + { + _loc10_ = new Joint(); + _loc10_.name = _loc9_.name; + _loc5_ = _loc9_.applyAnimation(_loc9_.applyTransformations(_loc10_)); + _loc5_.jointNode = _loc9_; + param2[param4[_loc9_]] = _loc5_; + param1.addChild(_loc10_); + this.addJointChildren(_loc10_,param2,_loc9_,param4); + } + else if(this.hasJointInDescendants(_loc9_,param4)) + { + _loc10_ = new Joint(); + _loc10_.name = _loc9_.name; + _loc5_ = _loc9_.applyAnimation(_loc9_.applyTransformations(_loc10_)); + _loc5_.jointNode = _loc9_; + param2.push(_loc5_); + param1.addChild(_loc10_); + this.addJointChildren(_loc10_,param2,_loc9_,param4); + } + _loc7_++; + } + } + + private function hasJointInDescendants(param1:DaeNode, param2:Dictionary) : Boolean + { + var _loc6_:DaeNode = null; + var _loc3_:Vector. = param1.nodes; + var _loc4_:int = 0; + var _loc5_:int = _loc3_.length; + while(_loc4_ < _loc5_) + { + _loc6_ = _loc3_[_loc4_]; + if(_loc6_ in param2 || this.hasJointInDescendants(_loc6_,param2)) + { + return true; + } + _loc4_++; + } + return false; + } + + private function applyBindShapeMatrix(param1:Skin) : void + { + var _loc3_:Array = null; + var _loc4_:Number = NaN; + var _loc5_:Number = NaN; + var _loc6_:Number = NaN; + var _loc7_:Number = NaN; + var _loc8_:Number = NaN; + var _loc9_:Number = NaN; + var _loc10_:Number = NaN; + var _loc11_:Number = NaN; + var _loc12_:Number = NaN; + var _loc13_:Number = NaN; + var _loc14_:Number = NaN; + var _loc15_:Number = NaN; + var _loc16_:Vertex = null; + var _loc17_:Number = NaN; + var _loc18_:Number = NaN; + var _loc19_:Number = NaN; + var _loc2_:XML = data.skin.bind_shape_matrix[0]; + if(_loc2_ != null) + { + _loc3_ = parseNumbersArray(_loc2_); + if(_loc3_.length >= 16) + { + _loc4_ = _loc3_[0]; + _loc5_ = _loc3_[1]; + _loc6_ = _loc3_[2]; + _loc7_ = _loc3_[3]; + _loc8_ = _loc3_[4]; + _loc9_ = _loc3_[5]; + _loc10_ = _loc3_[6]; + _loc11_ = _loc3_[7]; + _loc12_ = _loc3_[8]; + _loc13_ = _loc3_[9]; + _loc14_ = _loc3_[10]; + _loc15_ = _loc3_[11]; + _loc16_ = param1.vertexList; + while(_loc16_ != null) + { + _loc17_ = _loc16_.x; + _loc18_ = _loc16_.y; + _loc19_ = _loc16_.z; + _loc16_.x = _loc4_ * _loc17_ + _loc5_ * _loc18_ + _loc6_ * _loc19_ + _loc7_; + _loc16_.y = _loc8_ * _loc17_ + _loc9_ * _loc18_ + _loc10_ * _loc19_ + _loc11_; + _loc16_.z = _loc12_ * _loc17_ + _loc13_ * _loc18_ + _loc14_ * _loc19_ + _loc15_; + _loc16_ = _loc16_.next; + } + } + } + } + + private function isRootJointNode(param1:DaeNode, param2:Dictionary) : Boolean + { + var _loc3_:DaeNode = param1.parent; + while(_loc3_ != null) + { + if(_loc3_ in param2) + { + return false; + } + _loc3_ = _loc3_.parent; + } + return true; + } + + public function findRootJointNodes(param1:Vector.) : Vector. + { + var _loc5_:Dictionary = null; + var _loc6_:Vector. = null; + var _loc7_:DaeNode = null; + var _loc2_:Vector. = this.findNodes(param1); + var _loc3_:int = 0; + var _loc4_:int = _loc2_.length; + if(_loc4_ > 0) + { + _loc5_ = new Dictionary(); + _loc3_ = 0; + while(_loc3_ < _loc4_) + { + _loc5_[_loc2_[_loc3_]] = _loc3_; + _loc3_++; + } + _loc6_ = new Vector.(); + _loc3_ = 0; + while(_loc3_ < _loc4_) + { + _loc7_ = _loc2_[_loc3_]; + if(this.isRootJointNode(_loc7_,_loc5_)) + { + _loc6_.push(_loc7_); + } + _loc3_++; + } + return _loc6_; + } + return null; + } + + private function findNode(param1:String, param2:Vector.) : DaeNode + { + var _loc5_:DaeNode = null; + var _loc3_:int = param2.length; + var _loc4_:int = 0; + while(_loc4_ < _loc3_) + { + _loc5_ = param2[_loc4_].getNodeBySid(param1); + if(_loc5_ != null) + { + return _loc5_; + } + _loc4_++; + } + return null; + } + + private function findNodes(param1:Vector.) : Vector. + { + var jointsXML:XML = null; + var jointsSource:DaeSource = null; + var stride:int = 0; + var count:int = 0; + var nodes:Vector. = null; + var i:int = 0; + var node:DaeNode = null; + var skeletons:Vector. = param1; + jointsXML = data.skin.joints.input.(@semantic == "JOINT")[0]; + if(jointsXML != null) + { + jointsSource = document.findSource(jointsXML.@source[0]); + if(jointsSource != null) + { + if(jointsSource.parse() && jointsSource.names != null) + { + stride = jointsSource.stride; + count = jointsSource.names.length / stride; + nodes = new Vector.(count); + i = 0; + while(i < count) + { + node = this.findNode(jointsSource.names[int(stride * i)],skeletons); + if(node == null) + { + } + nodes[i] = node; + i++; + } + return nodes; + } + } + else + { + document.logger.logNotFoundError(jointsXML.@source[0]); + } + } + return null; + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeDocument.as b/src/alternativa/engine3d/loaders/collada/DaeDocument.as new file mode 100644 index 0000000..9830b82 --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeDocument.as @@ -0,0 +1,348 @@ +package alternativa.engine3d.loaders.collada +{ + import alternativa.engine3d.alternativa3d; + + use namespace collada; + use namespace alternativa3d; + use namespace daeAlternativa3DLibrary; + + public class DaeDocument + { + + + public var scene:DaeVisualScene; + + private var data:XML; + + public var sources:Object; + + public var arrays:Object; + + public var vertices:Object; + + public var geometries:Object; + + public var nodes:Object; + + public var lights:Object; + + public var images:Object; + + public var effects:Object; + + public var controllers:Object; + + public var samplers:Object; + + public var alternativa3DObjects:Object; + + public var materials:Object; + + public var logger:DaeLogger; + + public var versionMajor:uint; + + public var versionMinor:uint; + + public var alternativa3DExtensionVersionMajor:uint = 0; + + public var alternativa3DExtensionVersionMinor:uint = 0; + + public function DaeDocument(param1:XML) + { + super(); + this.data = param1; + var _loc2_:Array = this.data.@version[0].toString().split(/[.,]/); + this.versionMajor = parseInt(_loc2_[1],10); + this.versionMinor = parseInt(_loc2_[2],10); + this.logger = new DaeLogger(); + this.constructStructures(); + this.constructScenes(); + this.registerInstanceControllers(); + this.constructAnimations(); + this.constructAlternativa3DObjects(); + } + + private function getLocalID(param1:XML) : String + { + var _loc2_:String = param1.toString(); + if(_loc2_.charAt(0) == "#") + { + return _loc2_.substr(1); + } + this.logger.logExternalError(param1); + return null; + } + + private function constructStructures() : void + { + var _loc1_:XML = null; + var _loc2_:DaeSource = null; + var _loc3_:DaeLight = null; + var _loc4_:DaeImage = null; + var _loc5_:DaeEffect = null; + var _loc6_:DaeMaterial = null; + var _loc7_:DaeGeometry = null; + var _loc8_:DaeController = null; + var _loc9_:DaeNode = null; + this.sources = new Object(); + this.arrays = new Object(); + for each(_loc1_ in this.data..source) + { + _loc2_ = new DaeSource(_loc1_,this); + if(_loc2_.id != null) + { + this.sources[_loc2_.id] = _loc2_; + } + } + this.lights = new Object(); + for each(_loc1_ in this.data.library_lights.light) + { + _loc3_ = new DaeLight(_loc1_,this); + if(_loc3_.id != null) + { + this.lights[_loc3_.id] = _loc3_; + } + } + this.images = new Object(); + for each(_loc1_ in this.data.library_images.image) + { + _loc4_ = new DaeImage(_loc1_,this); + if(_loc4_.id != null) + { + this.images[_loc4_.id] = _loc4_; + } + } + this.effects = new Object(); + for each(_loc1_ in this.data.library_effects.effect) + { + _loc5_ = new DaeEffect(_loc1_,this); + if(_loc5_.id != null) + { + this.effects[_loc5_.id] = _loc5_; + } + } + this.materials = new Object(); + for each(_loc1_ in this.data.library_materials.material) + { + _loc6_ = new DaeMaterial(_loc1_,this); + if(_loc6_.id != null) + { + this.materials[_loc6_.id] = _loc6_; + } + } + this.geometries = new Object(); + this.vertices = new Object(); + for each(_loc1_ in this.data.library_geometries.geometry) + { + _loc7_ = new DaeGeometry(_loc1_,this); + if(_loc7_.id != null) + { + this.geometries[_loc7_.id] = _loc7_; + } + } + this.controllers = new Object(); + for each(_loc1_ in this.data.library_controllers.controller) + { + _loc8_ = new DaeController(_loc1_,this); + if(_loc8_.id != null) + { + this.controllers[_loc8_.id] = _loc8_; + } + } + this.nodes = new Object(); + for each(_loc1_ in this.data.library_nodes.node) + { + _loc9_ = new DaeNode(_loc1_,this); + if(_loc9_.id != null) + { + this.nodes[_loc9_.id] = _loc9_; + } + } + } + + private function constructScenes() : void + { + var _loc3_:XML = null; + var _loc4_:DaeVisualScene = null; + var _loc1_:XML = this.data.scene.instance_visual_scene.@url[0]; + var _loc2_:String = this.getLocalID(_loc1_); + for each(_loc3_ in this.data.library_visual_scenes.visual_scene) + { + _loc4_ = new DaeVisualScene(_loc3_,this); + if(_loc4_.id == _loc2_) + { + this.scene = _loc4_; + } + } + if(_loc2_ != null && this.scene == null) + { + this.logger.logNotFoundError(_loc1_); + } + } + + private function registerInstanceControllers() : void + { + var _loc1_:int = 0; + var _loc2_:int = 0; + if(this.scene != null) + { + _loc1_ = 0; + _loc2_ = this.scene.nodes.length; + while(_loc1_ < _loc2_) + { + this.scene.nodes[_loc1_].registerInstanceControllers(); + _loc1_++; + } + } + } + + private function constructAnimations() : void + { + var _loc1_:XML = null; + var _loc2_:DaeSampler = null; + var _loc3_:DaeChannel = null; + var _loc4_:DaeNode = null; + this.samplers = new Object(); + for each(_loc1_ in this.data.library_animations..sampler) + { + _loc2_ = new DaeSampler(_loc1_,this); + if(_loc2_.id != null) + { + this.samplers[_loc2_.id] = _loc2_; + } + } + for each(_loc1_ in this.data.library_animations..channel) + { + _loc3_ = new DaeChannel(_loc1_,this); + _loc4_ = _loc3_.node; + if(_loc4_ != null) + { + _loc4_.addChannel(_loc3_); + } + } + } + + private function constructAlternativa3DObjects() : void + { + var alternativa3dXML:XML = null; + var versionComponents:Array = null; + var element:XML = null; + var object:DaeAlternativa3DObject = null; + this.alternativa3DObjects = new Object(); + alternativa3dXML = this.data.extra.technique.(@profile = "Alternativa3D").library[0]; + if(alternativa3dXML != null) + { + versionComponents = alternativa3dXML.version[0].text().toString().split(/[.,]/); + this.alternativa3DExtensionVersionMajor = parseInt(versionComponents[0],10); + this.alternativa3DExtensionVersionMinor = parseInt(versionComponents[1],10); + for each(element in alternativa3dXML.library_containers.children()) + { + object = new DaeAlternativa3DObject(element,this); + if(object.id != null) + { + this.alternativa3DObjects[object.id] = object; + } + } + for each(element in alternativa3dXML.library_sprites.sprite) + { + object = new DaeAlternativa3DObject(element,this); + if(object.id != null) + { + this.alternativa3DObjects[object.id] = object; + } + } + for each(element in alternativa3dXML.library_lods.lod) + { + object = new DaeAlternativa3DObject(element,this); + if(object.id != null) + { + this.alternativa3DObjects[object.id] = object; + } + } + for each(element in alternativa3dXML.library_meshes.mesh) + { + object = new DaeAlternativa3DObject(element,this); + if(object.id != null) + { + this.alternativa3DObjects[object.id] = object; + } + } + } + else + { + this.alternativa3DExtensionVersionMajor = this.alternativa3DExtensionVersionMinor = 0; + } + } + + public function findArray(param1:XML) : DaeArray + { + return this.arrays[this.getLocalID(param1)]; + } + + public function findSource(param1:XML) : DaeSource + { + return this.sources[this.getLocalID(param1)]; + } + + public function findLight(param1:XML) : DaeLight + { + return this.lights[this.getLocalID(param1)]; + } + + public function findImage(param1:XML) : DaeImage + { + return this.images[this.getLocalID(param1)]; + } + + public function findImageByID(param1:String) : DaeImage + { + return this.images[param1]; + } + + public function findEffect(param1:XML) : DaeEffect + { + return this.effects[this.getLocalID(param1)]; + } + + public function findMaterial(param1:XML) : DaeMaterial + { + return this.materials[this.getLocalID(param1)]; + } + + public function findVertices(param1:XML) : DaeVertices + { + return this.vertices[this.getLocalID(param1)]; + } + + public function findGeometry(param1:XML) : DaeGeometry + { + return this.geometries[this.getLocalID(param1)]; + } + + public function findNode(param1:XML) : DaeNode + { + return this.nodes[this.getLocalID(param1)]; + } + + public function findNodeByID(param1:String) : DaeNode + { + return this.nodes[param1]; + } + + public function findController(param1:XML) : DaeController + { + return this.controllers[this.getLocalID(param1)]; + } + + public function findSampler(param1:XML) : DaeSampler + { + return this.samplers[this.getLocalID(param1)]; + } + + public function findAlternativa3DObject(param1:XML) : DaeAlternativa3DObject + { + return this.alternativa3DObjects[this.getLocalID(param1)]; + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeEffect.as b/src/alternativa/engine3d/loaders/collada/DaeEffect.as new file mode 100644 index 0000000..42b2c18 --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeEffect.as @@ -0,0 +1,195 @@ +package alternativa.engine3d.loaders.collada +{ + import alternativa.engine3d.materials.FillMaterial; + import alternativa.engine3d.materials.Material; + import alternativa.engine3d.materials.TextureMaterial; + + use namespace collada; + + public class DaeEffect extends DaeElement + { + + + private var effectParams:Object; + + private var commonParams:Object; + + private var techniqueParams:Object; + + private var diffuse:DaeEffectParam; + + private var emission:DaeEffectParam; + + private var transparent:DaeEffectParam; + + private var transparency:DaeEffectParam; + + public function DaeEffect(param1:XML, param2:DaeDocument) + { + super(param1,param2); + this.constructImages(); + } + + private function constructImages() : void + { + var _loc2_:XML = null; + var _loc3_:DaeImage = null; + var _loc1_:XMLList = data..image; + for each(_loc2_ in _loc1_) + { + _loc3_ = new DaeImage(_loc2_,document); + if(_loc3_.id != null) + { + document.images[_loc3_.id] = _loc3_; + } + } + } + + override protected function parseImplementation() : Boolean + { + var element:XML = null; + var param:DaeParam = null; + var technique:XML = null; + var transparentXML:XML = null; + var transparencyXML:XML = null; + var emissionXML:XML = null; + var diffuseXML:XML = null; + this.effectParams = new Object(); + for each(element in data.newparam) + { + param = new DaeParam(element,document); + this.effectParams[param.sid] = param; + } + this.commonParams = new Object(); + for each(element in data.profile_COMMON.newparam) + { + param = new DaeParam(element,document); + this.commonParams[param.sid] = param; + } + this.techniqueParams = new Object(); + technique = data.profile_COMMON.technique[0]; + if(technique != null) + { + for each(element in technique.newparam) + { + param = new DaeParam(element,document); + this.techniqueParams[param.sid] = param; + } + } + var shader:XML = data.profile_COMMON.technique.*.(localName() == "constant" || localName() == "lambert" || localName() == "phong" || localName() == "blinn")[0]; + if(shader != null) + { + if(shader.localName() == "constant") + { + emissionXML = shader.emission[0]; + if(emissionXML != null) + { + this.emission = new DaeEffectParam(emissionXML,this); + } + } + else + { + diffuseXML = shader.diffuse[0]; + if(diffuseXML != null) + { + this.diffuse = new DaeEffectParam(diffuseXML,this); + } + } + transparentXML = shader.transparent[0]; + if(transparentXML != null) + { + this.transparent = new DaeEffectParam(transparentXML,this); + } + transparencyXML = shader.transparency[0]; + if(transparencyXML != null) + { + this.transparency = new DaeEffectParam(transparencyXML,this); + } + } + return true; + } + + public function getParam(param1:String, param2:Object) : DaeParam + { + var _loc3_:DaeParam = param2[param1]; + if(_loc3_ != null) + { + return _loc3_; + } + _loc3_ = this.techniqueParams[param1]; + if(_loc3_ != null) + { + return _loc3_; + } + _loc3_ = this.commonParams[param1]; + if(_loc3_ != null) + { + return _loc3_; + } + return this.effectParams[param1]; + } + + private function float4ToUint(param1:Array, param2:Boolean = true) : uint + { + var _loc6_:uint = 0; + var _loc3_:uint = param1[0] * 255; + var _loc4_:uint = param1[1] * 255; + var _loc5_:uint = param1[2] * 255; + if(param2) + { + _loc6_ = param1[3] * 255; + return _loc6_ << 24 | _loc3_ << 16 | _loc4_ << 8 | _loc5_; + } + return _loc3_ << 16 | _loc4_ << 8 | _loc5_; + } + + public function getMaterial(param1:Object) : Material + { + var _loc3_:Array = null; + var _loc4_:FillMaterial = null; + var _loc5_:Number = NaN; + var _loc6_:DaeImage = null; + var _loc7_:DaeParam = null; + var _loc8_:TextureMaterial = null; + var _loc9_:DaeImage = null; + var _loc2_:DaeEffectParam = this.diffuse != null ? this.diffuse : this.emission; + if(_loc2_ != null) + { + _loc3_ = _loc2_.getColor(param1); + if(_loc3_ != null) + { + _loc4_ = new FillMaterial(this.float4ToUint(_loc3_,false),_loc3_[3]); + if(this.transparency != null) + { + _loc5_ = this.transparency.getFloat(param1); + if(!isNaN(_loc5_)) + { + _loc4_.alpha = _loc5_; + } + } + return _loc4_; + } + _loc6_ = _loc2_.getImage(param1); + if(_loc6_ != null) + { + _loc7_ = _loc2_.getSampler(param1); + _loc8_ = new TextureMaterial(); + _loc8_.repeat = _loc7_ == null ? Boolean(true) : _loc7_.wrap_s == null || _loc7_.wrap_s == "WRAP"; + _loc8_.diffuseMapURL = _loc6_.init_from; + _loc9_ = this.transparent == null ? null : this.transparent.getImage(param1); + if(_loc9_ != null) + { + _loc8_.opacityMapURL = _loc9_.init_from; + } + return _loc8_; + } + } + return null; + } + + public function get diffuseTexCoords() : String + { + return this.diffuse == null && this.emission == null ? null : (this.diffuse != null ? this.diffuse.texCoord : this.emission.texCoord); + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeEffectParam.as b/src/alternativa/engine3d/loaders/collada/DaeEffectParam.as new file mode 100644 index 0000000..b530d78 --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeEffectParam.as @@ -0,0 +1,101 @@ +package alternativa.engine3d.loaders.collada +{ + use namespace collada; + + public class DaeEffectParam extends DaeElement + { + + + private var effect:DaeEffect; + + public function DaeEffectParam(param1:XML, param2:DaeEffect) + { + super(param1,param2.document); + this.effect = param2; + } + + public function getFloat(param1:Object) : Number + { + var _loc4_:DaeParam = null; + var _loc2_:XML = data.float[0]; + if(_loc2_ != null) + { + return parseNumber(_loc2_); + } + var _loc3_:XML = data.param.@ref[0]; + if(_loc3_ != null) + { + _loc4_ = this.effect.getParam(_loc3_.toString(),param1); + if(_loc4_ != null) + { + return _loc4_.getFloat(); + } + } + return NaN; + } + + public function getColor(param1:Object) : Array + { + var _loc4_:DaeParam = null; + var _loc2_:XML = data.color[0]; + if(_loc2_ != null) + { + return parseNumbersArray(_loc2_); + } + var _loc3_:XML = data.param.@ref[0]; + if(_loc3_ != null) + { + _loc4_ = this.effect.getParam(_loc3_.toString(),param1); + if(_loc4_ != null) + { + return _loc4_.getFloat4(); + } + } + return null; + } + + private function get texture() : String + { + var _loc1_:XML = data.texture.@texture[0]; + return _loc1_ == null ? null : _loc1_.toString(); + } + + public function getSampler(param1:Object) : DaeParam + { + var _loc2_:String = this.texture; + if(_loc2_ != null) + { + return this.effect.getParam(_loc2_,param1); + } + return null; + } + + public function getImage(param1:Object) : DaeImage + { + var _loc3_:String = null; + var _loc4_:DaeParam = null; + var _loc2_:DaeParam = this.getSampler(param1); + if(_loc2_ != null) + { + _loc3_ = _loc2_.surfaceSID; + if(_loc3_ != null) + { + _loc4_ = this.effect.getParam(_loc3_,param1); + if(_loc4_ != null) + { + return _loc4_.image; + } + return null; + } + return _loc2_.image; + } + return document.findImageByID(this.texture); + } + + public function get texCoord() : String + { + var _loc1_:XML = data.texture.@texcoord[0]; + return _loc1_ == null ? null : _loc1_.toString(); + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeElement.as b/src/alternativa/engine3d/loaders/collada/DaeElement.as new file mode 100644 index 0000000..fe2d09f --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeElement.as @@ -0,0 +1,100 @@ +package alternativa.engine3d.loaders.collada +{ + use namespace collada; + + public class DaeElement + { + + + public var document:DaeDocument; + + public var data:XML; + + private var _parsed:int = -1; + + public function DaeElement(param1:XML, param2:DaeDocument) + { + super(); + this.document = param2; + this.data = param1; + } + + public function parse() : Boolean + { + if(this._parsed < 0) + { + this._parsed = !!this.parseImplementation() ? int(1) : int(0); + return this._parsed != 0; + } + return this._parsed != 0; + } + + protected function parseImplementation() : Boolean + { + return true; + } + + protected function parseStringArray(param1:XML) : Array + { + return param1.text().toString().split(/\s+/); + } + + protected function parseNumbersArray(param1:XML) : Array + { + var _loc5_:String = null; + var _loc2_:Array = param1.text().toString().split(/\s+/); + var _loc3_:int = 0; + var _loc4_:int = _loc2_.length; + while(_loc3_ < _loc4_) + { + _loc5_ = _loc2_[_loc3_]; + if(_loc5_.indexOf(",") != -1) + { + _loc5_ = _loc5_.replace(/,/,"."); + } + _loc2_[_loc3_] = parseFloat(_loc5_); + _loc3_++; + } + return _loc2_; + } + + protected function parseIntsArray(param1:XML) : Array + { + var _loc5_:String = null; + var _loc2_:Array = param1.text().toString().split(/\s+/); + var _loc3_:int = 0; + var _loc4_:int = _loc2_.length; + while(_loc3_ < _loc4_) + { + _loc5_ = _loc2_[_loc3_]; + _loc2_[_loc3_] = parseInt(_loc5_,10); + _loc3_++; + } + return _loc2_; + } + + protected function parseNumber(param1:XML) : Number + { + var _loc2_:String = param1.toString().replace(/,/,"."); + return parseFloat(_loc2_); + } + + public function get id() : String + { + var _loc1_:XML = this.data.@id[0]; + return _loc1_ == null ? null : _loc1_.toString(); + } + + public function get sid() : String + { + var _loc1_:XML = this.data.@sid[0]; + return _loc1_ == null ? null : _loc1_.toString(); + } + + public function get name() : String + { + var _loc1_:XML = this.data.@name[0]; + return _loc1_ == null ? null : _loc1_.toString(); + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeGeometry.as b/src/alternativa/engine3d/loaders/collada/DaeGeometry.as new file mode 100644 index 0000000..52ea5ad --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeGeometry.as @@ -0,0 +1,115 @@ +package alternativa.engine3d.loaders.collada +{ + import alternativa.engine3d.alternativa3d; + import alternativa.engine3d.core.Vertex; + import alternativa.engine3d.objects.Mesh; + + use namespace collada; + use namespace alternativa3d; + use namespace daeAlternativa3DMesh; + + public class DaeGeometry extends DaeElement + { + + + private var primitives:Vector.; + + private var vertices:DaeVertices; + + public function DaeGeometry(param1:XML, param2:DaeDocument) + { + super(param1,param2); + this.constructVertices(); + } + + private function constructVertices() : void + { + var _loc1_:XML = data.mesh.vertices[0]; + if(_loc1_ != null) + { + this.vertices = new DaeVertices(_loc1_,document); + document.vertices[this.vertices.id] = this.vertices; + } + } + + override protected function parseImplementation() : Boolean + { + if(this.vertices != null) + { + return this.parsePrimitives(); + } + return false; + } + + private function parsePrimitives() : Boolean + { + var _loc4_:XML = null; + this.primitives = new Vector.(); + var _loc1_:XMLList = data.mesh.children(); + var _loc2_:int = 0; + var _loc3_:int = _loc1_.length(); + while(_loc2_ < _loc3_) + { + _loc4_ = _loc1_[_loc2_]; + switch(_loc4_.localName()) + { + case "polygons": + case "polylist": + case "triangles": + case "trifans": + case "tristrips": + this.primitives.push(new DaePrimitive(_loc4_,document)); + break; + } + _loc2_++; + } + return true; + } + + public function parseMesh(param1:Object) : Mesh + { + var _loc2_:Mesh = null; + if(data.mesh.length() > 0) + { + _loc2_ = new Mesh(); + this.fillInMesh(_loc2_,param1); + this.cleanVertices(_loc2_); + _loc2_.calculateFacesNormals(true); + _loc2_.calculateBounds(); + return _loc2_; + } + return null; + } + + public function fillInMesh(param1:Mesh, param2:Object) : Vector. + { + var _loc6_:DaePrimitive = null; + this.vertices.parse(); + var _loc3_:Vector. = this.vertices.fillInMesh(param1); + var _loc4_:int = 0; + var _loc5_:int = this.primitives.length; + while(_loc4_ < _loc5_) + { + _loc6_ = this.primitives[_loc4_]; + _loc6_.parse(); + if(_loc6_.verticesEquals(this.vertices)) + { + _loc6_.fillInMesh(param1,_loc3_,param2[_loc6_.materialSymbol]); + } + _loc4_++; + } + return _loc3_; + } + + public function cleanVertices(param1:Mesh) : void + { + var _loc2_:Vertex = param1.vertexList; + while(_loc2_ != null) + { + _loc2_.index = 0; + _loc2_.value = null; + _loc2_ = _loc2_.next; + } + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeImage.as b/src/alternativa/engine3d/loaders/collada/DaeImage.as new file mode 100644 index 0000000..6fe5a61 --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeImage.as @@ -0,0 +1,30 @@ +package alternativa.engine3d.loaders.collada +{ + use namespace collada; + + public class DaeImage extends DaeElement + { + + + public function DaeImage(param1:XML, param2:DaeDocument) + { + super(param1,param2); + } + + public function get init_from() : String + { + var _loc2_:XML = null; + var _loc1_:XML = data.init_from[0]; + if(_loc1_ != null) + { + if(document.versionMajor > 4) + { + _loc2_ = _loc1_.ref[0]; + return _loc2_ == null ? null : _loc2_.text().toString(); + } + return _loc1_.text().toString(); + } + return null; + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeInput.as b/src/alternativa/engine3d/loaders/collada/DaeInput.as new file mode 100644 index 0000000..e968772 --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeInput.as @@ -0,0 +1,55 @@ +package alternativa.engine3d.loaders.collada +{ + use namespace collada; + + public class DaeInput extends DaeElement + { + + + public function DaeInput(param1:XML, param2:DaeDocument) + { + super(param1,param2); + } + + public function get semantic() : String + { + var _loc1_:XML = data.@semantic[0]; + return _loc1_ == null ? null : _loc1_.toString(); + } + + public function get source() : XML + { + return data.@source[0]; + } + + public function get offset() : int + { + var _loc1_:XML = data.@offset[0]; + return _loc1_ == null ? int(0) : int(parseInt(_loc1_.toString(),10)); + } + + public function get setNum() : int + { + var _loc1_:XML = data.@set[0]; + return _loc1_ == null ? int(0) : int(parseInt(_loc1_.toString(),10)); + } + + public function prepareSource(param1:int) : DaeSource + { + var _loc2_:DaeSource = document.findSource(this.source); + if(_loc2_ != null) + { + _loc2_.parse(); + if(_loc2_.numbers != null && _loc2_.stride >= param1) + { + return _loc2_; + } + } + else + { + document.logger.logNotFoundError(data.@source[0]); + } + return null; + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeInstanceController.as b/src/alternativa/engine3d/loaders/collada/DaeInstanceController.as new file mode 100644 index 0000000..6c76f72 --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeInstanceController.as @@ -0,0 +1,128 @@ +package alternativa.engine3d.loaders.collada +{ + import flash.utils.Dictionary; + + use namespace collada; + + public class DaeInstanceController extends DaeElement + { + + + public var node:DaeNode; + + public var topmostJoints:Vector.; + + public function DaeInstanceController(param1:XML, param2:DaeDocument, param3:DaeNode) + { + super(param1,param2); + this.node = param3; + } + + override protected function parseImplementation() : Boolean + { + var _loc1_:DaeController = this.controller; + if(_loc1_ != null) + { + this.topmostJoints = _loc1_.findRootJointNodes(this.skeletons); + if(this.topmostJoints != null && this.topmostJoints.length > 1) + { + this.replaceNodesByTopmost(this.topmostJoints); + } + } + return this.topmostJoints != null; + } + + private function replaceNodesByTopmost(param1:Vector.) : void + { + var _loc2_:int = 0; + var _loc3_:DaeNode = null; + var _loc4_:DaeNode = null; + var _loc5_:int = param1.length; + var _loc6_:Dictionary = new Dictionary(); + var _loc7_:Number; + _loc2_ = 0; + while(_loc2_ < _loc5_) + { + _loc3_ = param1[_loc2_]; + _loc4_ = _loc3_.parent; + while(_loc4_ != null) + { + if(_loc6_[_loc4_]) + { + ++_loc6_[_loc7_]; + } + else + { + _loc6_[_loc4_] = 1; + } + _loc4_ = _loc4_.parent; + } + _loc2_++; + } + _loc2_ = 0; + while(_loc2_ < _loc5_) + { + _loc3_ = param1[_loc2_]; + while((_loc4_ = _loc3_.parent) != null && _loc6_[_loc4_] != _loc5_) + { + _loc3_ = _loc3_.parent; + } + param1[_loc2_] = _loc3_; + _loc2_++; + } + } + + private function get controller() : DaeController + { + var _loc1_:DaeController = document.findController(data.@url[0]); + if(_loc1_ == null) + { + document.logger.logNotFoundError(data.@url[0]); + } + return _loc1_; + } + + private function get skeletons() : Vector. + { + var _loc2_:Vector. = null; + var _loc3_:int = 0; + var _loc4_:int = 0; + var _loc5_:XML = null; + var _loc6_:DaeNode = null; + var _loc1_:XMLList = data.skeleton; + if(_loc1_.length() > 0) + { + _loc2_ = new Vector.(); + _loc3_ = 0; + _loc4_ = _loc1_.length(); + while(_loc3_ < _loc4_) + { + _loc5_ = _loc1_[_loc3_]; + _loc6_ = document.findNode(_loc5_.text()[0]); + if(_loc6_ != null) + { + _loc2_.push(_loc6_); + } + else + { + document.logger.logNotFoundError(_loc5_); + } + _loc3_++; + } + return _loc2_; + } + return null; + } + + public function parseSkin(param1:Object) : DaeObject + { + var _loc2_:DaeController = this.controller; + if(_loc2_ != null) + { + _loc2_.parse(); + return _loc2_.parseSkin(param1,this.topmostJoints,this.skeletons); + } + return null; + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeInstanceMaterial.as b/src/alternativa/engine3d/loaders/collada/DaeInstanceMaterial.as new file mode 100644 index 0000000..86d78e1 --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeInstanceMaterial.as @@ -0,0 +1,49 @@ +package alternativa.engine3d.loaders.collada +{ + use namespace collada; + + public class DaeInstanceMaterial extends DaeElement + { + + + public function DaeInstanceMaterial(param1:XML, param2:DaeDocument) + { + super(param1,param2); + } + + public function get symbol() : String + { + var _loc1_:XML = data.@symbol[0]; + return _loc1_ == null ? null : _loc1_.toString(); + } + + private function get target() : XML + { + return data.@target[0]; + } + + public function get material() : DaeMaterial + { + var _loc1_:DaeMaterial = document.findMaterial(this.target); + if(_loc1_ == null) + { + document.logger.logNotFoundError(this.target); + } + return _loc1_; + } + + public function getBindVertexInputSetNum(param1:String) : int + { + var bindVertexInputXML:XML = null; + var setNumXML:XML = null; + var semantic:String = param1; + bindVertexInputXML = data.bind_vertex_input.(@semantic == semantic)[0]; + if(bindVertexInputXML == null) + { + return 0; + } + setNumXML = bindVertexInputXML.@input_set[0]; + return setNumXML == null ? int(0) : int(parseInt(setNumXML.toString(),10)); + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeLight.as b/src/alternativa/engine3d/loaders/collada/DaeLight.as new file mode 100644 index 0000000..bb979b5 --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeLight.as @@ -0,0 +1,148 @@ +package alternativa.engine3d.loaders.collada +{ + import alternativa.engine3d.core.Light3D; + import alternativa.engine3d.lights.AmbientLight; + import alternativa.engine3d.lights.DirectionalLight; + import alternativa.engine3d.lights.OmniLight; + import alternativa.engine3d.lights.SpotLight; + + use namespace collada; + + public class DaeLight extends DaeElement + { + + + public function DaeLight(param1:XML, param2:DaeDocument) + { + super(param1,param2); + } + + private function float4ToUint(param1:Array) : uint + { + var _loc2_:uint = param1[0] * 255; + var _loc3_:uint = param1[1] * 255; + var _loc4_:uint = param1[2] * 255; + return _loc2_ << 16 | _loc3_ << 8 | _loc4_ | 4278190080; + } + + public function get revertDirection() : Boolean + { + var _loc1_:XML = data.technique_common.children()[0]; + return _loc1_ == null ? Boolean(false) : _loc1_.localName() == "directional" || _loc1_.localName() == "spot"; + } + + public function parseLight() : Light3D + { + var info:XML = null; + var extra:XML = null; + var light:Light3D = null; + var color:uint = 0; + var constantAttenuationXML:XML = null; + var linearAttenuationXML:XML = null; + var linearAttenuation:Number = NaN; + var attenuationStart:Number = NaN; + var attenuationEnd:Number = NaN; + var hotspot:Number = NaN; + var fallof:Number = NaN; + var DEG2RAD:Number = NaN; + info = data.technique_common.children()[0]; + extra = data.extra.technique.(@profile[0] == "OpenCOLLADA3dsMax").light[0]; + light = null; + if(info != null) + { + color = this.float4ToUint(parseNumbersArray(info.color[0])); + linearAttenuation = 0; + attenuationStart = 0; + attenuationEnd = 1; + switch(info.localName()) + { + case "ambient": + light = new AmbientLight(color); + light.calculateBounds(); + break; + case "directional": + light = new DirectionalLight(color); + if(extra != null) + { + light.intensity = parseNumber(extra.multiplier[0]); + } + light.calculateBounds(); + break; + case "point": + if(extra != null) + { + attenuationStart = parseNumber(extra.attenuation_far_start[0]); + attenuationEnd = parseNumber(extra.attenuation_far_end[0]); + } + else + { + constantAttenuationXML = info.constant_attenuation[0]; + linearAttenuationXML = info.linear_attenuation[0]; + if(constantAttenuationXML != null) + { + attenuationStart = -parseNumber(constantAttenuationXML); + } + if(linearAttenuationXML != null) + { + linearAttenuation = parseNumber(linearAttenuationXML); + } + if(linearAttenuation > 0) + { + attenuationEnd = 1 / linearAttenuation + attenuationStart; + } + else + { + attenuationEnd = attenuationStart + 1; + } + } + light = new OmniLight(color,attenuationStart,attenuationEnd); + if(extra != null) + { + light.intensity = parseNumber(extra.multiplier[0]); + } + light.calculateBounds(); + break; + case "spot": + hotspot = 0; + fallof = Math.PI / 4; + DEG2RAD = Math.PI / 180; + if(extra != null) + { + attenuationStart = parseNumber(extra.attenuation_far_start[0]); + attenuationEnd = parseNumber(extra.attenuation_far_end[0]); + hotspot = DEG2RAD * parseNumber(extra.hotspot_beam[0]); + fallof = DEG2RAD * parseNumber(extra.falloff[0]); + } + else + { + constantAttenuationXML = info.constant_attenuation[0]; + linearAttenuationXML = info.linear_attenuation[0]; + if(constantAttenuationXML != null) + { + attenuationStart = -parseNumber(constantAttenuationXML); + } + if(linearAttenuationXML != null) + { + linearAttenuation = parseNumber(linearAttenuationXML); + } + if(linearAttenuation > 0) + { + attenuationEnd = 1 / linearAttenuation + attenuationStart; + } + else + { + attenuationEnd = attenuationStart + 1; + } + } + light = new SpotLight(color,attenuationStart,attenuationEnd,hotspot,fallof); + if(extra != null) + { + light.intensity = parseNumber(extra.multiplier[0]); + } + light.calculateBounds(); + } + } + return light; + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeLogger.as b/src/alternativa/engine3d/loaders/collada/DaeLogger.as new file mode 100644 index 0000000..6a59944 --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeLogger.as @@ -0,0 +1,59 @@ +package alternativa.engine3d.loaders.collada +{ + public class DaeLogger + { + + + public function DaeLogger() + { + super(); + } + + private function logMessage(param1:String, param2:XML) : void + { + var _loc3_:int = 0; + var _loc4_:String = param2.nodeKind() == "attribute" ? "@" + param2.localName() : param2.localName() + (_loc3_ > 0 ? "[" + _loc3_ + "]" : ""); + var _loc5_:* = param2.parent(); + while(_loc5_ != null) + { + _loc4_ = _loc5_.localName() + (_loc3_ > 0 ? "[" + _loc3_ + "]" : "") + "." + _loc4_; + _loc5_ = _loc5_.parent(); + } + } + + private function logError(param1:String, param2:XML) : void + { + this.logMessage("[ERROR] " + param1,param2); + } + + public function logExternalError(param1:XML) : void + { + this.logError("External urls don\'t supported",param1); + } + + public function logSkewError(param1:XML) : void + { + this.logError(" don\'t supported",param1); + } + + public function logJointInAnotherSceneError(param1:XML) : void + { + this.logError("Joints in different scenes don\'t supported",param1); + } + + public function logInstanceNodeError(param1:XML) : void + { + this.logError(" don\'t supported",param1); + } + + public function logNotFoundError(param1:XML) : void + { + this.logError("Element with url \"" + param1.toString() + "\" not found",param1); + } + + public function logNotEnoughDataError(param1:XML) : void + { + this.logError("Not enough data",param1); + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeMaterial.as b/src/alternativa/engine3d/loaders/collada/DaeMaterial.as new file mode 100644 index 0000000..93b4f2c --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeMaterial.as @@ -0,0 +1,58 @@ +package alternativa.engine3d.loaders.collada +{ + import alternativa.engine3d.materials.Material; + + use namespace collada; + + public class DaeMaterial extends DaeElement + { + + + public var material:Material; + + public var diffuseTexCoords:String; + + public var used:Boolean = false; + + public function DaeMaterial(param1:XML, param2:DaeDocument) + { + super(param1,param2); + } + + private function parseSetParams() : Object + { + var _loc3_:XML = null; + var _loc4_:DaeParam = null; + var _loc1_:Object = new Object(); + var _loc2_:XMLList = data.instance_effect.setparam; + for each(_loc3_ in _loc2_) + { + _loc4_ = new DaeParam(_loc3_,document); + _loc1_[_loc4_.ref] = _loc4_; + } + return _loc1_; + } + + private function get effectURL() : XML + { + return data.instance_effect.@url[0]; + } + + override protected function parseImplementation() : Boolean + { + var _loc1_:DaeEffect = document.findEffect(this.effectURL); + if(_loc1_ != null) + { + _loc1_.parse(); + this.material = _loc1_.getMaterial(this.parseSetParams()); + this.diffuseTexCoords = _loc1_.diffuseTexCoords; + if(this.material != null) + { + this.material.name = name; + } + return true; + } + return false; + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeNode.as b/src/alternativa/engine3d/loaders/collada/DaeNode.as new file mode 100644 index 0000000..648f5c6 --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeNode.as @@ -0,0 +1,767 @@ +package alternativa.engine3d.loaders.collada +{ + import alternativa.engine3d.alternativa3d; + import alternativa.engine3d.animation.AnimationClip; + import alternativa.engine3d.animation.keys.NumberTrack; + import alternativa.engine3d.animation.keys.Track; + import alternativa.engine3d.animation.keys.TransformTrack; + import alternativa.engine3d.containers.LODContainer; + import alternativa.engine3d.core.Light3D; + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.core.Object3DContainer; + import alternativa.engine3d.core.Sorting; + import alternativa.engine3d.objects.BSP; + import alternativa.engine3d.objects.Mesh; + import alternativa.engine3d.objects.Skin; + import alternativa.engine3d.objects.Sprite3D; + import flash.geom.Matrix3D; + import flash.geom.Vector3D; + + use namespace collada; + use namespace alternativa3d; + use namespace daeAlternativa3DInstance; + + public class DaeNode extends DaeElement + { + + + public var scene:DaeVisualScene; + + public var parent:DaeNode; + + public var skinOrTopmostJoint:Boolean = false; + + public var rootJoint:DaeNode = null; + + private var channels:Vector.; + + private var instanceControllers:Vector.; + + public var nodes:Vector.; + + public var objects:Vector.; + + public var skins:Vector.; + + public function DaeNode(param1:XML, param2:DaeDocument, param3:DaeVisualScene = null, param4:DaeNode = null) + { + super(param1,param2); + this.scene = param3; + this.parent = param4; + this.constructNodes(); + } + + public function get animName() : String + { + var _loc1_:String = this.name; + return _loc1_ == null ? this.id : _loc1_; + } + + private function constructNodes() : void + { + var _loc4_:DaeNode = null; + var _loc1_:XMLList = data.node; + var _loc2_:int = _loc1_.length(); + this.nodes = new Vector.(_loc2_); + var _loc3_:int = 0; + while(_loc3_ < _loc2_) + { + _loc4_ = new DaeNode(_loc1_[_loc3_],document,this.scene,this); + if(_loc4_.id != null) + { + document.nodes[_loc4_.id] = _loc4_; + } + this.nodes[_loc3_] = _loc4_; + _loc3_++; + } + } + + public function registerInstanceControllers() : void + { + var _loc2_:int = 0; + var _loc4_:XML = null; + var _loc5_:DaeInstanceController = null; + var _loc6_:Vector. = null; + var _loc7_:int = 0; + var _loc8_:DaeNode = null; + var _loc9_:int = 0; + var _loc1_:XMLList = data.instance_controller; + var _loc3_:int = _loc1_.length(); + _loc2_ = 0; + while(_loc2_ < _loc3_) + { + this.skinOrTopmostJoint = true; + _loc4_ = _loc1_[_loc2_]; + _loc5_ = new DaeInstanceController(_loc4_,document,this); + if(_loc5_.parse()) + { + _loc6_ = _loc5_.topmostJoints; + _loc7_ = _loc6_.length; + if(_loc7_ > 0) + { + _loc8_ = _loc6_[0]; + _loc8_.addInstanceController(_loc5_); + if(this.rootJoint == null) + { + this.rootJoint = _loc8_; + } + _loc9_ = 0; + while(_loc9_ < _loc7_) + { + _loc6_[_loc9_].skinOrTopmostJoint = true; + _loc9_++; + } + } + } + _loc2_++; + } + _loc3_ = this.nodes.length; + _loc2_ = 0; + while(_loc2_ < _loc3_) + { + this.nodes[_loc2_].registerInstanceControllers(); + _loc2_++; + } + } + + public function addChannel(param1:DaeChannel) : void + { + if(this.channels == null) + { + this.channels = new Vector.(); + } + this.channels.push(param1); + } + + public function addInstanceController(param1:DaeInstanceController) : void + { + if(this.instanceControllers == null) + { + this.instanceControllers = new Vector.(); + } + this.instanceControllers.push(param1); + } + + override protected function parseImplementation() : Boolean + { + this.skins = this.parseSkins(); + this.objects = this.parseObjects(); + return true; + } + + private function parseInstanceMaterials(param1:XML) : Object + { + var _loc6_:DaeInstanceMaterial = null; + var _loc2_:Object = new Object(); + var _loc3_:XMLList = param1.bind_material.technique_common.instance_material; + var _loc4_:int = 0; + var _loc5_:int = _loc3_.length(); + while(_loc4_ < _loc5_) + { + _loc6_ = new DaeInstanceMaterial(_loc3_[_loc4_],document); + _loc2_[_loc6_.symbol] = _loc6_; + _loc4_++; + } + return _loc2_; + } + + public function getNodeBySid(param1:String) : DaeNode + { + var _loc5_:int = 0; + var _loc6_:Vector.> = null; + var _loc7_:Vector. = null; + var _loc8_:int = 0; + var _loc9_:int = 0; + var _loc10_:DaeNode = null; + if(param1 == this.sid) + { + return this; + } + var _loc2_:Vector.> = new Vector.>(); + var _loc3_:Vector.> = new Vector.>(); + _loc2_.push(this.nodes); + var _loc4_:int = _loc2_.length; + while(_loc4_ > 0) + { + _loc5_ = 0; + while(_loc5_ < _loc4_) + { + _loc7_ = _loc2_[_loc5_]; + _loc8_ = _loc7_.length; + _loc9_ = 0; + while(_loc9_ < _loc8_) + { + _loc10_ = _loc7_[_loc9_]; + if(_loc10_.sid == param1) + { + return _loc10_; + } + if(_loc10_.nodes.length > 0) + { + _loc3_.push(_loc10_.nodes); + } + _loc9_++; + } + _loc5_++; + } + _loc6_ = _loc2_; + _loc2_ = _loc3_; + _loc3_ = _loc6_; + _loc3_.length = 0; + _loc4_ = _loc2_.length; + } + return null; + } + + public function parseSkins() : Vector. + { + var _loc4_:DaeInstanceController = null; + var _loc5_:DaeObject = null; + var _loc6_:Skin = null; + var _loc7_:BSP = null; + var _loc8_:DaeObject = null; + if(this.instanceControllers == null) + { + return null; + } + var _loc1_:Vector. = new Vector.(); + var _loc2_:int = 0; + var _loc3_:int = this.instanceControllers.length; + while(_loc2_ < _loc3_) + { + _loc4_ = this.instanceControllers[_loc2_]; + _loc4_.parse(); + _loc5_ = _loc4_.parseSkin(this.parseInstanceMaterials(_loc4_.data)); + if(_loc5_ != null) + { + _loc6_ = Skin(_loc5_.object); + _loc6_.name = _loc4_.node.name; + if(this.isAlternativa3DObject(_loc4_.node)) + { + this.updateAlternativa3DMesh(_loc4_.node,_loc6_,_loc5_); + if(_loc6_.sorting == 3) + { + _loc7_ = new BSP(); + _loc7_.name = _loc6_.name; + _loc7_.splitAnalysis = _loc6_.transformId > 0; + _loc7_.createTree(_loc6_,true); + _loc8_ = this.applyAnimation(this.applyTransformations(_loc7_)); + _loc8_.isSplitter = _loc5_.isSplitter; + _loc8_.isStaticGeometry = _loc5_.isStaticGeometry; + _loc1_.push(_loc8_); + } + else + { + if(_loc6_.sorting == Sorting.DYNAMIC_BSP && _loc6_.transformId > 0) + { + _loc6_.optimizeForDynamicBSP(); + } + _loc1_.push(_loc5_); + } + } + else + { + _loc1_.push(_loc5_); + } + } + _loc2_++; + } + return _loc1_.length > 0 ? _loc1_ : null; + } + + public function parseObjects() : Vector. + { + var _loc3_:int = 0; + var _loc4_:int = 0; + var _loc5_:DaeObject = null; + var _loc6_:XML = null; + var _loc7_:DaeLight = null; + var _loc8_:DaeGeometry = null; + var _loc9_:Light3D = null; + var _loc10_:Matrix3D = null; + var _loc11_:Mesh = null; + var _loc12_:DaeObject = null; + var _loc13_:BSP = null; + var _loc1_:Vector. = new Vector.(); + if(this.isAlternativa3DObject(this)) + { + _loc5_ = this.parseAlternativa3DObject(); + if(_loc5_ != null) + { + _loc1_.push(_loc5_); + } + } + var _loc2_:XMLList = data.children(); + _loc3_ = 0; + _loc4_ = _loc2_.length(); + while(_loc3_ < _loc4_) + { + _loc6_ = _loc2_[_loc3_]; + switch(_loc6_.localName()) + { + case "instance_light": + _loc7_ = document.findLight(_loc6_.@url[0]); + if(_loc7_ != null) + { + _loc9_ = _loc7_.parseLight(); + if(_loc9_ != null) + { + _loc9_.name = name; + if(_loc7_.revertDirection) + { + _loc10_ = new Matrix3D(); + _loc10_.appendRotation(180,Vector3D.X_AXIS); + _loc1_.push(new DaeObject(this.applyTransformations(_loc9_,_loc10_))); + } + else + { + _loc1_.push(this.applyAnimation(this.applyTransformations(_loc9_))); + } + } + } + else + { + document.logger.logNotFoundError(_loc6_.@url[0]); + } + break; + case "instance_geometry": + _loc8_ = document.findGeometry(_loc6_.@url[0]); + if(_loc8_ != null) + { + _loc8_.parse(); + _loc11_ = _loc8_.parseMesh(this.parseInstanceMaterials(_loc6_)); + if(_loc11_ != null) + { + _loc11_.name = name; + _loc12_ = this.applyAnimation(this.applyTransformations(_loc11_)); + if(this.isAlternativa3DObject(this)) + { + this.updateAlternativa3DMesh(this,_loc11_,_loc12_); + if(_loc11_.sorting == 3) + { + _loc13_ = new BSP(); + _loc13_.splitAnalysis = _loc11_.transformId > 0; + _loc13_.createTree(_loc11_,true); + _loc13_.name = _loc11_.name; + _loc13_.matrix = _loc11_.matrix; + _loc12_.object = _loc13_; + } + else if(_loc11_.sorting == Sorting.DYNAMIC_BSP && _loc11_.transformId > 0) + { + _loc11_.optimizeForDynamicBSP(); + } + } + _loc1_.push(_loc12_); + } + } + else + { + document.logger.logNotFoundError(_loc6_.@url[0]); + } + break; + case "instance_node": + document.logger.logInstanceNodeError(_loc6_); + break; + } + _loc3_++; + } + return _loc1_.length > 0 ? _loc1_ : null; + } + + private function getMatrix(param1:Matrix3D = null) : Matrix3D + { + var _loc3_:Array = null; + var _loc6_:XML = null; + var _loc7_:XML = null; + var _loc2_:Matrix3D = param1 == null ? new Matrix3D() : param1; + var _loc4_:XMLList = data.children(); + var _loc5_:int = _loc4_.length() - 1; + for(; _loc5_ >= 0; _loc5_--) + { + _loc6_ = _loc4_[_loc5_]; + _loc7_ = _loc6_.@sid[0]; + if(_loc7_ != null && _loc7_.toString() == "post-rotationY") + { + continue; + } + switch(_loc6_.localName()) + { + case "scale": + _loc3_ = parseNumbersArray(_loc6_); + _loc2_.appendScale(_loc3_[0],_loc3_[1],_loc3_[2]); + break; + case "rotate": + _loc3_ = parseNumbersArray(_loc6_); + _loc2_.appendRotation(_loc3_[3],new Vector3D(_loc3_[0],_loc3_[1],_loc3_[2])); + break; + case "translate": + _loc3_ = parseNumbersArray(_loc6_); + _loc2_.appendTranslation(_loc3_[0],_loc3_[1],_loc3_[2]); + break; + case "matrix": + _loc3_ = parseNumbersArray(_loc6_); + _loc2_.append(new Matrix3D(Vector.([_loc3_[0],_loc3_[4],_loc3_[8],_loc3_[12],_loc3_[1],_loc3_[5],_loc3_[9],_loc3_[13],_loc3_[2],_loc3_[6],_loc3_[10],_loc3_[14],_loc3_[3],_loc3_[7],_loc3_[11],_loc3_[15]]))); + break; + case "lookat": + break; + case "skew": + document.logger.logSkewError(_loc6_); + break; + } + } + return _loc2_; + } + + public function applyTransformations(param1:Object3D, param2:Matrix3D = null, param3:Matrix3D = null) : Object3D + { + var _loc4_:Matrix3D = null; + if(param3 != null) + { + _loc4_ = this.getMatrix(param2); + _loc4_.append(param3); + param1.matrix = _loc4_; + } + else + { + param1.matrix = this.getMatrix(param2); + } + return param1; + } + + private function isAlternativa3DObject(param1:DaeNode) : Boolean + { + var node:DaeNode = param1; + return node.data.extra.technique.(@profile == "Alternativa3D")[0] != null; + } + + private function parseAlternativa3DObject() : DaeObject + { + var techniqueXML:XML = null; + var profile:XML = null; + var containerXML:XML = null; + var spriteXML:XML = null; + var lodXML:XML = null; + var daeContainer:DaeAlternativa3DObject = null; + var container:Object3DContainer = null; + var daeSprite:DaeAlternativa3DObject = null; + var sprite:Sprite3D = null; + var material:DaeMaterial = null; + var daeLod:DaeAlternativa3DObject = null; + var lod:LODContainer = null; + techniqueXML = data.extra.technique.(@profile == "Alternativa3D")[0]; + profile = techniqueXML.instance[0]; + if(profile != null) + { + containerXML = profile.instance_container[0]; + if(containerXML != null) + { + daeContainer = document.findAlternativa3DObject(containerXML.@url[0]); + if(daeContainer != null) + { + container = daeContainer.parseContainer(name); + return container != null ? this.applyAnimation(this.applyTransformations(container)) : null; + } + document.logger.logNotFoundError(containerXML.@url[0]); + } + spriteXML = profile.instance_sprite[0]; + if(spriteXML != null) + { + daeSprite = document.findAlternativa3DObject(spriteXML.@url[0]); + if(daeSprite != null) + { + material = document.findMaterial(spriteXML.instance_material.@target[0]); + if(material != null) + { + material.parse(); + material.used = true; + sprite = daeSprite.parseSprite3D(name,material.material); + } + else + { + sprite = daeSprite.parseSprite3D(name); + } + return sprite != null ? this.applyAnimation(this.applyTransformations(sprite)) : null; + } + document.logger.logNotFoundError(spriteXML.@url[0]); + } + lodXML = profile.instance_lod[0]; + if(lodXML != null) + { + daeLod = document.findAlternativa3DObject(lodXML.@url[0]); + if(daeLod != null) + { + lod = daeLod.parseLOD(name,this); + return lod != null ? this.applyAnimation(this.applyTransformations(lod)) : null; + } + document.logger.logNotFoundError(lodXML.@url[0]); + } + } + return null; + } + + private function updateAlternativa3DMesh(param1:DaeNode, param2:Mesh, param3:DaeObject) : void + { + var techniqueXML:XML = null; + var profile:XML = null; + var meshXML:XML = null; + var daeMesh:DaeAlternativa3DObject = null; + var node:DaeNode = param1; + var mesh:Mesh = param2; + var daeObject:DaeObject = param3; + techniqueXML = node.data.extra.technique.(@profile == "Alternativa3D")[0]; + profile = techniqueXML.instance[0]; + if(profile != null) + { + meshXML = profile.instance_mesh[0]; + if(meshXML != null) + { + daeMesh = document.findAlternativa3DObject(meshXML.@url[0]); + daeMesh.parse(); + if(daeMesh != null) + { + daeMesh.applyA3DMeshProperties(mesh); + daeObject.isSplitter = daeMesh.isSplitter; + daeObject.isStaticGeometry = daeMesh.isBaseGeometry; + } + else + { + document.logger.logNotFoundError(meshXML.@url[0]); + } + } + } + } + + public function applyAnimation(param1:Object3D) : DaeObject + { + var _loc2_:AnimationClip = this.parseAnimation(param1); + if(_loc2_ == null) + { + return new DaeObject(param1); + } + param1.name = this.animName; + _loc2_.attach(param1,false); + return new DaeObject(param1,_loc2_); + } + + public function parseAnimation(param1:Object3D = null) : AnimationClip + { + if(this.channels == null || !this.hasTransformationAnimation()) + { + return null; + } + var _loc2_:DaeChannel = this.getChannel(DaeChannel.PARAM_MATRIX); + if(_loc2_ != null) + { + return this.createClip(_loc2_.tracks); + } + var _loc3_:AnimationClip = new AnimationClip(); + var _loc4_:Vector. = param1 != null ? null : this.getMatrix().decompose(); + _loc2_ = this.getChannel(DaeChannel.PARAM_TRANSLATE); + if(_loc2_ != null) + { + this.addTracksToClip(_loc3_,_loc2_.tracks); + } + else + { + _loc2_ = this.getChannel(DaeChannel.PARAM_TRANSLATE_X); + if(_loc2_ != null) + { + this.addTracksToClip(_loc3_,_loc2_.tracks); + } + else + { + _loc3_.addTrack(this.createValueStaticTrack("x",param1 == null ? Number(_loc4_[0].x) : Number(param1.x))); + } + _loc2_ = this.getChannel(DaeChannel.PARAM_TRANSLATE_Y); + if(_loc2_ != null) + { + this.addTracksToClip(_loc3_,_loc2_.tracks); + } + else + { + _loc3_.addTrack(this.createValueStaticTrack("y",param1 == null ? Number(_loc4_[0].y) : Number(param1.y))); + } + _loc2_ = this.getChannel(DaeChannel.PARAM_TRANSLATE_Z); + if(_loc2_ != null) + { + this.addTracksToClip(_loc3_,_loc2_.tracks); + } + else + { + _loc3_.addTrack(this.createValueStaticTrack("z",param1 == null ? Number(_loc4_[0].z) : Number(param1.z))); + } + } + _loc2_ = this.getChannel(DaeChannel.PARAM_ROTATION_X); + if(_loc2_ != null) + { + this.addTracksToClip(_loc3_,_loc2_.tracks); + } + else + { + _loc3_.addTrack(this.createValueStaticTrack("rotationX",param1 == null ? Number(_loc4_[1].x) : Number(param1.rotationX))); + } + _loc2_ = this.getChannel(DaeChannel.PARAM_ROTATION_Y); + if(_loc2_ != null) + { + this.addTracksToClip(_loc3_,_loc2_.tracks); + } + else + { + _loc3_.addTrack(this.createValueStaticTrack("rotationY",param1 == null ? Number(_loc4_[1].y) : Number(param1.rotationY))); + } + _loc2_ = this.getChannel(DaeChannel.PARAM_ROTATION_Z); + if(_loc2_ != null) + { + this.addTracksToClip(_loc3_,_loc2_.tracks); + } + else + { + _loc3_.addTrack(this.createValueStaticTrack("rotationZ",param1 == null ? Number(_loc4_[1].z) : Number(param1.rotationZ))); + } + _loc2_ = this.getChannel(DaeChannel.PARAM_SCALE); + if(_loc2_ != null) + { + this.addTracksToClip(_loc3_,_loc2_.tracks); + } + else + { + _loc2_ = this.getChannel(DaeChannel.PARAM_SCALE_X); + if(_loc2_ != null) + { + this.addTracksToClip(_loc3_,_loc2_.tracks); + } + else + { + _loc3_.addTrack(this.createValueStaticTrack("scaleX",param1 == null ? Number(_loc4_[2].x) : Number(param1.scaleX))); + } + _loc2_ = this.getChannel(DaeChannel.PARAM_SCALE_Y); + if(_loc2_ != null) + { + this.addTracksToClip(_loc3_,_loc2_.tracks); + } + else + { + _loc3_.addTrack(this.createValueStaticTrack("scaleY",param1 == null ? Number(_loc4_[2].y) : Number(param1.scaleY))); + } + _loc2_ = this.getChannel(DaeChannel.PARAM_SCALE_Z); + if(_loc2_ != null) + { + this.addTracksToClip(_loc3_,_loc2_.tracks); + } + else + { + _loc3_.addTrack(this.createValueStaticTrack("scaleZ",param1 == null ? Number(_loc4_[2].z) : Number(param1.scaleZ))); + } + } + if(_loc3_.numTracks > 0) + { + return _loc3_; + } + return null; + } + + private function createClip(param1:Vector.) : AnimationClip + { + var _loc2_:AnimationClip = new AnimationClip(); + var _loc3_:int = 0; + var _loc4_:int = param1.length; + while(_loc3_ < _loc4_) + { + _loc2_.addTrack(param1[_loc3_]); + _loc3_++; + } + return _loc2_; + } + + private function addTracksToClip(param1:AnimationClip, param2:Vector.) : void + { + var _loc3_:int = 0; + var _loc4_:int = param2.length; + while(_loc3_ < _loc4_) + { + param1.addTrack(param2[_loc3_]); + _loc3_++; + } + } + + private function hasTransformationAnimation() : Boolean + { + var _loc3_:DaeChannel = null; + var _loc4_:Boolean = false; + var _loc1_:int = 0; + var _loc2_:int = this.channels.length; + while(_loc1_ < _loc2_) + { + _loc3_ = this.channels[_loc1_]; + _loc3_.parse(); + _loc4_ = _loc3_.animatedParam == DaeChannel.PARAM_MATRIX; + _loc4_ = _loc4_ || _loc3_.animatedParam == DaeChannel.PARAM_TRANSLATE; + _loc4_ = _loc4_ || _loc3_.animatedParam == DaeChannel.PARAM_TRANSLATE_X; + _loc4_ = _loc4_ || _loc3_.animatedParam == DaeChannel.PARAM_TRANSLATE_Y; + _loc4_ = _loc4_ || _loc3_.animatedParam == DaeChannel.PARAM_TRANSLATE_Z; + _loc4_ = _loc4_ || _loc3_.animatedParam == DaeChannel.PARAM_ROTATION_X; + _loc4_ = _loc4_ || _loc3_.animatedParam == DaeChannel.PARAM_ROTATION_Y; + _loc4_ = _loc4_ || _loc3_.animatedParam == DaeChannel.PARAM_ROTATION_Z; + _loc4_ = _loc4_ || _loc3_.animatedParam == DaeChannel.PARAM_SCALE; + _loc4_ = _loc4_ || _loc3_.animatedParam == DaeChannel.PARAM_SCALE_X; + _loc4_ = _loc4_ || _loc3_.animatedParam == DaeChannel.PARAM_SCALE_Y; + _loc4_ = _loc4_ || _loc3_.animatedParam == DaeChannel.PARAM_SCALE_Z; + if(_loc4_) + { + return true; + } + _loc1_++; + } + return false; + } + + private function getChannel(param1:String) : DaeChannel + { + var _loc4_:DaeChannel = null; + var _loc2_:int = 0; + var _loc3_:int = this.channels.length; + while(_loc2_ < _loc3_) + { + _loc4_ = this.channels[_loc2_]; + _loc4_.parse(); + if(_loc4_.animatedParam == param1) + { + return _loc4_; + } + _loc2_++; + } + return null; + } + + private function concatTracks(param1:Vector., param2:Vector.) : void + { + var _loc3_:int = 0; + var _loc4_:int = param1.length; + while(_loc3_ < _loc4_) + { + param2.push(param1[_loc3_]); + _loc3_++; + } + } + + private function createValueStaticTrack(param1:String, param2:Number) : Track + { + var _loc3_:NumberTrack = new NumberTrack(this.animName,param1); + _loc3_.addKey(0,param2); + return _loc3_; + } + + public function createStaticTransformTrack() : TransformTrack + { + var _loc1_:TransformTrack = new TransformTrack(this.animName); + _loc1_.addKey(0,this.getMatrix()); + return _loc1_; + } + + public function get layer() : String + { + var _loc1_:XML = data.@layer[0]; + return _loc1_ == null ? null : _loc1_.toString(); + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeObject.as b/src/alternativa/engine3d/loaders/collada/DaeObject.as new file mode 100644 index 0000000..c7c9d02 --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeObject.as @@ -0,0 +1,29 @@ +package alternativa.engine3d.loaders.collada +{ + import alternativa.engine3d.animation.AnimationClip; + import alternativa.engine3d.core.Object3D; + + public class DaeObject + { + + + public var object:Object3D; + + public var animation:AnimationClip; + + public var jointNode:DaeNode; + + public var isSplitter:Boolean = false; + + public var isStaticGeometry:Boolean = false; + + public var lodDistance:Number = 0; + + public function DaeObject(param1:Object3D, param2:AnimationClip = null) + { + super(); + this.object = param1; + this.animation = param2; + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeParam.as b/src/alternativa/engine3d/loaders/collada/DaeParam.as new file mode 100644 index 0000000..25bbeda --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeParam.as @@ -0,0 +1,89 @@ +package alternativa.engine3d.loaders.collada +{ + use namespace collada; + + public class DaeParam extends DaeElement + { + + + public function DaeParam(param1:XML, param2:DaeDocument) + { + super(param1,param2); + } + + public function get ref() : String + { + var _loc1_:XML = data.@ref[0]; + return _loc1_ == null ? null : _loc1_.toString(); + } + + public function getFloat() : Number + { + var _loc1_:XML = data.float[0]; + if(_loc1_ != null) + { + return parseNumber(_loc1_); + } + return NaN; + } + + public function getFloat4() : Array + { + var _loc2_:Array = null; + var _loc1_:XML = data.float4[0]; + if(_loc1_ == null) + { + _loc1_ = data.float3[0]; + if(_loc1_ != null) + { + _loc2_ = parseNumbersArray(_loc1_); + _loc2_[3] = 1; + } + } + else + { + _loc2_ = parseNumbersArray(_loc1_); + } + return _loc2_; + } + + public function get surfaceSID() : String + { + var _loc1_:XML = data.sampler2D.source[0]; + return _loc1_ == null ? null : _loc1_.text().toString(); + } + + public function get wrap_s() : String + { + var _loc1_:XML = data.sampler2D.wrap_s[0]; + return _loc1_ == null ? null : _loc1_.text().toString(); + } + + public function get image() : DaeImage + { + var _loc2_:DaeImage = null; + var _loc3_:XML = null; + var _loc4_:XML = null; + var _loc1_:XML = data.surface[0]; + if(_loc1_ != null) + { + _loc3_ = _loc1_.init_from[0]; + if(_loc3_ == null) + { + return null; + } + _loc2_ = document.findImageByID(_loc3_.text().toString()); + } + else + { + _loc4_ = data.instance_image.@url[0]; + if(_loc4_ == null) + { + return null; + } + _loc2_ = document.findImage(_loc4_); + } + return _loc2_; + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaePrimitive.as b/src/alternativa/engine3d/loaders/collada/DaePrimitive.as new file mode 100644 index 0000000..315af71 --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaePrimitive.as @@ -0,0 +1,378 @@ +package alternativa.engine3d.loaders.collada +{ + import alternativa.engine3d.alternativa3d; + import alternativa.engine3d.core.Face; + import alternativa.engine3d.core.Vertex; + import alternativa.engine3d.core.Wrapper; + import alternativa.engine3d.materials.Material; + import alternativa.engine3d.objects.Mesh; + + use namespace alternativa3d; + use namespace collada; + + public class DaePrimitive extends DaeElement + { + + + private var verticesInput:DaeInput; + + private var texCoordsInputs:Vector.; + + private var inputsStride:int; + + public function DaePrimitive(param1:XML, param2:DaeDocument) + { + super(param1,param2); + } + + override protected function parseImplementation() : Boolean + { + this.parseInputs(); + return true; + } + + private function parseInputs() : void + { + var _loc5_:DaeInput = null; + var _loc6_:String = null; + var _loc7_:int = 0; + this.texCoordsInputs = new Vector.(); + var _loc1_:XMLList = data.input; + var _loc2_:int = 0; + var _loc3_:int = 0; + var _loc4_:int = _loc1_.length(); + for(; _loc3_ < _loc4_; _loc7_ = _loc5_.offset,_loc2_ = _loc7_ > _loc2_ ? int(_loc7_) : int(_loc2_),_loc3_++) + { + _loc5_ = new DaeInput(_loc1_[_loc3_],document); + _loc6_ = _loc5_.semantic; + if(_loc6_ == null) + { + continue; + } + switch(_loc6_) + { + case "VERTEX": + if(this.verticesInput == null) + { + this.verticesInput = _loc5_; + } + break; + case "TEXCOORD": + this.texCoordsInputs.push(_loc5_); + break; + } + } + this.inputsStride = _loc2_ + 1; + } + + private function findTexCoordsInput(param1:int) : DaeInput + { + var _loc4_:DaeInput = null; + var _loc2_:int = 0; + var _loc3_:int = this.texCoordsInputs.length; + while(_loc2_ < _loc3_) + { + _loc4_ = this.texCoordsInputs[_loc2_]; + if(_loc4_.setNum == param1) + { + return _loc4_; + } + _loc2_++; + } + return this.texCoordsInputs.length > 0 ? this.texCoordsInputs[0] : null; + } + + private function get type() : String + { + return data.localName() as String; + } + + public function fillInMesh(param1:Mesh, param2:Vector., param3:DaeInstanceMaterial = null) : void + { + var _loc6_:DaeInput = null; + var _loc7_:Material = null; + var _loc8_:Vector. = null; + var _loc11_:XML = null; + var _loc12_:Array = null; + var _loc13_:DaeMaterial = null; + var _loc14_:Vertex = null; + var _loc15_:DaeSource = null; + var _loc16_:XMLList = null; + var _loc17_:int = 0; + var _loc18_:int = 0; + var _loc19_:XML = null; + var _loc20_:Array = null; + var _loc4_:XML = data.@count[0]; + if(_loc4_ == null) + { + document.logger.logNotEnoughDataError(data); + return; + } + var _loc5_:int = parseInt(_loc4_.toString(),10); + if(param3 != null) + { + _loc13_ = param3.material; + _loc13_.parse(); + if(_loc13_.diffuseTexCoords != null) + { + _loc6_ = this.findTexCoordsInput(param3.getBindVertexInputSetNum(_loc13_.diffuseTexCoords)); + } + else + { + _loc6_ = this.findTexCoordsInput(-1); + } + _loc13_.used = true; + _loc7_ = _loc13_.material; + } + else + { + _loc6_ = this.findTexCoordsInput(-1); + } + if(_loc6_ != null) + { + for each(_loc14_ in param2) + { + while(_loc14_ != null && _loc14_.index != -1) + { + _loc14_.index = -2; + _loc14_ = _loc14_.value; + } + } + } + var _loc9_:int = 1; + var _loc10_:int = 0; + if(_loc6_ != null) + { + _loc15_ = _loc6_.prepareSource(2); + if(_loc15_ != null) + { + _loc8_ = _loc15_.numbers; + _loc9_ = _loc15_.stride; + _loc10_ = _loc6_.offset; + } + } + switch(this.type) + { + case "polygons": + if(data.ph.length() > 0) + { + } + _loc16_ = data.p; + _loc17_ = 0; + _loc18_ = _loc16_.length(); + while(_loc17_ < _loc18_) + { + _loc12_ = parseIntsArray(_loc16_[_loc17_]); + this.fillInPolygon(param1,_loc7_,param2,this.verticesInput.offset,_loc12_.length / this.inputsStride,_loc12_,_loc8_,_loc9_,_loc10_); + _loc17_++; + } + break; + case "polylist": + _loc11_ = data.p[0]; + if(_loc11_ == null) + { + document.logger.logNotEnoughDataError(data); + return; + } + _loc12_ = parseIntsArray(_loc11_); + _loc19_ = data.vcount[0]; + if(_loc19_ != null) + { + _loc20_ = parseIntsArray(_loc19_); + if(_loc20_.length < _loc5_) + { + return; + } + this.fillInPolylist(param1,_loc7_,param2,this.verticesInput.offset,_loc5_,_loc12_,_loc20_,_loc8_,_loc9_,_loc10_); + } + else + { + this.fillInPolygon(param1,_loc7_,param2,this.verticesInput.offset,_loc5_,_loc12_,_loc8_,_loc9_,_loc10_); + } + break; + case "triangles": + _loc11_ = data.p[0]; + if(_loc11_ == null) + { + document.logger.logNotEnoughDataError(data); + return; + } + _loc12_ = parseIntsArray(_loc11_); + this.fillInTriangles(param1,_loc7_,param2,this.verticesInput.offset,_loc5_,_loc12_,_loc8_,_loc9_,_loc10_); + break; + } + } + + private function applyUV(param1:Mesh, param2:Vertex, param3:Vector., param4:int) : Vertex + { + var _loc7_:Vertex = null; + var _loc5_:Number = param3[param4]; + var _loc6_:Number = 1 - param3[int(param4 + 1)]; + if(param2.index == -1) + { + param2.u = _loc5_; + param2.v = _loc6_; + param2.index = param4; + return param2; + } + if(param2.index == param4) + { + return param2; + } + while(param2.value != null) + { + param2 = param2.value; + if(param2.index == param4) + { + return param2; + } + } + _loc7_ = new Vertex(); + _loc7_.next = param1.vertexList; + param1.vertexList = _loc7_; + _loc7_.x = param2.x; + _loc7_.y = param2.y; + _loc7_.z = param2.z; + _loc7_.u = _loc5_; + _loc7_.v = _loc6_; + param2.value = _loc7_; + _loc7_.index = param4; + return _loc7_; + } + + private function fillInPolygon(param1:Mesh, param2:Material, param3:Vector., param4:int, param5:int, param6:Array, param7:Vector., param8:int = 1, param9:int = 0) : void + { + var _loc11_:Wrapper = null; + var _loc13_:Vertex = null; + var _loc14_:Wrapper = null; + var _loc10_:Face = new Face(); + _loc10_.material = param2; + _loc10_.next = param1.faceList; + param1.faceList = _loc10_; + var _loc12_:int = 0; + while(_loc12_ < param5) + { + _loc13_ = param3[param6[int(this.inputsStride * _loc12_ + param4)]]; + if(param7 != null) + { + _loc13_ = this.applyUV(param1,_loc13_,param7,param8 * param6[int(this.inputsStride * _loc12_ + param9)]); + } + _loc14_ = new Wrapper(); + _loc14_.vertex = _loc13_; + if(_loc11_ != null) + { + _loc11_.next = _loc14_; + } + else + { + _loc10_.wrapper = _loc14_; + } + _loc11_ = _loc14_; + _loc12_++; + } + } + + private function fillInPolylist(param1:Mesh, param2:Material, param3:Vector., param4:int, param5:int, param6:Array, param7:Array, param8:Vector. = null, param9:int = 1, param10:int = 0) : void + { + var _loc13_:int = 0; + var _loc14_:Face = null; + var _loc15_:Wrapper = null; + var _loc16_:int = 0; + var _loc17_:int = 0; + var _loc18_:Vertex = null; + var _loc19_:Wrapper = null; + var _loc11_:int = 0; + var _loc12_:int = 0; + while(_loc12_ < param5) + { + _loc13_ = param7[_loc12_]; + if(_loc13_ >= 3) + { + _loc14_ = new Face(); + _loc14_.material = param2; + _loc14_.next = param1.faceList; + param1.faceList = _loc14_; + _loc15_ = null; + _loc16_ = 0; + while(_loc16_ < _loc13_) + { + _loc17_ = this.inputsStride * (_loc11_ + _loc16_); + _loc18_ = param3[param6[int(_loc17_ + param4)]]; + if(param8 != null) + { + _loc18_ = this.applyUV(param1,_loc18_,param8,param9 * param6[int(_loc17_ + param10)]); + } + _loc19_ = new Wrapper(); + _loc19_.vertex = _loc18_; + if(_loc15_ != null) + { + _loc15_.next = _loc19_; + } + else + { + _loc14_.wrapper = _loc19_; + } + _loc15_ = _loc19_; + _loc16_++; + } + _loc11_ += _loc13_; + } + _loc12_++; + } + } + + private function fillInTriangles(param1:Mesh, param2:Material, param3:Vector., param4:int, param5:int, param6:Array, param7:Vector. = null, param8:int = 1, param9:int = 0) : void + { + var _loc11_:int = 0; + var _loc12_:int = 0; + var _loc13_:Vertex = null; + var _loc14_:Vertex = null; + var _loc15_:Vertex = null; + var _loc16_:Face = null; + var _loc17_:int = 0; + var _loc10_:int = 0; + while(_loc10_ < param5) + { + _loc11_ = 3 * this.inputsStride * _loc10_; + _loc12_ = _loc11_ + param4; + _loc13_ = param3[param6[int(_loc12_)]]; + _loc14_ = param3[param6[int(_loc12_ + this.inputsStride)]]; + _loc15_ = param3[param6[int(_loc12_ + 2 * this.inputsStride)]]; + if(param7 != null) + { + _loc17_ = _loc11_ + param9; + _loc13_ = this.applyUV(param1,_loc13_,param7,param8 * param6[int(_loc17_)]); + _loc14_ = this.applyUV(param1,_loc14_,param7,param8 * param6[int(_loc17_ + this.inputsStride)]); + _loc15_ = this.applyUV(param1,_loc15_,param7,param8 * param6[int(_loc17_ + 2 * this.inputsStride)]); + } + _loc16_ = new Face(); + _loc16_.material = param2; + _loc16_.next = param1.faceList; + param1.faceList = _loc16_; + _loc16_.wrapper = new Wrapper(); + _loc16_.wrapper.vertex = _loc13_; + _loc16_.wrapper.next = new Wrapper(); + _loc16_.wrapper.next.vertex = _loc14_; + _loc16_.wrapper.next.next = new Wrapper(); + _loc16_.wrapper.next.next.vertex = _loc15_; + _loc10_++; + } + } + + public function verticesEquals(param1:DaeVertices) : Boolean + { + var _loc2_:DaeVertices = document.findVertices(this.verticesInput.source); + if(_loc2_ == null) + { + document.logger.logNotFoundError(this.verticesInput.source); + } + return _loc2_ == param1; + } + + public function get materialSymbol() : String + { + var _loc1_:XML = data.@material[0]; + return _loc1_ == null ? null : _loc1_.toString(); + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeSampler.as b/src/alternativa/engine3d/loaders/collada/DaeSampler.as new file mode 100644 index 0000000..e623e73 --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeSampler.as @@ -0,0 +1,144 @@ +package alternativa.engine3d.loaders.collada +{ + import alternativa.engine3d.animation.keys.NumberTrack; + import alternativa.engine3d.animation.keys.Track; + import alternativa.engine3d.animation.keys.TransformTrack; + import flash.geom.Matrix3D; + + use namespace collada; + + public class DaeSampler extends DaeElement + { + + + private var times:Vector.; + + private var values:Vector.; + + private var timesStride:int; + + private var valuesStride:int; + + public function DaeSampler(param1:XML, param2:DaeDocument) + { + super(param1,param2); + } + + override protected function parseImplementation() : Boolean + { + var _loc2_:DaeSource = null; + var _loc3_:DaeSource = null; + var _loc6_:DaeInput = null; + var _loc7_:String = null; + var _loc1_:XMLList = data.input; + var _loc4_:int = 0; + var _loc5_:int = _loc1_.length(); + for(; _loc4_ < _loc5_; _loc4_++) + { + _loc6_ = new DaeInput(_loc1_[_loc4_],document); + _loc7_ = _loc6_.semantic; + if(_loc7_ == null) + { + continue; + } + switch(_loc7_) + { + case "INPUT": + _loc2_ = _loc6_.prepareSource(1); + if(_loc2_ != null) + { + this.times = _loc2_.numbers; + this.timesStride = _loc2_.stride; + } + break; + case "OUTPUT": + _loc3_ = _loc6_.prepareSource(1); + if(_loc3_ != null) + { + this.values = _loc3_.numbers; + this.valuesStride = _loc3_.stride; + } + break; + } + } + return true; + } + + public function parseNumbersTrack(param1:String, param2:String) : NumberTrack + { + var _loc3_:NumberTrack = null; + var _loc4_:int = 0; + var _loc5_:int = 0; + if(this.times != null && this.values != null && this.timesStride > 0) + { + _loc3_ = new NumberTrack(param1,param2); + _loc4_ = this.times.length / this.timesStride; + _loc5_ = 0; + while(_loc5_ < _loc4_) + { + _loc3_.addKey(this.times[int(this.timesStride * _loc5_)],this.values[int(this.valuesStride * _loc5_)]); + _loc5_++; + } + return _loc3_; + } + return null; + } + + public function parseTransformationTrack(param1:String) : Track + { + var _loc2_:TransformTrack = null; + var _loc3_:int = 0; + var _loc4_:int = 0; + var _loc5_:int = 0; + var _loc6_:Matrix3D = null; + if(this.times != null && this.values != null && this.timesStride != 0) + { + _loc2_ = new TransformTrack(param1); + _loc3_ = this.times.length / this.timesStride; + _loc4_ = 0; + while(_loc4_ < _loc3_) + { + _loc5_ = this.valuesStride * _loc4_; + _loc6_ = new Matrix3D(Vector.([this.values[_loc5_],this.values[_loc5_ + 4],this.values[_loc5_ + 8],this.values[_loc5_ + 12],this.values[_loc5_ + 1],this.values[_loc5_ + 5],this.values[_loc5_ + 9],this.values[_loc5_ + 13],this.values[_loc5_ + 2],this.values[_loc5_ + 6],this.values[_loc5_ + 10],this.values[_loc5_ + 14],this.values[_loc5_ + 3],this.values[_loc5_ + 7],this.values[_loc5_ + 11],this.values[_loc5_ + 15]])); + _loc2_.addKey(this.times[_loc4_ * this.timesStride],_loc6_); + _loc4_++; + } + return _loc2_; + } + return null; + } + + public function parsePointsTracks(param1:String, param2:String, param3:String, param4:String) : Vector. + { + var _loc5_:NumberTrack = null; + var _loc6_:NumberTrack = null; + var _loc7_:NumberTrack = null; + var _loc8_:int = 0; + var _loc9_:int = 0; + var _loc10_:int = 0; + var _loc11_:Number = NaN; + if(this.times != null && this.values != null && this.timesStride != 0) + { + _loc5_ = new NumberTrack(param1,param2); + _loc5_.object = param1; + _loc6_ = new NumberTrack(param1,param3); + _loc6_.object = param1; + _loc7_ = new NumberTrack(param1,param4); + _loc7_.object = param1; + _loc8_ = this.times.length / this.timesStride; + _loc9_ = 0; + while(_loc9_ < _loc8_) + { + _loc10_ = _loc9_ * this.valuesStride; + _loc11_ = this.times[_loc9_ * this.timesStride]; + _loc5_.addKey(_loc11_,this.values[_loc10_]); + _loc6_.addKey(_loc11_,this.values[_loc10_ + 1]); + _loc7_.addKey(_loc11_,this.values[_loc10_ + 2]); + _loc9_++; + } + return Vector.([_loc5_,_loc6_,_loc7_]); + } + return null; + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeSource.as b/src/alternativa/engine3d/loaders/collada/DaeSource.as new file mode 100644 index 0000000..af5498f --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeSource.as @@ -0,0 +1,182 @@ +package alternativa.engine3d.loaders.collada +{ + use namespace collada; + + public class DaeSource extends DaeElement + { + + + private const FLOAT_ARRAY:String = "float_array"; + + private const INT_ARRAY:String = "int_array"; + + private const NAME_ARRAY:String = "Name_array"; + + public var numbers:Vector.; + + public var ints:Vector.; + + public var names:Vector.; + + public var stride:int; + + public function DaeSource(param1:XML, param2:DaeDocument) + { + super(param1,param2); + this.constructArrays(); + } + + private function constructArrays() : void + { + var _loc4_:XML = null; + var _loc5_:DaeArray = null; + var _loc1_:XMLList = data.children(); + var _loc2_:int = 0; + var _loc3_:int = _loc1_.length(); + while(_loc2_ < _loc3_) + { + _loc4_ = _loc1_[_loc2_]; + switch(_loc4_.localName()) + { + case this.FLOAT_ARRAY: + case this.INT_ARRAY: + case this.NAME_ARRAY: + _loc5_ = new DaeArray(_loc4_,document); + if(_loc5_.id != null) + { + document.arrays[_loc5_.id] = _loc5_; + } + break; + } + _loc2_++; + } + } + + private function get accessor() : XML + { + return data.technique_common.accessor[0]; + } + + override protected function parseImplementation() : Boolean + { + var _loc2_:XML = null; + var _loc3_:DaeArray = null; + var _loc4_:String = null; + var _loc5_:int = 0; + var _loc6_:XML = null; + var _loc7_:XML = null; + var _loc8_:int = 0; + var _loc9_:int = 0; + var _loc1_:XML = this.accessor; + if(_loc1_ != null) + { + _loc2_ = _loc1_.@source[0]; + _loc3_ = _loc2_ == null ? null : document.findArray(_loc2_); + if(_loc3_ != null) + { + _loc4_ = _loc1_.@count[0]; + if(_loc4_ != null) + { + _loc5_ = parseInt(_loc4_.toString(),10); + _loc6_ = _loc1_.@offset[0]; + _loc7_ = _loc1_.@stride[0]; + _loc8_ = _loc6_ == null ? int(0) : int(parseInt(_loc6_.toString(),10)); + _loc9_ = _loc7_ == null ? int(1) : int(parseInt(_loc7_.toString(),10)); + _loc3_.parse(); + if(_loc3_.array.length < _loc8_ + _loc5_ * _loc9_) + { + document.logger.logNotEnoughDataError(_loc1_); + return false; + } + this.stride = this.parseArray(_loc8_,_loc5_,_loc9_,_loc3_.array,_loc3_.type); + return true; + } + } + else + { + document.logger.logNotFoundError(_loc2_); + } + } + return false; + } + + private function numValidParams(param1:XMLList) : int + { + var _loc2_:int = 0; + var _loc3_:int = 0; + var _loc4_:int = param1.length(); + while(_loc3_ < _loc4_) + { + if(param1[_loc3_].@name[0] != null) + { + _loc2_++; + } + _loc3_++; + } + return _loc2_; + } + + private function parseArray(param1:int, param2:int, param3:int, param4:Array, param5:String) : int + { + var _loc10_:XML = null; + var _loc11_:int = 0; + var _loc12_:String = null; + var _loc6_:XMLList = this.accessor.param; + var _loc7_:int = Math.max(this.numValidParams(_loc6_),param3); + switch(param5) + { + case this.FLOAT_ARRAY: + this.numbers = new Vector.(int(_loc7_ * param2)); + break; + case this.INT_ARRAY: + this.ints = new Vector.(int(_loc7_ * param2)); + break; + case this.NAME_ARRAY: + this.names = new Vector.(int(_loc7_ * param2)); + } + var _loc8_:int = 0; + var _loc9_:int = 0; + while(_loc9_ < _loc7_) + { + _loc10_ = _loc6_[_loc9_]; + if(_loc10_ == null || _loc10_.hasOwnProperty("@name")) + { + switch(param5) + { + case this.FLOAT_ARRAY: + _loc11_ = 0; + while(_loc11_ < param2) + { + _loc12_ = param4[int(param1 + param3 * _loc11_ + _loc9_)]; + if(_loc12_.indexOf(",") != -1) + { + _loc12_ = _loc12_.replace(/,/,"."); + } + this.numbers[int(_loc7_ * _loc11_ + _loc8_)] = parseFloat(_loc12_); + _loc11_++; + } + break; + case this.INT_ARRAY: + _loc11_ = 0; + while(_loc11_ < param2) + { + this.ints[int(_loc7_ * _loc11_ + _loc8_)] = parseInt(param4[int(param1 + param3 * _loc11_ + _loc9_)],10); + _loc11_++; + } + break; + case this.NAME_ARRAY: + _loc11_ = 0; + while(_loc11_ < param2) + { + this.names[int(_loc7_ * _loc11_ + _loc8_)] = param4[int(param1 + param3 * _loc11_ + _loc9_)]; + _loc11_++; + } + } + _loc8_++; + } + _loc9_++; + } + return _loc7_; + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeVertices.as b/src/alternativa/engine3d/loaders/collada/DaeVertices.as new file mode 100644 index 0000000..938cdf7 --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeVertices.as @@ -0,0 +1,62 @@ +package alternativa.engine3d.loaders.collada +{ + import alternativa.engine3d.alternativa3d; + import alternativa.engine3d.core.Vertex; + import alternativa.engine3d.objects.Mesh; + + use namespace alternativa3d; + use namespace collada; + + public class DaeVertices extends DaeElement + { + + + private var positions:DaeSource; + + public function DaeVertices(param1:XML, param2:DaeDocument) + { + super(param1,param2); + } + + override protected function parseImplementation() : Boolean + { + var inputXML:XML = null; + inputXML = data.input.(@semantic == "POSITION")[0]; + if(inputXML != null) + { + this.positions = new DaeInput(inputXML,document).prepareSource(3); + if(this.positions != null) + { + return true; + } + } + return false; + } + + public function fillInMesh(param1:Mesh) : Vector. + { + var _loc6_:int = 0; + var _loc7_:int = 0; + var _loc8_:Vertex = null; + var _loc2_:int = this.positions.stride; + var _loc3_:Vector. = this.positions.numbers; + var _loc4_:int = this.positions.numbers.length / _loc2_; + var _loc5_:Vector. = new Vector.(_loc4_); + _loc6_ = 0; + while(_loc6_ < _loc4_) + { + _loc7_ = _loc2_ * _loc6_; + _loc8_ = new Vertex(); + _loc8_.next = param1.vertexList; + param1.vertexList = _loc8_; + _loc8_.x = _loc3_[_loc7_]; + _loc8_.y = _loc3_[int(_loc7_ + 1)]; + _loc8_.z = _loc3_[int(_loc7_ + 2)]; + _loc8_.index = -1; + _loc5_[_loc6_] = _loc8_; + _loc6_++; + } + return _loc5_; + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/DaeVisualScene.as b/src/alternativa/engine3d/loaders/collada/DaeVisualScene.as new file mode 100644 index 0000000..f38094b --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/DaeVisualScene.as @@ -0,0 +1,36 @@ +package alternativa.engine3d.loaders.collada +{ + use namespace collada; + + public class DaeVisualScene extends DaeElement + { + + + public var nodes:Vector.; + + public function DaeVisualScene(param1:XML, param2:DaeDocument) + { + super(param1,param2); + this.constructNodes(); + } + + public function constructNodes() : void + { + var _loc4_:DaeNode = null; + var _loc1_:XMLList = data.node; + var _loc2_:int = _loc1_.length(); + this.nodes = new Vector.(_loc2_); + var _loc3_:int = 0; + while(_loc3_ < _loc2_) + { + _loc4_ = new DaeNode(_loc1_[_loc3_],document,this); + if(_loc4_.id != null) + { + document.nodes[_loc4_.id] = _loc4_; + } + this.nodes[_loc3_] = _loc4_; + _loc3_++; + } + } + } +} diff --git a/src/alternativa/engine3d/loaders/collada/collada.as b/src/alternativa/engine3d/loaders/collada/collada.as new file mode 100644 index 0000000..b0c1e3b --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/collada.as @@ -0,0 +1,4 @@ +package alternativa.engine3d.loaders.collada +{ + public namespace collada = "http://www.collada.org/2005/11/COLLADASchema"; +} diff --git a/src/alternativa/engine3d/loaders/collada/daeAlternativa3DInstance.as b/src/alternativa/engine3d/loaders/collada/daeAlternativa3DInstance.as new file mode 100644 index 0000000..25dd859 --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/daeAlternativa3DInstance.as @@ -0,0 +1,4 @@ +package alternativa.engine3d.loaders.collada +{ + public namespace daeAlternativa3DInstance = "http://alternativaplatform.com/a3d/Instance"; +} diff --git a/src/alternativa/engine3d/loaders/collada/daeAlternativa3DLibrary.as b/src/alternativa/engine3d/loaders/collada/daeAlternativa3DLibrary.as new file mode 100644 index 0000000..dd0daad --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/daeAlternativa3DLibrary.as @@ -0,0 +1,4 @@ +package alternativa.engine3d.loaders.collada +{ + public namespace daeAlternativa3DLibrary = "http://alternativaplatform.com/a3d/Library"; +} diff --git a/src/alternativa/engine3d/loaders/collada/daeAlternativa3DMesh.as b/src/alternativa/engine3d/loaders/collada/daeAlternativa3DMesh.as new file mode 100644 index 0000000..304a218 --- /dev/null +++ b/src/alternativa/engine3d/loaders/collada/daeAlternativa3DMesh.as @@ -0,0 +1,4 @@ +package alternativa.engine3d.loaders.collada +{ + public namespace daeAlternativa3DMesh = "http://alternativaplatform.com/a3d/Mesh"; +} diff --git a/src/alternativa/engine3d/loaders/events/LoaderErrorEvent.as b/src/alternativa/engine3d/loaders/events/LoaderErrorEvent.as new file mode 100644 index 0000000..6ccf5db --- /dev/null +++ b/src/alternativa/engine3d/loaders/events/LoaderErrorEvent.as @@ -0,0 +1,36 @@ +package alternativa.engine3d.loaders.events +{ + import flash.events.ErrorEvent; + import flash.events.Event; + + public class LoaderErrorEvent extends ErrorEvent + { + + public static const LOADER_ERROR:String = "loaderError"; + + + private var _url:String; + + public function LoaderErrorEvent(param1:String, param2:String, param3:String) + { + super(param1); + this.text = param3; + this._url = param2; + } + + public function get url() : String + { + return this._url; + } + + override public function clone() : Event + { + return new LoaderErrorEvent(type,this._url,text); + } + + override public function toString() : String + { + return "[LoaderErrorEvent url=" + this._url + ", text=" + text + "]"; + } + } +} diff --git a/src/alternativa/engine3d/loaders/events/LoaderEvent.as b/src/alternativa/engine3d/loaders/events/LoaderEvent.as new file mode 100644 index 0000000..35117b9 --- /dev/null +++ b/src/alternativa/engine3d/loaders/events/LoaderEvent.as @@ -0,0 +1,52 @@ +package alternativa.engine3d.loaders.events +{ + import flash.events.Event; + + public class LoaderEvent extends Event + { + + public static const PART_OPEN:String = "partOpen"; + + public static const PART_COMPLETE:String = "partComplete"; + + + private var _partsTotal:int; + + private var _currentPart:int; + + private var _target:Object; + + public function LoaderEvent(param1:String, param2:int, param3:int, param4:Object = null) + { + super(param1); + this._partsTotal = param2; + this._currentPart = param3; + this._target = param4; + } + + public function get partsTotal() : int + { + return this._partsTotal; + } + + public function get currentPart() : int + { + return this._currentPart; + } + + override public function get target() : Object + { + return this._target; + } + + override public function clone() : Event + { + return new LoaderEvent(type,this._partsTotal,this._currentPart,this._target); + } + + override public function toString() : String + { + return "[LoaderEvent type=" + type + ", partsTotal=" + this._partsTotal + ", currentPart=" + this._currentPart + ", target=" + this._target + "]"; + } + } +} diff --git a/src/alternativa/engine3d/loaders/events/LoaderProgressEvent.as b/src/alternativa/engine3d/loaders/events/LoaderProgressEvent.as new file mode 100644 index 0000000..3711291 --- /dev/null +++ b/src/alternativa/engine3d/loaders/events/LoaderProgressEvent.as @@ -0,0 +1,51 @@ +package alternativa.engine3d.loaders.events +{ + import flash.events.Event; + import flash.events.ProgressEvent; + + public class LoaderProgressEvent extends ProgressEvent + { + + public static const LOADER_PROGRESS:String = "loaderProgress"; + + + private var _filesTotal:int; + + private var _filesLoaded:int; + + private var _totalProgress:Number = 0; + + public function LoaderProgressEvent(param1:String, param2:int, param3:int, param4:Number = 0, param5:uint = 0, param6:uint = 0) + { + super(param1,false,false,param5,param6); + this._filesTotal = param2; + this._filesLoaded = param3; + this._totalProgress = param4; + } + + public function get filesTotal() : int + { + return this._filesTotal; + } + + public function get filesLoaded() : int + { + return this._filesLoaded; + } + + public function get totalProgress() : Number + { + return this._totalProgress; + } + + override public function clone() : Event + { + return new LoaderProgressEvent(type,this._filesTotal,this._filesLoaded,this._totalProgress,bytesLoaded,bytesTotal); + } + + override public function toString() : String + { + return "[LoaderProgressEvent filesTotal=" + this._filesTotal + ", filesLoaded=" + this._filesLoaded + ", totalProgress=" + this._totalProgress.toFixed(2) + "]"; + } + } +} diff --git a/src/alternativa/engine3d/materials/AverageLightMaterial.as b/src/alternativa/engine3d/materials/AverageLightMaterial.as new file mode 100644 index 0000000..9c6309a --- /dev/null +++ b/src/alternativa/engine3d/materials/AverageLightMaterial.as @@ -0,0 +1,12 @@ +package alternativa.engine3d.materials +{ + public class AverageLightMaterial extends TextureMaterial + { + + + public function AverageLightMaterial() + { + super(); + } + } +} diff --git a/src/alternativa/engine3d/materials/FillMaterial.as b/src/alternativa/engine3d/materials/FillMaterial.as new file mode 100644 index 0000000..0c6e3bd --- /dev/null +++ b/src/alternativa/engine3d/materials/FillMaterial.as @@ -0,0 +1,71 @@ +package alternativa.engine3d.materials +{ + import flash.display.BitmapData; + import alternativa.engine3d.core.Camera3D; + import alternativa.gfx.core.VertexBufferResource; + import alternativa.gfx.core.IndexBufferResource; + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class FillMaterial extends TextureMaterial + { + + public var color:int; + public var alpha:Number; + public var lineThickness:Number; + public var lineColor:int; + + public function FillMaterial(_arg_1:int=0x7F7F7F, _arg_2:Number=1, _arg_3:Number=-1, _arg_4:int=0xFFFFFF) + { + this.color = _arg_1; + this.alpha = _arg_2; + this.lineThickness = _arg_3; + this.lineColor = _arg_4; + //_texture = new BitmapData(1,1,true,(alpha * 255 << 24) + color); + } + + override alternativa3d function get transparent():Boolean + { + return (this.alpha < 1); + } + + override public function clone():Material + { + var _local_1:FillMaterial = new FillMaterial(this.color, this.alpha, this.lineThickness, this.lineColor); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + override alternativa3d function drawOpaque(_arg_1:Camera3D, _arg_2:VertexBufferResource, _arg_3:IndexBufferResource, _arg_4:int, _arg_5:int, _arg_6:Object3D):void + { + var _local_7:uint = (((this.alpha * 0xFF) << 24) + this.color); + var _local_8:BitmapData = texture; + if (_local_8 != null) + { + if (_local_7 != _local_8.getPixel32(0, 0)) + { + _local_8.setPixel32(0, 0, _local_7); + }; + super.drawOpaque(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6); + }; + } + + override alternativa3d function drawTransparent(_arg_1:Camera3D, _arg_2:VertexBufferResource, _arg_3:IndexBufferResource, _arg_4:int, _arg_5:int, _arg_6:Object3D, _arg_7:Boolean=false):void + { + var _local_8:uint = (((this.alpha * 0xFF) << 24) + this.color); + var _local_9:BitmapData = texture; + if (_local_9 != null) + { + if (_local_8 != _local_9.getPixel32(0, 0)) + { + _local_9.setPixel32(0, 0, _local_8); + }; + super.drawTransparent(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7); + }; + } + + + } +}//package alternativa.engine3d.materials \ No newline at end of file diff --git a/src/alternativa/engine3d/materials/FlatShadingMaterial.as b/src/alternativa/engine3d/materials/FlatShadingMaterial.as new file mode 100644 index 0000000..41581d6 --- /dev/null +++ b/src/alternativa/engine3d/materials/FlatShadingMaterial.as @@ -0,0 +1,12 @@ +package alternativa.engine3d.materials +{ + public class FlatShadingMaterial extends TextureMaterial + { + + + public function FlatShadingMaterial() + { + super(); + } + } +} diff --git a/src/alternativa/engine3d/materials/Material.as b/src/alternativa/engine3d/materials/Material.as new file mode 100644 index 0000000..7ae0191 --- /dev/null +++ b/src/alternativa/engine3d/materials/Material.as @@ -0,0 +1,68 @@ +package alternativa.engine3d.materials +{ + import flash.utils.getQualifiedClassName; + import alternativa.engine3d.core.Camera3D; + import alternativa.gfx.core.VertexBufferResource; + import alternativa.gfx.core.IndexBufferResource; + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class Material + { + + public var name:String; + public var alphaTestThreshold:Number = 0; + public var zOffset:Boolean = false; + public var uploadEveryFrame:Boolean = false; + alternativa3d var drawId:uint = 0; + alternativa3d var useVerticesNormals:Boolean = true; + private var isTransparent:Boolean; + + + alternativa3d function get transparent():Boolean + { + return (this.isTransparent); + } + + alternativa3d function set transparent(_arg_1:Boolean):void + { + this.isTransparent = _arg_1; + } + + public function clone():Material + { + var _local_1:Material = new Material(); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + protected function clonePropertiesFrom(_arg_1:Material):void + { + this.name = _arg_1.name; + this.alphaTestThreshold = _arg_1.alphaTestThreshold; + this.useVerticesNormals = _arg_1.useVerticesNormals; + } + + public function toString():String + { + var _local_1:String = getQualifiedClassName(this); + return (((("[" + _local_1.substr((_local_1.indexOf("::") + 2))) + " ") + this.name) + "]"); + } + + alternativa3d function drawOpaque(_arg_1:Camera3D, _arg_2:VertexBufferResource, _arg_3:IndexBufferResource, _arg_4:int, _arg_5:int, _arg_6:Object3D):void + { + } + + alternativa3d function drawTransparent(_arg_1:Camera3D, _arg_2:VertexBufferResource, _arg_3:IndexBufferResource, _arg_4:int, _arg_5:int, _arg_6:Object3D, _arg_7:Boolean=false):void + { + } + + public function dispose():void + { + } + + + } +}//package alternativa.engine3d.materials \ No newline at end of file diff --git a/src/alternativa/engine3d/materials/MaterialEntry.as b/src/alternativa/engine3d/materials/MaterialEntry.as new file mode 100644 index 0000000..26e9619 --- /dev/null +++ b/src/alternativa/engine3d/materials/MaterialEntry.as @@ -0,0 +1,25 @@ +package alternativa.engine3d.materials +{ + import flash.display.BitmapData; + + public class MaterialEntry + { + + + public var keyData:Object; + + public var texture:BitmapData; + + public var material:TextureMaterial; + + public var referenceCount:int; + + public function MaterialEntry(param1:Object, param2:TextureMaterial) + { + super(); + this.keyData = param1; + this.texture = param1 as BitmapData; + this.material = param2; + } + } +} diff --git a/src/alternativa/engine3d/materials/NormalMapMaterial.as b/src/alternativa/engine3d/materials/NormalMapMaterial.as new file mode 100644 index 0000000..2815b67 --- /dev/null +++ b/src/alternativa/engine3d/materials/NormalMapMaterial.as @@ -0,0 +1,12 @@ +package alternativa.engine3d.materials +{ + public class NormalMapMaterial extends TextureMaterial + { + + + public function NormalMapMaterial() + { + super(); + } + } +} diff --git a/src/alternativa/engine3d/materials/SphericalEnvironmentMaterial.as b/src/alternativa/engine3d/materials/SphericalEnvironmentMaterial.as new file mode 100644 index 0000000..8994975 --- /dev/null +++ b/src/alternativa/engine3d/materials/SphericalEnvironmentMaterial.as @@ -0,0 +1,12 @@ +package alternativa.engine3d.materials +{ + public class SphericalEnvironmentMaterial extends TextureMaterial + { + + + public function SphericalEnvironmentMaterial() + { + super(); + } + } +} diff --git a/src/alternativa/engine3d/materials/TextureMaterial.as b/src/alternativa/engine3d/materials/TextureMaterial.as new file mode 100644 index 0000000..b0fa847 --- /dev/null +++ b/src/alternativa/engine3d/materials/TextureMaterial.as @@ -0,0 +1,487 @@ +package alternativa.engine3d.materials +{ + import __AS3__.vec.Vector; + import flash.utils.ByteArray; + import alternativa.gfx.core.BitmapTextureResource; + import alternativa.gfx.core.CompressedTextureResource; + import flash.display.BitmapData; + import alternativa.gfx.core.Device; + import alternativa.engine3d.objects.Decal; + import alternativa.engine3d.objects.SkyBox; + import alternativa.engine3d.core.Camera3D; + import flash.display3D.Context3DVertexBufferFormat; + import flash.display3D.Context3DProgramType; + import alternativa.gfx.core.VertexBufferResource; + import alternativa.gfx.core.IndexBufferResource; + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.objects.Sprite3D; + import alternativa.gfx.core.ProgramResource; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class TextureMaterial extends Material + { + + protected static const skyFogConst:Vector. = Vector.([0, 0, 0, 1]); + protected static const correctionConst:Vector. = Vector.([0, 0, 0, 1, 0, 0, 0, 1]); + protected static const uvCorrection:Vector. = Vector.([1, 1, 0, 1]); + protected static const fragmentConst:Vector. = Vector.([0, 0, 0, 1]); + private static var programs:Array = new Array(); + + protected var uvTransformConst:Vector. = Vector.([1, 0, 0, 0, 0, 1, 0, 0]); + public var diffuseMapURL:String; + public var opacityMapURL:String; + public var repeat:Boolean = false; + public var smooth:Boolean = true; + public var resolution:Number = 1; + public var threshold:Number = 0.01; + public var correctUV:Boolean = false; + alternativa3d var _textureATF:ByteArray; + alternativa3d var _textureATFAlpha:ByteArray; + alternativa3d var _mipMapping:int = 0; + alternativa3d var _hardwareMipMaps:Boolean = false; + alternativa3d var textureResource:BitmapTextureResource; + alternativa3d var textureATFResource:CompressedTextureResource; + alternativa3d var textureATFAlphaResource:CompressedTextureResource; + protected var bitmap:BitmapData; + + public function TextureMaterial(_arg_1:BitmapData=null, _arg_2:Boolean=false, _arg_3:Boolean=true, _arg_4:int=0, _arg_5:Number=1) + { + this.repeat = _arg_2; + this.smooth = _arg_3; + this._mipMapping = _arg_4; + this.resolution = _arg_5; + if (_arg_1 != null) + { + this.bitmap = _arg_1; + this.textureResource = TextureResourcesRegistry.getTextureResource(_arg_1, (this._mipMapping > 0), _arg_2, this._hardwareMipMaps); + }; + } + + public function get texture():BitmapData + { + if (this.textureResource != null) + { + return (this.textureResource.bitmapData); + }; + return (null); + } + + public function set texture(_arg_1:BitmapData):void + { + var _local_2:BitmapData = this.texture; + if (_arg_1 != _local_2) + { + if (_local_2 != null) + { + this.textureResource.dispose(); + this.textureResource = null; + }; + if (_arg_1 != null) + { + this.textureResource = TextureResourcesRegistry.getTextureResource(_arg_1, (this._mipMapping > 0), this.repeat, this._hardwareMipMaps); + }; + }; + } + + public function get textureATF():ByteArray + { + return (this._textureATF); + } + + public function set textureATF(_arg_1:ByteArray):void + { + if (_arg_1 != this._textureATF) + { + if (this._textureATF != null) + { + this.textureATFResource.dispose(); + this.textureATFResource = null; + }; + this._textureATF = _arg_1; + if (this._textureATF != null) + { + this.textureATFResource = new CompressedTextureResource(this._textureATF); + }; + }; + } + + public function get textureATFAlpha():ByteArray + { + return (this._textureATFAlpha); + } + + public function set textureATFAlpha(_arg_1:ByteArray):void + { + if (_arg_1 != this._textureATFAlpha) + { + if (this._textureATFAlpha != null) + { + this.textureATFAlphaResource.dispose(); + this.textureATFAlphaResource = null; + }; + this._textureATFAlpha = _arg_1; + if (this._textureATFAlpha != null) + { + this.textureATFAlphaResource = new CompressedTextureResource(this._textureATFAlpha); + }; + }; + } + + public function get mipMapping():int + { + return (this._mipMapping); + } + + public function set mipMapping(_arg_1:int):void + { + this._mipMapping = _arg_1; + if (this.bitmap != null) + { + this.textureResource = TextureResourcesRegistry.getTextureResource(this.bitmap, (this._mipMapping > 0), this.repeat, this._hardwareMipMaps); + }; + } + + public function disposeResource():void + { + if (this.textureResource != null) + { + this.textureResource.dispose(); + this.textureResource = null; + }; + } + + public function get hardwareMipMaps():Boolean + { + return (this._hardwareMipMaps); + } + + public function set hardwareMipMaps(_arg_1:Boolean):void + { + if (_arg_1 != this._hardwareMipMaps) + { + this._hardwareMipMaps = _arg_1; + if (this.texture != null) + { + this.textureResource.calculateMipMapsUsingGPU = this._hardwareMipMaps; + }; + }; + } + + override public function clone():Material + { + var _local_1:TextureMaterial = new TextureMaterial(this.texture, this.repeat, this.smooth, this._mipMapping, this.resolution); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + override protected function clonePropertiesFrom(_arg_1:Material):void + { + super.clonePropertiesFrom(_arg_1); + var _local_2:TextureMaterial = (_arg_1 as TextureMaterial); + this.diffuseMapURL = _local_2.diffuseMapURL; + this.opacityMapURL = _local_2.opacityMapURL; + this.threshold = _local_2.threshold; + this.correctUV = _local_2.correctUV; + this.textureATF = _local_2.textureATF; + this.textureATFAlpha = _local_2.textureATFAlpha; + this.hardwareMipMaps = _local_2.hardwareMipMaps; + } + + override alternativa3d function get transparent():Boolean + { + if (super.transparent) + { + return (true); + }; + if (this.texture != null) + { + return (this.texture.transparent); + }; + if (this._textureATF != null) + { + return (!(this._textureATFAlpha == null)); + }; + return (false); + } + + override alternativa3d function drawOpaque(_arg_1:Camera3D, _arg_2:VertexBufferResource, _arg_3:IndexBufferResource, _arg_4:int, _arg_5:int, _arg_6:Object3D):void + { + var _local_7:BitmapData = this.texture; + if (((_local_7 == null) && (this._textureATF == null))) + { + return; + }; + var _local_8:Device = _arg_1.device; + var _local_9:Boolean = (_arg_6 is Decal); + var _local_10:Boolean = ((!(_local_9)) && (zOffset)); + var _local_11:Boolean = ((_arg_6 is SkyBox) && (SkyBox(_arg_6).autoSize)); + var _local_12:Boolean = ((_arg_1.fogAlpha > 0) && (_arg_1.fogStrength > 0)); + var _local_13:Boolean = (((((!(_arg_1.view.constrained)) && (_arg_1.ssao)) && (_arg_1.ssaoStrength > 0)) && (_arg_6.useDepth)) && (!(_local_11))); + var _local_14:Boolean = (((((!(_arg_1.view.constrained)) && (!(_arg_1.directionalLight == null))) && (_arg_1.directionalLightStrength > 0)) && (_arg_6.useLight)) && (!(_local_11))); + var _local_15:Boolean = ((((((!(_arg_1.view.constrained)) && (!(_arg_1.shadowMap == null))) && (_arg_1.shadowMapStrength > 0)) && (_arg_6.useLight)) && (_arg_6.useShadowMap)) && (!(_local_11))); + var _local_16:Boolean = ((((((!(_arg_1.view.constrained)) && (_arg_1.deferredLighting)) && (_arg_1.deferredLightingStrength > 0)) && (_arg_6.useDepth)) && (_arg_6.useLight)) && (!(_local_11))); + var _local_17:Boolean = ((alphaTestThreshold > 0) && (this.transparent)); + _local_8.setProgram(this.getProgram(((!(_local_9)) && (!(_local_17))), _local_11, ((_local_9) || (_local_10)), false, _arg_1.view.quality, this.repeat, (this._mipMapping > 0), (!(_arg_6.concatenatedColorTransform == null)), ((_local_9) && (_arg_6.concatenatedAlpha < 1)), _local_12, false, _local_13, _local_14, _local_15, (_local_7 == null), false, _local_16, false, _arg_1.view.correction, (!(_arg_6.concatenatedBlendMode == "normal")), _local_17, false)); + if (_local_7 != null) + { + if (((uploadEveryFrame) && (!(drawId == Camera3D.renderId)))) + { + _local_8.uploadResource(this.textureResource); + drawId = Camera3D.renderId; + }; + _local_8.setTextureAt(0, this.textureResource); + uvCorrection[0] = this.textureResource.correctionU; + uvCorrection[1] = this.textureResource.correctionV; + } else + { + _local_8.setTextureAt(0, this.textureATFResource); + uvCorrection[0] = 1; + uvCorrection[1] = 1; + }; + if (_local_13) + { + _local_8.setTextureAt(1, _arg_1.depthMap); + } else + { + _local_8.setTextureAt(1, null); + }; + if (_local_15) + { + _local_8.setTextureAt(2, _arg_1.shadowMap.map); + _local_8.setTextureAt(3, _arg_1.shadowMap.noise); + } else + { + _local_8.setTextureAt(2, null); + _local_8.setTextureAt(3, null); + }; + _local_8.setTextureAt(4, null); + _local_8.setTextureAt(6, null); + if (_local_16) + { + _local_8.setTextureAt(5, _arg_1.lightMap); + } else + { + _local_8.setTextureAt(5, null); + }; + _local_8.setVertexBufferAt(0, _arg_2, 0, Context3DVertexBufferFormat.FLOAT_3); + _local_8.setVertexBufferAt(1, _arg_2, 3, Context3DVertexBufferFormat.FLOAT_2); + if (_local_14) + { + _local_8.setVertexBufferAt(2, _arg_2, 5, Context3DVertexBufferFormat.FLOAT_3); + } else + { + _local_8.setVertexBufferAt(2, null); + }; + _local_8.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 0, _arg_6.transformConst, 3, false); + _local_8.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 4, uvCorrection, 1); + if (_local_9) + { + correctionConst[0] = (_arg_6.md * _arg_1.correctionX); + correctionConst[1] = (_arg_6.mh * _arg_1.correctionY); + correctionConst[2] = _arg_6.ml; + correctionConst[3] = _arg_1.correctionX; + correctionConst[4] = ((_arg_6.mc * _arg_1.correctionX) / Decal(_arg_6).attenuation); + correctionConst[5] = ((_arg_6.mg * _arg_1.correctionY) / Decal(_arg_6).attenuation); + correctionConst[6] = (_arg_6.mk / Decal(_arg_6).attenuation); + correctionConst[7] = _arg_1.correctionY; + _local_8.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 11, correctionConst, 2, false); + } else + { + if (_local_10) + { + correctionConst[0] = 0; + correctionConst[1] = 0; + correctionConst[2] = 0; + correctionConst[3] = _arg_1.correctionX; + correctionConst[4] = 0; + correctionConst[5] = 0; + correctionConst[6] = 0; + correctionConst[7] = _arg_1.correctionY; + _local_8.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 11, correctionConst, 2, false); + } else + { + if (_local_11) + { + _local_8.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 11, SkyBox(_arg_6).reduceConst, 1); + if (_local_12) + { + skyFogConst[0] = (_arg_1.fogFragment[0] * _arg_1.fogFragment[3]); + skyFogConst[1] = (_arg_1.fogFragment[1] * _arg_1.fogFragment[3]); + skyFogConst[2] = (_arg_1.fogFragment[2] * _arg_1.fogFragment[3]); + skyFogConst[3] = (1 - _arg_1.fogFragment[3]); + _local_8.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 13, skyFogConst, 1); + }; + }; + }; + }; + if (_arg_6.concatenatedColorTransform != null) + { + _local_8.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 0, _arg_6.colorConst, 2, false); + } else + { + if (((_local_9) && (_arg_6.concatenatedAlpha < 1))) + { + _local_8.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 0, _arg_6.colorConst, 1); + }; + }; + if (_local_17) + { + fragmentConst[3] = alphaTestThreshold; + _local_8.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 14, fragmentConst, 1, false); + }; + _local_8.drawTriangles(_arg_3, _arg_4, _arg_5); + _arg_1.numDraws++; + _arg_1.numTriangles = (_arg_1.numTriangles + _arg_5); + } + + override alternativa3d function drawTransparent(_arg_1:Camera3D, _arg_2:VertexBufferResource, _arg_3:IndexBufferResource, _arg_4:int, _arg_5:int, _arg_6:Object3D, _arg_7:Boolean=false):void + { + var _local_8:BitmapData = this.texture; + if (((_local_8 == null) && (this._textureATF == null))) + { + return; + }; + var _local_9:Device = _arg_1.device; + var _local_10:Boolean = zOffset; + var _local_11:Boolean = ((_arg_1.fogAlpha > 0) && (_arg_1.fogStrength > 0)); + var _local_12:Boolean = (_arg_6 is Sprite3D); + var _local_13:Boolean = ((((!(_arg_1.view.constrained)) && (_arg_1.softTransparency)) && (_arg_1.softTransparencyStrength > 0)) && (_arg_6.softAttenuation > 0)); + var _local_14:Boolean = ((((!(_arg_1.view.constrained)) && (_arg_1.ssao)) && (_arg_1.ssaoStrength > 0)) && (_arg_6.useDepth)); + var _local_15:Boolean = ((((!(_arg_1.view.constrained)) && (!(_arg_1.directionalLight == null))) && (_arg_1.directionalLightStrength > 0)) && (_arg_6.useLight)); + var _local_16:Boolean = (((((!(_arg_1.view.constrained)) && (!(_arg_1.shadowMap == null))) && (_arg_1.shadowMapStrength > 0)) && (_arg_6.useLight)) && (_arg_6.useShadowMap)); + var _local_17:Boolean = (((!(_arg_1.view.constrained)) && (_arg_1.deferredLighting)) && (_arg_1.deferredLightingStrength > 0)); + var _local_18:Boolean = ((((_local_17) && (_arg_6.useDepth)) && (_arg_6.useLight)) && (!(_local_12))); + var _local_19:Boolean = (((_local_17) && (_local_12)) && (_arg_6.useLight)); + _local_9.setProgram(this.getProgram(false, false, _local_10, _local_12, _arg_1.view.quality, this.repeat, (this._mipMapping > 0), (!(_arg_6.concatenatedColorTransform == null)), (_arg_6.concatenatedAlpha < 1), _local_11, _local_13, _local_14, _local_15, _local_16, (_local_8 == null), ((_local_8 == null) && (!(this._textureATFAlpha == null))), _local_18, _local_19, _arg_1.view.correction, (!(_arg_6.concatenatedBlendMode == "normal")), false, _arg_7)); + if (_local_8 != null) + { + if (((uploadEveryFrame) && (!(drawId == Camera3D.renderId)))) + { + _local_9.uploadResource(this.textureResource); + drawId = Camera3D.renderId; + }; + _local_9.setTextureAt(0, this.textureResource); + uvCorrection[0] = this.textureResource.correctionU; + uvCorrection[1] = this.textureResource.correctionV; + } else + { + _local_9.setTextureAt(0, this.textureATFResource); + if (this._textureATFAlpha != null) + { + _local_9.setTextureAt(4, this.textureATFAlphaResource); + } else + { + _local_9.setTextureAt(4, null); + }; + uvCorrection[0] = 1; + uvCorrection[1] = 1; + }; + if (((_local_14) || (_local_13))) + { + _local_9.setTextureAt(1, _arg_1.depthMap); + } else + { + _local_9.setTextureAt(1, null); + }; + if (_local_16) + { + _local_9.setTextureAt(2, _arg_1.shadowMap.map); + _local_9.setTextureAt(3, _arg_1.shadowMap.noise); + } else + { + _local_9.setTextureAt(2, null); + _local_9.setTextureAt(3, null); + }; + _local_9.setTextureAt(4, null); + _local_9.setTextureAt(6, null); + if (_local_18) + { + _local_9.setTextureAt(5, _arg_1.lightMap); + } else + { + _local_9.setTextureAt(5, null); + }; + _local_9.setVertexBufferAt(0, _arg_2, 0, Context3DVertexBufferFormat.FLOAT_1); + _local_9.setVertexBufferAt(1, null); + _local_9.setVertexBufferAt(2, null); + if ((!(_local_12))) + { + _local_9.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 0, _arg_6.transformConst, 3, false); + }; + _local_9.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 4, uvCorrection, 1); + if (_local_13) + { + fragmentConst[2] = _arg_6.softAttenuation; + _local_9.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 14, fragmentConst, 1); + }; + if (_local_10) + { + correctionConst[0] = 0; + correctionConst[1] = 0; + correctionConst[2] = 0; + correctionConst[3] = _arg_1.correctionX; + correctionConst[4] = 0; + correctionConst[5] = 0; + correctionConst[6] = 0; + correctionConst[7] = _arg_1.correctionY; + _local_9.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 11, correctionConst, 2, false); + } else + { + if (_local_12) + { + if (_local_15) + { + correctionConst[0] = _arg_1.correctionX; + correctionConst[1] = _arg_1.correctionY; + correctionConst[2] = 1; + correctionConst[3] = 0.5; + _local_9.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 11, correctionConst, 1, false); + }; + if (_local_19) + { + _local_9.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 13, Sprite3D(_arg_6).lightConst, 1, false); + }; + }; + }; + if (_arg_6.concatenatedColorTransform != null) + { + _local_9.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 0, _arg_6.colorConst, 2, false); + } else + { + if (_arg_6.concatenatedAlpha < 1) + { + _local_9.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 0, _arg_6.colorConst, 1); + }; + }; + _local_9.drawTriangles(_arg_3, _arg_4, _arg_5); + _arg_1.numDraws++; + _arg_1.numTriangles = (_arg_1.numTriangles + _arg_5); + } + + protected function getProgram(_arg_1:Boolean, _arg_2:Boolean, _arg_3:Boolean, _arg_4:Boolean, _arg_5:Boolean, _arg_6:Boolean, _arg_7:Boolean, _arg_8:Boolean, _arg_9:Boolean, _arg_10:Boolean, _arg_11:Boolean, _arg_12:Boolean, _arg_13:Boolean, _arg_14:Boolean, _arg_15:Boolean, _arg_16:Boolean, _arg_17:Boolean, _arg_18:Boolean, _arg_19:Boolean, _arg_20:Boolean, _arg_21:Boolean, _arg_22:Boolean):ProgramResource + { + var _local_25:ByteArray; + var _local_26:ByteArray; + var _local_23:int = (((((((((((((((((((((int(_arg_1) | (int(_arg_2) << 1)) | (int(_arg_3) << 2)) | (int(_arg_4) << 3)) | (int(_arg_5) << 4)) | (int(_arg_6) << 5)) | (int(_arg_7) << 6)) | (int(_arg_8) << 7)) | (int(_arg_9) << 8)) | (int(_arg_10) << 9)) | (int(_arg_11) << 10)) | (int(_arg_12) << 11)) | (int(_arg_13) << 12)) | (int(_arg_14) << 13)) | (int(_arg_15) << 14)) | (int(_arg_16) << 15)) | (int(_arg_17) << 16)) | (int(_arg_18) << 17)) | (int(_arg_19) << 18)) | (int(_arg_20) << 19)) | (int(_arg_21) << 20)) | (int(_arg_22) << 21)); + var _local_24:ProgramResource = programs[_local_23]; + if (_local_24 == null) + { + _local_25 = new TextureMaterialVertexShader((!(_arg_22)), ((((_arg_14) || (_arg_11)) || (_arg_12)) || (_arg_17)), _arg_13, _arg_4, _arg_14, _arg_10, _arg_2, _arg_3, _arg_3, _arg_19).agalcode; + _local_26 = new TextureMaterialFragmentShader(_arg_6, _arg_5, _arg_7, _arg_15, _arg_16, _arg_21, (((!(_arg_1)) && (!(_arg_16))) && (!(_arg_15))), _arg_8, _arg_9, _arg_3, _arg_13, _arg_11, _arg_12, _arg_17, _arg_18, _arg_14, _arg_10, _arg_2, _arg_20).agalcode; + _local_24 = new ProgramResource(_local_25, _local_26); + programs[_local_23] = _local_24; + }; + return (_local_24); + } + + override public function dispose():void + { + this.disposeResource(); + } + + + } +}//package alternativa.engine3d.materials \ No newline at end of file diff --git a/src/alternativa/engine3d/materials/TextureMaterialFragmentShader.as b/src/alternativa/engine3d/materials/TextureMaterialFragmentShader.as new file mode 100644 index 0000000..4377d14 --- /dev/null +++ b/src/alternativa/engine3d/materials/TextureMaterialFragmentShader.as @@ -0,0 +1,194 @@ +package alternativa.engine3d.materials +{ + import alternativa.gfx.agal.FragmentShader; + import alternativa.gfx.agal.SamplerRepeat; + import alternativa.gfx.agal.SamplerFilter; + import alternativa.gfx.agal.SamplerMipMap; + import alternativa.gfx.agal.SamplerType; + import alternativa.gfx.agal.SamplerDim; + import alternativa.engine3d.core.ShadowMap; + + public class TextureMaterialFragmentShader extends FragmentShader + { + + public function TextureMaterialFragmentShader(_arg_1:Boolean, _arg_2:Boolean, _arg_3:Boolean, _arg_4:Boolean, _arg_5:Boolean, _arg_6:Boolean, _arg_7:Boolean, _arg_8:Boolean, _arg_9:Boolean, _arg_10:Boolean, _arg_11:Boolean, _arg_12:Boolean, _arg_13:Boolean, _arg_14:Boolean, _arg_15:Boolean, _arg_16:Boolean, _arg_17:Boolean, _arg_18:Boolean, _arg_19:Boolean) + { + var _local_24:int; + super(); + var _local_20:SamplerRepeat = ((_arg_1) ? SamplerRepeat.WRAP : SamplerRepeat.CLAMP); + var _local_21:SamplerFilter = ((_arg_2) ? SamplerFilter.LINEAR : SamplerFilter.NEAREST); + var _local_22:SamplerMipMap = ((_arg_3) ? ((_arg_2) ? SamplerMipMap.LINEAR : SamplerMipMap.NEAREST) : SamplerMipMap.NONE); + var _local_23:SamplerType = ((_arg_4) ? SamplerType.DXT1 : SamplerType.RGBA); + tex(ft0, v0, fs0.dim(SamplerDim.D2).repeat(_local_20).filter(_local_21).mipmap(_local_22).type(_local_23)); + if (_arg_6) + { + sub(ft1.w, ft0, fc[14]); + kil(ft1.w); + }; + if (_arg_7) + { + add(ft1.w, ft0, fc[18]); + div(ft0.xyz, ft0, ft1.w); + }; + if (_arg_8) + { + mul(ft0.xyz, ft0, fc[0]); + add(ft0.xyz, ft0, fc[1]); + }; + if (_arg_9) + { + mul(ft0.w, ft0, fc[0]); + }; + if (_arg_10) + { + abs(ft1, v0.z); + sat(ft1, ft1); + sub(ft1, fc[17], ft1); + mul(ft0.w, ft0, ft1); + }; + if (((((_arg_12) || (_arg_13)) || (_arg_14)) || (_arg_16))) + { + div(ft4, v1, v1.z); + mul(ft4.xy, ft4, fc[18]); + add(ft4.xy, ft4, fc[18]); + }; + if ((((_arg_12) || (_arg_13)) || (_arg_14))) + { + mul(ft3, ft4, fc[4]); + }; + if (((_arg_12) || (_arg_13))) + { + tex(ft1, ft3, fs1.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + }; + if (_arg_14) + { + tex(ft6, ft3, fs5.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + }; + if (_arg_12) + { + dp3(ft2, ft1, fc[17]); + sub(ft2, ft2, v1); + abs(ft2, ft2); + div(ft2, ft2, fc[14]); + sat(ft2, ft2); + mul(ft0.w, ft0, ft2.z); + }; + if (_arg_13) + { + mul(ft2, fc[12], ft1.w); + sub(ft2, fc[17].w, ft2); + mul(ft0.xyz, ft0, ft2); + }; + if (_arg_16) + { + mov(ft5, fc[5]); + mul(ft5.z, ft5, v2); + mul(ft3, ft4, fc[7]); + tex(ft1, ft3, fs3.dim(SamplerDim.D2).repeat(SamplerRepeat.WRAP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + mul(ft1.z, ft1, fc[6]); + mul(ft2, ft1.z, ft1); + _local_24 = 0; + while (_local_24 < ShadowMap.numSamples) + { + if (_local_24 == 0) + { + add(ft1, ft2, v2); + tex(ft1, ft1, fs2.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + dp3(ft1, ft1, ft5); + sat(ft1, ft1); + mov(ft4, ft1); + } else + { + if ((_local_24 % 2) > 0) + { + dp3(ft3.x, ft2, fc[8]); + dp3(ft3.y, ft2, fc[9]); + add(ft1, ft3, v2); + } else + { + dp3(ft2.x, ft3, fc[8]); + dp3(ft2.y, ft3, fc[9]); + add(ft1, ft2, v2); + }; + tex(ft1, ft1, fs2.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE)); + dp3(ft1, ft1, ft5); + sat(ft1, ft1); + add(ft4, ft4, ft1); + }; + _local_24++; + }; + mul(ft2, ft4, fc[6]); + sat(ft1, v2); + mul(ft2, ft2, ft1); + mul(ft2.w, ft2, fc[7]); + }; + if (_arg_11) + { + if (_arg_16) + { + sat(ft1, v1); + max(ft2, ft2, ft1); + } else + { + sat(ft2, v1); + }; + }; + if (((_arg_16) || (_arg_11))) + { + sub(ft2, fc[17], ft2); + mul(ft2, fc[10], ft2.w); + add(ft2, ft2, fc[11]); + if (_arg_14) + { + add(ft6, ft6, ft6); + add(ft2, ft2, ft6); + } else + { + if (_arg_15) + { + add(ft2, ft2, fc[13]); + }; + }; + mul(ft0.xyz, ft0, ft2); + } else + { + if (_arg_14) + { + add(ft2, ft6, ft6); + mul(ft0.xyz, ft0, ft2); + } else + { + if (_arg_15) + { + mul(ft0.xyz, ft0, fc[13]); + }; + }; + }; + if (_arg_17) + { + if (_arg_18) + { + mul(ft0.xyz, ft0, fc[13].w); + add(ft0.xyz, ft0, fc[13]); + } else + { + sat(ft1, v0); + mul(ft1, ft1, fc[2]); + if (_arg_19) + { + sub(ft1, fc[17], ft1); + mul(ft0.w, ft0, ft1); + } else + { + mul(ft1.xyz, fc[2], ft1.w); + sub(ft1.w, fc[17], ft1); + mul(ft0.xyz, ft0, ft1.w); + add(ft0.xyz, ft0, ft1); + }; + }; + }; + mov(oc, ft0); + } + + } +}//package alternativa.engine3d.materials \ No newline at end of file diff --git a/src/alternativa/engine3d/materials/TextureMaterialVertexShader.as b/src/alternativa/engine3d/materials/TextureMaterialVertexShader.as new file mode 100644 index 0000000..6b3da93 --- /dev/null +++ b/src/alternativa/engine3d/materials/TextureMaterialVertexShader.as @@ -0,0 +1,133 @@ +package alternativa.engine3d.materials +{ + import alternativa.gfx.agal.VertexShader; + + public class TextureMaterialVertexShader extends VertexShader + { + + public function TextureMaterialVertexShader(_arg_1:Boolean, _arg_2:Boolean, _arg_3:Boolean, _arg_4:Boolean, _arg_5:Boolean, _arg_6:Boolean, _arg_7:Boolean, _arg_8:Boolean, _arg_9:Boolean, _arg_10:Boolean) + { + mov(vt0, vc[4]); + if (_arg_1) + { + dp4(vt0.x, va0, vc[0]); + dp4(vt0.y, va0, vc[1]); + dp4(vt0.z, va0, vc[2]); + mul(v0, va1, vc[4]); + } else + { + mov(vt0.xyz, cc.rel(va0.x, 0)); + mov(vt1, cc.rel(va0.x, 1)); + mul(v0, vt1, vc[4]); + }; + if (((_arg_2) || (_arg_3))) + { + mov(v1, vt0); + }; + if (_arg_3) + { + if (_arg_1) + { + if (_arg_4) + { + mul(vt1, va2, vc[11]); + nrm(vt1.xyz, vt1.xyz); + div(vt1, vt1, vc[11]); + } else + { + mov(vt1, vc[4]); + dp3(vt1.x, va2, vc[0]); + dp3(vt1.y, va2, vc[1]); + dp3(vt1.z, va2, vc[2]); + }; + } else + { + mov(vt2, vc[4]); + mov(vt2.x, cc.rel(va0.x, 0).w); + mov(vt2.y, cc.rel(va0.x, 1).z); + mov(vt2.z, cc.rel(va0.x, 1).w); + if (_arg_4) + { + mul(vt1, vt2, vc[11]); + nrm(vt1.xyz, vt1.xyz); + div(vt1, vt1, vc[11]); + } else + { + mov(vt1, vc[4]); + dp3(vt1.x, vt2, vc[0]); + dp3(vt1.y, vt2, vc[1]); + dp3(vt1.z, vt2, vc[2]); + }; + }; + dp3(vt1.w, vt1, vc[10]); + if (_arg_4) + { + sub(vt1.w, vc[4], vt1); + mul(v1.w, vt1, vc[11]); + } else + { + sub(v1.w, vc[4], vt1); + }; + } else + { + if (((((_arg_5) || (_arg_6)) || (_arg_9)) || (_arg_10))) + { + mov(vt1, vc[4]); + }; + }; + if (_arg_5) + { + dp4(v2.x, vt0, vc[6]); + dp4(v2.y, vt0, vc[7]); + dp4(v2.z, vt0, vc[8]); + sub(vt1.w, vt0.z, vc[9].x); + div(vt1.w, vt1, vc[9].y); + sub(v2.w, vc[4], vt1); + }; + if (_arg_6) + { + sub(vt1.w, vt0.z, vc[5].z); + div(v0.w, vt1, vc[5]); + }; + if (_arg_8) + { + mov(vt1, vt0); + mul(vt1.x, vt1, vc[11].w); + mul(vt1.y, vt1, vc[12].w); + sub(vt1, vt1, vc[11]); + dp3(v0.z, vt1, vc[12]); + }; + if (_arg_7) + { + mul(vt0.xyz, vt0, vc[11]); + }; + if (_arg_9) + { + div(vt1.z, vc[3].w, vt0); + add(vt1.z, vt1, vc[3]); + mul(vt1.z, vt1, vc[3].x); + sub(vt1.z, vt1, vc[3].y); + div(vt1.z, vt1, vc[3].x); + sub(vt1.z, vt1, vc[3]); + div(vt1.z, vc[3].w, vt1); + mov(vt2, vc[4]); + nrm(vt2.xyz, vt0.xyz); + sub(vt1.z, vt0, vt1); + div(vt1.z, vt1, vt2); + mul(vt2, vt2, vt1.z); + sub(vt0, vt0, vt2); + }; + if (_arg_10) + { + mul(vt0.xy, vt0, vc[13]); + mul(vt1.xy, vc[13].zw, vt0.z); + add(vt0.xy, vt0, vt1); + }; + mov(op.xw, vt0.xz); + neg(op.y, vt0); + mul(vt0.z, vt0, vc[3]); + add(op.z, vt0, vc[3].w); + } + + } +}//package alternativa.engine3d.materials \ No newline at end of file diff --git a/src/alternativa/engine3d/materials/TextureResourcesRegistry.as b/src/alternativa/engine3d/materials/TextureResourcesRegistry.as new file mode 100644 index 0000000..f6eab23 --- /dev/null +++ b/src/alternativa/engine3d/materials/TextureResourcesRegistry.as @@ -0,0 +1,48 @@ +package alternativa.engine3d.materials +{ + import flash.utils.Dictionary; + import alternativa.gfx.core.BitmapTextureResource; + import flash.display.BitmapData; + + public class TextureResourcesRegistry + { + + public static var texture2Resource:Dictionary = new Dictionary(); + + + public static function getTextureResource(_arg_1:BitmapData, _arg_2:Boolean, _arg_3:Boolean, _arg_4:Boolean):BitmapTextureResource + { + var _local_5:BitmapTextureResource; + if ((_arg_1 in texture2Resource)) + { + _local_5 = texture2Resource[_arg_1]; + _local_5.increaseReferencesCount(); + return (_local_5); + }; + var _local_6:BitmapTextureResource = new BitmapTextureResource(_arg_1, _arg_2, _arg_3, _arg_4); + texture2Resource[_arg_1] = _local_6; + return (_local_6); + } + + public static function releaseTextureResources():void + { + var _local_1:*; + var _local_2:BitmapTextureResource; + for (_local_1 in texture2Resource) + { + _local_2 = texture2Resource[_local_1]; + _local_2.forceDispose(); + }; + } + + public static function release(_arg_1:BitmapData):void + { + if ((_arg_1 in texture2Resource)) + { + delete texture2Resource[_arg_1]; + }; + } + + + } +}//package alternativa.engine3d.materials \ No newline at end of file diff --git a/src/alternativa/engine3d/materials/UVMatrixProvider.as b/src/alternativa/engine3d/materials/UVMatrixProvider.as new file mode 100644 index 0000000..7df536e --- /dev/null +++ b/src/alternativa/engine3d/materials/UVMatrixProvider.as @@ -0,0 +1,35 @@ +package alternativa.engine3d.materials +{ + import __AS3__.vec.Vector; + import flash.geom.Matrix; + import __AS3__.vec.*; + + public class UVMatrixProvider + { + + private var matrixValues:Vector. = new Vector.(8); + private var matrix:Matrix = new Matrix(); + + + public function getMatrix():Matrix + { + return (this.matrix); + } + + public function getValues():Vector. + { + var _local_1:Matrix = this.getMatrix(); + this.matrixValues[0] = _local_1.a; + this.matrixValues[1] = _local_1.b; + this.matrixValues[2] = _local_1.tx; + this.matrixValues[3] = 0; + this.matrixValues[4] = _local_1.c; + this.matrixValues[5] = _local_1.d; + this.matrixValues[6] = _local_1.ty; + this.matrixValues[7] = 0; + return (this.matrixValues); + } + + + } +}//package alternativa.engine3d.materials \ No newline at end of file diff --git a/src/alternativa/engine3d/materials/VertexLightMaterial.as b/src/alternativa/engine3d/materials/VertexLightMaterial.as new file mode 100644 index 0000000..99c9ad4 --- /dev/null +++ b/src/alternativa/engine3d/materials/VertexLightMaterial.as @@ -0,0 +1,12 @@ +package alternativa.engine3d.materials +{ + public class VertexLightMaterial extends TextureMaterial + { + + + public function VertexLightMaterial() + { + super(); + } + } +} diff --git a/src/alternativa/engine3d/objects/AnimSprite.as b/src/alternativa/engine3d/objects/AnimSprite.as new file mode 100644 index 0000000..16b8f11 --- /dev/null +++ b/src/alternativa/engine3d/objects/AnimSprite.as @@ -0,0 +1,101 @@ +package alternativa.engine3d.objects +{ + import __AS3__.vec.Vector; + import alternativa.engine3d.materials.Material; + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class AnimSprite extends Sprite3D + { + + private var _materials:Vector.; + private var _frame:int = 0; + private var _loop:Boolean = false; + + public function AnimSprite(_arg_1:Number, _arg_2:Number, _arg_3:Vector.=null, _arg_4:Boolean=false, _arg_5:int=0) + { + super(_arg_1, _arg_2); + this._materials = _arg_3; + this._loop = _arg_4; + this.frame = _arg_5; + } + + public function get materials():Vector. + { + return (this._materials); + } + + public function set materials(_arg_1:Vector.):void + { + this._materials = _arg_1; + if (_arg_1 != null) + { + this.frame = this._frame; + } else + { + material = null; + }; + } + + public function get loop():Boolean + { + return (this._loop); + } + + public function set loop(_arg_1:Boolean):void + { + this._loop = _arg_1; + this.frame = this._frame; + } + + public function get frame():int + { + return (this._frame); + } + + public function set frame(_arg_1:int):void + { + var _local_2:int; + var _local_3:int; + var _local_4:int; + this._frame = _arg_1; + if (this._materials != null) + { + _local_2 = this._materials.length; + _local_3 = this._frame; + if (this._frame < 0) + { + _local_4 = (this._frame % _local_2); + _local_3 = (((this._loop) && (!(_local_4 == 0))) ? (_local_4 + _local_2) : 0); + } else + { + if (this._frame > (_local_2 - 1)) + { + _local_3 = ((this._loop) ? (this._frame % _local_2) : (_local_2 - 1)); + }; + }; + material = this._materials[_local_3]; + }; + } + + override public function clone():Object3D + { + var _local_1:AnimSprite = new AnimSprite(width, height); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + override protected function clonePropertiesFrom(_arg_1:Object3D):void + { + super.clonePropertiesFrom(_arg_1); + var _local_2:AnimSprite = (_arg_1 as AnimSprite); + this._materials = _local_2._materials; + this._loop = _local_2._loop; + this._frame = _local_2._frame; + } + + + } +}//package alternativa.engine3d.objects \ No newline at end of file diff --git a/src/alternativa/engine3d/objects/BSP.as b/src/alternativa/engine3d/objects/BSP.as new file mode 100644 index 0000000..1fd2352 --- /dev/null +++ b/src/alternativa/engine3d/objects/BSP.as @@ -0,0 +1,1718 @@ +package alternativa.engine3d.objects +{ + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.core.Vertex; + import __AS3__.vec.Vector; + import alternativa.engine3d.core.Face; + import alternativa.gfx.core.VertexBufferResource; + import alternativa.gfx.core.IndexBufferResource; + import alternativa.engine3d.materials.Material; + import flash.geom.Vector3D; + import flash.utils.Dictionary; + import alternativa.engine3d.core.Camera3D; + import alternativa.engine3d.core.RayIntersectionData; + import alternativa.engine3d.core.Wrapper; + import alternativa.engine3d.core.Debug; + import alternativa.engine3d.core.VG; + import alternativa.engine3d.objects.BSP; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class BSP extends Object3D + { + + public var clipping:int = 2; + public var threshold:Number = 0.01; + public var splitAnalysis:Boolean = true; + alternativa3d var vertexList:Vertex; + alternativa3d var root:Node; + alternativa3d var faces:Vector. = new Vector.(); + alternativa3d var vertexBuffer:VertexBufferResource; + alternativa3d var indexBuffer:IndexBufferResource; + alternativa3d var numTriangles:int; + + + public function createTree(_arg_1:Mesh, _arg_2:Boolean=false):void + { + this.destroyTree(); + if ((!(_arg_2))) + { + _arg_1 = (_arg_1.clone() as Mesh); + }; + var _local_3:Face = _arg_1.faceList; + this.vertexList = _arg_1.vertexList; + _arg_1.faceList = null; + _arg_1.vertexList = null; + var _local_4:Vertex = this.vertexList; + while (_local_4 != null) + { + _local_4.transformId = 0; + _local_4.id = null; + _local_4 = _local_4.next; + }; + var _local_5:int; + var _local_6:Face = _local_3; + while (_local_6 != null) + { + _local_6.calculateBestSequenceAndNormal(); + _local_6.id = null; + this.faces[_local_5] = _local_6; + _local_5++; + _local_6 = _local_6.next; + }; + if (_local_3 != null) + { + this.root = this.createNode(_local_3); + }; + calculateBounds(); + } + + public function destroyTree():void + { + this.deleteResources(); + this.vertexList = null; + if (this.root != null) + { + this.destroyNode(this.root); + this.root = null; + }; + this.faces.length = 0; + } + + public function setMaterialToAllFaces(_arg_1:Material):void + { + var _local_4:Face; + this.deleteResources(); + var _local_2:int = this.faces.length; + var _local_3:int; + while (_local_3 < _local_2) + { + _local_4 = this.faces[_local_3]; + _local_4.material = _arg_1; + _local_3++; + }; + if (this.root != null) + { + this.setMaterialToNode(this.root, _arg_1); + }; + } + + override public function intersectRay(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Dictionary=null, _arg_4:Camera3D=null):RayIntersectionData + { + if ((((!(_arg_3 == null)) && (_arg_3[this])) || (this.root == null))) + { + return (null); + }; + if ((!(boundIntersectRay(_arg_1, _arg_2, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ)))) + { + return (null); + }; + return (this.intersectRayNode(this.root, _arg_1.x, _arg_1.y, _arg_1.z, _arg_2.x, _arg_2.y, _arg_2.z)); + } + + private function intersectRayNode(_arg_1:Node, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number):RayIntersectionData + { + var _local_8:RayIntersectionData; + var _local_13:Number; + var _local_14:Number; + var _local_15:Number; + var _local_16:Number; + var _local_17:Number; + var _local_18:Face; + var _local_19:Wrapper; + var _local_20:Vertex; + var _local_21:Vertex; + var _local_22:Number; + var _local_23:Number; + var _local_24:Number; + var _local_25:Number; + var _local_26:Number; + var _local_27:Number; + var _local_9:Number = _arg_1.normalX; + var _local_10:Number = _arg_1.normalY; + var _local_11:Number = _arg_1.normalZ; + var _local_12:Number = ((((_local_9 * _arg_2) + (_local_10 * _arg_3)) + (_local_11 * _arg_4)) - _arg_1.offset); + if (_local_12 > 0) + { + if (_arg_1.positive != null) + { + _local_8 = this.intersectRayNode(_arg_1.positive, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7); + if (_local_8 != null) + { + return (_local_8); + }; + }; + _local_13 = (((_arg_5 * _local_9) + (_arg_6 * _local_10)) + (_arg_7 * _local_11)); + if (_local_13 < 0) + { + _local_14 = (-(_local_12) / _local_13); + _local_15 = (_arg_2 + (_arg_5 * _local_14)); + _local_16 = (_arg_3 + (_arg_6 * _local_14)); + _local_17 = (_arg_4 + (_arg_7 * _local_14)); + _local_18 = _arg_1.faceList; + while (_local_18 != null) + { + _local_19 = _local_18.wrapper; + while (_local_19 != null) + { + _local_20 = _local_19.vertex; + _local_21 = ((_local_19.next != null) ? _local_19.next.vertex : _local_18.wrapper.vertex); + _local_22 = (_local_21.x - _local_20.x); + _local_23 = (_local_21.y - _local_20.y); + _local_24 = (_local_21.z - _local_20.z); + _local_25 = (_local_15 - _local_20.x); + _local_26 = (_local_16 - _local_20.y); + _local_27 = (_local_17 - _local_20.z); + if ((((((_local_27 * _local_23) - (_local_26 * _local_24)) * _local_9) + (((_local_25 * _local_24) - (_local_27 * _local_22)) * _local_10)) + (((_local_26 * _local_22) - (_local_25 * _local_23)) * _local_11)) < 0) break; + _local_19 = _local_19.next; + }; + if (_local_19 == null) + { + _local_8 = new RayIntersectionData(); + _local_8.object = this; + _local_8.face = _local_18; + _local_8.point = new Vector3D(_local_15, _local_16, _local_17); + _local_8.uv = _local_18.getUV(_local_8.point); + _local_8.time = _local_14; + return (_local_8); + }; + _local_18 = _local_18.next; + }; + if (_arg_1.negative != null) + { + return (this.intersectRayNode(_arg_1.negative, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7)); + }; + }; + } else + { + if (_arg_1.negative != null) + { + _local_8 = this.intersectRayNode(_arg_1.negative, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7); + if (_local_8 != null) + { + return (_local_8); + }; + }; + if (((!(_arg_1.positive == null)) && ((((_arg_5 * _local_9) + (_arg_6 * _local_10)) + (_arg_7 * _local_11)) > 0))) + { + return (this.intersectRayNode(_arg_1.positive, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7)); + }; + }; + return (null); + } + + override alternativa3d function checkIntersection(_arg_1:Number, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Dictionary):Boolean + { + return ((this.root != null) ? this.checkIntersectionNode(this.root, _arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7) : false); + } + + private function checkIntersectionNode(_arg_1:Node, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Number):Boolean + { + var _local_9:Number; + var _local_14:Number; + var _local_15:Number; + var _local_16:Number; + var _local_17:Number; + var _local_18:Face; + var _local_19:Wrapper; + var _local_20:Vertex; + var _local_21:Vertex; + var _local_22:Number; + var _local_23:Number; + var _local_24:Number; + var _local_25:Number; + var _local_26:Number; + var _local_27:Number; + var _local_10:Number = _arg_1.normalX; + var _local_11:Number = _arg_1.normalY; + var _local_12:Number = _arg_1.normalZ; + var _local_13:Number = ((((_local_10 * _arg_2) + (_local_11 * _arg_3)) + (_local_12 * _arg_4)) - _arg_1.offset); + if (_local_13 > 0) + { + _local_9 = (((_arg_5 * _local_10) + (_arg_6 * _local_11)) + (_arg_7 * _local_12)); + if (_local_9 < 0) + { + _local_14 = (-(_local_13) / _local_9); + if (_local_14 < _arg_8) + { + _local_15 = (_arg_2 + (_arg_5 * _local_14)); + _local_16 = (_arg_3 + (_arg_6 * _local_14)); + _local_17 = (_arg_4 + (_arg_7 * _local_14)); + _local_18 = _arg_1.faceList; + while (_local_18 != null) + { + _local_19 = _local_18.wrapper; + while (_local_19 != null) + { + _local_20 = _local_19.vertex; + _local_21 = ((_local_19.next != null) ? _local_19.next.vertex : _local_18.wrapper.vertex); + _local_22 = (_local_21.x - _local_20.x); + _local_23 = (_local_21.y - _local_20.y); + _local_24 = (_local_21.z - _local_20.z); + _local_25 = (_local_15 - _local_20.x); + _local_26 = (_local_16 - _local_20.y); + _local_27 = (_local_17 - _local_20.z); + if ((((((_local_27 * _local_23) - (_local_26 * _local_24)) * _local_10) + (((_local_25 * _local_24) - (_local_27 * _local_22)) * _local_11)) + (((_local_26 * _local_22) - (_local_25 * _local_23)) * _local_12)) < 0) break; + _local_19 = _local_19.next; + }; + if (_local_19 == null) + { + return (true); + }; + _local_18 = _local_18.next; + }; + if (((!(_arg_1.negative == null)) && (this.checkIntersectionNode(_arg_1.negative, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8)))) + { + return (true); + }; + }; + }; + return ((!(_arg_1.positive == null)) && (this.checkIntersectionNode(_arg_1.positive, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8))); + }; + if (((!(_arg_1.negative == null)) && (this.checkIntersectionNode(_arg_1.negative, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8)))) + { + return (true); + }; + if (_arg_1.positive != null) + { + _local_9 = (((_arg_5 * _local_10) + (_arg_6 * _local_11)) + (_arg_7 * _local_12)); + return (((_local_9 > 0) && ((-(_local_13) / _local_9) < _arg_8)) && (this.checkIntersectionNode(_arg_1.positive, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8))); + }; + return (false); + } + + override alternativa3d function collectPlanes(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Vector3D, _arg_4:Vector3D, _arg_5:Vector3D, _arg_6:Vector., _arg_7:Dictionary=null):void + { + if ((((!(_arg_7 == null)) && (_arg_7[this])) || (this.root == null))) + { + return; + }; + var _local_8:Vector3D = calculateSphere(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5); + if ((!(boundIntersectSphere(_local_8, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ)))) + { + return; + }; + this.collectPlanesNode(this.root, _local_8, _arg_6); + } + + private function collectPlanesNode(_arg_1:Node, _arg_2:Vector3D, _arg_3:Vector.):void + { + var _local_5:Face; + var _local_6:Wrapper; + var _local_7:Vertex; + var _local_4:Number = ((((_arg_1.normalX * _arg_2.x) + (_arg_1.normalY * _arg_2.y)) + (_arg_1.normalZ * _arg_2.z)) - _arg_1.offset); + if (_local_4 >= _arg_2.w) + { + if (_arg_1.positive != null) + { + this.collectPlanesNode(_arg_1.positive, _arg_2, _arg_3); + }; + } else + { + if (_local_4 <= -(_arg_2.w)) + { + if (_arg_1.negative != null) + { + this.collectPlanesNode(_arg_1.negative, _arg_2, _arg_3); + }; + } else + { + _local_5 = _arg_1.faceList; + while (_local_5 != null) + { + _local_6 = _local_5.wrapper; + while (_local_6 != null) + { + _local_7 = _local_6.vertex; + _local_7.cameraX = ((((ma * _local_7.x) + (mb * _local_7.y)) + (mc * _local_7.z)) + md); + _local_7.cameraY = ((((me * _local_7.x) + (mf * _local_7.y)) + (mg * _local_7.z)) + mh); + _local_7.cameraZ = ((((mi * _local_7.x) + (mj * _local_7.y)) + (mk * _local_7.z)) + ml); + _local_6 = _local_6.next; + }; + _arg_3.push(_local_5); + _local_5 = _local_5.next; + }; + if (_arg_1.positive != null) + { + this.collectPlanesNode(_arg_1.positive, _arg_2, _arg_3); + }; + if (_arg_1.negative != null) + { + this.collectPlanesNode(_arg_1.negative, _arg_2, _arg_3); + }; + }; + }; + } + + override public function clone():Object3D + { + var _local_1:BSP = new BSP(); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + override protected function clonePropertiesFrom(_arg_1:Object3D):void + { + var _local_3:Vertex; + var _local_4:Vertex; + var _local_8:Vertex; + var _local_9:Face; + var _local_10:Face; + var _local_11:Wrapper; + var _local_12:Wrapper; + var _local_13:Wrapper; + super.clonePropertiesFrom(_arg_1); + var _local_2:BSP = (_arg_1 as BSP); + this.clipping = _local_2.clipping; + this.threshold = _local_2.threshold; + this.splitAnalysis = _local_2.splitAnalysis; + _local_3 = _local_2.vertexList; + while (_local_3 != null) + { + _local_8 = new Vertex(); + _local_8.x = _local_3.x; + _local_8.y = _local_3.y; + _local_8.z = _local_3.z; + _local_8.u = _local_3.u; + _local_8.v = _local_3.v; + _local_8.normalX = _local_3.normalX; + _local_8.normalY = _local_3.normalY; + _local_8.normalZ = _local_3.normalZ; + _local_3.value = _local_8; + if (_local_4 != null) + { + _local_4.next = _local_8; + } else + { + this.vertexList = _local_8; + }; + _local_4 = _local_8; + _local_3 = _local_3.next; + }; + var _local_5:Dictionary = new Dictionary(); + var _local_6:int = _local_2.faces.length; + var _local_7:int; + while (_local_7 < _local_6) + { + _local_9 = _local_2.faces[_local_7]; + _local_10 = new Face(); + _local_10.material = _local_9.material; + _local_10.smoothingGroups = _local_9.smoothingGroups; + _local_10.normalX = _local_9.normalX; + _local_10.normalY = _local_9.normalY; + _local_10.normalZ = _local_9.normalZ; + _local_10.offset = _local_9.offset; + _local_11 = null; + _local_12 = _local_9.wrapper; + while (_local_12 != null) + { + _local_13 = new Wrapper(); + _local_13.vertex = _local_12.vertex.value; + if (_local_11 != null) + { + _local_11.next = _local_13; + } else + { + _local_10.wrapper = _local_13; + }; + _local_11 = _local_13; + _local_12 = _local_12.next; + }; + this.faces[_local_7] = _local_10; + _local_5[_local_9] = _local_10; + _local_7++; + }; + if (_local_2.root != null) + { + this.root = _local_2.cloneNode(_local_2.root, _local_5); + }; + _local_3 = _local_2.vertexList; + while (_local_3 != null) + { + _local_3.value = null; + _local_3 = _local_3.next; + }; + } + + private function cloneNode(_arg_1:Node, _arg_2:Dictionary):Node + { + var _local_4:Face; + var _local_6:Face; + var _local_7:Wrapper; + var _local_8:Wrapper; + var _local_9:Wrapper; + var _local_3:Node = new Node(); + var _local_5:Face = _arg_1.faceList; + while (_local_5 != null) + { + _local_6 = _arg_2[_local_5]; + if (_local_6 == null) + { + _local_6 = new Face(); + _local_6.material = _local_5.material; + _local_6.normalX = _local_5.normalX; + _local_6.normalY = _local_5.normalY; + _local_6.normalZ = _local_5.normalZ; + _local_6.offset = _local_5.offset; + _local_7 = null; + _local_8 = _local_5.wrapper; + while (_local_8 != null) + { + _local_9 = new Wrapper(); + _local_9.vertex = _local_8.vertex.value; + if (_local_7 != null) + { + _local_7.next = _local_9; + } else + { + _local_6.wrapper = _local_9; + }; + _local_7 = _local_9; + _local_8 = _local_8.next; + }; + }; + if (_local_3.faceList != null) + { + _local_4.next = _local_6; + } else + { + _local_3.faceList = _local_6; + }; + _local_4 = _local_6; + _local_5 = _local_5.next; + }; + _local_3.normalX = _arg_1.normalX; + _local_3.normalY = _arg_1.normalY; + _local_3.normalZ = _arg_1.normalZ; + _local_3.offset = _arg_1.offset; + if (_arg_1.negative != null) + { + _local_3.negative = this.cloneNode(_arg_1.negative, _arg_2); + }; + if (_arg_1.positive != null) + { + _local_3.positive = this.cloneNode(_arg_1.positive, _arg_2); + }; + return (_local_3); + } + + private function setMaterialToNode(_arg_1:Node, _arg_2:Material):void + { + var _local_3:Face = _arg_1.faceList; + while (_local_3 != null) + { + _local_3.material = _arg_2; + _local_3 = _local_3.next; + }; + if (_arg_1.negative != null) + { + this.setMaterialToNode(_arg_1.negative, _arg_2); + }; + if (_arg_1.positive != null) + { + this.setMaterialToNode(_arg_1.positive, _arg_2); + }; + } + + override alternativa3d function draw(_arg_1:Camera3D):void + { + var _local_4:Face; + var _local_5:Face; + var _local_6:Face; + var _local_7:Face; + var _local_8:Vertex; + if (this.root == null) + { + return; + }; + if (this.clipping == 0) + { + if ((culling & 0x01)) + { + return; + }; + culling = 0; + }; + this.prepareResources(); + if ((useDepth = (((!(_arg_1.view.constrained)) && ((((_arg_1.softTransparency) && (_arg_1.softTransparencyStrength > 0)) || ((_arg_1.ssao) && (_arg_1.ssaoStrength > 0))) || ((_arg_1.deferredLighting) && (_arg_1.deferredLightingStrength > 0)))) && (concatenatedAlpha >= depthMapAlphaThreshold)))) + { + _arg_1.depthObjects[_arg_1.depthCount] = this; + _arg_1.depthCount++; + }; + var _local_2:int = ((_arg_1.debug) ? _arg_1.checkInDebug(this) : 0); + var _local_3:Face = this.faces[0]; + if (((((concatenatedAlpha >= 1) && (concatenatedBlendMode == "normal")) && (!(_local_3.material == null))) && ((!(_local_3.material.transparent)) || (_local_3.material.alphaTestThreshold > 0)))) + { + _arg_1.addOpaque(_local_3.material, this.vertexBuffer, this.indexBuffer, 0, this.numTriangles, this); + if (_local_2 > 0) + { + if ((_local_2 & Debug.EDGES)) + { + Debug.drawEdges(_arg_1, null, 0xFFFFFF); + }; + if ((_local_2 & Debug.BOUNDS)) + { + Debug.drawBounds(_arg_1, this, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ); + }; + }; + } else + { + if (transformId > 0x1DCD6500) + { + transformId = 0; + _local_8 = this.vertexList; + while (_local_8 != null) + { + _local_8.transformId = 0; + _local_8 = _local_8.next; + }; + }; + transformId++; + calculateInverseMatrix(); + _local_4 = this.collectNode(this.root); + if (_local_4 == null) + { + return; + }; + if (culling > 0) + { + if (this.clipping == 1) + { + _local_4 = _arg_1.cull(_local_4, culling); + } else + { + _local_4 = _arg_1.clip(_local_4, culling); + }; + if (_local_4 == null) + { + return; + }; + }; + if (_local_2 > 0) + { + if ((_local_2 & Debug.EDGES)) + { + Debug.drawEdges(_arg_1, _local_4, 0xFFFFFF); + }; + if ((_local_2 & Debug.BOUNDS)) + { + Debug.drawBounds(_arg_1, this, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ); + }; + }; + _local_7 = _local_4; + while (_local_7 != null) + { + _local_5 = _local_7.processNext; + if (((_local_5 == null) || (!(_local_5.material == _local_4.material)))) + { + _local_7.processNext = null; + if (_local_4.material != null) + { + _local_4.processNegative = _local_6; + _local_6 = _local_4; + } else + { + while (_local_4 != null) + { + _local_7 = _local_4.processNext; + _local_4.processNext = null; + _local_4 = _local_7; + }; + }; + _local_4 = _local_5; + }; + _local_7 = _local_5; + }; + _local_4 = _local_6; + while (_local_4 != null) + { + _local_5 = _local_4.processNegative; + _local_4.processNegative = null; + _arg_1.addTransparent(_local_4, this); + _local_4 = _local_5; + }; + }; + transformConst[0] = ma; + transformConst[1] = mb; + transformConst[2] = mc; + transformConst[3] = md; + transformConst[4] = me; + transformConst[5] = mf; + transformConst[6] = mg; + transformConst[7] = mh; + transformConst[8] = mi; + transformConst[9] = mj; + transformConst[10] = mk; + transformConst[11] = ml; + } + + override alternativa3d function getVG(_arg_1:Camera3D):VG + { + var _local_4:Face; + var _local_5:Vertex; + if (this.root == null) + { + return (null); + }; + if (this.clipping == 0) + { + if ((culling & 0x01)) + { + return (null); + }; + culling = 0; + }; + this.prepareResources(); + if ((useDepth = (((!(_arg_1.view.constrained)) && ((((_arg_1.softTransparency) && (_arg_1.softTransparencyStrength > 0)) || ((_arg_1.ssao) && (_arg_1.ssaoStrength > 0))) || ((_arg_1.deferredLighting) && (_arg_1.deferredLightingStrength > 0)))) && (concatenatedAlpha >= depthMapAlphaThreshold)))) + { + _arg_1.depthObjects[_arg_1.depthCount] = this; + _arg_1.depthCount++; + }; + var _local_2:int = ((_arg_1.debug) ? _arg_1.checkInDebug(this) : 0); + var _local_3:Face = this.faces[0]; + if (((((concatenatedAlpha >= 1) && (concatenatedBlendMode == "normal")) && (!(_local_3.material == null))) && ((!(_local_3.material.transparent)) || (_local_3.material.alphaTestThreshold > 0)))) + { + _arg_1.addOpaque(_local_3.material, this.vertexBuffer, this.indexBuffer, 0, this.numTriangles, this); + if (_local_2 > 0) + { + if ((_local_2 & Debug.EDGES)) + { + Debug.drawEdges(_arg_1, null, 0xFFFFFF); + }; + if ((_local_2 & Debug.BOUNDS)) + { + Debug.drawBounds(_arg_1, this, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ); + }; + }; + transformConst[0] = ma; + transformConst[1] = mb; + transformConst[2] = mc; + transformConst[3] = md; + transformConst[4] = me; + transformConst[5] = mf; + transformConst[6] = mg; + transformConst[7] = mh; + transformConst[8] = mi; + transformConst[9] = mj; + transformConst[10] = mk; + transformConst[11] = ml; + return (null); + }; + if (transformId > 0x1DCD6500) + { + transformId = 0; + _local_5 = this.vertexList; + while (_local_5 != null) + { + _local_5.transformId = 0; + _local_5 = _local_5.next; + }; + }; + transformId++; + calculateInverseMatrix(); + transformConst[0] = ma; + transformConst[1] = mb; + transformConst[2] = mc; + transformConst[3] = md; + transformConst[4] = me; + transformConst[5] = mf; + transformConst[6] = mg; + transformConst[7] = mh; + transformConst[8] = mi; + transformConst[9] = mj; + transformConst[10] = mk; + transformConst[11] = ml; + _local_4 = this.prepareNode(this.root, culling, _arg_1); + if (_local_4 != null) + { + return (VG.create(this, _local_4, 3, _local_2, false)); + }; + return (null); + } + + alternativa3d function prepareResources():void + { + var _local_1:Vector.; + var _local_2:int; + var _local_3:int; + var _local_4:Vertex; + var _local_5:Vector.; + var _local_6:int; + var _local_7:Face; + var _local_8:Wrapper; + var _local_9:uint; + var _local_10:uint; + var _local_11:uint; + if (this.vertexBuffer == null) + { + _local_1 = new Vector.(); + _local_2 = 0; + _local_3 = 0; + _local_4 = this.vertexList; + while (_local_4 != null) + { + _local_1[_local_2] = _local_4.x; + _local_2++; + _local_1[_local_2] = _local_4.y; + _local_2++; + _local_1[_local_2] = _local_4.z; + _local_2++; + _local_1[_local_2] = _local_4.u; + _local_2++; + _local_1[_local_2] = _local_4.v; + _local_2++; + _local_1[_local_2] = _local_4.normalX; + _local_2++; + _local_1[_local_2] = _local_4.normalY; + _local_2++; + _local_1[_local_2] = _local_4.normalZ; + _local_2++; + _local_4.index = _local_3; + _local_3++; + _local_4 = _local_4.next; + }; + this.vertexBuffer = new VertexBufferResource(_local_1, 8); + _local_5 = new Vector.(); + _local_6 = 0; + this.numTriangles = 0; + for each (_local_7 in this.faces) + { + _local_8 = _local_7.wrapper; + _local_9 = _local_8.vertex.index; + _local_8 = _local_8.next; + _local_10 = _local_8.vertex.index; + _local_8 = _local_8.next; + while (_local_8 != null) + { + _local_11 = _local_8.vertex.index; + _local_5[_local_6] = _local_9; + _local_6++; + _local_5[_local_6] = _local_10; + _local_6++; + _local_5[_local_6] = _local_11; + _local_6++; + _local_10 = _local_11; + this.numTriangles++; + _local_8 = _local_8.next; + }; + }; + this.indexBuffer = new IndexBufferResource(_local_5); + }; + } + + alternativa3d function deleteResources():void + { + if (this.vertexBuffer != null) + { + this.vertexBuffer.dispose(); + this.vertexBuffer = null; + this.indexBuffer.dispose(); + this.indexBuffer = null; + this.numTriangles = 0; + }; + } + + private function collectNode(_arg_1:Node, _arg_2:Face=null):Face + { + var _local_3:Face; + var _local_4:Wrapper; + var _local_5:Vertex; + var _local_6:Number; + var _local_7:Number; + var _local_8:Number; + if ((((_arg_1.normalX * imd) + (_arg_1.normalY * imh)) + (_arg_1.normalZ * iml)) > _arg_1.offset) + { + if (_arg_1.positive != null) + { + _arg_2 = this.collectNode(_arg_1.positive, _arg_2); + }; + _local_3 = _arg_1.faceList; + while (_local_3 != null) + { + _local_4 = _local_3.wrapper; + while (_local_4 != null) + { + _local_5 = _local_4.vertex; + if (_local_5.transformId != transformId) + { + _local_6 = _local_5.x; + _local_7 = _local_5.y; + _local_8 = _local_5.z; + _local_5.cameraX = ((((ma * _local_6) + (mb * _local_7)) + (mc * _local_8)) + md); + _local_5.cameraY = ((((me * _local_6) + (mf * _local_7)) + (mg * _local_8)) + mh); + _local_5.cameraZ = ((((mi * _local_6) + (mj * _local_7)) + (mk * _local_8)) + ml); + _local_5.transformId = transformId; + _local_5.drawId = 0; + }; + _local_4 = _local_4.next; + }; + _local_3.processNext = _arg_2; + _arg_2 = _local_3; + _local_3 = _local_3.next; + }; + if (_arg_1.negative != null) + { + _arg_2 = this.collectNode(_arg_1.negative, _arg_2); + }; + } else + { + if (_arg_1.negative != null) + { + _arg_2 = this.collectNode(_arg_1.negative, _arg_2); + }; + if (_arg_1.positive != null) + { + _arg_2 = this.collectNode(_arg_1.positive, _arg_2); + }; + }; + return (_arg_2); + } + + private function prepareNode(_arg_1:Node, _arg_2:int, _arg_3:Camera3D):Face + { + var _local_4:Face; + var _local_5:Wrapper; + var _local_8:Face; + var _local_9:Vertex; + var _local_10:Number; + var _local_11:Number; + var _local_12:Number; + var _local_13:Vertex; + var _local_14:Vertex; + var _local_15:Vertex; + var _local_16:Number; + var _local_17:Number; + var _local_18:Number; + var _local_19:Number; + var _local_20:Number; + var _local_21:Number; + var _local_22:Number; + var _local_23:Number; + var _local_24:Number; + var _local_25:Number; + if ((((imd * _arg_1.normalX) + (imh * _arg_1.normalY)) + (iml * _arg_1.normalZ)) > _arg_1.offset) + { + _local_4 = _arg_1.faceList; + _local_8 = _local_4; + while (_local_8 != null) + { + _local_5 = _local_8.wrapper; + while (_local_5 != null) + { + _local_9 = _local_5.vertex; + if (_local_9.transformId != transformId) + { + _local_10 = _local_9.x; + _local_11 = _local_9.y; + _local_12 = _local_9.z; + _local_9.cameraX = ((((ma * _local_10) + (mb * _local_11)) + (mc * _local_12)) + md); + _local_9.cameraY = ((((me * _local_10) + (mf * _local_11)) + (mg * _local_12)) + mh); + _local_9.cameraZ = ((((mi * _local_10) + (mj * _local_11)) + (mk * _local_12)) + ml); + _local_9.transformId = transformId; + _local_9.drawId = 0; + }; + _local_5 = _local_5.next; + }; + _local_8.processNext = _local_8.next; + _local_8 = _local_8.next; + }; + if (_arg_2 > 0) + { + if (this.clipping == 1) + { + _local_4 = _arg_3.cull(_local_4, _arg_2); + } else + { + _local_4 = _arg_3.clip(_local_4, _arg_2); + }; + }; + }; + var _local_6:Face = ((_arg_1.negative != null) ? this.prepareNode(_arg_1.negative, _arg_2, _arg_3) : null); + var _local_7:Face = ((_arg_1.positive != null) ? this.prepareNode(_arg_1.positive, _arg_2, _arg_3) : null); + if (((!(_local_4 == null)) || ((!(_local_6 == null)) && (!(_local_7 == null))))) + { + if (_local_4 == null) + { + _local_4 = _arg_1.faceList.create(); + _arg_3.lastFace.next = _local_4; + _arg_3.lastFace = _local_4; + }; + _local_5 = _arg_1.faceList.wrapper; + _local_13 = _local_5.vertex; + _local_5 = _local_5.next; + _local_14 = _local_5.vertex; + _local_5 = _local_5.next; + _local_15 = _local_5.vertex; + if (_local_13.transformId != transformId) + { + _local_13.cameraX = ((((ma * _local_13.x) + (mb * _local_13.y)) + (mc * _local_13.z)) + md); + _local_13.cameraY = ((((me * _local_13.x) + (mf * _local_13.y)) + (mg * _local_13.z)) + mh); + _local_13.cameraZ = ((((mi * _local_13.x) + (mj * _local_13.y)) + (mk * _local_13.z)) + ml); + _local_13.transformId = transformId; + _local_13.drawId = 0; + }; + if (_local_14.transformId != transformId) + { + _local_14.cameraX = ((((ma * _local_14.x) + (mb * _local_14.y)) + (mc * _local_14.z)) + md); + _local_14.cameraY = ((((me * _local_14.x) + (mf * _local_14.y)) + (mg * _local_14.z)) + mh); + _local_14.cameraZ = ((((mi * _local_14.x) + (mj * _local_14.y)) + (mk * _local_14.z)) + ml); + _local_14.transformId = transformId; + _local_14.drawId = 0; + }; + if (_local_15.transformId != transformId) + { + _local_15.cameraX = ((((ma * _local_15.x) + (mb * _local_15.y)) + (mc * _local_15.z)) + md); + _local_15.cameraY = ((((me * _local_15.x) + (mf * _local_15.y)) + (mg * _local_15.z)) + mh); + _local_15.cameraZ = ((((mi * _local_15.x) + (mj * _local_15.y)) + (mk * _local_15.z)) + ml); + _local_15.transformId = transformId; + _local_15.drawId = 0; + }; + _local_16 = (_local_14.cameraX - _local_13.cameraX); + _local_17 = (_local_14.cameraY - _local_13.cameraY); + _local_18 = (_local_14.cameraZ - _local_13.cameraZ); + _local_19 = (_local_15.cameraX - _local_13.cameraX); + _local_20 = (_local_15.cameraY - _local_13.cameraY); + _local_21 = (_local_15.cameraZ - _local_13.cameraZ); + _local_22 = ((_local_21 * _local_17) - (_local_20 * _local_18)); + _local_23 = ((_local_19 * _local_18) - (_local_21 * _local_16)); + _local_24 = ((_local_20 * _local_16) - (_local_19 * _local_17)); + _local_25 = (((_local_22 * _local_22) + (_local_23 * _local_23)) + (_local_24 * _local_24)); + if (_local_25 > 0) + { + _local_25 = (1 / Math.sqrt(length)); + _local_22 = (_local_22 * _local_25); + _local_23 = (_local_23 * _local_25); + _local_24 = (_local_24 * _local_25); + }; + _local_4.normalX = _local_22; + _local_4.normalY = _local_23; + _local_4.normalZ = _local_24; + _local_4.offset = (((_local_13.cameraX * _local_22) + (_local_13.cameraY * _local_23)) + (_local_13.cameraZ * _local_24)); + _local_4.processNegative = _local_6; + _local_4.processPositive = _local_7; + } else + { + _local_4 = ((_local_6 != null) ? _local_6 : _local_7); + }; + return (_local_4); + } + + override alternativa3d function updateBounds(_arg_1:Object3D, _arg_2:Object3D=null):void + { + var _local_3:Vertex = this.vertexList; + while (_local_3 != null) + { + if (_arg_2 != null) + { + _local_3.cameraX = ((((_arg_2.ma * _local_3.x) + (_arg_2.mb * _local_3.y)) + (_arg_2.mc * _local_3.z)) + _arg_2.md); + _local_3.cameraY = ((((_arg_2.me * _local_3.x) + (_arg_2.mf * _local_3.y)) + (_arg_2.mg * _local_3.z)) + _arg_2.mh); + _local_3.cameraZ = ((((_arg_2.mi * _local_3.x) + (_arg_2.mj * _local_3.y)) + (_arg_2.mk * _local_3.z)) + _arg_2.ml); + } else + { + _local_3.cameraX = _local_3.x; + _local_3.cameraY = _local_3.y; + _local_3.cameraZ = _local_3.z; + }; + if (_local_3.cameraX < _arg_1.boundMinX) + { + _arg_1.boundMinX = _local_3.cameraX; + }; + if (_local_3.cameraX > _arg_1.boundMaxX) + { + _arg_1.boundMaxX = _local_3.cameraX; + }; + if (_local_3.cameraY < _arg_1.boundMinY) + { + _arg_1.boundMinY = _local_3.cameraY; + }; + if (_local_3.cameraY > _arg_1.boundMaxY) + { + _arg_1.boundMaxY = _local_3.cameraY; + }; + if (_local_3.cameraZ < _arg_1.boundMinZ) + { + _arg_1.boundMinZ = _local_3.cameraZ; + }; + if (_local_3.cameraZ > _arg_1.boundMaxZ) + { + _arg_1.boundMaxZ = _local_3.cameraZ; + }; + _local_3 = _local_3.next; + }; + } + + override alternativa3d function split(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Vector3D, _arg_4:Number):Vector. + { + var _local_9:Vertex; + var _local_10:Vertex; + var _local_14:Face; + var _local_15:Face; + var _local_16:Face; + var _local_17:Face; + var _local_22:Face; + var _local_23:Face; + var _local_24:Wrapper; + var _local_25:Vertex; + var _local_26:Vertex; + var _local_27:Vertex; + var _local_28:Boolean; + var _local_29:Boolean; + var _local_30:Face; + var _local_31:Face; + var _local_32:Wrapper; + var _local_33:Wrapper; + var _local_34:Wrapper; + var _local_35:Number; + var _local_36:Vertex; + var _local_5:Vector. = new Vector.(2); + var _local_6:Vector3D = calculatePlane(_arg_1, _arg_2, _arg_3); + var _local_7:Number = (_local_6.w - _arg_4); + var _local_8:Number = (_local_6.w + _arg_4); + _local_9 = this.vertexList; + while (_local_9 != null) + { + _local_10 = _local_9.next; + _local_9.next = null; + _local_9.offset = (((_local_9.x * _local_6.x) + (_local_9.y * _local_6.y)) + (_local_9.z * _local_6.z)); + if (((_local_9.offset >= _local_7) && (_local_9.offset <= _local_8))) + { + _local_9.value = new Vertex(); + _local_9.value.x = _local_9.x; + _local_9.value.y = _local_9.y; + _local_9.value.z = _local_9.z; + _local_9.value.u = _local_9.u; + _local_9.value.v = _local_9.v; + _local_9.value.normalX = _local_9.normalX; + _local_9.value.normalY = _local_9.normalY; + _local_9.value.normalZ = _local_9.normalZ; + }; + _local_9.transformId = 0; + _local_9 = _local_10; + }; + this.vertexList = null; + if (this.root != null) + { + this.destroyNode(this.root); + this.root = null; + }; + var _local_11:Vector. = this.faces; + this.faces = new Vector.(); + var _local_12:BSP = (this.clone() as BSP); + var _local_13:BSP = (this.clone() as BSP); + var _local_18:int; + var _local_19:int; + var _local_20:int = _local_11.length; + var _local_21:int; + while (_local_21 < _local_20) + { + _local_22 = _local_11[_local_21]; + _local_23 = _local_22.next; + _local_24 = _local_22.wrapper; + _local_25 = _local_24.vertex; + _local_24 = _local_24.next; + _local_26 = _local_24.vertex; + _local_24 = _local_24.next; + _local_27 = _local_24.vertex; + _local_28 = (((_local_25.offset < _local_7) || (_local_26.offset < _local_7)) || (_local_27.offset < _local_7)); + _local_29 = (((_local_25.offset > _local_8) || (_local_26.offset > _local_8)) || (_local_27.offset > _local_8)); + _local_24 = _local_24.next; + while (_local_24 != null) + { + _local_9 = _local_24.vertex; + if (_local_9.offset < _local_7) + { + _local_28 = true; + } else + { + if (_local_9.offset > _local_8) + { + _local_29 = true; + }; + }; + _local_24 = _local_24.next; + }; + if ((!(_local_28))) + { + if (_local_17 != null) + { + _local_17.next = _local_22; + } else + { + _local_16 = _local_22; + }; + _local_17 = _local_22; + _local_13.faces[_local_19] = _local_22; + _local_19++; + } else + { + if ((!(_local_29))) + { + if (_local_15 != null) + { + _local_15.next = _local_22; + } else + { + _local_14 = _local_22; + }; + _local_15 = _local_22; + _local_12.faces[_local_18] = _local_22; + _local_18++; + _local_24 = _local_22.wrapper; + while (_local_24 != null) + { + if (_local_24.vertex.value != null) + { + _local_24.vertex = _local_24.vertex.value; + }; + _local_24 = _local_24.next; + }; + } else + { + _local_30 = new Face(); + _local_31 = new Face(); + _local_32 = null; + _local_33 = null; + _local_24 = _local_22.wrapper.next.next; + while (_local_24.next != null) + { + _local_24 = _local_24.next; + }; + _local_25 = _local_24.vertex; + _local_24 = _local_22.wrapper; + while (_local_24 != null) + { + _local_26 = _local_24.vertex; + if ((((_local_25.offset < _local_7) && (_local_26.offset > _local_8)) || ((_local_25.offset > _local_8) && (_local_26.offset < _local_7)))) + { + _local_35 = ((_local_6.w - _local_25.offset) / (_local_26.offset - _local_25.offset)); + _local_9 = new Vertex(); + _local_9.x = (_local_25.x + ((_local_26.x - _local_25.x) * _local_35)); + _local_9.y = (_local_25.y + ((_local_26.y - _local_25.y) * _local_35)); + _local_9.z = (_local_25.z + ((_local_26.z - _local_25.z) * _local_35)); + _local_9.u = (_local_25.u + ((_local_26.u - _local_25.u) * _local_35)); + _local_9.v = (_local_25.v + ((_local_26.v - _local_25.v) * _local_35)); + _local_9.normalX = (_local_25.normalX + ((_local_26.normalX - _local_25.normalX) * _local_35)); + _local_9.normalY = (_local_25.normalY + ((_local_26.normalY - _local_25.normalY) * _local_35)); + _local_9.normalZ = (_local_25.normalZ + ((_local_26.normalZ - _local_25.normalZ) * _local_35)); + _local_34 = new Wrapper(); + _local_34.vertex = _local_9; + if (_local_32 != null) + { + _local_32.next = _local_34; + } else + { + _local_30.wrapper = _local_34; + }; + _local_32 = _local_34; + _local_36 = new Vertex(); + _local_36.x = _local_9.x; + _local_36.y = _local_9.y; + _local_36.z = _local_9.z; + _local_36.u = _local_9.u; + _local_36.v = _local_9.v; + _local_36.normalX = _local_9.normalX; + _local_36.normalY = _local_9.normalY; + _local_36.normalZ = _local_9.normalZ; + _local_34 = new Wrapper(); + _local_34.vertex = _local_36; + if (_local_33 != null) + { + _local_33.next = _local_34; + } else + { + _local_31.wrapper = _local_34; + }; + _local_33 = _local_34; + }; + if (_local_26.offset < _local_7) + { + _local_34 = _local_24.create(); + _local_34.vertex = _local_26; + if (_local_32 != null) + { + _local_32.next = _local_34; + } else + { + _local_30.wrapper = _local_34; + }; + _local_32 = _local_34; + } else + { + if (_local_26.offset > _local_8) + { + _local_34 = _local_24.create(); + _local_34.vertex = _local_26; + if (_local_33 != null) + { + _local_33.next = _local_34; + } else + { + _local_31.wrapper = _local_34; + }; + _local_33 = _local_34; + } else + { + _local_34 = _local_24.create(); + _local_34.vertex = _local_26.value; + if (_local_32 != null) + { + _local_32.next = _local_34; + } else + { + _local_30.wrapper = _local_34; + }; + _local_32 = _local_34; + _local_34 = _local_24.create(); + _local_34.vertex = _local_26; + if (_local_33 != null) + { + _local_33.next = _local_34; + } else + { + _local_31.wrapper = _local_34; + }; + _local_33 = _local_34; + }; + }; + _local_25 = _local_26; + _local_24 = _local_24.next; + }; + _local_30.material = _local_22.material; + _local_30.calculateBestSequenceAndNormal(); + if (_local_15 != null) + { + _local_15.next = _local_30; + } else + { + _local_14 = _local_30; + }; + _local_15 = _local_30; + _local_12.faces[_local_18] = _local_30; + _local_18++; + _local_31.material = _local_22.material; + _local_31.calculateBestSequenceAndNormal(); + if (_local_17 != null) + { + _local_17.next = _local_31; + } else + { + _local_16 = _local_31; + }; + _local_17 = _local_31; + _local_13.faces[_local_19] = _local_31; + _local_19++; + }; + }; + _local_21++; + }; + if (_local_15 != null) + { + _local_15.next = null; + _local_12.transformId++; + _local_12.collectVertices(); + _local_12.root = _local_12.createNode(_local_14); + _local_12.calculateBounds(); + _local_5[0] = _local_12; + }; + if (_local_17 != null) + { + _local_17.next = null; + _local_13.transformId++; + _local_13.collectVertices(); + _local_13.root = _local_13.createNode(_local_16); + _local_13.calculateBounds(); + _local_5[1] = _local_13; + }; + return (_local_5); + } + + private function collectVertices():void + { + var _local_3:Face; + var _local_4:Wrapper; + var _local_5:Vertex; + var _local_1:int = this.faces.length; + var _local_2:int; + while (_local_2 < _local_1) + { + _local_3 = this.faces[_local_2]; + _local_4 = _local_3.wrapper; + while (_local_4 != null) + { + _local_5 = _local_4.vertex; + if (_local_5.transformId != transformId) + { + _local_5.next = this.vertexList; + this.vertexList = _local_5; + _local_5.transformId = transformId; + _local_5.value = null; + }; + _local_4 = _local_4.next; + }; + _local_2++; + }; + } + + private function createNode(_arg_1:Face):Node + { + var _local_3:Wrapper; + var _local_4:Vertex; + var _local_5:Vertex; + var _local_6:Vertex; + var _local_7:Vertex; + var _local_8:Boolean; + var _local_9:Boolean; + var _local_10:Number; + var _local_11:Number; + var _local_12:Number; + var _local_13:Number; + var _local_14:Number; + var _local_15:Number; + var _local_16:Number; + var _local_17:Number; + var _local_18:Number; + var _local_19:Number; + var _local_21:Face; + var _local_22:Face; + var _local_25:Face; + var _local_26:Face; + var _local_27:int; + var _local_28:Face; + var _local_29:int; + var _local_30:Face; + var _local_31:Face; + var _local_32:Face; + var _local_33:Face; + var _local_34:Wrapper; + var _local_35:Wrapper; + var _local_36:Wrapper; + var _local_37:Number; + var _local_2:Node = new Node(); + var _local_20:Face = _arg_1; + if (((this.splitAnalysis) && (!(_arg_1.next == null)))) + { + _local_27 = 2147483647; + _local_28 = _arg_1; + while (_local_28 != null) + { + _local_14 = _local_28.normalX; + _local_15 = _local_28.normalY; + _local_16 = _local_28.normalZ; + _local_17 = _local_28.offset; + _local_18 = (_local_17 - this.threshold); + _local_19 = (_local_17 + this.threshold); + _local_29 = 0; + _local_30 = _arg_1; + while (_local_30 != null) + { + if (_local_30 != _local_28) + { + _local_3 = _local_30.wrapper; + _local_4 = _local_3.vertex; + _local_3 = _local_3.next; + _local_5 = _local_3.vertex; + _local_3 = _local_3.next; + _local_6 = _local_3.vertex; + _local_3 = _local_3.next; + _local_10 = (((_local_4.x * _local_14) + (_local_4.y * _local_15)) + (_local_4.z * _local_16)); + _local_11 = (((_local_5.x * _local_14) + (_local_5.y * _local_15)) + (_local_5.z * _local_16)); + _local_12 = (((_local_6.x * _local_14) + (_local_6.y * _local_15)) + (_local_6.z * _local_16)); + _local_8 = (((_local_10 < _local_18) || (_local_11 < _local_18)) || (_local_12 < _local_18)); + _local_9 = (((_local_10 > _local_19) || (_local_11 > _local_19)) || (_local_12 > _local_19)); + while (_local_3 != null) + { + _local_7 = _local_3.vertex; + _local_13 = (((_local_7.x * _local_14) + (_local_7.y * _local_15)) + (_local_7.z * _local_16)); + if (_local_13 < _local_18) + { + _local_8 = true; + if (_local_9) break; + } else + { + if (_local_13 > _local_19) + { + _local_9 = true; + if (_local_8) break; + }; + }; + _local_3 = _local_3.next; + }; + if (((_local_9) && (_local_8))) + { + _local_29++; + if (_local_29 >= _local_27) break; + }; + }; + _local_30 = _local_30.next; + }; + if (_local_29 < _local_27) + { + _local_20 = _local_28; + _local_27 = _local_29; + if (_local_27 == 0) break; + }; + _local_28 = _local_28.next; + }; + }; + var _local_23:Face = _local_20; + var _local_24:Face = _local_20.next; + _local_14 = _local_20.normalX; + _local_15 = _local_20.normalY; + _local_16 = _local_20.normalZ; + _local_17 = _local_20.offset; + _local_18 = (_local_17 - this.threshold); + _local_19 = (_local_17 + this.threshold); + while (_arg_1 != null) + { + if (_arg_1 != _local_20) + { + _local_31 = _arg_1.next; + _local_3 = _arg_1.wrapper; + _local_4 = _local_3.vertex; + _local_3 = _local_3.next; + _local_5 = _local_3.vertex; + _local_3 = _local_3.next; + _local_6 = _local_3.vertex; + _local_3 = _local_3.next; + _local_10 = (((_local_4.x * _local_14) + (_local_4.y * _local_15)) + (_local_4.z * _local_16)); + _local_11 = (((_local_5.x * _local_14) + (_local_5.y * _local_15)) + (_local_5.z * _local_16)); + _local_12 = (((_local_6.x * _local_14) + (_local_6.y * _local_15)) + (_local_6.z * _local_16)); + _local_8 = (((_local_10 < _local_18) || (_local_11 < _local_18)) || (_local_12 < _local_18)); + _local_9 = (((_local_10 > _local_19) || (_local_11 > _local_19)) || (_local_12 > _local_19)); + while (_local_3 != null) + { + _local_7 = _local_3.vertex; + _local_13 = (((_local_7.x * _local_14) + (_local_7.y * _local_15)) + (_local_7.z * _local_16)); + if (_local_13 < _local_18) + { + _local_8 = true; + } else + { + if (_local_13 > _local_19) + { + _local_9 = true; + }; + }; + _local_7.offset = _local_13; + _local_3 = _local_3.next; + }; + if ((!(_local_8))) + { + if ((!(_local_9))) + { + if ((((_arg_1.normalX * _local_14) + (_arg_1.normalY * _local_15)) + (_arg_1.normalZ * _local_16)) > 0) + { + _local_23.next = _arg_1; + _local_23 = _arg_1; + } else + { + if (_local_21 != null) + { + _local_22.next = _arg_1; + } else + { + _local_21 = _arg_1; + }; + _local_22 = _arg_1; + }; + } else + { + if (_local_25 != null) + { + _local_26.next = _arg_1; + } else + { + _local_25 = _arg_1; + }; + _local_26 = _arg_1; + }; + } else + { + if ((!(_local_9))) + { + if (_local_21 != null) + { + _local_22.next = _arg_1; + } else + { + _local_21 = _arg_1; + }; + _local_22 = _arg_1; + } else + { + _local_4.offset = _local_10; + _local_5.offset = _local_11; + _local_6.offset = _local_12; + _local_32 = new Face(); + _local_33 = new Face(); + _local_34 = null; + _local_35 = null; + _local_3 = _arg_1.wrapper.next.next; + while (_local_3.next != null) + { + _local_3 = _local_3.next; + }; + _local_4 = _local_3.vertex; + _local_10 = _local_4.offset; + _local_3 = _arg_1.wrapper; + while (_local_3 != null) + { + _local_5 = _local_3.vertex; + _local_11 = _local_5.offset; + if ((((_local_10 < _local_18) && (_local_11 > _local_19)) || ((_local_10 > _local_19) && (_local_11 < _local_18)))) + { + _local_37 = ((_local_17 - _local_10) / (_local_11 - _local_10)); + _local_7 = new Vertex(); + _local_7.next = this.vertexList; + this.vertexList = _local_7; + _local_7.x = (_local_4.x + ((_local_5.x - _local_4.x) * _local_37)); + _local_7.y = (_local_4.y + ((_local_5.y - _local_4.y) * _local_37)); + _local_7.z = (_local_4.z + ((_local_5.z - _local_4.z) * _local_37)); + _local_7.u = (_local_4.u + ((_local_5.u - _local_4.u) * _local_37)); + _local_7.v = (_local_4.v + ((_local_5.v - _local_4.v) * _local_37)); + _local_7.normalX = (_local_4.normalX + ((_local_5.normalX - _local_4.normalX) * _local_37)); + _local_7.normalY = (_local_4.normalY + ((_local_5.normalY - _local_4.normalY) * _local_37)); + _local_7.normalZ = (_local_4.normalZ + ((_local_5.normalZ - _local_4.normalZ) * _local_37)); + _local_36 = new Wrapper(); + _local_36.vertex = _local_7; + if (_local_34 != null) + { + _local_34.next = _local_36; + } else + { + _local_32.wrapper = _local_36; + }; + _local_34 = _local_36; + _local_36 = new Wrapper(); + _local_36.vertex = _local_7; + if (_local_35 != null) + { + _local_35.next = _local_36; + } else + { + _local_33.wrapper = _local_36; + }; + _local_35 = _local_36; + }; + if (_local_11 <= _local_19) + { + _local_36 = new Wrapper(); + _local_36.vertex = _local_5; + if (_local_34 != null) + { + _local_34.next = _local_36; + } else + { + _local_32.wrapper = _local_36; + }; + _local_34 = _local_36; + }; + if (_local_11 >= _local_18) + { + _local_36 = new Wrapper(); + _local_36.vertex = _local_5; + if (_local_35 != null) + { + _local_35.next = _local_36; + } else + { + _local_33.wrapper = _local_36; + }; + _local_35 = _local_36; + }; + _local_4 = _local_5; + _local_10 = _local_11; + _local_3 = _local_3.next; + }; + _local_32.material = _arg_1.material; + _local_32.smoothingGroups = _arg_1.smoothingGroups; + _local_32.calculateBestSequenceAndNormal(); + if (_local_21 != null) + { + _local_22.next = _local_32; + } else + { + _local_21 = _local_32; + }; + _local_22 = _local_32; + _local_33.material = _arg_1.material; + _local_33.smoothingGroups = _arg_1.smoothingGroups; + _local_33.calculateBestSequenceAndNormal(); + if (_local_25 != null) + { + _local_26.next = _local_33; + } else + { + _local_25 = _local_33; + }; + _local_26 = _local_33; + }; + }; + _arg_1 = _local_31; + } else + { + _arg_1 = _local_24; + }; + }; + if (_local_21 != null) + { + _local_22.next = null; + _local_2.negative = this.createNode(_local_21); + }; + _local_23.next = null; + _local_2.faceList = _local_20; + _local_2.normalX = _local_14; + _local_2.normalY = _local_15; + _local_2.normalZ = _local_16; + _local_2.offset = _local_17; + if (_local_25 != null) + { + _local_26.next = null; + _local_2.positive = this.createNode(_local_25); + }; + return (_local_2); + } + + private function destroyNode(_arg_1:Node):void + { + var _local_3:Face; + if (_arg_1.negative != null) + { + this.destroyNode(_arg_1.negative); + _arg_1.negative = null; + }; + if (_arg_1.positive != null) + { + this.destroyNode(_arg_1.positive); + _arg_1.positive = null; + }; + var _local_2:Face = _arg_1.faceList; + while (_local_2 != null) + { + _local_3 = _local_2.next; + _local_2.next = null; + _local_2 = _local_3; + }; + } + + + } +}//package alternativa.engine3d.objects + +import alternativa.engine3d.core.Face; + +class Node +{ + + public var negative:Node; + public var positive:Node; + public var faceList:Face; + public var normalX:Number; + public var normalY:Number; + public var normalZ:Number; + public var offset:Number; + + +} diff --git a/src/alternativa/engine3d/objects/Bone.as b/src/alternativa/engine3d/objects/Bone.as new file mode 100644 index 0000000..7c62926 --- /dev/null +++ b/src/alternativa/engine3d/objects/Bone.as @@ -0,0 +1,95 @@ +package alternativa.engine3d.objects +{ + import alternativa.engine3d.core.Vertex; + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.core.Debug; + import alternativa.engine3d.core.Camera3D; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class Bone extends Joint + { + + public var length:Number; + alternativa3d var lx:Number; + alternativa3d var ly:Number; + alternativa3d var lz:Number; + alternativa3d var ldot:Number; + + public function Bone(_arg_1:Number, _arg_2:Number) + { + this.length = _arg_1; + this.distance = _arg_2; + } + + public function bindVerticesByDistance(_arg_1:Skin):void + { + var _local_2:Vertex = _arg_1.vertexList; + while (_local_2 != null) + { + this.bindVertexByDistance(_local_2); + _local_2 = _local_2.next; + }; + } + + public function bindVertexByDistance(_arg_1:Vertex):void + { + var _local_2:Number = (_arg_1.x - md); + var _local_3:Number = (_arg_1.y - mh); + var _local_4:Number = (_arg_1.z - ml); + var _local_5:Number = (((_local_2 * this.lx) + (_local_3 * this.ly)) + (_local_4 * this.lz)); + if (_local_5 > 0) + { + if (this.ldot > _local_5) + { + _local_5 = (_local_5 / this.ldot); + _local_2 = ((_arg_1.x - md) - (_local_5 * this.lx)); + _local_3 = ((_arg_1.y - mh) - (_local_5 * this.ly)); + _local_4 = ((_arg_1.z - ml) - (_local_5 * this.lz)); + } else + { + _local_2 = (_local_2 - this.lx); + _local_3 = (_local_3 - this.ly); + _local_4 = (_local_4 - this.lz); + }; + }; + bindVertex(_arg_1, (1 - (Math.sqrt((((_local_2 * _local_2) + (_local_3 * _local_3)) + (_local_4 * _local_4))) / distance))); + } + + override alternativa3d function calculateBindingMatrix(_arg_1:Object3D):void + { + super.calculateBindingMatrix(_arg_1); + this.lx = (mc * this.length); + this.ly = (mg * this.length); + this.lz = (mk * this.length); + this.ldot = (((this.lx * this.lx) + (this.ly * this.ly)) + (this.lz * this.lz)); + } + + override alternativa3d function drawDebug(_arg_1:Camera3D):void + { + var _local_2:Number; + var _local_3:Number; + var _local_4:Number; + var _local_5:Number; + var _local_6:Number; + if (numChildren == 0) + { + _local_2 = ((md * _arg_1.viewSizeX) / ml); + _local_3 = ((mh * _arg_1.viewSizeY) / ml); + _local_4 = ((mi * this.length) + ml); + _local_5 = ((((ma * this.length) + md) * _arg_1.viewSizeX) / _local_4); + _local_6 = ((((me * this.length) + mh) * _arg_1.viewSizeY) / _local_4); + if (((ml > 0) && (_local_4 > 0))) + { + Debug.drawBone(_arg_1, _local_2, _local_3, _local_5, _local_6, ((10 * _arg_1.focalLength) / ml), 39423); + }; + } else + { + super.drawDebug(_arg_1); + }; + } + + + } +}//package alternativa.engine3d.objects \ No newline at end of file diff --git a/src/alternativa/engine3d/objects/Decal.as b/src/alternativa/engine3d/objects/Decal.as new file mode 100644 index 0000000..63f4507 --- /dev/null +++ b/src/alternativa/engine3d/objects/Decal.as @@ -0,0 +1,210 @@ +package alternativa.engine3d.objects +{ + import alternativa.engine3d.core.Vertex; + import alternativa.engine3d.core.Face; + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.core.Debug; + import alternativa.engine3d.core.Camera3D; + import alternativa.engine3d.core.VG; + import __AS3__.vec.Vector; + import alternativa.engine3d.core.Wrapper; + import alternativa.gfx.core.VertexBufferResource; + import alternativa.gfx.core.IndexBufferResource; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class Decal extends Mesh + { + + public var attenuation:Number = 1000000; + + public function Decal() + { + shadowMapAlphaThreshold = 100; + } + + public function createGeometry(_arg_1:Mesh, _arg_2:Boolean=false):void + { + if ((!(_arg_2))) + { + _arg_1 = (_arg_1.clone() as Mesh); + }; + faceList = _arg_1.faceList; + vertexList = _arg_1.vertexList; + _arg_1.faceList = null; + _arg_1.vertexList = null; + var _local_3:Vertex = vertexList; + while (_local_3 != null) + { + _local_3.transformId = 0; + _local_3.id = null; + _local_3 = _local_3.next; + }; + var _local_4:Face = faceList; + while (_local_4 != null) + { + _local_4.id = null; + _local_4 = _local_4.next; + }; + calculateBounds(); + } + + override public function clone():Object3D + { + var _local_1:Decal = new Decal(); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + override protected function clonePropertiesFrom(_arg_1:Object3D):void + { + super.clonePropertiesFrom(_arg_1); + var _local_2:Decal = (_arg_1 as Decal); + this.attenuation = _local_2.attenuation; + } + + override alternativa3d function draw(_arg_1:Camera3D):void + { + var _local_3:Face; + var _local_4:Vertex; + if (faceList == null) + { + return; + }; + if (clipping == 0) + { + if ((culling & 0x01)) + { + return; + }; + culling = 0; + }; + this.prepareResources(); + useDepth = true; + if (faceList.material != null) + { + _arg_1.addDecal(this); + transformConst[0] = ma; + transformConst[1] = mb; + transformConst[2] = mc; + transformConst[3] = md; + transformConst[4] = me; + transformConst[5] = mf; + transformConst[6] = mg; + transformConst[7] = mh; + transformConst[8] = mi; + transformConst[9] = mj; + transformConst[10] = mk; + transformConst[11] = ml; + }; + var _local_2:int = ((_arg_1.debug) ? _arg_1.checkInDebug(this) : 0); + if ((_local_2 & Debug.BOUNDS)) + { + Debug.drawBounds(_arg_1, this, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ); + }; + if ((_local_2 & Debug.EDGES)) + { + if (transformId > 0x1DCD6500) + { + transformId = 0; + _local_4 = vertexList; + while (_local_4 != null) + { + _local_4.transformId = 0; + _local_4 = _local_4.next; + }; + }; + transformId++; + calculateInverseMatrix(); + _local_3 = prepareFaces(_arg_1, faceList); + if (_local_3 == null) + { + return; + }; + Debug.drawEdges(_arg_1, _local_3, 0xFFFFFF); + }; + } + + override alternativa3d function getVG(_arg_1:Camera3D):VG + { + this.draw(_arg_1); + return (null); + } + + override alternativa3d function prepareResources():void + { + var _local_1:Vector.; + var _local_2:int; + var _local_3:int; + var _local_4:Vertex; + var _local_5:Vector.; + var _local_6:int; + var _local_7:Face; + var _local_8:Wrapper; + var _local_9:uint; + var _local_10:uint; + var _local_11:uint; + if (vertexBuffer == null) + { + _local_1 = new Vector.(); + _local_2 = 0; + _local_3 = 0; + _local_4 = vertexList; + while (_local_4 != null) + { + _local_1[_local_2] = _local_4.x; + _local_2++; + _local_1[_local_2] = _local_4.y; + _local_2++; + _local_1[_local_2] = _local_4.z; + _local_2++; + _local_1[_local_2] = _local_4.u; + _local_2++; + _local_1[_local_2] = _local_4.v; + _local_2++; + _local_1[_local_2] = _local_4.normalX; + _local_2++; + _local_1[_local_2] = _local_4.normalY; + _local_2++; + _local_1[_local_2] = _local_4.normalZ; + _local_2++; + _local_4.index = _local_3; + _local_3++; + _local_4 = _local_4.next; + }; + vertexBuffer = new VertexBufferResource(_local_1, 8); + _local_5 = new Vector.(); + _local_6 = 0; + numTriangles = 0; + _local_7 = faceList; + while (_local_7 != null) + { + _local_8 = _local_7.wrapper; + _local_9 = _local_8.vertex.index; + _local_8 = _local_8.next; + _local_10 = _local_8.vertex.index; + _local_8 = _local_8.next; + while (_local_8 != null) + { + _local_11 = _local_8.vertex.index; + _local_5[_local_6] = _local_9; + _local_6++; + _local_5[_local_6] = _local_10; + _local_6++; + _local_5[_local_6] = _local_11; + _local_6++; + _local_10 = _local_11; + numTriangles++; + _local_8 = _local_8.next; + }; + _local_7 = _local_7.next; + }; + indexBuffer = new IndexBufferResource(_local_5); + }; + } + + + } +}//package alternativa.engine3d.objects \ No newline at end of file diff --git a/src/alternativa/engine3d/objects/Joint.as b/src/alternativa/engine3d/objects/Joint.as new file mode 100644 index 0000000..5ee9426 --- /dev/null +++ b/src/alternativa/engine3d/objects/Joint.as @@ -0,0 +1,605 @@ +package alternativa.engine3d.objects +{ + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.core.Vertex; + import flash.geom.Matrix3D; + import __AS3__.vec.Vector; + import flash.geom.Vector3D; + import alternativa.engine3d.core.Debug; + import alternativa.engine3d.core.Camera3D; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class Joint extends Object3D + { + + alternativa3d var vertexBindingList:VertexBinding; + alternativa3d var bma:Number; + alternativa3d var bmb:Number; + alternativa3d var bmc:Number; + alternativa3d var bmd:Number; + alternativa3d var bme:Number; + alternativa3d var bmf:Number; + alternativa3d var bmg:Number; + alternativa3d var bmh:Number; + alternativa3d var bmi:Number; + alternativa3d var bmj:Number; + alternativa3d var bmk:Number; + alternativa3d var bml:Number; + alternativa3d var _parentJoint:Joint; + alternativa3d var _skin:Skin; + alternativa3d var nextJoint:Joint; + alternativa3d var childrenList:Joint; + + + public function addChild(_arg_1:Joint):Joint + { + var _local_3:Joint; + if (_arg_1 == null) + { + throw (new TypeError("Parameter child must be non-null.")); + }; + if (_arg_1 == this) + { + throw (new ArgumentError("A joint cannot be added as a child of itself.")); + }; + var _local_2:Joint = this._parentJoint; + while (_local_2 != null) + { + if (_local_2 == _arg_1) + { + throw (new ArgumentError("A joint cannot be added as a child to one of it's children (or children's children, etc.).")); + }; + _local_2 = _local_2._parentJoint; + }; + if (_arg_1._parentJoint != null) + { + _arg_1._parentJoint.removeChild(_arg_1); + } else + { + if (_arg_1._skin != null) + { + _arg_1._skin.removeJoint(_arg_1); + }; + }; + _arg_1._parentJoint = this; + _arg_1.setSkin(this._skin); + if (this.childrenList == null) + { + this.childrenList = _arg_1; + } else + { + _local_3 = this.childrenList; + while (_local_3 != null) + { + if (_local_3.nextJoint == null) + { + _local_3.nextJoint = _arg_1; + break; + }; + _local_3 = _local_3.nextJoint; + }; + }; + return (_arg_1); + } + + alternativa3d function addChildFast(_arg_1:Joint):Joint + { + var _local_2:Joint; + _arg_1._parentJoint = this; + _arg_1.setSkinFast(this._skin); + if (this.childrenList == null) + { + this.childrenList = _arg_1; + } else + { + _local_2 = this.childrenList; + while (_local_2 != null) + { + if (_local_2.nextJoint == null) + { + _local_2.nextJoint = _arg_1; + break; + }; + _local_2 = _local_2.nextJoint; + }; + }; + return (_arg_1); + } + + public function removeChild(_arg_1:Joint):Joint + { + var _local_2:Joint; + var _local_3:Joint; + if (_arg_1 == null) + { + throw (new TypeError("Parameter child must be non-null.")); + }; + if (_arg_1._parentJoint != this) + { + throw (new ArgumentError("The supplied Joint must be a child of the caller.")); + }; + _local_3 = this.childrenList; + while (_local_3 != null) + { + if (_local_3 == _arg_1) + { + if (_local_2 != null) + { + _local_2.nextJoint = _local_3.nextJoint; + } else + { + this.childrenList = _local_3.nextJoint; + }; + _local_3.nextJoint = null; + _local_3._parentJoint = null; + _local_3.setSkin(null); + return (_arg_1); + }; + _local_2 = _local_3; + _local_3 = _local_3.nextJoint; + }; + return (null); + } + + public function getChildAt(_arg_1:int):Joint + { + if (_arg_1 < 0) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + var _local_2:Joint = this.childrenList; + var _local_3:int; + while (_local_3 < _arg_1) + { + if (_local_2 == null) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + _local_2 = _local_2.nextJoint; + _local_3++; + }; + if (_local_2 == null) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + return (_local_2); + } + + public function get numChildren():int + { + var _local_1:int; + var _local_2:Joint = this.childrenList; + while (_local_2 != null) + { + _local_1++; + _local_2 = _local_2.nextJoint; + }; + return (_local_1); + } + + public function get skin():Skin + { + return (this._skin); + } + + public function get parentJoint():Joint + { + return (this._parentJoint); + } + + public function bindVertex(_arg_1:Vertex, _arg_2:Number):void + { + var _local_4:Vertex; + var _local_5:VertexBinding; + if (this._skin != null) + { + _local_4 = this._skin.vertexList; + while (_local_4 != null) + { + if (_local_4 == _arg_1) break; + _local_4 = _local_4.next; + }; + if (_local_4 == null) + { + throw (new ArgumentError("Vertex not found")); + }; + } else + { + throw (new ArgumentError("Vertex not found")); + }; + var _local_3:VertexBinding = this.vertexBindingList; + while (_local_3 != null) + { + if (_local_3.vertex == _arg_1) break; + _local_3 = _local_3.next; + }; + if (_local_3 != null) + { + _local_3.weight = _arg_2; + } else + { + _local_5 = new VertexBinding(); + _local_5.next = this.vertexBindingList; + this.vertexBindingList = _local_5; + _local_5.vertex = _arg_1; + _local_5.weight = _arg_2; + }; + } + + public function unbindVertex(_arg_1:Vertex):void + { + var _local_2:VertexBinding; + var _local_3:VertexBinding; + _local_3 = this.vertexBindingList; + while (_local_3 != null) + { + if (_local_3.vertex == _arg_1) + { + if (_local_2 != null) + { + _local_2.next = _local_3.next; + } else + { + this.vertexBindingList = _local_3.next; + }; + _local_3.next = null; + return; + }; + _local_2 = _local_3; + _local_3 = _local_3.next; + }; + } + + alternativa3d function calculateBindingMatrix(_arg_1:Object3D):void + { + composeAndAppend(_arg_1); + var _local_2:Number = (1 / (((((((-(mc) * mf) * mi) + ((mb * mg) * mi)) + ((mc * me) * mj)) - ((ma * mg) * mj)) - ((mb * me) * mk)) + ((ma * mf) * mk))); + this.bma = (((-(mg) * mj) + (mf * mk)) * _local_2); + this.bmb = (((mc * mj) - (mb * mk)) * _local_2); + this.bmc = (((-(mc) * mf) + (mb * mg)) * _local_2); + this.bmd = ((((((((md * mg) * mj) - ((mc * mh) * mj)) - ((md * mf) * mk)) + ((mb * mh) * mk)) + ((mc * mf) * ml)) - ((mb * mg) * ml)) * _local_2); + this.bme = (((mg * mi) - (me * mk)) * _local_2); + this.bmf = (((-(mc) * mi) + (ma * mk)) * _local_2); + this.bmg = (((mc * me) - (ma * mg)) * _local_2); + this.bmh = ((((((((mc * mh) * mi) - ((md * mg) * mi)) + ((md * me) * mk)) - ((ma * mh) * mk)) - ((mc * me) * ml)) + ((ma * mg) * ml)) * _local_2); + this.bmi = (((-(mf) * mi) + (me * mj)) * _local_2); + this.bmj = (((mb * mi) - (ma * mj)) * _local_2); + this.bmk = (((-(mb) * me) + (ma * mf)) * _local_2); + this.bml = ((((((((md * mf) * mi) - ((mb * mh) * mi)) - ((md * me) * mj)) + ((ma * mh) * mj)) + ((mb * me) * ml)) - ((ma * mf) * ml)) * _local_2); + var _local_3:Joint = this.childrenList; + while (_local_3 != null) + { + _local_3.calculateBindingMatrix(this); + _local_3 = _local_3.nextJoint; + }; + } + + override public function get matrix():Matrix3D + { + return (super.matrix); + } + + override public function set matrix(_arg_1:Matrix3D):void + { + var _local_2:Vector. = _arg_1.decompose(); + var _local_3:Vector3D = _local_2[0]; + var _local_4:Vector3D = _local_2[1]; + var _local_5:Vector3D = _local_2[2]; + x = _local_3.x; + y = _local_3.y; + z = _local_3.z; + rotationX = _local_4.x; + rotationY = _local_4.y; + rotationZ = _local_4.z; + scaleX = _local_5.x; + scaleY = _local_5.y; + scaleZ = _local_5.z; + } + + override public function get concatenatedMatrix():Matrix3D + { + var _local_2:Object3D; + tA.composeMatrixFromSource(this); + var _local_1:Joint = this; + while (_local_1._parentJoint != null) + { + _local_1 = _local_1._parentJoint; + tB.composeMatrixFromSource(_local_1); + tA.appendMatrix(tB); + }; + if (this._skin != null) + { + tB.composeMatrixFromSource(this._skin); + tA.appendMatrix(tB); + _local_2 = this._skin; + while (_local_2._parent != null) + { + _local_2 = _local_2._parent; + tB.composeMatrixFromSource(_local_2); + tA.appendMatrix(tB); + }; + }; + return (new Matrix3D(Vector.([tA.ma, tA.me, tA.mi, 0, tA.mb, tA.mf, tA.mj, 0, tA.mc, tA.mg, tA.mk, 0, tA.md, tA.mh, tA.ml, 1]))); + } + + override public function localToGlobal(_arg_1:Vector3D):Vector3D + { + var _local_4:Object3D; + tA.composeMatrixFromSource(this); + var _local_2:Joint = this; + while (_local_2._parentJoint != null) + { + _local_2 = _local_2._parentJoint; + tB.composeMatrixFromSource(_local_2); + tA.appendMatrix(tB); + }; + if (this._skin != null) + { + tB.composeMatrixFromSource(this._skin); + tA.appendMatrix(tB); + _local_4 = this._skin; + while (_local_4._parent != null) + { + _local_4 = _local_4._parent; + tB.composeMatrixFromSource(_local_4); + tA.appendMatrix(tB); + }; + }; + var _local_3:Vector3D = new Vector3D(); + _local_3.x = ((((tA.ma * _arg_1.x) + (tA.mb * _arg_1.y)) + (tA.mc * _arg_1.z)) + tA.md); + _local_3.y = ((((tA.me * _arg_1.x) + (tA.mf * _arg_1.y)) + (tA.mg * _arg_1.z)) + tA.mh); + _local_3.z = ((((tA.mi * _arg_1.x) + (tA.mj * _arg_1.y)) + (tA.mk * _arg_1.z)) + tA.ml); + return (_local_3); + } + + override public function globalToLocal(_arg_1:Vector3D):Vector3D + { + var _local_4:Object3D; + tA.composeMatrixFromSource(this); + var _local_2:Joint = this; + while (_local_2._parentJoint != null) + { + _local_2 = _local_2._parentJoint; + tB.composeMatrixFromSource(_local_2); + tA.appendMatrix(tB); + }; + if (this._skin != null) + { + tB.composeMatrixFromSource(this._skin); + tA.appendMatrix(tB); + _local_4 = this._skin; + while (_local_4._parent != null) + { + _local_4 = _local_4._parent; + tB.composeMatrixFromSource(_local_4); + tA.appendMatrix(tB); + }; + }; + tA.invertMatrix(); + var _local_3:Vector3D = new Vector3D(); + _local_3.x = ((((tA.ma * _arg_1.x) + (tA.mb * _arg_1.y)) + (tA.mc * _arg_1.z)) + tA.md); + _local_3.y = ((((tA.me * _arg_1.x) + (tA.mf * _arg_1.y)) + (tA.mg * _arg_1.z)) + tA.mh); + _local_3.z = ((((tA.mi * _arg_1.x) + (tA.mj * _arg_1.y)) + (tA.mk * _arg_1.z)) + tA.ml); + return (_local_3); + } + + public function get bindingMatrix():Matrix3D + { + return (new Matrix3D(Vector.([this.bma, this.bme, this.bmi, 0, this.bmb, this.bmf, this.bmj, 0, this.bmc, this.bmg, this.bmk, 0, this.bmd, this.bmh, this.bml, 1]))); + } + + public function set bindingMatrix(_arg_1:Matrix3D):void + { + var _local_2:Vector. = _arg_1.rawData; + this.bma = _local_2[0]; + this.bmb = _local_2[4]; + this.bmc = _local_2[8]; + this.bmd = _local_2[12]; + this.bme = _local_2[1]; + this.bmf = _local_2[5]; + this.bmg = _local_2[9]; + this.bmh = _local_2[13]; + this.bmi = _local_2[2]; + this.bmj = _local_2[6]; + this.bmk = _local_2[10]; + this.bml = _local_2[14]; + } + + alternativa3d function addWeights():void + { + var _local_1:VertexBinding = this.vertexBindingList; + while (_local_1 != null) + { + _local_1.vertex.offset = (_local_1.vertex.offset + _local_1.weight); + _local_1 = _local_1.next; + }; + var _local_2:Joint = this.childrenList; + while (_local_2 != null) + { + _local_2.addWeights(); + _local_2 = _local_2.nextJoint; + }; + } + + alternativa3d function normalizeWeights():void + { + var _local_1:VertexBinding = this.vertexBindingList; + while (_local_1 != null) + { + _local_1.weight = (_local_1.weight / _local_1.vertex.offset); + _local_1 = _local_1.next; + }; + var _local_2:Joint = this.childrenList; + while (_local_2 != null) + { + _local_2.normalizeWeights(); + _local_2 = _local_2.nextJoint; + }; + } + + alternativa3d function drawDebug(_arg_1:Camera3D):void + { + var _local_4:Number; + var _local_5:Number; + var _local_6:Number; + var _local_7:Number; + var _local_11:Number; + var _local_12:Number; + var _local_13:Number; + appendMatrix(this._skin); + var _local_2:Number = ((md * _arg_1.viewSizeX) / ml); + var _local_3:Number = ((mh * _arg_1.viewSizeY) / ml); + var _local_8:Number = (_arg_1.focalLength / _arg_1.viewSizeX); + var _local_9:Number = (_arg_1.focalLength / _arg_1.viewSizeY); + var _local_10:Joint = this.childrenList; + while (_local_10 != null) + { + _local_4 = ((((mi * _local_10.x) + (mj * _local_10.y)) + (mk * _local_10.z)) + ml); + _local_5 = ((((((ma * _local_10.x) + (mb * _local_10.y)) + (mc * _local_10.z)) + md) * _arg_1.viewSizeX) / _local_4); + _local_6 = ((((((me * _local_10.x) + (mf * _local_10.y)) + (mg * _local_10.z)) + mh) * _arg_1.viewSizeY) / _local_4); + _local_11 = ((((ma * _local_10.x) + (mb * _local_10.y)) + (mc * _local_10.z)) / _local_8); + _local_12 = ((((me * _local_10.x) + (mf * _local_10.y)) + (mg * _local_10.z)) / _local_9); + _local_13 = (((mi * _local_10.x) + (mj * _local_10.y)) + (mk * _local_10.z)); + _local_7 = Math.sqrt((((_local_11 * _local_11) + (_local_12 * _local_12)) + (_local_13 * _local_13))); + if (((ml > 0) && (_local_4 > 0))) + { + Debug.drawBone(_arg_1, _local_2, _local_3, _local_5, _local_6, (((_local_7 / 10) * _arg_1.focalLength) / ml), 0xFF); + }; + _local_10.drawDebug(_arg_1); + _local_10 = _local_10.nextJoint; + }; + } + + alternativa3d function calculateVertices(_arg_1:Boolean, _arg_2:Boolean):void + { + var _local_15:VertexBinding; + var _local_16:Vertex; + var _local_17:Number; + var _local_18:Vertex; + var _local_19:Joint; + var _local_20:Number; + var _local_21:Number; + var _local_22:Number; + var _local_23:Number; + var _local_24:Number; + var _local_25:Number; + var _local_26:Number; + var _local_27:Number; + var _local_28:Number; + var _local_29:Number; + var _local_30:Number; + var _local_31:Number; + var _local_32:Number; + var _local_3:Number = (((ma * this.bma) + (mb * this.bme)) + (mc * this.bmi)); + var _local_4:Number = (((ma * this.bmb) + (mb * this.bmf)) + (mc * this.bmj)); + var _local_5:Number = (((ma * this.bmc) + (mb * this.bmg)) + (mc * this.bmk)); + var _local_6:Number = ((((ma * this.bmd) + (mb * this.bmh)) + (mc * this.bml)) + md); + var _local_7:Number = (((me * this.bma) + (mf * this.bme)) + (mg * this.bmi)); + var _local_8:Number = (((me * this.bmb) + (mf * this.bmf)) + (mg * this.bmj)); + var _local_9:Number = (((me * this.bmc) + (mf * this.bmg)) + (mg * this.bmk)); + var _local_10:Number = ((((me * this.bmd) + (mf * this.bmh)) + (mg * this.bml)) + mh); + var _local_11:Number = (((mi * this.bma) + (mj * this.bme)) + (mk * this.bmi)); + var _local_12:Number = (((mi * this.bmb) + (mj * this.bmf)) + (mk * this.bmj)); + var _local_13:Number = (((mi * this.bmc) + (mj * this.bmg)) + (mk * this.bmk)); + var _local_14:Number = ((((mi * this.bmd) + (mj * this.bmh)) + (mk * this.bml)) + ml); + if (_arg_1) + { + _arg_2 = ((_arg_2) || (((!(scaleX == 1)) || (!(scaleY == 1))) || (!(scaleZ == 1)))); + if (_arg_2) + { + _local_20 = (1 / (((((((-(_local_5) * _local_8) * _local_11) + ((_local_4 * _local_9) * _local_11)) + ((_local_5 * _local_7) * _local_12)) - ((_local_3 * _local_9) * _local_12)) - ((_local_4 * _local_7) * _local_13)) + ((_local_3 * _local_8) * _local_13))); + _local_21 = (((-(_local_9) * _local_12) + (_local_8 * _local_13)) * _local_20); + _local_22 = (((_local_5 * _local_12) - (_local_4 * _local_13)) * _local_20); + _local_23 = (((-(_local_5) * _local_8) + (_local_4 * _local_9)) * _local_20); + _local_24 = ((((((((_local_6 * _local_9) * _local_12) - ((_local_5 * _local_10) * _local_12)) - ((_local_6 * _local_8) * _local_13)) + ((_local_4 * _local_10) * _local_13)) + ((_local_5 * _local_8) * _local_14)) - ((_local_4 * _local_9) * _local_14)) * _local_20); + _local_25 = (((_local_9 * _local_11) - (_local_7 * _local_13)) * _local_20); + _local_26 = (((-(_local_5) * _local_11) + (_local_3 * _local_13)) * _local_20); + _local_27 = (((_local_5 * _local_7) - (_local_3 * _local_9)) * _local_20); + _local_28 = ((((((((_local_5 * _local_10) * _local_11) - ((_local_6 * _local_9) * _local_11)) + ((_local_6 * _local_7) * _local_13)) - ((_local_3 * _local_10) * _local_13)) - ((_local_5 * _local_7) * _local_14)) + ((_local_3 * _local_9) * _local_14)) * _local_20); + _local_29 = (((-(_local_8) * _local_11) + (_local_7 * _local_12)) * _local_20); + _local_30 = (((_local_4 * _local_11) - (_local_3 * _local_12)) * _local_20); + _local_31 = (((-(_local_4) * _local_7) + (_local_3 * _local_8)) * _local_20); + _local_32 = ((((((((_local_6 * _local_8) * _local_11) - ((_local_4 * _local_10) * _local_11)) - ((_local_6 * _local_7) * _local_12)) + ((_local_3 * _local_10) * _local_12)) + ((_local_4 * _local_7) * _local_14)) - ((_local_3 * _local_8) * _local_14)) * _local_20); + _local_15 = this.vertexBindingList; + while (_local_15 != null) + { + _local_16 = _local_15.vertex; + _local_17 = _local_15.weight; + _local_18 = _local_16.value; + _local_18.x = (_local_18.x + (((((_local_3 * _local_16.x) + (_local_4 * _local_16.y)) + (_local_5 * _local_16.z)) + _local_6) * _local_17)); + _local_18.y = (_local_18.y + (((((_local_7 * _local_16.x) + (_local_8 * _local_16.y)) + (_local_9 * _local_16.z)) + _local_10) * _local_17)); + _local_18.z = (_local_18.z + (((((_local_11 * _local_16.x) + (_local_12 * _local_16.y)) + (_local_13 * _local_16.z)) + _local_14) * _local_17)); + _local_18.normalX = (_local_18.normalX + ((((_local_21 * _local_16.normalX) + (_local_25 * _local_16.normalY)) + (_local_29 * _local_16.normalZ)) * _local_17)); + _local_18.normalY = (_local_18.normalY + ((((_local_22 * _local_16.normalX) + (_local_26 * _local_16.normalY)) + (_local_30 * _local_16.normalZ)) * _local_17)); + _local_18.normalZ = (_local_18.normalZ + ((((_local_23 * _local_16.normalX) + (_local_27 * _local_16.normalY)) + (_local_31 * _local_16.normalZ)) * _local_17)); + _local_15 = _local_15.next; + }; + } else + { + _local_15 = this.vertexBindingList; + while (_local_15 != null) + { + _local_16 = _local_15.vertex; + _local_17 = _local_15.weight; + _local_18 = _local_16.value; + _local_18.x = (_local_18.x + (((((_local_3 * _local_16.x) + (_local_4 * _local_16.y)) + (_local_5 * _local_16.z)) + _local_6) * _local_17)); + _local_18.y = (_local_18.y + (((((_local_7 * _local_16.x) + (_local_8 * _local_16.y)) + (_local_9 * _local_16.z)) + _local_10) * _local_17)); + _local_18.z = (_local_18.z + (((((_local_11 * _local_16.x) + (_local_12 * _local_16.y)) + (_local_13 * _local_16.z)) + _local_14) * _local_17)); + _local_18.normalX = (_local_18.normalX + ((((_local_3 * _local_16.normalX) + (_local_4 * _local_16.normalY)) + (_local_5 * _local_16.normalZ)) * _local_17)); + _local_18.normalY = (_local_18.normalY + ((((_local_7 * _local_16.normalX) + (_local_8 * _local_16.normalY)) + (_local_9 * _local_16.normalZ)) * _local_17)); + _local_18.normalZ = (_local_18.normalZ + ((((_local_11 * _local_16.normalX) + (_local_12 * _local_16.normalY)) + (_local_13 * _local_16.normalZ)) * _local_17)); + _local_15 = _local_15.next; + }; + }; + } else + { + _local_15 = this.vertexBindingList; + while (_local_15 != null) + { + _local_16 = _local_15.vertex; + _local_17 = _local_15.weight; + _local_18 = _local_16.value; + _local_18.x = (_local_18.x + (((((_local_3 * _local_16.x) + (_local_4 * _local_16.y)) + (_local_5 * _local_16.z)) + _local_6) * _local_17)); + _local_18.y = (_local_18.y + (((((_local_7 * _local_16.x) + (_local_8 * _local_16.y)) + (_local_9 * _local_16.z)) + _local_10) * _local_17)); + _local_18.z = (_local_18.z + (((((_local_11 * _local_16.x) + (_local_12 * _local_16.y)) + (_local_13 * _local_16.z)) + _local_14) * _local_17)); + _local_15 = _local_15.next; + }; + }; + _local_19 = this.childrenList; + while (_local_19 != null) + { + _local_19.composeAndAppend(this); + _local_19.calculateVertices(_arg_1, _arg_2); + _local_19 = _local_19.nextJoint; + }; + } + + alternativa3d function setSkin(_arg_1:Skin):void + { + this.vertexBindingList = null; + this._skin = _arg_1; + var _local_2:Joint = this.childrenList; + while (_local_2 != null) + { + _local_2.setSkin(_arg_1); + _local_2 = _local_2.nextJoint; + }; + } + + alternativa3d function setSkinFast(_arg_1:Skin):void + { + this._skin = _arg_1; + var _local_2:Joint = this.childrenList; + while (_local_2 != null) + { + _local_2.setSkinFast(_arg_1); + _local_2 = _local_2.nextJoint; + }; + } + + + } +}//package alternativa.engine3d.objects \ No newline at end of file diff --git a/src/alternativa/engine3d/objects/Mesh.as b/src/alternativa/engine3d/objects/Mesh.as new file mode 100644 index 0000000..0ffda37 --- /dev/null +++ b/src/alternativa/engine3d/objects/Mesh.as @@ -0,0 +1,3426 @@ +package alternativa.engine3d.objects +{ + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.core.Vertex; + import alternativa.engine3d.core.Face; + import alternativa.gfx.core.VertexBufferResource; + import alternativa.gfx.core.IndexBufferResource; + import __AS3__.vec.Vector; + import alternativa.engine3d.materials.Material; + import alternativa.engine3d.core.Wrapper; + import flash.utils.Dictionary; + import flash.geom.Vector3D; + import alternativa.engine3d.core.RayIntersectionData; + import alternativa.engine3d.core.Camera3D; + import alternativa.engine3d.core.Debug; + import alternativa.engine3d.core.VG; + import alternativa.engine3d.objects.Mesh; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class Mesh extends Object3D + { + + public var clipping:int = 2; + public var sorting:int = 1; + public var threshold:Number = 0.01; + alternativa3d var vertexList:Vertex; + public var faceList:Face; + alternativa3d var vertexBuffer:VertexBufferResource; + alternativa3d var indexBuffer:IndexBufferResource; + alternativa3d var numOpaqueTriangles:int; + alternativa3d var numTriangles:int; + protected var opaqueMaterials:Vector. = new Vector.(); + protected var opaqueBegins:Vector. = new Vector.(); + protected var opaqueNums:Vector. = new Vector.(); + protected var opaqueLength:int = 0; + private var transparentList:Face; + + + public override function destroy() : void + { + + + super.destroy(); + } + + public static function calculateVerticesNormalsBySmoothingGroupsForMeshList(_arg_1:Vector., _arg_2:Number=0):void + { + var _local_3:int; + var _local_4:Number; + var _local_5:Number; + var _local_6:Number; + var _local_7:*; + var _local_8:Mesh; + var _local_9:Face; + var _local_10:Vertex; + var _local_11:Wrapper; + var _local_16:Object3D; + var _local_17:Vertex; + var _local_18:Number; + var _local_19:Face; + var _local_12:Dictionary = new Dictionary(); + var _local_13:int = _arg_1.length; + _local_3 = 0; + while (_local_3 < _local_13) + { + _local_8 = (_arg_1[_local_3] as Mesh); + if (_local_8 != null) + { + _local_8.deleteResources(); + _local_8.composeMatrix(); + _local_16 = _local_8; + while (_local_16._parent != null) + { + _local_16 = _local_16._parent; + _local_16.composeMatrix(); + _local_8.appendMatrix(_local_16); + }; + _local_10 = _local_8.vertexList; + while (_local_10 != null) + { + _local_4 = _local_10.x; + _local_5 = _local_10.y; + _local_6 = _local_10.z; + _local_10.x = ((((_local_8.ma * _local_4) + (_local_8.mb * _local_5)) + (_local_8.mc * _local_6)) + _local_8.md); + _local_10.y = ((((_local_8.me * _local_4) + (_local_8.mf * _local_5)) + (_local_8.mg * _local_6)) + _local_8.mh); + _local_10.z = ((((_local_8.mi * _local_4) + (_local_8.mj * _local_5)) + (_local_8.mk * _local_6)) + _local_8.ml); + _local_10 = _local_10.next; + }; + _local_8.calculateNormalsAndRemoveDegenerateFaces(); + _local_9 = _local_8.faceList; + while (_local_9 != null) + { + if (_local_9.smoothingGroups > 0) + { + _local_11 = _local_9.wrapper; + while (_local_11 != null) + { + _local_10 = _local_11.vertex; + if ((!(_local_12[_local_10]))) + { + _local_12[_local_10] = new Dictionary(); + }; + _local_12[_local_10][_local_9] = true; + _local_11 = _local_11.next; + }; + }; + _local_9 = _local_9.next; + }; + }; + _local_3++; + }; + var _local_14:Vector. = new Vector.(); + var _local_15:int; + for (_local_7 in _local_12) + { + _local_14[_local_15] = _local_7; + _local_15++; + }; + if (_local_15 > 0) + { + shareFaces(_local_14, 0, _local_15, 0, _arg_2, new Vector.(), _local_12); + }; + _local_3 = 0; + while (_local_3 < _local_13) + { + _local_8 = (_arg_1[_local_3] as Mesh); + if (_local_8 != null) + { + _local_8.vertexList = null; + _local_9 = _local_8.faceList; + while (_local_9 != null) + { + _local_11 = _local_9.wrapper; + while (_local_11 != null) + { + _local_10 = _local_11.vertex; + _local_17 = new Vertex(); + _local_17.x = _local_10.x; + _local_17.y = _local_10.y; + _local_17.z = _local_10.z; + _local_17.u = _local_10.u; + _local_17.v = _local_10.v; + _local_17.id = _local_10.id; + _local_17.normalX = _local_9.normalX; + _local_17.normalY = _local_9.normalY; + _local_17.normalZ = _local_9.normalZ; + if (_local_9.smoothingGroups > 0) + { + for (_local_7 in _local_12[_local_10]) + { + _local_19 = _local_7; + if (((!(_local_9 == _local_19)) && ((_local_9.smoothingGroups & _local_19.smoothingGroups) > 0))) + { + _local_17.normalX = (_local_17.normalX + _local_19.normalX); + _local_17.normalY = (_local_17.normalY + _local_19.normalY); + _local_17.normalZ = (_local_17.normalZ + _local_19.normalZ); + }; + }; + _local_18 = (((_local_17.normalX * _local_17.normalX) + (_local_17.normalY * _local_17.normalY)) + (_local_17.normalZ * _local_17.normalZ)); + if (_local_18 > 0.001) + { + _local_18 = (1 / Math.sqrt(_local_18)); + _local_17.normalX = (_local_17.normalX * _local_18); + _local_17.normalY = (_local_17.normalY * _local_18); + _local_17.normalZ = (_local_17.normalZ * _local_18); + }; + }; + _local_11.vertex = _local_17; + _local_17.next = _local_8.vertexList; + _local_8.vertexList = _local_17; + _local_11 = _local_11.next; + }; + _local_9 = _local_9.next; + }; + }; + _local_3++; + }; + _local_3 = 0; + while (_local_3 < _local_13) + { + _local_8 = (_arg_1[_local_3] as Mesh); + if (_local_8 != null) + { + _local_8.invertMatrix(); + _local_10 = _local_8.vertexList; + while (_local_10 != null) + { + _local_4 = _local_10.x; + _local_5 = _local_10.y; + _local_6 = _local_10.z; + _local_10.x = ((((_local_8.ma * _local_4) + (_local_8.mb * _local_5)) + (_local_8.mc * _local_6)) + _local_8.md); + _local_10.y = ((((_local_8.me * _local_4) + (_local_8.mf * _local_5)) + (_local_8.mg * _local_6)) + _local_8.mh); + _local_10.z = ((((_local_8.mi * _local_4) + (_local_8.mj * _local_5)) + (_local_8.mk * _local_6)) + _local_8.ml); + _local_4 = _local_10.normalX; + _local_5 = _local_10.normalY; + _local_6 = _local_10.normalZ; + _local_10.normalX = (((_local_8.ma * _local_4) + (_local_8.mb * _local_5)) + (_local_8.mc * _local_6)); + _local_10.normalY = (((_local_8.me * _local_4) + (_local_8.mf * _local_5)) + (_local_8.mg * _local_6)); + _local_10.normalZ = (((_local_8.mi * _local_4) + (_local_8.mj * _local_5)) + (_local_8.mk * _local_6)); + _local_10 = _local_10.next; + }; + _local_9 = _local_8.faceList; + while (_local_9 != null) + { + _local_4 = _local_9.normalX; + _local_5 = _local_9.normalY; + _local_6 = _local_9.normalZ; + _local_9.normalX = (((_local_8.ma * _local_4) + (_local_8.mb * _local_5)) + (_local_8.mc * _local_6)); + _local_9.normalY = (((_local_8.me * _local_4) + (_local_8.mf * _local_5)) + (_local_8.mg * _local_6)); + _local_9.normalZ = (((_local_8.mi * _local_4) + (_local_8.mj * _local_5)) + (_local_8.mk * _local_6)); + _local_9.offset = (((_local_9.wrapper.vertex.x * _local_9.normalX) + (_local_9.wrapper.vertex.y * _local_9.normalY)) + (_local_9.wrapper.vertex.z * _local_9.normalZ)); + _local_9 = _local_9.next; + }; + }; + _local_3++; + }; + } + + private static function shareFaces(_arg_1:Vector., _arg_2:int, _arg_3:int, _arg_4:int, _arg_5:Number, _arg_6:Vector., _arg_7:Dictionary):void + { + var _local_8:int; + var _local_9:int; + var _local_10:int; + var _local_11:Vertex; + var _local_13:Vertex; + var _local_14:int; + var _local_15:int; + var _local_16:Number; + var _local_17:Vertex; + var _local_18:Vertex; + var _local_19:*; + switch (_arg_4) + { + case 0: + _local_8 = _arg_2; + while (_local_8 < _arg_3) + { + _local_11 = _arg_1[_local_8]; + _local_11.offset = _local_11.x; + _local_8++; + }; + break; + case 1: + _local_8 = _arg_2; + while (_local_8 < _arg_3) + { + _local_11 = _arg_1[_local_8]; + _local_11.offset = _local_11.y; + _local_8++; + }; + break; + case 2: + _local_8 = _arg_2; + while (_local_8 < _arg_3) + { + _local_11 = _arg_1[_local_8]; + _local_11.offset = _local_11.z; + _local_8++; + }; + break; + }; + _arg_6[0] = _arg_2; + _arg_6[1] = (_arg_3 - 1); + var _local_12:int = 2; + while (_local_12 > 0) + { + _local_12--; + _local_14 = _arg_6[_local_12]; + _local_9 = _local_14; + _local_12--; + _local_15 = _arg_6[_local_12]; + _local_8 = _local_15; + _local_11 = _arg_1[((_local_14 + _local_15) >> 1)]; + _local_16 = _local_11.offset; + while (_local_8 <= _local_9) + { + _local_17 = _arg_1[_local_8]; + while (_local_17.offset > _local_16) + { + _local_8++; + _local_17 = _arg_1[_local_8]; + }; + _local_18 = _arg_1[_local_9]; + while (_local_18.offset < _local_16) + { + _local_9--; + _local_18 = _arg_1[_local_9]; + }; + if (_local_8 <= _local_9) + { + _arg_1[_local_8] = _local_18; + _arg_1[_local_9] = _local_17; + _local_8++; + _local_9--; + }; + }; + if (_local_15 < _local_9) + { + _arg_6[_local_12] = _local_15; + _local_12++; + _arg_6[_local_12] = _local_9; + _local_12++; + }; + if (_local_8 < _local_14) + { + _arg_6[_local_12] = _local_8; + _local_12++; + _arg_6[_local_12] = _local_14; + _local_12++; + }; + }; + _local_8 = _arg_2; + _local_11 = _arg_1[_local_8]; + _local_9 = (_local_8 + 1); + while (_local_9 <= _arg_3) + { + if (_local_9 < _arg_3) + { + _local_13 = _arg_1[_local_9]; + }; + if (((_local_9 == _arg_3) || ((_local_11.offset - _local_13.offset) > _arg_5))) + { + if ((_local_9 - _local_8) > 1) + { + if (_arg_4 < 2) + { + shareFaces(_arg_1, _local_8, _local_9, (_arg_4 + 1), _arg_5, _arg_6, _arg_7); + } else + { + _local_10 = (_local_8 + 1); + while (_local_10 < _local_9) + { + _local_13 = _arg_1[_local_10]; + for (_local_19 in _arg_7[_local_13]) + { + _arg_7[_local_11][_local_19] = true; + }; + _local_10++; + }; + _local_10 = (_local_8 + 1); + while (_local_10 < _local_9) + { + _local_13 = _arg_1[_local_10]; + for (_local_19 in _arg_7[_local_11]) + { + _arg_7[_local_13][_local_19] = true; + }; + _local_10++; + }; + }; + }; + if (_local_9 < _arg_3) + { + _local_8 = _local_9; + _local_11 = _arg_1[_local_8]; + }; + }; + _local_9++; + }; + } + + + public function addVertex(_arg_1:Number, _arg_2:Number, _arg_3:Number, _arg_4:Number=0, _arg_5:Number=0, _arg_6:Object=null):Vertex + { + var _local_8:Vertex; + this.deleteResources(); + var _local_7:Vertex = new Vertex(); + _local_7.x = _arg_1; + _local_7.y = _arg_2; + _local_7.z = _arg_3; + _local_7.u = _arg_4; + _local_7.v = _arg_5; + _local_7.id = _arg_6; + if (this.vertexList != null) + { + _local_8 = this.vertexList; + while (_local_8.next != null) + { + _local_8 = _local_8.next; + }; + _local_8.next = _local_7; + } else + { + this.vertexList = _local_7; + }; + return (_local_7); + } + + public function removeVertex(_arg_1:Vertex):Vertex + { + var _local_3:Vertex; + var _local_5:Face; + var _local_6:Face; + var _local_7:Wrapper; + this.deleteResources(); + if (_arg_1 == null) + { + throw (new TypeError("Parameter vertex must be non-null.")); + }; + var _local_2:Vertex = this.vertexList; + while (_local_2 != null) + { + if (_local_2 == _arg_1) + { + if (_local_3 != null) + { + _local_3.next = _local_2.next; + } else + { + this.vertexList = _local_2.next; + }; + _local_2.next = null; + break; + }; + _local_3 = _local_2; + _local_2 = _local_2.next; + }; + if (_local_2 == null) + { + throw (new ArgumentError("Vertex not found.")); + }; + var _local_4:Face = this.faceList; + while (_local_4 != null) + { + _local_6 = _local_4.next; + _local_7 = _local_4.wrapper; + while (_local_7 != null) + { + if (_local_7.vertex == _local_2) break; + _local_7 = _local_7.next; + }; + if (_local_7 != null) + { + if (_local_5 != null) + { + _local_5.next = _local_6; + } else + { + this.faceList = _local_6; + }; + _local_4.next = null; + } else + { + _local_5 = _local_4; + }; + _local_4 = _local_6; + }; + return (_local_2); + } + + public function removeVertexById(_arg_1:Object):Vertex + { + var _local_3:Vertex; + var _local_5:Face; + var _local_6:Face; + var _local_7:Wrapper; + this.deleteResources(); + if (_arg_1 == null) + { + throw (new TypeError("Parameter id must be non-null.")); + }; + var _local_2:Vertex = this.vertexList; + while (_local_2 != null) + { + if (_local_2.id == _arg_1) + { + if (_local_3 != null) + { + _local_3.next = _local_2.next; + } else + { + this.vertexList = _local_2.next; + }; + _local_2.next = null; + break; + }; + _local_3 = _local_2; + _local_2 = _local_2.next; + }; + if (_local_2 == null) + { + throw (new ArgumentError("Vertex not found.")); + }; + var _local_4:Face = this.faceList; + while (_local_4 != null) + { + _local_6 = _local_4.next; + _local_7 = _local_4.wrapper; + while (_local_7 != null) + { + if (_local_7.vertex == _local_2) break; + _local_7 = _local_7.next; + }; + if (_local_7 != null) + { + if (_local_5 != null) + { + _local_5.next = _local_6; + } else + { + this.faceList = _local_6; + }; + _local_4.next = null; + } else + { + _local_5 = _local_4; + }; + _local_4 = _local_6; + }; + return (_local_2); + } + + public function containsVertex(_arg_1:Vertex):Boolean + { + if (_arg_1 == null) + { + throw (new TypeError("Parameter vertex must be non-null.")); + }; + var _local_2:Vertex = this.vertexList; + while (_local_2 != null) + { + if (_local_2 == _arg_1) + { + return (true); + }; + _local_2 = _local_2.next; + }; + return (false); + } + + public function containsVertexWithId(_arg_1:Object):Boolean + { + if (_arg_1 == null) + { + throw (new TypeError("Parameter id must be non-null.")); + }; + var _local_2:Vertex = this.vertexList; + while (_local_2 != null) + { + if (_local_2.id == _arg_1) + { + return (true); + }; + _local_2 = _local_2.next; + }; + return (false); + } + + public function getVertexById(_arg_1:Object):Vertex + { + if (_arg_1 == null) + { + throw (new TypeError("Parameter id must be non-null.")); + }; + var _local_2:Vertex = this.vertexList; + while (_local_2 != null) + { + if (_local_2.id == _arg_1) + { + return (_local_2); + }; + _local_2 = _local_2.next; + }; + return (null); + } + + public function addFace(_arg_1:Vector., _arg_2:Material=null, _arg_3:Object=null):Face + { + var _local_8:Wrapper; + var _local_9:Vertex; + var _local_10:Face; + this.deleteResources(); + if (_arg_1 == null) + { + throw (new TypeError("Parameter vertices must be non-null.")); + }; + var _local_4:int = _arg_1.length; + if (_local_4 < 3) + { + throw (new ArgumentError((_local_4 + " vertices not enough."))); + }; + var _local_5:Face = new Face(); + _local_5.material = _arg_2; + _local_5.id = _arg_3; + var _local_6:Wrapper; + var _local_7:int; + while (_local_7 < _local_4) + { + _local_8 = new Wrapper(); + _local_9 = _arg_1[_local_7]; + if (_local_9 == null) + { + throw (new ArgumentError("Null vertex in vector.")); + }; + if ((!(this.containsVertex(_local_9)))) + { + throw (new ArgumentError("Vertex not found.")); + }; + _local_8.vertex = _local_9; + if (_local_6 != null) + { + _local_6.next = _local_8; + } else + { + _local_5.wrapper = _local_8; + }; + _local_6 = _local_8; + _local_7++; + }; + if (this.faceList != null) + { + _local_10 = this.faceList; + while (_local_10.next != null) + { + _local_10 = _local_10.next; + }; + _local_10.next = _local_5; + } else + { + this.faceList = _local_5; + }; + return (_local_5); + } + + public function addFaceByIds(_arg_1:Array, _arg_2:Material=null, _arg_3:Object=null):Face + { + var _local_8:Wrapper; + var _local_9:Vertex; + var _local_10:Face; + this.deleteResources(); + if (_arg_1 == null) + { + throw (new TypeError("Parameter vertices must be non-null.")); + }; + var _local_4:int = _arg_1.length; + if (_local_4 < 3) + { + throw (new ArgumentError((_local_4 + " vertices not enough."))); + }; + var _local_5:Face = new Face(); + _local_5.material = _arg_2; + _local_5.id = _arg_3; + var _local_6:Wrapper; + var _local_7:int; + while (_local_7 < _local_4) + { + _local_8 = new Wrapper(); + _local_9 = this.getVertexById(_arg_1[_local_7]); + if (_local_9 == null) + { + throw (new ArgumentError("Vertex not found.")); + }; + _local_8.vertex = _local_9; + if (_local_6 != null) + { + _local_6.next = _local_8; + } else + { + _local_5.wrapper = _local_8; + }; + _local_6 = _local_8; + _local_7++; + }; + if (this.faceList != null) + { + _local_10 = this.faceList; + while (_local_10.next != null) + { + _local_10 = _local_10.next; + }; + _local_10.next = _local_5; + } else + { + this.faceList = _local_5; + }; + return (_local_5); + } + + public function addTriFace(_arg_1:Vertex, _arg_2:Vertex, _arg_3:Vertex, _arg_4:Material=null, _arg_5:Object=null):Face + { + var _local_7:Face; + this.deleteResources(); + if (_arg_1 == null) + { + throw (new TypeError("Parameter v1 must be non-null.")); + }; + if (_arg_2 == null) + { + throw (new TypeError("Parameter v2 must be non-null.")); + }; + if (_arg_3 == null) + { + throw (new TypeError("Parameter v3 must be non-null.")); + }; + if ((!(this.containsVertex(_arg_1)))) + { + throw (new ArgumentError("Vertex not found.")); + }; + if ((!(this.containsVertex(_arg_2)))) + { + throw (new ArgumentError("Vertex not found.")); + }; + if ((!(this.containsVertex(_arg_3)))) + { + throw (new ArgumentError("Vertex not found.")); + }; + var _local_6:Face = new Face(); + _local_6.material = _arg_4; + _local_6.id = _arg_5; + _local_6.wrapper = new Wrapper(); + _local_6.wrapper.vertex = _arg_1; + _local_6.wrapper.next = new Wrapper(); + _local_6.wrapper.next.vertex = _arg_2; + _local_6.wrapper.next.next = new Wrapper(); + _local_6.wrapper.next.next.vertex = _arg_3; + if (this.faceList != null) + { + _local_7 = this.faceList; + while (_local_7.next != null) + { + _local_7 = _local_7.next; + }; + _local_7.next = _local_6; + } else + { + this.faceList = _local_6; + }; + return (_local_6); + } + + public function addQuadFace(_arg_1:Vertex, _arg_2:Vertex, _arg_3:Vertex, _arg_4:Vertex, _arg_5:Material=null, _arg_6:Object=null):Face + { + var _local_8:Face; + this.deleteResources(); + if (_arg_1 == null) + { + throw (new TypeError("Parameter v1 must be non-null.")); + }; + if (_arg_2 == null) + { + throw (new TypeError("Parameter v2 must be non-null.")); + }; + if (_arg_3 == null) + { + throw (new TypeError("Parameter v3 must be non-null.")); + }; + if (_arg_4 == null) + { + throw (new TypeError("Parameter v4 must be non-null.")); + }; + if ((!(this.containsVertex(_arg_1)))) + { + throw (new ArgumentError("Vertex not found.")); + }; + if ((!(this.containsVertex(_arg_2)))) + { + throw (new ArgumentError("Vertex not found.")); + }; + if ((!(this.containsVertex(_arg_3)))) + { + throw (new ArgumentError("Vertex not found.")); + }; + if ((!(this.containsVertex(_arg_4)))) + { + throw (new ArgumentError("Vertex not found.")); + }; + var _local_7:Face = new Face(); + _local_7.material = _arg_5; + _local_7.id = _arg_6; + _local_7.wrapper = new Wrapper(); + _local_7.wrapper.vertex = _arg_1; + _local_7.wrapper.next = new Wrapper(); + _local_7.wrapper.next.vertex = _arg_2; + _local_7.wrapper.next.next = new Wrapper(); + _local_7.wrapper.next.next.vertex = _arg_3; + _local_7.wrapper.next.next.next = new Wrapper(); + _local_7.wrapper.next.next.next.vertex = _arg_4; + if (this.faceList != null) + { + _local_8 = this.faceList; + while (_local_8.next != null) + { + _local_8 = _local_8.next; + }; + _local_8.next = _local_7; + } else + { + this.faceList = _local_7; + }; + return (_local_7); + } + + public function removeFace(_arg_1:Face):Face + { + var _local_3:Face; + this.deleteResources(); + if (_arg_1 == null) + { + throw (new TypeError("Parameter face must be non-null.")); + }; + var _local_2:Face = this.faceList; + while (_local_2 != null) + { + if (_local_2 == _arg_1) + { + if (_local_3 != null) + { + _local_3.next = _local_2.next; + } else + { + this.faceList = _local_2.next; + }; + _local_2.next = null; + break; + }; + _local_3 = _local_2; + _local_2 = _local_2.next; + }; + if (_local_2 == null) + { + throw (new ArgumentError("Face not found.")); + }; + return (_local_2); + } + + public function removeFaceById(_arg_1:Object):Face + { + var _local_3:Face; + this.deleteResources(); + if (_arg_1 == null) + { + throw (new TypeError("Parameter id must be non-null.")); + }; + var _local_2:Face = this.faceList; + while (_local_2 != null) + { + if (_local_2.id == _arg_1) + { + if (_local_3 != null) + { + _local_3.next = _local_2.next; + } else + { + this.faceList = _local_2.next; + }; + _local_2.next = null; + break; + }; + _local_3 = _local_2; + _local_2 = _local_2.next; + }; + if (_local_2 == null) + { + throw (new ArgumentError("Face not found.")); + }; + return (_local_2); + } + + public function containsFace(_arg_1:Face):Boolean + { + if (_arg_1 == null) + { + throw (new TypeError("Parameter face must be non-null.")); + }; + var _local_2:Face = this.faceList; + while (_local_2 != null) + { + if (_local_2 == _arg_1) + { + return (true); + }; + _local_2 = _local_2.next; + }; + return (false); + } + + public function containsFaceWithId(_arg_1:Object):Boolean + { + if (_arg_1 == null) + { + throw (new TypeError("Parameter id must be non-null.")); + }; + var _local_2:Face = this.faceList; + while (_local_2 != null) + { + if (_local_2.id == _arg_1) + { + return (true); + }; + _local_2 = _local_2.next; + }; + return (false); + } + + public function getFaceById(_arg_1:Object):Face + { + if (_arg_1 == null) + { + throw (new TypeError("Parameter id must be non-null.")); + }; + var _local_2:Face = this.faceList; + while (_local_2 != null) + { + if (_local_2.id == _arg_1) + { + return (_local_2); + }; + _local_2 = _local_2.next; + }; + return (null); + } + + public function addVerticesAndFaces(_arg_1:Vector., _arg_2:Vector., _arg_3:Vector., _arg_4:Boolean=false, _arg_5:Material=null):void + { + var _local_6:int; + var _local_7:int; + var _local_8:int; + var _local_11:Vertex; + var _local_13:Face; + var _local_14:Face; + var _local_15:Wrapper; + var _local_16:int; + var _local_17:int; + var _local_18:Vertex; + var _local_19:Wrapper; + this.deleteResources(); + if (_arg_1 == null) + { + throw (new TypeError("Parameter vertices must be non-null.")); + }; + if (_arg_2 == null) + { + throw (new TypeError("Parameter uvs must be non-null.")); + }; + if (_arg_3 == null) + { + throw (new TypeError("Parameter indices must be non-null.")); + }; + var _local_9:int = int((_arg_1.length / 3)); + if (_local_9 != (_arg_2.length / 2)) + { + throw (new ArgumentError("Vertices count and uvs count doesn't match.")); + }; + var _local_10:int = _arg_3.length; + if (((!(_arg_4)) && (_local_10 % 3))) + { + throw (new ArgumentError("Incorrect indices.")); + }; + _local_6 = 0; + _local_8 = 0; + while (_local_6 < _local_10) + { + if (_local_6 == _local_8) + { + _local_17 = ((_arg_4) ? _arg_3[_local_6] : 3); + if (_local_17 < 3) + { + throw (new ArgumentError((_local_17 + " vertices not enough."))); + }; + _local_8 = ((_arg_4) ? (_local_17 + ++_local_6) : (_local_6 + _local_17)); + if (_local_8 > _local_10) + { + throw (new ArgumentError("Incorrect indices.")); + }; + }; + _local_16 = _arg_3[_local_6]; + if (((_local_16 < 0) || (_local_16 >= _local_9))) + { + throw (new RangeError("Index is out of bounds.")); + }; + _local_6++; + }; + if (this.vertexList != null) + { + _local_11 = this.vertexList; + while (_local_11.next != null) + { + _local_11 = _local_11.next; + }; + }; + var _local_12:Vector. = new Vector.(_local_9); + _local_6 = 0; + _local_7 = 0; + _local_8 = 0; + while (_local_6 < _local_9) + { + _local_18 = new Vertex(); + _local_18.x = _arg_1[_local_7]; + _local_7++; + _local_18.y = _arg_1[_local_7]; + _local_7++; + _local_18.z = _arg_1[_local_7]; + _local_7++; + _local_18.u = _arg_2[_local_8]; + _local_8++; + _local_18.v = _arg_2[_local_8]; + _local_8++; + _local_12[_local_6] = _local_18; + if (_local_11 != null) + { + _local_11.next = _local_18; + } else + { + this.vertexList = _local_18; + }; + _local_11 = _local_18; + _local_6++; + }; + if (this.faceList != null) + { + _local_13 = this.faceList; + while (_local_13.next != null) + { + _local_13 = _local_13.next; + }; + }; + _local_6 = 0; + _local_8 = 0; + while (_local_6 < _local_10) + { + if (_local_6 == _local_8) + { + _local_8 = ((_arg_4) ? (_arg_3[_local_6] + ++_local_6) : (_local_6 + 3)); + _local_15 = null; + _local_14 = new Face(); + _local_14.material = _arg_5; + if (_local_13 != null) + { + _local_13.next = _local_14; + } else + { + this.faceList = _local_14; + }; + _local_13 = _local_14; + }; + _local_19 = new Wrapper(); + _local_19.vertex = _local_12[_arg_3[_local_6]]; + if (_local_15 != null) + { + _local_15.next = _local_19; + } else + { + _local_14.wrapper = _local_19; + }; + _local_15 = _local_19; + _local_6++; + }; + } + + public function get vertices():Vector. + { + var _local_1:Vector. = new Vector.(); + var _local_2:int; + var _local_3:Vertex = this.vertexList; + while (_local_3 != null) + { + _local_1[_local_2] = _local_3; + _local_2++; + _local_3 = _local_3.next; + }; + return (_local_1); + } + + public function get faces():Vector. + { + var _local_1:Vector. = new Vector.(); + var _local_2:int; + var _local_3:Face = this.faceList; + while (_local_3 != null) + { + _local_1[_local_2] = _local_3; + _local_2++; + _local_3 = _local_3.next; + }; + return (_local_1); + } + + public function weldVertices(_arg_1:Number=0, _arg_2:Number=0):void + { + var _local_3:Vertex; + var _local_4:Vertex; + var _local_9:Wrapper; + this.deleteResources(); + var _local_5:Vector. = new Vector.(); + var _local_6:int; + _local_3 = this.vertexList; + while (_local_3 != null) + { + _local_4 = _local_3.next; + _local_3.next = null; + _local_5[_local_6] = _local_3; + _local_6++; + _local_3 = _local_4; + }; + this.vertexList = null; + this.group(_local_5, 0, _local_6, 0, _arg_1, _arg_2, new Vector.()); + var _local_7:Face = this.faceList; + while (_local_7 != null) + { + _local_9 = _local_7.wrapper; + while (_local_9 != null) + { + if (_local_9.vertex.value != null) + { + _local_9.vertex = _local_9.vertex.value; + }; + _local_9 = _local_9.next; + }; + _local_7 = _local_7.next; + }; + var _local_8:int; + while (_local_8 < _local_6) + { + _local_3 = _local_5[_local_8]; + if (_local_3.value == null) + { + _local_3.next = this.vertexList; + this.vertexList = _local_3; + }; + _local_8++; + }; + } + + public function weldFaces(_arg_1:Number=0, _arg_2:Number=0, _arg_3:Number=0, _arg_4:Boolean=false):void + { + var _local_5:int; + var _local_6:int; + var _local_7:*; + var _local_8:Face; + var _local_9:Face; + var _local_10:Face; + var _local_11:Wrapper; + var _local_12:Wrapper; + var _local_13:Wrapper; + var _local_14:Wrapper; + var _local_15:Wrapper; + var _local_16:Wrapper; + var _local_17:Wrapper; + var _local_18:Wrapper; + var _local_19:Vertex; + var _local_20:Vertex; + var _local_21:Vertex; + var _local_22:Vertex; + var _local_23:Number; + var _local_24:Number; + var _local_25:Number; + var _local_26:Number; + var _local_27:Number; + var _local_28:Number; + var _local_29:Number; + var _local_30:Number; + var _local_31:Number; + var _local_32:Number; + var _local_33:Number; + var _local_34:Number; + var _local_35:Number; + var _local_36:Number; + var _local_37:Dictionary; + var _local_44:int; + var _local_45:Number; + var _local_46:Number; + var _local_47:Number; + var _local_48:Number; + var _local_49:Number; + var _local_50:Number; + var _local_51:Number; + var _local_52:Number; + var _local_53:Number; + var _local_54:Number; + var _local_55:Number; + var _local_56:Number; + var _local_57:Number; + var _local_58:Number; + var _local_59:Number; + var _local_60:Number; + var _local_61:Number; + var _local_62:Number; + var _local_63:Number; + var _local_64:Boolean; + var _local_65:Face; + this.deleteResources(); + var _local_38:Number = 0.001; + _arg_1 = (Math.cos(_arg_1) - _local_38); + _arg_2 = (_arg_2 + _local_38); + _arg_3 = (Math.cos((Math.PI - _arg_3)) - _local_38); + var _local_39:Dictionary = new Dictionary(); + var _local_40:Dictionary = new Dictionary(); + _local_9 = this.faceList; + while (_local_9 != null) + { + _local_10 = _local_9.next; + _local_9.next = null; + _local_20 = _local_9.wrapper.vertex; + _local_21 = _local_9.wrapper.next.vertex; + _local_22 = _local_9.wrapper.next.next.vertex; + _local_23 = (_local_21.x - _local_20.x); + _local_24 = (_local_21.y - _local_20.y); + _local_25 = (_local_21.z - _local_20.z); + _local_28 = (_local_22.x - _local_20.x); + _local_29 = (_local_22.y - _local_20.y); + _local_30 = (_local_22.z - _local_20.z); + _local_33 = ((_local_30 * _local_24) - (_local_29 * _local_25)); + _local_34 = ((_local_28 * _local_25) - (_local_30 * _local_23)); + _local_35 = ((_local_29 * _local_23) - (_local_28 * _local_24)); + _local_36 = (((_local_33 * _local_33) + (_local_34 * _local_34)) + (_local_35 * _local_35)); + if (_local_36 > _local_38) + { + _local_36 = (1 / Math.sqrt(_local_36)); + _local_33 = (_local_33 * _local_36); + _local_34 = (_local_34 * _local_36); + _local_35 = (_local_35 * _local_36); + _local_9.normalX = _local_33; + _local_9.normalY = _local_34; + _local_9.normalZ = _local_35; + _local_9.offset = (((_local_20.x * _local_33) + (_local_20.y * _local_34)) + (_local_20.z * _local_35)); + _local_39[_local_9] = true; + _local_15 = _local_9.wrapper; + while (_local_15 != null) + { + _local_19 = _local_15.vertex; + _local_37 = _local_40[_local_19]; + if (_local_37 == null) + { + _local_37 = new Dictionary(); + _local_40[_local_19] = _local_37; + }; + _local_37[_local_9] = true; + _local_15 = _local_15.next; + }; + }; + _local_9 = _local_10; + }; + this.faceList = null; + var _local_41:Vector. = new Vector.(); + var _local_42:Dictionary = new Dictionary(); + var _local_43:Dictionary = new Dictionary(); + while (true) + { + _local_9 = null; + for (_local_7 in _local_39) + { + _local_9 = _local_7; + delete _local_39[_local_7]; + break; + }; + if (_local_9 == null) break; + _local_44 = 0; + _local_41[_local_44] = _local_9; + _local_44++; + _local_20 = _local_9.wrapper.vertex; + _local_21 = _local_9.wrapper.next.vertex; + _local_22 = _local_9.wrapper.next.next.vertex; + _local_23 = (_local_21.x - _local_20.x); + _local_24 = (_local_21.y - _local_20.y); + _local_25 = (_local_21.z - _local_20.z); + _local_26 = (_local_21.u - _local_20.u); + _local_27 = (_local_21.v - _local_20.v); + _local_28 = (_local_22.x - _local_20.x); + _local_29 = (_local_22.y - _local_20.y); + _local_30 = (_local_22.z - _local_20.z); + _local_31 = (_local_22.u - _local_20.u); + _local_32 = (_local_22.v - _local_20.v); + _local_33 = _local_9.normalX; + _local_34 = _local_9.normalY; + _local_35 = _local_9.normalZ; + _local_45 = (((((((-(_local_33) * _local_29) * _local_25) + ((_local_28 * _local_34) * _local_25)) + ((_local_33 * _local_24) * _local_30)) - ((_local_23 * _local_34) * _local_30)) - ((_local_28 * _local_24) * _local_35)) + ((_local_23 * _local_29) * _local_35)); + _local_46 = (((-(_local_34) * _local_30) + (_local_29 * _local_35)) / _local_45); + _local_47 = (((_local_33 * _local_30) - (_local_28 * _local_35)) / _local_45); + _local_48 = (((-(_local_33) * _local_29) + (_local_28 * _local_34)) / _local_45); + _local_49 = ((((((((_local_20.x * _local_34) * _local_30) - ((_local_33 * _local_20.y) * _local_30)) - ((_local_20.x * _local_29) * _local_35)) + ((_local_28 * _local_20.y) * _local_35)) + ((_local_33 * _local_29) * _local_20.z)) - ((_local_28 * _local_34) * _local_20.z)) / _local_45); + _local_50 = (((_local_34 * _local_25) - (_local_24 * _local_35)) / _local_45); + _local_51 = (((-(_local_33) * _local_25) + (_local_23 * _local_35)) / _local_45); + _local_52 = (((_local_33 * _local_24) - (_local_23 * _local_34)) / _local_45); + _local_53 = ((((((((_local_33 * _local_20.y) * _local_25) - ((_local_20.x * _local_34) * _local_25)) + ((_local_20.x * _local_24) * _local_35)) - ((_local_23 * _local_20.y) * _local_35)) - ((_local_33 * _local_24) * _local_20.z)) + ((_local_23 * _local_34) * _local_20.z)) / _local_45); + _local_54 = ((_local_26 * _local_46) + (_local_31 * _local_50)); + _local_55 = ((_local_26 * _local_47) + (_local_31 * _local_51)); + _local_56 = ((_local_26 * _local_48) + (_local_31 * _local_52)); + _local_57 = (((_local_26 * _local_49) + (_local_31 * _local_53)) + _local_20.u); + _local_58 = ((_local_27 * _local_46) + (_local_32 * _local_50)); + _local_59 = ((_local_27 * _local_47) + (_local_32 * _local_51)); + _local_60 = ((_local_27 * _local_48) + (_local_32 * _local_52)); + _local_61 = (((_local_27 * _local_49) + (_local_32 * _local_53)) + _local_20.v); + for (_local_7 in _local_43) + { + delete _local_43[_local_7]; + }; + _local_5 = 0; + while (_local_5 < _local_44) + { + _local_9 = _local_41[_local_5]; + for (_local_7 in _local_42) + { + delete _local_42[_local_7]; + }; + _local_13 = _local_9.wrapper; + while (_local_13 != null) + { + for (_local_7 in _local_40[_local_13.vertex]) + { + if (((_local_39[_local_7]) && (!(_local_43[_local_7])))) + { + _local_42[_local_7] = true; + }; + }; + _local_13 = _local_13.next; + }; + for (_local_7 in _local_42) + { + _local_8 = _local_7; + if ((((_local_33 * _local_8.normalX) + (_local_34 * _local_8.normalY)) + (_local_35 * _local_8.normalZ)) >= _arg_1) + { + _local_14 = _local_8.wrapper; + while (_local_14 != null) + { + _local_19 = _local_14.vertex; + _local_62 = (((((_local_54 * _local_19.x) + (_local_55 * _local_19.y)) + (_local_56 * _local_19.z)) + _local_57) - _local_19.u); + _local_63 = (((((_local_58 * _local_19.x) + (_local_59 * _local_19.y)) + (_local_60 * _local_19.z)) + _local_61) - _local_19.v); + if (((((_local_62 > _arg_2) || (_local_62 < -(_arg_2))) || (_local_63 > _arg_2)) || (_local_63 < -(_arg_2)))) break; + _local_14 = _local_14.next; + }; + if (_local_14 == null) + { + _local_13 = _local_9.wrapper; + while (_local_13 != null) + { + _local_15 = ((_local_13.next != null) ? _local_13.next : _local_9.wrapper); + _local_14 = _local_8.wrapper; + while (_local_14 != null) + { + _local_16 = ((_local_14.next != null) ? _local_14.next : _local_8.wrapper); + if (((_local_13.vertex == _local_16.vertex) && (_local_15.vertex == _local_14.vertex))) break; + _local_14 = _local_14.next; + }; + if (_local_14 != null) break; + _local_13 = _local_13.next; + }; + if (_local_13 != null) + { + _local_41[_local_44] = _local_8; + _local_44++; + delete _local_39[_local_8]; + }; + } else + { + _local_43[_local_8] = true; + }; + } else + { + _local_43[_local_8] = true; + }; + }; + _local_5++; + }; + if (_local_44 == 1) + { + _local_9 = _local_41[0]; + _local_9.next = this.faceList; + this.faceList = _local_9; + } else + { + while (true) + { + _local_64 = false; + _local_5 = 0; + while (_local_5 < (_local_44 - 1)) + { + _local_9 = _local_41[_local_5]; + if (_local_9 != null) + { + _local_6 = 1; + for (;_local_6 < _local_44;_local_6++) + { + _local_8 = _local_41[_local_6]; + if (_local_8 != null) + { + _local_13 = _local_9.wrapper; + while (_local_13 != null) + { + _local_15 = ((_local_13.next != null) ? _local_13.next : _local_9.wrapper); + _local_14 = _local_8.wrapper; + while (_local_14 != null) + { + _local_16 = ((_local_14.next != null) ? _local_14.next : _local_8.wrapper); + if (((_local_13.vertex == _local_16.vertex) && (_local_15.vertex == _local_14.vertex))) break; + _local_14 = _local_14.next; + }; + if (_local_14 != null) break; + _local_13 = _local_13.next; + }; + if (_local_13 != null) + { + while (true) + { + _local_17 = ((_local_15.next != null) ? _local_15.next : _local_9.wrapper); + _local_12 = _local_8.wrapper; + while (((!(_local_12.next == _local_14)) && (!(_local_12.next == null)))) + { + _local_12 = _local_12.next; + }; + if (_local_17.vertex == _local_12.vertex) + { + _local_15 = _local_17; + _local_14 = _local_12; + } else + { + break; + }; + }; + while (true) + { + _local_11 = _local_9.wrapper; + while (((!(_local_11.next == _local_13)) && (!(_local_11.next == null)))) + { + _local_11 = _local_11.next; + }; + _local_18 = ((_local_16.next != null) ? _local_16.next : _local_8.wrapper); + if (_local_11.vertex == _local_18.vertex) + { + _local_13 = _local_11; + _local_16 = _local_18; + } else + { + break; + }; + }; + _local_20 = _local_13.vertex; + _local_21 = _local_18.vertex; + _local_22 = _local_11.vertex; + _local_23 = (_local_21.x - _local_20.x); + _local_24 = (_local_21.y - _local_20.y); + _local_25 = (_local_21.z - _local_20.z); + _local_28 = (_local_22.x - _local_20.x); + _local_29 = (_local_22.y - _local_20.y); + _local_30 = (_local_22.z - _local_20.z); + _local_33 = ((_local_30 * _local_24) - (_local_29 * _local_25)); + _local_34 = ((_local_28 * _local_25) - (_local_30 * _local_23)); + _local_35 = ((_local_29 * _local_23) - (_local_28 * _local_24)); + if (((((((_local_33 < _local_38) && (_local_33 > -(_local_38))) && (_local_34 < _local_38)) && (_local_34 > -(_local_38))) && (_local_35 < _local_38)) && (_local_35 > -(_local_38)))) + { + if ((((_local_23 * _local_28) + (_local_24 * _local_29)) + (_local_25 * _local_30)) > 0) continue; + } else + { + if ((((_local_9.normalX * _local_33) + (_local_9.normalY * _local_34)) + (_local_9.normalZ * _local_35)) < 0) continue; + }; + _local_36 = (1 / Math.sqrt((((_local_23 * _local_23) + (_local_24 * _local_24)) + (_local_25 * _local_25)))); + _local_23 = (_local_23 * _local_36); + _local_24 = (_local_24 * _local_36); + _local_25 = (_local_25 * _local_36); + _local_36 = (1 / Math.sqrt((((_local_28 * _local_28) + (_local_29 * _local_29)) + (_local_30 * _local_30)))); + _local_28 = (_local_28 * _local_36); + _local_29 = (_local_29 * _local_36); + _local_30 = (_local_30 * _local_36); + if ((((_local_23 * _local_28) + (_local_24 * _local_29)) + (_local_25 * _local_30)) >= _arg_3) + { + _local_20 = _local_14.vertex; + _local_21 = _local_17.vertex; + _local_22 = _local_12.vertex; + _local_23 = (_local_21.x - _local_20.x); + _local_24 = (_local_21.y - _local_20.y); + _local_25 = (_local_21.z - _local_20.z); + _local_28 = (_local_22.x - _local_20.x); + _local_29 = (_local_22.y - _local_20.y); + _local_30 = (_local_22.z - _local_20.z); + _local_33 = ((_local_30 * _local_24) - (_local_29 * _local_25)); + _local_34 = ((_local_28 * _local_25) - (_local_30 * _local_23)); + _local_35 = ((_local_29 * _local_23) - (_local_28 * _local_24)); + if (((((((_local_33 < _local_38) && (_local_33 > -(_local_38))) && (_local_34 < _local_38)) && (_local_34 > -(_local_38))) && (_local_35 < _local_38)) && (_local_35 > -(_local_38)))) + { + if ((((_local_23 * _local_28) + (_local_24 * _local_29)) + (_local_25 * _local_30)) > 0) continue; + } else + { + if ((((_local_9.normalX * _local_33) + (_local_9.normalY * _local_34)) + (_local_9.normalZ * _local_35)) < 0) continue; + }; + _local_36 = (1 / Math.sqrt((((_local_23 * _local_23) + (_local_24 * _local_24)) + (_local_25 * _local_25)))); + _local_23 = (_local_23 * _local_36); + _local_24 = (_local_24 * _local_36); + _local_25 = (_local_25 * _local_36); + _local_36 = (1 / Math.sqrt((((_local_28 * _local_28) + (_local_29 * _local_29)) + (_local_30 * _local_30)))); + _local_28 = (_local_28 * _local_36); + _local_29 = (_local_29 * _local_36); + _local_30 = (_local_30 * _local_36); + if ((((_local_23 * _local_28) + (_local_24 * _local_29)) + (_local_25 * _local_30)) >= _arg_3) + { + _local_64 = true; + _local_65 = new Face(); + _local_65.material = _local_9.material; + _local_65.smoothingGroups = _local_9.smoothingGroups; + _local_65.normalX = _local_9.normalX; + _local_65.normalY = _local_9.normalY; + _local_65.normalZ = _local_9.normalZ; + _local_65.offset = _local_9.offset; + _local_65.id = _local_9.id; + _local_17 = null; + while (_local_15 != _local_13) + { + _local_18 = new Wrapper(); + _local_18.vertex = _local_15.vertex; + if (_local_17 != null) + { + _local_17.next = _local_18; + } else + { + _local_65.wrapper = _local_18; + }; + _local_17 = _local_18; + _local_15 = ((_local_15.next != null) ? _local_15.next : _local_9.wrapper); + }; + while (_local_16 != _local_14) + { + _local_18 = new Wrapper(); + _local_18.vertex = _local_16.vertex; + if (_local_17 != null) + { + _local_17.next = _local_18; + } else + { + _local_65.wrapper = _local_18; + }; + _local_17 = _local_18; + _local_16 = ((_local_16.next != null) ? _local_16.next : _local_8.wrapper); + }; + _local_41[_local_5] = _local_65; + _local_41[_local_6] = null; + _local_9 = _local_65; + if (_arg_4) break; + }; + }; + }; + }; + }; + }; + _local_5++; + }; + if ((!(_local_64))) break; + }; + _local_5 = 0; + while (_local_5 < _local_44) + { + _local_9 = _local_41[_local_5]; + if (_local_9 != null) + { + _local_9.calculateBestSequenceAndNormal(); + _local_9.next = this.faceList; + this.faceList = _local_9; + }; + _local_5++; + }; + }; + }; + } + + private function group(_arg_1:Vector., _arg_2:int, _arg_3:int, _arg_4:int, _arg_5:Number, _arg_6:Number, _arg_7:Vector.):void + { + var _local_8:int; + var _local_9:int; + var _local_10:Vertex; + var _local_11:Number; + var _local_13:Vertex; + var _local_14:int; + var _local_15:int; + var _local_16:Number; + var _local_17:Vertex; + var _local_18:Vertex; + switch (_arg_4) + { + case 0: + _local_8 = _arg_2; + while (_local_8 < _arg_3) + { + _local_10 = _arg_1[_local_8]; + _local_10.offset = _local_10.x; + _local_8++; + }; + _local_11 = _arg_5; + break; + case 1: + _local_8 = _arg_2; + while (_local_8 < _arg_3) + { + _local_10 = _arg_1[_local_8]; + _local_10.offset = _local_10.y; + _local_8++; + }; + _local_11 = _arg_5; + break; + case 2: + _local_8 = _arg_2; + while (_local_8 < _arg_3) + { + _local_10 = _arg_1[_local_8]; + _local_10.offset = _local_10.z; + _local_8++; + }; + _local_11 = _arg_5; + break; + case 3: + _local_8 = _arg_2; + while (_local_8 < _arg_3) + { + _local_10 = _arg_1[_local_8]; + _local_10.offset = _local_10.u; + _local_8++; + }; + _local_11 = _arg_6; + break; + case 4: + _local_8 = _arg_2; + while (_local_8 < _arg_3) + { + _local_10 = _arg_1[_local_8]; + _local_10.offset = _local_10.v; + _local_8++; + }; + _local_11 = _arg_6; + break; + }; + _arg_7[0] = _arg_2; + _arg_7[1] = (_arg_3 - 1); + var _local_12:int = 2; + while (_local_12 > 0) + { + _local_12--; + _local_14 = _arg_7[_local_12]; + _local_9 = _local_14; + _local_12--; + _local_15 = _arg_7[_local_12]; + _local_8 = _local_15; + _local_10 = _arg_1[((_local_14 + _local_15) >> 1)]; + _local_16 = _local_10.offset; + while (_local_8 <= _local_9) + { + _local_17 = _arg_1[_local_8]; + while (_local_17.offset > _local_16) + { + _local_8++; + _local_17 = _arg_1[_local_8]; + }; + _local_18 = _arg_1[_local_9]; + while (_local_18.offset < _local_16) + { + _local_9--; + _local_18 = _arg_1[_local_9]; + }; + if (_local_8 <= _local_9) + { + _arg_1[_local_8] = _local_18; + _arg_1[_local_9] = _local_17; + _local_8++; + _local_9--; + }; + }; + if (_local_15 < _local_9) + { + _arg_7[_local_12] = _local_15; + _local_12++; + _arg_7[_local_12] = _local_9; + _local_12++; + }; + if (_local_8 < _local_14) + { + _arg_7[_local_12] = _local_8; + _local_12++; + _arg_7[_local_12] = _local_14; + _local_12++; + }; + }; + _local_8 = _arg_2; + _local_10 = _arg_1[_local_8]; + _local_9 = (_local_8 + 1); + while (_local_9 <= _arg_3) + { + if (_local_9 < _arg_3) + { + _local_13 = _arg_1[_local_9]; + }; + if (((_local_9 == _arg_3) || ((_local_10.offset - _local_13.offset) > _local_11))) + { + if (((_arg_4 < 4) && ((_local_9 - _local_8) > 1))) + { + this.group(_arg_1, _local_8, _local_9, (_arg_4 + 1), _arg_5, _arg_6, _arg_7); + }; + if (_local_9 < _arg_3) + { + _local_8 = _local_9; + _local_10 = _arg_1[_local_8]; + }; + } else + { + if (_arg_4 == 4) + { + _local_13.value = _local_10; + }; + }; + _local_9++; + }; + } + + public function setMaterialToAllFaces(_arg_1:Material):void + { + this.deleteResources(); + var _local_2:Face = this.faceList; + while (_local_2 != null) + { + _local_2.material = _arg_1; + _local_2 = _local_2.next; + }; + } + + public function calculateFacesNormals(_arg_1:Boolean=true):void + { + var _local_3:Wrapper; + var _local_4:Vertex; + var _local_5:Vertex; + var _local_6:Vertex; + var _local_7:Number; + var _local_8:Number; + var _local_9:Number; + var _local_10:Number; + var _local_11:Number; + var _local_12:Number; + var _local_13:Number; + var _local_14:Number; + var _local_15:Number; + var _local_16:Number; + this.deleteResources(); + var _local_2:Face = this.faceList; + while (_local_2 != null) + { + _local_3 = _local_2.wrapper; + _local_4 = _local_3.vertex; + _local_3 = _local_3.next; + _local_5 = _local_3.vertex; + _local_3 = _local_3.next; + _local_6 = _local_3.vertex; + _local_7 = (_local_5.x - _local_4.x); + _local_8 = (_local_5.y - _local_4.y); + _local_9 = (_local_5.z - _local_4.z); + _local_10 = (_local_6.x - _local_4.x); + _local_11 = (_local_6.y - _local_4.y); + _local_12 = (_local_6.z - _local_4.z); + _local_13 = ((_local_12 * _local_8) - (_local_11 * _local_9)); + _local_14 = ((_local_10 * _local_9) - (_local_12 * _local_7)); + _local_15 = ((_local_11 * _local_7) - (_local_10 * _local_8)); + if (_arg_1) + { + _local_16 = (((_local_13 * _local_13) + (_local_14 * _local_14)) + (_local_15 * _local_15)); + if (_local_16 > 0.001) + { + _local_16 = (1 / Math.sqrt(_local_16)); + _local_13 = (_local_13 * _local_16); + _local_14 = (_local_14 * _local_16); + _local_15 = (_local_15 * _local_16); + }; + }; + _local_2.normalX = _local_13; + _local_2.normalY = _local_14; + _local_2.normalZ = _local_15; + _local_2.offset = (((_local_4.x * _local_13) + (_local_4.y * _local_14)) + (_local_4.z * _local_15)); + _local_2 = _local_2.next; + }; + } + + public function calculateVerticesNormals(_arg_1:Boolean=false, _arg_2:Number=0):void + { + var _local_3:Vertex; + var _local_4:Number; + var _local_6:Wrapper; + var _local_7:Vertex; + var _local_8:Vertex; + var _local_9:Vertex; + var _local_10:Number; + var _local_11:Number; + var _local_12:Number; + var _local_13:Number; + var _local_14:Number; + var _local_15:Number; + var _local_16:Number; + var _local_17:Number; + var _local_18:Number; + var _local_19:Vector.; + this.deleteResources(); + _local_3 = this.vertexList; + while (_local_3 != null) + { + _local_3.normalX = 0; + _local_3.normalY = 0; + _local_3.normalZ = 0; + _local_3 = _local_3.next; + }; + var _local_5:Face = this.faceList; + while (_local_5 != null) + { + _local_6 = _local_5.wrapper; + _local_7 = _local_6.vertex; + _local_6 = _local_6.next; + _local_8 = _local_6.vertex; + _local_6 = _local_6.next; + _local_9 = _local_6.vertex; + _local_10 = (_local_8.x - _local_7.x); + _local_11 = (_local_8.y - _local_7.y); + _local_12 = (_local_8.z - _local_7.z); + _local_13 = (_local_9.x - _local_7.x); + _local_14 = (_local_9.y - _local_7.y); + _local_15 = (_local_9.z - _local_7.z); + _local_16 = ((_local_15 * _local_11) - (_local_14 * _local_12)); + _local_17 = ((_local_13 * _local_12) - (_local_15 * _local_10)); + _local_18 = ((_local_14 * _local_10) - (_local_13 * _local_11)); + _local_4 = (((_local_16 * _local_16) + (_local_17 * _local_17)) + (_local_18 * _local_18)); + if (_local_4 > 0.001) + { + _local_4 = (1 / Math.sqrt(_local_4)); + _local_16 = (_local_16 * _local_4); + _local_17 = (_local_17 * _local_4); + _local_18 = (_local_18 * _local_4); + }; + _local_6 = _local_5.wrapper; + while (_local_6 != null) + { + _local_3 = _local_6.vertex; + _local_3.normalX = (_local_3.normalX + _local_16); + _local_3.normalY = (_local_3.normalY + _local_17); + _local_3.normalZ = (_local_3.normalZ + _local_18); + _local_6 = _local_6.next; + }; + _local_5 = _local_5.next; + }; + if (_arg_1) + { + _local_19 = this.vertices; + this.weldNormals(_local_19, 0, _local_19.length, 0, _arg_2, new Vector.()); + }; + _local_3 = this.vertexList; + while (_local_3 != null) + { + _local_4 = (((_local_3.normalX * _local_3.normalX) + (_local_3.normalY * _local_3.normalY)) + (_local_3.normalZ * _local_3.normalZ)); + if (_local_4 > 0.001) + { + _local_4 = (1 / Math.sqrt(_local_4)); + _local_3.normalX = (_local_3.normalX * _local_4); + _local_3.normalY = (_local_3.normalY * _local_4); + _local_3.normalZ = (_local_3.normalZ * _local_4); + }; + _local_3 = _local_3.next; + }; + } + + alternativa3d function weldNormals(_arg_1:Vector., _arg_2:int, _arg_3:int, _arg_4:int, _arg_5:Number, _arg_6:Vector.):void + { + var _local_7:int; + var _local_8:int; + var _local_9:int; + var _local_10:Vertex; + var _local_12:Vertex; + var _local_13:int; + var _local_14:int; + var _local_15:Number; + var _local_16:Vertex; + var _local_17:Vertex; + switch (_arg_4) + { + case 0: + _local_7 = _arg_2; + while (_local_7 < _arg_3) + { + _local_10 = _arg_1[_local_7]; + _local_10.offset = _local_10.x; + _local_7++; + }; + break; + case 1: + _local_7 = _arg_2; + while (_local_7 < _arg_3) + { + _local_10 = _arg_1[_local_7]; + _local_10.offset = _local_10.y; + _local_7++; + }; + break; + case 2: + _local_7 = _arg_2; + while (_local_7 < _arg_3) + { + _local_10 = _arg_1[_local_7]; + _local_10.offset = _local_10.z; + _local_7++; + }; + break; + }; + _arg_6[0] = _arg_2; + _arg_6[1] = (_arg_3 - 1); + var _local_11:int = 2; + while (_local_11 > 0) + { + _local_11--; + _local_13 = _arg_6[_local_11]; + _local_8 = _local_13; + _local_11--; + _local_14 = _arg_6[_local_11]; + _local_7 = _local_14; + _local_10 = _arg_1[((_local_13 + _local_14) >> 1)]; + _local_15 = _local_10.offset; + while (_local_7 <= _local_8) + { + _local_16 = _arg_1[_local_7]; + while (_local_16.offset > _local_15) + { + _local_7++; + _local_16 = _arg_1[_local_7]; + }; + _local_17 = _arg_1[_local_8]; + while (_local_17.offset < _local_15) + { + _local_8--; + _local_17 = _arg_1[_local_8]; + }; + if (_local_7 <= _local_8) + { + _arg_1[_local_7] = _local_17; + _arg_1[_local_8] = _local_16; + _local_7++; + _local_8--; + }; + }; + if (_local_14 < _local_8) + { + _arg_6[_local_11] = _local_14; + _local_11++; + _arg_6[_local_11] = _local_8; + _local_11++; + }; + if (_local_7 < _local_13) + { + _arg_6[_local_11] = _local_7; + _local_11++; + _arg_6[_local_11] = _local_13; + _local_11++; + }; + }; + _local_7 = _arg_2; + _local_10 = _arg_1[_local_7]; + _local_8 = (_local_7 + 1); + while (_local_8 <= _arg_3) + { + if (_local_8 < _arg_3) + { + _local_12 = _arg_1[_local_8]; + }; + if (((_local_8 == _arg_3) || ((_local_10.offset - _local_12.offset) > _arg_5))) + { + if ((_local_8 - _local_7) > 1) + { + if (_arg_4 < 2) + { + this.weldNormals(_arg_1, _local_7, _local_8, (_arg_4 + 1), _arg_5, _arg_6); + } else + { + _local_9 = (_local_7 + 1); + while (_local_9 < _local_8) + { + _local_12 = _arg_1[_local_9]; + _local_10.normalX = (_local_10.normalX + _local_12.normalX); + _local_10.normalY = (_local_10.normalY + _local_12.normalY); + _local_10.normalZ = (_local_10.normalZ + _local_12.normalZ); + _local_9++; + }; + _local_9 = (_local_7 + 1); + while (_local_9 < _local_8) + { + _local_12 = _arg_1[_local_9]; + _local_12.normalX = _local_10.normalX; + _local_12.normalY = _local_10.normalY; + _local_12.normalZ = _local_10.normalZ; + _local_9++; + }; + }; + }; + if (_local_8 < _arg_3) + { + _local_7 = _local_8; + _local_10 = _arg_1[_local_7]; + }; + }; + _local_8++; + }; + } + + public function calculateVerticesNormalsByAngle(_arg_1:Number, _arg_2:Number=0):void + { + var _local_3:Face; + var _local_4:Wrapper; + var _local_5:Vertex; + var _local_8:Vertex; + var _local_9:*; + var _local_10:Number; + var _local_11:Face; + this.deleteResources(); + this.calculateNormalsAndRemoveDegenerateFaces(); + var _local_6:Dictionary = new Dictionary(); + _local_5 = this.vertexList; + while (_local_5 != null) + { + _local_6[_local_5] = new Dictionary(); + _local_5 = _local_5.next; + }; + _local_3 = this.faceList; + while (_local_3 != null) + { + _local_4 = _local_3.wrapper; + while (_local_4 != null) + { + _local_5 = _local_4.vertex; + _local_6[_local_5][_local_3] = true; + _local_4 = _local_4.next; + }; + _local_3 = _local_3.next; + }; + var _local_7:Vector. = this.vertices; + shareFaces(_local_7, 0, _local_7.length, 0, _arg_2, new Vector.(), _local_6); + this.vertexList = null; + _arg_1 = Math.cos(_arg_1); + _local_3 = this.faceList; + while (_local_3 != null) + { + _local_4 = _local_3.wrapper; + while (_local_4 != null) + { + _local_5 = _local_4.vertex; + _local_8 = new Vertex(); + _local_8.x = _local_5.x; + _local_8.y = _local_5.y; + _local_8.z = _local_5.z; + _local_8.u = _local_5.u; + _local_8.v = _local_5.v; + _local_8.id = _local_5.id; + _local_8.normalX = _local_3.normalX; + _local_8.normalY = _local_3.normalY; + _local_8.normalZ = _local_3.normalZ; + for (_local_9 in _local_6[_local_5]) + { + _local_11 = _local_9; + if (((!(_local_3 == _local_11)) && ((((_local_3.normalX * _local_11.normalX) + (_local_3.normalY * _local_11.normalY)) + (_local_3.normalZ * _local_11.normalZ)) >= _arg_1))) + { + _local_8.normalX = (_local_8.normalX + _local_11.normalX); + _local_8.normalY = (_local_8.normalY + _local_11.normalY); + _local_8.normalZ = (_local_8.normalZ + _local_11.normalZ); + }; + }; + _local_10 = (((_local_8.normalX * _local_8.normalX) + (_local_8.normalY * _local_8.normalY)) + (_local_8.normalZ * _local_8.normalZ)); + if (_local_10 > 0.001) + { + _local_10 = (1 / Math.sqrt(_local_10)); + _local_8.normalX = (_local_8.normalX * _local_10); + _local_8.normalY = (_local_8.normalY * _local_10); + _local_8.normalZ = (_local_8.normalZ * _local_10); + }; + _local_4.vertex = _local_8; + _local_8.next = this.vertexList; + this.vertexList = _local_8; + _local_4 = _local_4.next; + }; + _local_3 = _local_3.next; + }; + } + + public function calculateVerticesNormalsBySmoothingGroups(_arg_1:Number=0):void + { + var _local_2:*; + var _local_3:Face; + var _local_4:Vertex; + var _local_5:Wrapper; + var _local_9:Vertex; + var _local_10:Number; + var _local_11:Face; + this.deleteResources(); + this.calculateNormalsAndRemoveDegenerateFaces(); + var _local_6:Dictionary = new Dictionary(); + _local_3 = this.faceList; + while (_local_3 != null) + { + if (_local_3.smoothingGroups > 0) + { + _local_5 = _local_3.wrapper; + while (_local_5 != null) + { + _local_4 = _local_5.vertex; + if ((!(_local_6[_local_4]))) + { + _local_6[_local_4] = new Dictionary(); + }; + _local_6[_local_4][_local_3] = true; + _local_5 = _local_5.next; + }; + }; + _local_3 = _local_3.next; + }; + var _local_7:Vector. = new Vector.(); + var _local_8:int; + for (_local_2 in _local_6) + { + _local_7[_local_8] = _local_2; + _local_8++; + }; + if (_local_8 > 0) + { + shareFaces(_local_7, 0, _local_8, 0, _arg_1, new Vector.(), _local_6); + }; + this.vertexList = null; + _local_3 = this.faceList; + while (_local_3 != null) + { + _local_5 = _local_3.wrapper; + while (_local_5 != null) + { + _local_4 = _local_5.vertex; + _local_9 = new Vertex(); + _local_9.x = _local_4.x; + _local_9.y = _local_4.y; + _local_9.z = _local_4.z; + _local_9.u = _local_4.u; + _local_9.v = _local_4.v; + _local_9.id = _local_4.id; + _local_9.normalX = _local_3.normalX; + _local_9.normalY = _local_3.normalY; + _local_9.normalZ = _local_3.normalZ; + if (_local_3.smoothingGroups > 0) + { + for (_local_2 in _local_6[_local_4]) + { + _local_11 = _local_2; + if (((!(_local_3 == _local_11)) && ((_local_3.smoothingGroups & _local_11.smoothingGroups) > 0))) + { + _local_9.normalX = (_local_9.normalX + _local_11.normalX); + _local_9.normalY = (_local_9.normalY + _local_11.normalY); + _local_9.normalZ = (_local_9.normalZ + _local_11.normalZ); + }; + }; + _local_10 = (((_local_9.normalX * _local_9.normalX) + (_local_9.normalY * _local_9.normalY)) + (_local_9.normalZ * _local_9.normalZ)); + if (_local_10 > 0.001) + { + _local_10 = (1 / Math.sqrt(_local_10)); + _local_9.normalX = (_local_9.normalX * _local_10); + _local_9.normalY = (_local_9.normalY * _local_10); + _local_9.normalZ = (_local_9.normalZ * _local_10); + }; + }; + _local_5.vertex = _local_9; + _local_9.next = this.vertexList; + this.vertexList = _local_9; + _local_5 = _local_5.next; + }; + _local_3 = _local_3.next; + }; + } + + private function calculateNormalsAndRemoveDegenerateFaces():void + { + var _local_2:Face; + var _local_3:Wrapper; + var _local_4:Vertex; + var _local_5:Vertex; + var _local_6:Vertex; + var _local_7:Number; + var _local_8:Number; + var _local_9:Number; + var _local_10:Number; + var _local_11:Number; + var _local_12:Number; + var _local_13:Number; + var _local_1:Face = this.faceList; + this.faceList = null; + while (_local_1 != null) + { + _local_2 = _local_1.next; + _local_3 = _local_1.wrapper; + _local_4 = _local_3.vertex; + _local_3 = _local_3.next; + _local_5 = _local_3.vertex; + _local_3 = _local_3.next; + _local_6 = _local_3.vertex; + _local_7 = (_local_5.x - _local_4.x); + _local_8 = (_local_5.y - _local_4.y); + _local_9 = (_local_5.z - _local_4.z); + _local_10 = (_local_6.x - _local_4.x); + _local_11 = (_local_6.y - _local_4.y); + _local_12 = (_local_6.z - _local_4.z); + _local_1.normalX = ((_local_12 * _local_8) - (_local_11 * _local_9)); + _local_1.normalY = ((_local_10 * _local_9) - (_local_12 * _local_7)); + _local_1.normalZ = ((_local_11 * _local_7) - (_local_10 * _local_8)); + _local_13 = (((_local_1.normalX * _local_1.normalX) + (_local_1.normalY * _local_1.normalY)) + (_local_1.normalZ * _local_1.normalZ)); + if (_local_13 > 0.001) + { + _local_13 = (1 / Math.sqrt(_local_13)); + _local_1.normalX = (_local_1.normalX * _local_13); + _local_1.normalY = (_local_1.normalY * _local_13); + _local_1.normalZ = (_local_1.normalZ * _local_13); + _local_1.offset = (((_local_4.x * _local_1.normalX) + (_local_4.y * _local_1.normalY)) + (_local_4.z * _local_1.normalZ)); + _local_1.next = this.faceList; + this.faceList = _local_1; + } else + { + _local_1.next = null; + }; + _local_1 = _local_2; + }; + } + + public function optimizeForDynamicBSP(_arg_1:int=1):void + { + var _local_3:Face; + var _local_5:Face; + var _local_6:Face; + var _local_7:Number; + var _local_8:Number; + var _local_9:Number; + var _local_10:Number; + var _local_11:Number; + var _local_12:Number; + var _local_13:int; + var _local_14:Face; + var _local_15:Wrapper; + var _local_16:Vertex; + var _local_17:Vertex; + var _local_18:Vertex; + var _local_19:Number; + var _local_20:Number; + var _local_21:Number; + var _local_22:Boolean; + var _local_23:Boolean; + var _local_24:Vertex; + var _local_25:Number; + this.deleteResources(); + var _local_2:Face = this.faceList; + var _local_4:int; + while (_local_4 < _arg_1) + { + _local_5 = null; + _local_6 = _local_2; + while (_local_6 != null) + { + _local_7 = _local_6.normalX; + _local_8 = _local_6.normalY; + _local_9 = _local_6.normalZ; + _local_10 = _local_6.offset; + _local_11 = (_local_10 - this.threshold); + _local_12 = (_local_10 + this.threshold); + _local_13 = 0; + _local_14 = _local_2; + while (_local_14 != null) + { + if (_local_14 != _local_6) + { + _local_15 = _local_14.wrapper; + _local_16 = _local_15.vertex; + _local_15 = _local_15.next; + _local_17 = _local_15.vertex; + _local_15 = _local_15.next; + _local_18 = _local_15.vertex; + _local_15 = _local_15.next; + _local_19 = (((_local_16.x * _local_7) + (_local_16.y * _local_8)) + (_local_16.z * _local_9)); + _local_20 = (((_local_17.x * _local_7) + (_local_17.y * _local_8)) + (_local_17.z * _local_9)); + _local_21 = (((_local_18.x * _local_7) + (_local_18.y * _local_8)) + (_local_18.z * _local_9)); + _local_22 = (((_local_19 < _local_11) || (_local_20 < _local_11)) || (_local_21 < _local_11)); + _local_23 = (((_local_19 > _local_12) || (_local_20 > _local_12)) || (_local_21 > _local_12)); + while (_local_15 != null) + { + _local_24 = _local_15.vertex; + _local_25 = (((_local_24.x * _local_7) + (_local_24.y * _local_8)) + (_local_24.z * _local_9)); + if (_local_25 < _local_11) + { + _local_22 = true; + if (_local_23) break; + } else + { + if (_local_25 > _local_12) + { + _local_23 = true; + if (_local_22) break; + }; + }; + _local_15 = _local_15.next; + }; + if (((_local_23) && (_local_22))) + { + _local_13++; + if (_local_13 > _local_4) break; + }; + }; + _local_14 = _local_14.next; + }; + if (_local_14 == null) + { + if (_local_5 != null) + { + _local_5.next = _local_6.next; + } else + { + _local_2 = _local_6.next; + }; + if (_local_3 != null) + { + _local_3.next = _local_6; + } else + { + this.faceList = _local_6; + }; + _local_3 = _local_6; + } else + { + _local_5 = _local_6; + }; + _local_6 = _local_6.next; + }; + if (_local_2 == null) break; + _local_4++; + }; + if (_local_3 != null) + { + _local_3.next = _local_2; + }; + } + + override public function intersectRay(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Dictionary=null, _arg_4:Camera3D=null):RayIntersectionData + { + var _local_11:Vector3D; + var _local_12:Face; + var _local_15:Number; + var _local_16:Number; + var _local_17:Number; + var _local_18:Number; + var _local_19:Number; + var _local_20:Number; + var _local_21:Number; + var _local_22:Number; + var _local_23:Number; + var _local_24:Wrapper; + var _local_25:Vertex; + var _local_26:Vertex; + var _local_27:Number; + var _local_28:Number; + var _local_29:Number; + var _local_30:Number; + var _local_31:Number; + var _local_32:Number; + var _local_33:RayIntersectionData; + if (((!(_arg_3 == null)) && (_arg_3[this]))) + { + return (null); + }; + if ((!(boundIntersectRay(_arg_1, _arg_2, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ)))) + { + return (null); + }; + var _local_5:Number = _arg_1.x; + var _local_6:Number = _arg_1.y; + var _local_7:Number = _arg_1.z; + var _local_8:Number = _arg_2.x; + var _local_9:Number = _arg_2.y; + var _local_10:Number = _arg_2.z; + var _local_13:Number = 1E22; + var _local_14:Face = this.faceList; + while (_local_14 != null) + { + _local_15 = _local_14.normalX; + _local_16 = _local_14.normalY; + _local_17 = _local_14.normalZ; + _local_18 = (((_local_8 * _local_15) + (_local_9 * _local_16)) + (_local_10 * _local_17)); + if (_local_18 < 0) + { + _local_19 = ((((_local_5 * _local_15) + (_local_6 * _local_16)) + (_local_7 * _local_17)) - _local_14.offset); + if (_local_19 > 0) + { + _local_20 = (-(_local_19) / _local_18); + if (((_local_11 == null) || (_local_20 < _local_13))) + { + _local_21 = (_local_5 + (_local_8 * _local_20)); + _local_22 = (_local_6 + (_local_9 * _local_20)); + _local_23 = (_local_7 + (_local_10 * _local_20)); + _local_24 = _local_14.wrapper; + while (_local_24 != null) + { + _local_25 = _local_24.vertex; + _local_26 = ((_local_24.next != null) ? _local_24.next.vertex : _local_14.wrapper.vertex); + _local_27 = (_local_26.x - _local_25.x); + _local_28 = (_local_26.y - _local_25.y); + _local_29 = (_local_26.z - _local_25.z); + _local_30 = (_local_21 - _local_25.x); + _local_31 = (_local_22 - _local_25.y); + _local_32 = (_local_23 - _local_25.z); + if ((((((_local_32 * _local_28) - (_local_31 * _local_29)) * _local_15) + (((_local_30 * _local_29) - (_local_32 * _local_27)) * _local_16)) + (((_local_31 * _local_27) - (_local_30 * _local_28)) * _local_17)) < 0) break; + _local_24 = _local_24.next; + }; + if (_local_24 == null) + { + if (_local_20 < _local_13) + { + _local_13 = _local_20; + if (_local_11 == null) + { + _local_11 = new Vector3D(); + }; + _local_11.x = _local_21; + _local_11.y = _local_22; + _local_11.z = _local_23; + _local_12 = _local_14; + }; + }; + }; + }; + }; + _local_14 = _local_14.next; + }; + if (_local_11 != null) + { + _local_33 = new RayIntersectionData(); + _local_33.object = this; + _local_33.face = _local_12; + _local_33.point = _local_11; + _local_33.uv = _local_12.getUV(_local_11); + _local_33.time = _local_13; + return (_local_33); + }; + return (null); + } + + override alternativa3d function checkIntersection(_arg_1:Number, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Dictionary):Boolean + { + var _local_10:Number; + var _local_11:Number; + var _local_12:Number; + var _local_13:Number; + var _local_14:Number; + var _local_15:Number; + var _local_16:Number; + var _local_17:Number; + var _local_18:Number; + var _local_19:Wrapper; + var _local_20:Vertex; + var _local_21:Vertex; + var _local_22:Number; + var _local_23:Number; + var _local_24:Number; + var _local_25:Number; + var _local_26:Number; + var _local_27:Number; + var _local_9:Face = this.faceList; + while (_local_9 != null) + { + _local_10 = _local_9.normalX; + _local_11 = _local_9.normalY; + _local_12 = _local_9.normalZ; + _local_13 = (((_arg_4 * _local_10) + (_arg_5 * _local_11)) + (_arg_6 * _local_12)); + if (_local_13 < 0) + { + _local_14 = ((((_arg_1 * _local_10) + (_arg_2 * _local_11)) + (_arg_3 * _local_12)) - _local_9.offset); + if (_local_14 > 0) + { + _local_15 = (-(_local_14) / _local_13); + if (_local_15 < _arg_7) + { + _local_16 = (_arg_1 + (_arg_4 * _local_15)); + _local_17 = (_arg_2 + (_arg_5 * _local_15)); + _local_18 = (_arg_3 + (_arg_6 * _local_15)); + _local_19 = _local_9.wrapper; + while (_local_19 != null) + { + _local_20 = _local_19.vertex; + _local_21 = ((_local_19.next != null) ? _local_19.next.vertex : _local_9.wrapper.vertex); + _local_22 = (_local_21.x - _local_20.x); + _local_23 = (_local_21.y - _local_20.y); + _local_24 = (_local_21.z - _local_20.z); + _local_25 = (_local_16 - _local_20.x); + _local_26 = (_local_17 - _local_20.y); + _local_27 = (_local_18 - _local_20.z); + if ((((((_local_27 * _local_23) - (_local_26 * _local_24)) * _local_10) + (((_local_25 * _local_24) - (_local_27 * _local_22)) * _local_11)) + (((_local_26 * _local_22) - (_local_25 * _local_23)) * _local_12)) < 0) break; + _local_19 = _local_19.next; + }; + if (_local_19 == null) + { + return (true); + }; + }; + }; + }; + _local_9 = _local_9.next; + }; + return (false); + } + + override alternativa3d function collectPlanes(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Vector3D, _arg_4:Vector3D, _arg_5:Vector3D, _arg_6:Vector., _arg_7:Dictionary=null):void + { + var _local_9:Vertex; + var _local_11:Number; + var _local_12:Wrapper; + if (((!(_arg_7 == null)) && (_arg_7[this]))) + { + return; + }; + var _local_8:Vector3D = calculateSphere(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5); + if ((!(boundIntersectSphere(_local_8, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ)))) + { + return; + }; + if (transformId > 0x1DCD6500) + { + transformId = 0; + _local_9 = this.vertexList; + while (_local_9 != null) + { + _local_9.transformId = 0; + _local_9 = _local_9.next; + }; + }; + transformId++; + var _local_10:Face = this.faceList; + while (_local_10 != null) + { + _local_11 = ((((_local_8.x * _local_10.normalX) + (_local_8.y * _local_10.normalY)) + (_local_8.z * _local_10.normalZ)) - _local_10.offset); + if (((_local_11 < _local_8.w) && (_local_11 > -(_local_8.w)))) + { + _local_12 = _local_10.wrapper; + while (_local_12 != null) + { + _local_9 = _local_12.vertex; + if (_local_9.transformId != transformId) + { + _local_9.cameraX = ((((ma * _local_9.x) + (mb * _local_9.y)) + (mc * _local_9.z)) + md); + _local_9.cameraY = ((((me * _local_9.x) + (mf * _local_9.y)) + (mg * _local_9.z)) + mh); + _local_9.cameraZ = ((((mi * _local_9.x) + (mj * _local_9.y)) + (mk * _local_9.z)) + ml); + _local_9.transformId = transformId; + }; + _local_12 = _local_12.next; + }; + _arg_6.push(_local_10); + }; + _local_10 = _local_10.next; + }; + } + + override public function clone():Object3D + { + var _local_1:Mesh = new Mesh(); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + override protected function clonePropertiesFrom(_arg_1:Object3D):void + { + var _local_3:Vertex; + var _local_4:Vertex; + var _local_5:Face; + var _local_7:Vertex; + var _local_8:Face; + var _local_9:Wrapper; + var _local_10:Wrapper; + var _local_11:Wrapper; + super.clonePropertiesFrom(_arg_1); + var _local_2:Mesh = (_arg_1 as Mesh); + this.clipping = _local_2.clipping; + this.sorting = _local_2.sorting; + this.threshold = _local_2.threshold; + _local_3 = _local_2.vertexList; + while (_local_3 != null) + { + _local_7 = new Vertex(); + _local_7.x = _local_3.x; + _local_7.y = _local_3.y; + _local_7.z = _local_3.z; + _local_7.u = _local_3.u; + _local_7.v = _local_3.v; + _local_7.normalX = _local_3.normalX; + _local_7.normalY = _local_3.normalY; + _local_7.normalZ = _local_3.normalZ; + _local_7.offset = _local_3.offset; + _local_7.id = _local_3.id; + _local_3.value = _local_7; + if (_local_4 != null) + { + _local_4.next = _local_7; + } else + { + this.vertexList = _local_7; + }; + _local_4 = _local_7; + _local_3 = _local_3.next; + }; + var _local_6:Face = _local_2.faceList; + while (_local_6 != null) + { + _local_8 = new Face(); + _local_8.material = _local_6.material; + _local_8.smoothingGroups = _local_6.smoothingGroups; + _local_8.id = _local_6.id; + _local_8.normalX = _local_6.normalX; + _local_8.normalY = _local_6.normalY; + _local_8.normalZ = _local_6.normalZ; + _local_8.offset = _local_6.offset; + _local_9 = null; + _local_10 = _local_6.wrapper; + while (_local_10 != null) + { + _local_11 = new Wrapper(); + _local_11.vertex = _local_10.vertex.value; + if (_local_9 != null) + { + _local_9.next = _local_11; + } else + { + _local_8.wrapper = _local_11; + }; + _local_9 = _local_11; + _local_10 = _local_10.next; + }; + if (_local_5 != null) + { + _local_5.next = _local_8; + } else + { + this.faceList = _local_8; + }; + _local_5 = _local_8; + _local_6 = _local_6.next; + }; + _local_3 = _local_2.vertexList; + while (_local_3 != null) + { + _local_3.value = null; + _local_3 = _local_3.next; + }; + } + + override alternativa3d function draw(_arg_1:Camera3D):void + { + var _local_2:Face; + var _local_4:Vertex; + if (this.faceList == null) + { + return; + }; + if (this.clipping == 0) + { + if ((culling & 0x01)) + { + return; + }; + culling = 0; + }; + this.prepareResources(); + if ((useDepth = (((!(_arg_1.view.constrained)) && ((((_arg_1.softTransparency) && (_arg_1.softTransparencyStrength > 0)) || ((_arg_1.ssao) && (_arg_1.ssaoStrength > 0))) || ((_arg_1.deferredLighting) && (_arg_1.deferredLightingStrength > 0)))) && (concatenatedAlpha >= depthMapAlphaThreshold)))) + { + _arg_1.depthObjects[_arg_1.depthCount] = this; + _arg_1.depthCount++; + }; + if (((concatenatedAlpha >= 1) && (concatenatedBlendMode == "normal"))) + { + this.addOpaque(_arg_1); + _local_2 = this.transparentList; + } else + { + _local_2 = this.faceList; + }; + transformConst[0] = ma; + transformConst[1] = mb; + transformConst[2] = mc; + transformConst[3] = md; + transformConst[4] = me; + transformConst[5] = mf; + transformConst[6] = mg; + transformConst[7] = mh; + transformConst[8] = mi; + transformConst[9] = mj; + transformConst[10] = mk; + transformConst[11] = ml; + var _local_3:int = ((_arg_1.debug) ? _arg_1.checkInDebug(this) : 0); + if ((_local_3 & Debug.BOUNDS)) + { + Debug.drawBounds(_arg_1, this, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ); + }; + if (_local_2 == null) + { + return; + }; + if (transformId > 0x1DCD6500) + { + transformId = 0; + _local_4 = this.vertexList; + while (_local_4 != null) + { + _local_4.transformId = 0; + _local_4 = _local_4.next; + }; + }; + transformId++; + calculateInverseMatrix(); + _local_2 = this.prepareFaces(_arg_1, _local_2); + if (_local_2 == null) + { + return; + }; + if (culling > 0) + { + if (this.clipping == 1) + { + _local_2 = _arg_1.cull(_local_2, culling); + } else + { + _local_2 = _arg_1.clip(_local_2, culling); + }; + if (_local_2 == null) + { + return; + }; + }; + if (_local_2.processNext != null) + { + if (this.sorting == 1) + { + _local_2 = _arg_1.sortByAverageZ(_local_2); + } else + { + if (this.sorting == 2) + { + _local_2 = _arg_1.sortByDynamicBSP(_local_2, this.threshold); + }; + }; + }; + if ((_local_3 & Debug.EDGES)) + { + Debug.drawEdges(_arg_1, _local_2, 0xFFFFFF); + }; + this.drawFaces(_arg_1, _local_2); + } + + override alternativa3d function getVG(_arg_1:Camera3D):VG + { + var _local_2:Face; + var _local_4:Vertex; + if (this.faceList == null) + { + return (null); + }; + if (this.clipping == 0) + { + if ((culling & 0x01)) + { + return (null); + }; + culling = 0; + }; + this.prepareResources(); + if ((useDepth = (((!(_arg_1.view.constrained)) && ((((_arg_1.softTransparency) && (_arg_1.softTransparencyStrength > 0)) || ((_arg_1.ssao) && (_arg_1.ssaoStrength > 0))) || ((_arg_1.deferredLighting) && (_arg_1.deferredLightingStrength > 0)))) && (concatenatedAlpha >= depthMapAlphaThreshold)))) + { + _arg_1.depthObjects[_arg_1.depthCount] = this; + _arg_1.depthCount++; + }; + if (((concatenatedAlpha >= 1) && (concatenatedBlendMode == "normal"))) + { + this.addOpaque(_arg_1); + _local_2 = this.transparentList; + } else + { + _local_2 = this.faceList; + }; + transformConst[0] = ma; + transformConst[1] = mb; + transformConst[2] = mc; + transformConst[3] = md; + transformConst[4] = me; + transformConst[5] = mf; + transformConst[6] = mg; + transformConst[7] = mh; + transformConst[8] = mi; + transformConst[9] = mj; + transformConst[10] = mk; + transformConst[11] = ml; + var _local_3:int = ((_arg_1.debug) ? _arg_1.checkInDebug(this) : 0); + if ((_local_3 & Debug.BOUNDS)) + { + Debug.drawBounds(_arg_1, this, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ); + }; + if (_local_2 == null) + { + return (null); + }; + if (transformId > 0x1DCD6500) + { + transformId = 0; + _local_4 = this.vertexList; + while (_local_4 != null) + { + _local_4.transformId = 0; + _local_4 = _local_4.next; + }; + }; + transformId++; + calculateInverseMatrix(); + _local_2 = this.prepareFaces(_arg_1, _local_2); + if (_local_2 == null) + { + return (null); + }; + if (culling > 0) + { + if (this.clipping == 1) + { + _local_2 = _arg_1.cull(_local_2, culling); + } else + { + _local_2 = _arg_1.clip(_local_2, culling); + }; + if (_local_2 == null) + { + return (null); + }; + }; + return (VG.create(this, _local_2, this.sorting, _local_3, false)); + } + + alternativa3d function prepareResources():void + { + var _local_1:Vector.; + var _local_2:int; + var _local_3:int; + var _local_4:Vertex; + var _local_5:int; + var _local_6:int; + var _local_7:int; + var _local_8:Face; + var _local_9:Face; + var _local_10:Face; + var _local_11:Wrapper; + var _local_12:Dictionary; + var _local_13:Vector.; + var _local_14:int; + var _local_15:*; + var _local_16:Face; + if (this.vertexBuffer == null) + { + _local_1 = new Vector.(); + _local_2 = 0; + _local_3 = 0; + _local_4 = this.vertexList; + while (_local_4 != null) + { + _local_1[_local_2] = _local_4.x; + _local_2++; + _local_1[_local_2] = _local_4.y; + _local_2++; + _local_1[_local_2] = _local_4.z; + _local_2++; + _local_1[_local_2] = _local_4.u; + _local_2++; + _local_1[_local_2] = _local_4.v; + _local_2++; + _local_1[_local_2] = _local_4.normalX; + _local_2++; + _local_1[_local_2] = _local_4.normalY; + _local_2++; + _local_1[_local_2] = _local_4.normalZ; + _local_2++; + _local_4.index = _local_3; + _local_3++; + _local_4 = _local_4.next; + }; + if (_local_3 > 0) + { + this.vertexBuffer = new VertexBufferResource(_local_1, 8); + }; + _local_12 = new Dictionary(); + _local_8 = this.faceList; + while (_local_8 != null) + { + _local_9 = _local_8.next; + _local_8.next = null; + if (((!(_local_8.material == null)) && ((!(_local_8.material.transparent)) || (_local_8.material.alphaTestThreshold > 0)))) + { + _local_8.next = _local_12[_local_8.material]; + _local_12[_local_8.material] = _local_8; + } else + { + if (_local_10 != null) + { + _local_10.next = _local_8; + } else + { + this.transparentList = _local_8; + }; + _local_10 = _local_8; + }; + _local_8 = _local_9; + }; + this.faceList = this.transparentList; + _local_13 = new Vector.(); + _local_14 = 0; + for (_local_15 in _local_12) + { + _local_16 = _local_12[_local_15]; + this.opaqueMaterials[this.opaqueLength] = _local_16.material; + this.opaqueBegins[this.opaqueLength] = (this.numTriangles * 3); + _local_8 = _local_16; + while (_local_8 != null) + { + _local_11 = _local_8.wrapper; + _local_5 = _local_11.vertex.index; + _local_11 = _local_11.next; + _local_6 = _local_11.vertex.index; + _local_11 = _local_11.next; + while (_local_11 != null) + { + _local_7 = _local_11.vertex.index; + _local_13[_local_14] = _local_5; + _local_14++; + _local_13[_local_14] = _local_6; + _local_14++; + _local_13[_local_14] = _local_7; + _local_14++; + _local_6 = _local_7; + this.numTriangles++; + _local_11 = _local_11.next; + }; + if (_local_8.next == null) + { + _local_10 = _local_8; + }; + _local_8 = _local_8.next; + }; + this.opaqueNums[this.opaqueLength] = (this.numTriangles - (this.opaqueBegins[this.opaqueLength] / 3)); + this.opaqueLength++; + _local_10.next = this.faceList; + this.faceList = _local_16; + }; + this.numOpaqueTriangles = this.numTriangles; + _local_8 = this.transparentList; + while (_local_8 != null) + { + _local_11 = _local_8.wrapper; + _local_5 = _local_11.vertex.index; + _local_11 = _local_11.next; + _local_6 = _local_11.vertex.index; + _local_11 = _local_11.next; + while (_local_11 != null) + { + _local_7 = _local_11.vertex.index; + _local_13[_local_14] = _local_5; + _local_14++; + _local_13[_local_14] = _local_6; + _local_14++; + _local_13[_local_14] = _local_7; + _local_14++; + _local_6 = _local_7; + this.numTriangles++; + _local_11 = _local_11.next; + }; + _local_8 = _local_8.next; + }; + if (_local_14 > 0) + { + this.indexBuffer = new IndexBufferResource(_local_13); + }; + }; + } + + alternativa3d function deleteResources():void + { + if (this.vertexBuffer != null) + { + this.vertexBuffer.dispose(); + this.vertexBuffer = null; + this.indexBuffer.dispose(); + this.indexBuffer = null; + this.numTriangles = 0; + this.numOpaqueTriangles = 0; + this.opaqueMaterials.length = 0; + this.opaqueBegins.length = 0; + this.opaqueNums.length = 0; + this.opaqueLength = 0; + this.transparentList = null; + }; + } + + alternativa3d function addOpaque(_arg_1:Camera3D):void + { + var _local_2:int; + while (_local_2 < this.opaqueLength) + { + _arg_1.addOpaque(this.opaqueMaterials[_local_2], this.vertexBuffer, this.indexBuffer, this.opaqueBegins[_local_2], this.opaqueNums[_local_2], this); + _local_2++; + }; + } + + alternativa3d function prepareFaces(_arg_1:Camera3D, _arg_2:Face):Face + { + var _local_3:Face; + var _local_4:Face; + var _local_5:Face; + var _local_6:Wrapper; + var _local_7:Vertex; + var _local_8:Number; + var _local_9:Number; + var _local_10:Number; + _local_5 = _arg_2; + while (_local_5 != null) + { + if ((((_local_5.normalX * imd) + (_local_5.normalY * imh)) + (_local_5.normalZ * iml)) > _local_5.offset) + { + _local_6 = _local_5.wrapper; + while (_local_6 != null) + { + _local_7 = _local_6.vertex; + if (_local_7.transformId != transformId) + { + _local_8 = _local_7.x; + _local_9 = _local_7.y; + _local_10 = _local_7.z; + _local_7.cameraX = ((((ma * _local_8) + (mb * _local_9)) + (mc * _local_10)) + md); + _local_7.cameraY = ((((me * _local_8) + (mf * _local_9)) + (mg * _local_10)) + mh); + _local_7.cameraZ = ((((mi * _local_8) + (mj * _local_9)) + (mk * _local_10)) + ml); + _local_7.transformId = transformId; + _local_7.drawId = 0; + }; + _local_6 = _local_6.next; + }; + if (_local_3 != null) + { + _local_4.processNext = _local_5; + } else + { + _local_3 = _local_5; + }; + _local_4 = _local_5; + }; + _local_5 = _local_5.next; + }; + if (_local_4 != null) + { + _local_4.processNext = null; + }; + return (_local_3); + } + + alternativa3d function drawFaces(_arg_1:Camera3D, _arg_2:Face):void + { + var _local_3:Face; + var _local_4:Face; + var _local_5:Face; + _local_5 = _arg_2; + while (_local_5 != null) + { + _local_3 = _local_5.processNext; + if (((_local_3 == null) || (!(_local_3.material == _arg_2.material)))) + { + _local_5.processNext = null; + if (_arg_2.material != null) + { + _arg_2.processNegative = _local_4; + _local_4 = _arg_2; + } else + { + while (_arg_2 != null) + { + _local_5 = _arg_2.processNext; + _arg_2.processNext = null; + _arg_2 = _local_5; + }; + }; + _arg_2 = _local_3; + }; + _local_5 = _local_3; + }; + _arg_2 = _local_4; + while (_arg_2 != null) + { + _local_3 = _arg_2.processNegative; + _arg_2.processNegative = null; + _arg_1.addTransparent(_arg_2, this); + _arg_2 = _local_3; + }; + } + + override alternativa3d function updateBounds(_arg_1:Object3D, _arg_2:Object3D=null):void + { + var _local_3:Vertex; + _local_3 = this.vertexList; + while (_local_3 != null) + { + if (_arg_2 != null) + { + _local_3.cameraX = ((((_arg_2.ma * _local_3.x) + (_arg_2.mb * _local_3.y)) + (_arg_2.mc * _local_3.z)) + _arg_2.md); + _local_3.cameraY = ((((_arg_2.me * _local_3.x) + (_arg_2.mf * _local_3.y)) + (_arg_2.mg * _local_3.z)) + _arg_2.mh); + _local_3.cameraZ = ((((_arg_2.mi * _local_3.x) + (_arg_2.mj * _local_3.y)) + (_arg_2.mk * _local_3.z)) + _arg_2.ml); + } else + { + _local_3.cameraX = _local_3.x; + _local_3.cameraY = _local_3.y; + _local_3.cameraZ = _local_3.z; + }; + if (_local_3.cameraX < _arg_1.boundMinX) + { + _arg_1.boundMinX = _local_3.cameraX; + }; + if (_local_3.cameraX > _arg_1.boundMaxX) + { + _arg_1.boundMaxX = _local_3.cameraX; + }; + if (_local_3.cameraY < _arg_1.boundMinY) + { + _arg_1.boundMinY = _local_3.cameraY; + }; + if (_local_3.cameraY > _arg_1.boundMaxY) + { + _arg_1.boundMaxY = _local_3.cameraY; + }; + if (_local_3.cameraZ < _arg_1.boundMinZ) + { + _arg_1.boundMinZ = _local_3.cameraZ; + }; + if (_local_3.cameraZ > _arg_1.boundMaxZ) + { + _arg_1.boundMaxZ = _local_3.cameraZ; + }; + _local_3 = _local_3.next; + }; + } + + override alternativa3d function split(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Vector3D, _arg_4:Number):Vector. + { + var _local_5:Vector.; + var _local_6:Vector3D; + var _local_7:Number; + var _local_8:Number; + var _local_9:Vertex; + var _local_10:Vertex; + var _local_11:Face; + var _local_12:Mesh; + var _local_13:Mesh; + var _local_14:Face; + var _local_15:Face; + var _local_16:Face; + var _local_17:Face; + var _local_18:Wrapper; + var _local_19:Vertex; + var _local_20:Vertex; + var _local_21:Vertex; + var _local_22:Boolean; + var _local_23:Boolean; + var _local_24:Face; + var _local_25:Face; + var _local_26:Wrapper; + var _local_27:Wrapper; + var _local_28:Wrapper; + var _local_29:Number; + var _local_30:Vertex; + this.deleteResources(); + _local_5 = new Vector.(2); + _local_6 = calculatePlane(_arg_1, _arg_2, _arg_3); + _local_7 = (_local_6.w - _arg_4); + _local_8 = (_local_6.w + _arg_4); + _local_9 = this.vertexList; + while (_local_9 != null) + { + _local_10 = _local_9.next; + _local_9.next = null; + _local_9.offset = (((_local_9.x * _local_6.x) + (_local_9.y * _local_6.y)) + (_local_9.z * _local_6.z)); + if (((_local_9.offset >= _local_7) && (_local_9.offset <= _local_8))) + { + _local_9.value = new Vertex(); + _local_9.value.x = _local_9.x; + _local_9.value.y = _local_9.y; + _local_9.value.z = _local_9.z; + _local_9.value.u = _local_9.u; + _local_9.value.v = _local_9.v; + _local_9.value.normalX = _local_9.normalX; + _local_9.value.normalY = _local_9.normalY; + _local_9.value.normalZ = _local_9.normalZ; + }; + _local_9.transformId = 0; + _local_9 = _local_10; + }; + this.vertexList = null; + _local_11 = this.faceList; + this.faceList = null; + _local_12 = (this.clone() as Mesh); + _local_13 = (this.clone() as Mesh); + _local_16 = _local_11; + while (_local_16 != null) + { + _local_17 = _local_16.next; + _local_18 = _local_16.wrapper; + _local_19 = _local_18.vertex; + _local_18 = _local_18.next; + _local_20 = _local_18.vertex; + _local_18 = _local_18.next; + _local_21 = _local_18.vertex; + _local_22 = (((_local_19.offset < _local_7) || (_local_20.offset < _local_7)) || (_local_21.offset < _local_7)); + _local_23 = (((_local_19.offset > _local_8) || (_local_20.offset > _local_8)) || (_local_21.offset > _local_8)); + _local_18 = _local_18.next; + while (_local_18 != null) + { + _local_9 = _local_18.vertex; + if (_local_9.offset < _local_7) + { + _local_22 = true; + } else + { + if (_local_9.offset > _local_8) + { + _local_23 = true; + }; + }; + _local_18 = _local_18.next; + }; + if ((!(_local_22))) + { + if (_local_15 != null) + { + _local_15.next = _local_16; + } else + { + _local_13.faceList = _local_16; + }; + _local_15 = _local_16; + } else + { + if ((!(_local_23))) + { + if (_local_14 != null) + { + _local_14.next = _local_16; + } else + { + _local_12.faceList = _local_16; + }; + _local_14 = _local_16; + _local_18 = _local_16.wrapper; + while (_local_18 != null) + { + if (_local_18.vertex.value != null) + { + _local_18.vertex = _local_18.vertex.value; + }; + _local_18 = _local_18.next; + }; + } else + { + _local_24 = new Face(); + _local_25 = new Face(); + _local_26 = null; + _local_27 = null; + _local_18 = _local_16.wrapper.next.next; + while (_local_18.next != null) + { + _local_18 = _local_18.next; + }; + _local_19 = _local_18.vertex; + _local_18 = _local_16.wrapper; + while (_local_18 != null) + { + _local_20 = _local_18.vertex; + if ((((_local_19.offset < _local_7) && (_local_20.offset > _local_8)) || ((_local_19.offset > _local_8) && (_local_20.offset < _local_7)))) + { + _local_29 = ((_local_6.w - _local_19.offset) / (_local_20.offset - _local_19.offset)); + _local_9 = new Vertex(); + _local_9.x = (_local_19.x + ((_local_20.x - _local_19.x) * _local_29)); + _local_9.y = (_local_19.y + ((_local_20.y - _local_19.y) * _local_29)); + _local_9.z = (_local_19.z + ((_local_20.z - _local_19.z) * _local_29)); + _local_9.u = (_local_19.u + ((_local_20.u - _local_19.u) * _local_29)); + _local_9.v = (_local_19.v + ((_local_20.v - _local_19.v) * _local_29)); + _local_9.normalX = (_local_19.normalX + ((_local_20.normalX - _local_19.normalX) * _local_29)); + _local_9.normalY = (_local_19.normalY + ((_local_20.normalY - _local_19.normalY) * _local_29)); + _local_9.normalZ = (_local_19.normalZ + ((_local_20.normalZ - _local_19.normalZ) * _local_29)); + _local_28 = new Wrapper(); + _local_28.vertex = _local_9; + if (_local_26 != null) + { + _local_26.next = _local_28; + } else + { + _local_24.wrapper = _local_28; + }; + _local_26 = _local_28; + _local_30 = new Vertex(); + _local_30.x = _local_9.x; + _local_30.y = _local_9.y; + _local_30.z = _local_9.z; + _local_30.u = _local_9.u; + _local_30.v = _local_9.v; + _local_30.normalX = _local_9.normalX; + _local_30.normalY = _local_9.normalY; + _local_30.normalZ = _local_9.normalZ; + _local_28 = new Wrapper(); + _local_28.vertex = _local_30; + if (_local_27 != null) + { + _local_27.next = _local_28; + } else + { + _local_25.wrapper = _local_28; + }; + _local_27 = _local_28; + }; + if (_local_20.offset < _local_7) + { + _local_28 = _local_18.create(); + _local_28.vertex = _local_20; + if (_local_26 != null) + { + _local_26.next = _local_28; + } else + { + _local_24.wrapper = _local_28; + }; + _local_26 = _local_28; + } else + { + if (_local_20.offset > _local_8) + { + _local_28 = _local_18.create(); + _local_28.vertex = _local_20; + if (_local_27 != null) + { + _local_27.next = _local_28; + } else + { + _local_25.wrapper = _local_28; + }; + _local_27 = _local_28; + } else + { + _local_28 = _local_18.create(); + _local_28.vertex = _local_20.value; + if (_local_26 != null) + { + _local_26.next = _local_28; + } else + { + _local_24.wrapper = _local_28; + }; + _local_26 = _local_28; + _local_28 = _local_18.create(); + _local_28.vertex = _local_20; + if (_local_27 != null) + { + _local_27.next = _local_28; + } else + { + _local_25.wrapper = _local_28; + }; + _local_27 = _local_28; + }; + }; + _local_19 = _local_20; + _local_18 = _local_18.next; + }; + _local_24.material = _local_16.material; + _local_24.calculateBestSequenceAndNormal(); + if (_local_14 != null) + { + _local_14.next = _local_24; + } else + { + _local_12.faceList = _local_24; + }; + _local_14 = _local_24; + _local_25.material = _local_16.material; + _local_25.calculateBestSequenceAndNormal(); + if (_local_15 != null) + { + _local_15.next = _local_25; + } else + { + _local_13.faceList = _local_25; + }; + _local_15 = _local_25; + }; + }; + _local_16 = _local_17; + }; + if (_local_14 != null) + { + _local_14.next = null; + _local_12.transformId++; + _local_12.collectVertices(); + _local_12.calculateBounds(); + _local_5[0] = _local_12; + }; + if (_local_15 != null) + { + _local_15.next = null; + _local_13.transformId++; + _local_13.collectVertices(); + _local_13.calculateBounds(); + _local_5[1] = _local_13; + }; + return (_local_5); + } + + private function collectVertices():void + { + var _local_1:Face; + var _local_2:Wrapper; + var _local_3:Vertex; + _local_1 = this.faceList; + while (_local_1 != null) + { + _local_2 = _local_1.wrapper; + while (_local_2 != null) + { + _local_3 = _local_2.vertex; + if (_local_3.transformId != transformId) + { + _local_3.next = this.vertexList; + this.vertexList = _local_3; + _local_3.transformId = transformId; + _local_3.value = null; + }; + _local_2 = _local_2.next; + }; + _local_1 = _local_1.next; + }; + } + + + } +}//package alternativa.engine3d.objects \ No newline at end of file diff --git a/src/alternativa/engine3d/objects/Occluder.as b/src/alternativa/engine3d/objects/Occluder.as new file mode 100644 index 0000000..3dfdc2e --- /dev/null +++ b/src/alternativa/engine3d/objects/Occluder.as @@ -0,0 +1,781 @@ +package alternativa.engine3d.objects +{ + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.core.Face; + import alternativa.engine3d.core.Vertex; + import alternativa.engine3d.core.Wrapper; + import flash.display.Sprite; + import alternativa.engine3d.core.Debug; + import alternativa.engine3d.core.Camera3D; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class Occluder extends Object3D + { + + alternativa3d var faceList:Face; + alternativa3d var edgeList:Edge; + alternativa3d var vertexList:Vertex; + public var minSize:Number = 0; + + + public function createForm(_arg_1:Mesh, _arg_2:Boolean=false):void + { + this.destroyForm(); + if ((!(_arg_2))) + { + _arg_1 = (_arg_1.clone() as Mesh); + }; + this.faceList = _arg_1.faceList; + this.vertexList = _arg_1.vertexList; + _arg_1.faceList = null; + _arg_1.vertexList = null; + var _local_3:Vertex = this.vertexList; + while (_local_3 != null) + { + _local_3.transformId = 0; + _local_3.id = null; + _local_3 = _local_3.next; + }; + var _local_4:Face = this.faceList; + while (_local_4 != null) + { + _local_4.id = null; + _local_4 = _local_4.next; + }; + var _local_5:String = this.calculateEdges(); + if (_local_5 != null) + { + this.destroyForm(); + throw (new ArgumentError(_local_5)); + }; + calculateBounds(); + } + + public function destroyForm():void + { + this.faceList = null; + this.edgeList = null; + this.vertexList = null; + } + + override public function clone():Object3D + { + var _local_1:Occluder = new Occluder(); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + override protected function clonePropertiesFrom(_arg_1:Object3D):void + { + var _local_3:Vertex; + var _local_4:Face; + var _local_5:Vertex; + var _local_6:Face; + var _local_7:Edge; + var _local_9:Vertex; + var _local_10:Face; + var _local_11:Wrapper; + var _local_12:Wrapper; + var _local_13:Wrapper; + var _local_14:Edge; + super.clonePropertiesFrom(_arg_1); + var _local_2:Occluder = (_arg_1 as Occluder); + this.minSize = _local_2.minSize; + _local_3 = _local_2.vertexList; + while (_local_3 != null) + { + _local_9 = new Vertex(); + _local_9.x = _local_3.x; + _local_9.y = _local_3.y; + _local_9.z = _local_3.z; + _local_9.u = _local_3.u; + _local_9.v = _local_3.v; + _local_9.normalX = _local_3.normalX; + _local_9.normalY = _local_3.normalY; + _local_9.normalZ = _local_3.normalZ; + _local_3.value = _local_9; + if (_local_5 != null) + { + _local_5.next = _local_9; + } else + { + this.vertexList = _local_9; + }; + _local_5 = _local_9; + _local_3 = _local_3.next; + }; + _local_4 = _local_2.faceList; + while (_local_4 != null) + { + _local_10 = new Face(); + _local_10.material = _local_4.material; + _local_10.normalX = _local_4.normalX; + _local_10.normalY = _local_4.normalY; + _local_10.normalZ = _local_4.normalZ; + _local_10.offset = _local_4.offset; + _local_4.processNext = _local_10; + _local_11 = null; + _local_12 = _local_4.wrapper; + while (_local_12 != null) + { + _local_13 = new Wrapper(); + _local_13.vertex = _local_12.vertex.value; + if (_local_11 != null) + { + _local_11.next = _local_13; + } else + { + _local_10.wrapper = _local_13; + }; + _local_11 = _local_13; + _local_12 = _local_12.next; + }; + if (_local_6 != null) + { + _local_6.next = _local_10; + } else + { + this.faceList = _local_10; + }; + _local_6 = _local_10; + _local_4 = _local_4.next; + }; + var _local_8:Edge = _local_2.edgeList; + while (_local_8 != null) + { + _local_14 = new Edge(); + _local_14.a = _local_8.a.value; + _local_14.b = _local_8.b.value; + _local_14.left = _local_8.left.processNext; + _local_14.right = _local_8.right.processNext; + if (_local_7 != null) + { + _local_7.next = _local_14; + } else + { + this.edgeList = _local_14; + }; + _local_7 = _local_14; + _local_8 = _local_8.next; + }; + _local_3 = _local_2.vertexList; + while (_local_3 != null) + { + _local_3.value = null; + _local_3 = _local_3.next; + }; + _local_4 = _local_2.faceList; + while (_local_4 != null) + { + _local_4.processNext = null; + _local_4 = _local_4.next; + }; + } + + private function calculateEdges():String + { + var _local_1:Face; + var _local_2:Wrapper; + var _local_3:Edge; + var _local_4:Vertex; + var _local_5:Vertex; + var _local_6:Number; + var _local_7:Number; + var _local_8:Number; + var _local_9:Number; + var _local_10:Number; + var _local_11:Number; + _local_1 = this.faceList; + while (_local_1 != null) + { + _local_1.calculateBestSequenceAndNormal(); + _local_2 = _local_1.wrapper; + while (_local_2 != null) + { + _local_4 = _local_2.vertex; + _local_5 = ((_local_2.next != null) ? _local_2.next.vertex : _local_1.wrapper.vertex); + _local_3 = this.edgeList; + while (_local_3 != null) + { + if (((_local_3.a == _local_4) && (_local_3.b == _local_5))) + { + return ("The supplied geometry is not valid."); + }; + if (((_local_3.a == _local_5) && (_local_3.b == _local_4))) break; + _local_3 = _local_3.next; + }; + if (_local_3 != null) + { + _local_3.right = _local_1; + } else + { + _local_3 = new Edge(); + _local_3.a = _local_4; + _local_3.b = _local_5; + _local_3.left = _local_1; + _local_3.next = this.edgeList; + this.edgeList = _local_3; + }; + _local_2 = _local_2.next; + _local_4 = _local_5; + }; + _local_1 = _local_1.next; + }; + _local_3 = this.edgeList; + while (_local_3 != null) + { + if (((_local_3.left == null) || (_local_3.right == null))) + { + return ("The supplied geometry is non whole."); + }; + _local_6 = (_local_3.b.x - _local_3.a.x); + _local_7 = (_local_3.b.y - _local_3.a.y); + _local_8 = (_local_3.b.z - _local_3.a.z); + _local_9 = ((_local_3.right.normalZ * _local_3.left.normalY) - (_local_3.right.normalY * _local_3.left.normalZ)); + _local_10 = ((_local_3.right.normalX * _local_3.left.normalZ) - (_local_3.right.normalZ * _local_3.left.normalX)); + _local_11 = ((_local_3.right.normalY * _local_3.left.normalX) - (_local_3.right.normalX * _local_3.left.normalY)); + if ((((_local_6 * _local_9) + (_local_7 * _local_10)) + (_local_8 * _local_11)) < 0) + { + }; + _local_3 = _local_3.next; + }; + return (null); + } + + override alternativa3d function draw(_arg_1:Camera3D):void + { + var _local_2:int; + var _local_3:Sprite; + var _local_6:Vertex; + var _local_11:Vertex; + var _local_12:Vertex; + var _local_13:Number; + var _local_14:Number; + var _local_15:Number; + var _local_16:Number; + var _local_17:Number; + var _local_18:Number; + var _local_19:Number; + var _local_21:Vertex; + var _local_22:Vertex; + var _local_23:Number; + if (((this.faceList == null) || (this.edgeList == null))) + { + return; + }; + calculateInverseMatrix(); + var _local_4:Boolean = true; + var _local_5:Face = this.faceList; + while (_local_5 != null) + { + if ((((_local_5.normalX * imd) + (_local_5.normalY * imh)) + (_local_5.normalZ * iml)) > _local_5.offset) + { + _local_5.distance = 1; + _local_4 = false; + } else + { + _local_5.distance = 0; + }; + _local_5 = _local_5.next; + }; + if (_local_4) + { + return; + }; + var _local_7:int; + var _local_8:Boolean = true; + var _local_9:Number = _arg_1.viewSizeX; + var _local_10:Number = _arg_1.viewSizeY; + var _local_20:Edge = this.edgeList; + for (;_local_20 != null;(_local_20 = _local_20.next)) + { + if (_local_20.left.distance != _local_20.right.distance) + { + if (_local_20.left.distance > 0) + { + _local_11 = _local_20.a; + _local_12 = _local_20.b; + } else + { + _local_11 = _local_20.b; + _local_12 = _local_20.a; + }; + _local_13 = ((((ma * _local_11.x) + (mb * _local_11.y)) + (mc * _local_11.z)) + md); + _local_14 = ((((me * _local_11.x) + (mf * _local_11.y)) + (mg * _local_11.z)) + mh); + _local_15 = ((((mi * _local_11.x) + (mj * _local_11.y)) + (mk * _local_11.z)) + ml); + _local_16 = ((((ma * _local_12.x) + (mb * _local_12.y)) + (mc * _local_12.z)) + md); + _local_17 = ((((me * _local_12.x) + (mf * _local_12.y)) + (mg * _local_12.z)) + mh); + _local_18 = ((((mi * _local_12.x) + (mj * _local_12.y)) + (mk * _local_12.z)) + ml); + if (culling > 0) + { + if (((_local_15 <= -(_local_13)) && (_local_18 <= -(_local_16)))) + { + if (((_local_8) && (((_local_17 * _local_13) - (_local_16 * _local_14)) > 0))) + { + _local_8 = false; + }; + continue; + }; + if (((_local_18 > -(_local_16)) && (_local_15 <= -(_local_13)))) + { + _local_19 = ((_local_13 + _local_15) / (((_local_13 + _local_15) - _local_16) - _local_18)); + _local_13 = (_local_13 + ((_local_16 - _local_13) * _local_19)); + _local_14 = (_local_14 + ((_local_17 - _local_14) * _local_19)); + _local_15 = (_local_15 + ((_local_18 - _local_15) * _local_19)); + } else + { + if (((_local_18 <= -(_local_16)) && (_local_15 > -(_local_13)))) + { + _local_19 = ((_local_13 + _local_15) / (((_local_13 + _local_15) - _local_16) - _local_18)); + _local_16 = (_local_13 + ((_local_16 - _local_13) * _local_19)); + _local_17 = (_local_14 + ((_local_17 - _local_14) * _local_19)); + _local_18 = (_local_15 + ((_local_18 - _local_15) * _local_19)); + }; + }; + if (((_local_15 <= _local_13) && (_local_18 <= _local_16))) + { + if (((_local_8) && (((_local_17 * _local_13) - (_local_16 * _local_14)) > 0))) + { + _local_8 = false; + }; + continue; + }; + if (((_local_18 > _local_16) && (_local_15 <= _local_13))) + { + _local_19 = ((_local_15 - _local_13) / (((_local_15 - _local_13) + _local_16) - _local_18)); + _local_13 = (_local_13 + ((_local_16 - _local_13) * _local_19)); + _local_14 = (_local_14 + ((_local_17 - _local_14) * _local_19)); + _local_15 = (_local_15 + ((_local_18 - _local_15) * _local_19)); + } else + { + if (((_local_18 <= _local_16) && (_local_15 > _local_13))) + { + _local_19 = ((_local_15 - _local_13) / (((_local_15 - _local_13) + _local_16) - _local_18)); + _local_16 = (_local_13 + ((_local_16 - _local_13) * _local_19)); + _local_17 = (_local_14 + ((_local_17 - _local_14) * _local_19)); + _local_18 = (_local_15 + ((_local_18 - _local_15) * _local_19)); + }; + }; + if (((_local_15 <= -(_local_14)) && (_local_18 <= -(_local_17)))) + { + if (((_local_8) && (((_local_17 * _local_13) - (_local_16 * _local_14)) > 0))) + { + _local_8 = false; + }; + continue; + }; + if (((_local_18 > -(_local_17)) && (_local_15 <= -(_local_14)))) + { + _local_19 = ((_local_14 + _local_15) / (((_local_14 + _local_15) - _local_17) - _local_18)); + _local_13 = (_local_13 + ((_local_16 - _local_13) * _local_19)); + _local_14 = (_local_14 + ((_local_17 - _local_14) * _local_19)); + _local_15 = (_local_15 + ((_local_18 - _local_15) * _local_19)); + } else + { + if (((_local_18 <= -(_local_17)) && (_local_15 > -(_local_14)))) + { + _local_19 = ((_local_14 + _local_15) / (((_local_14 + _local_15) - _local_17) - _local_18)); + _local_16 = (_local_13 + ((_local_16 - _local_13) * _local_19)); + _local_17 = (_local_14 + ((_local_17 - _local_14) * _local_19)); + _local_18 = (_local_15 + ((_local_18 - _local_15) * _local_19)); + }; + }; + if (((_local_15 <= _local_14) && (_local_18 <= _local_17))) + { + if (((_local_8) && (((_local_17 * _local_13) - (_local_16 * _local_14)) > 0))) + { + _local_8 = false; + }; + continue; + }; + if (((_local_18 > _local_17) && (_local_15 <= _local_14))) + { + _local_19 = ((_local_15 - _local_14) / (((_local_15 - _local_14) + _local_17) - _local_18)); + _local_13 = (_local_13 + ((_local_16 - _local_13) * _local_19)); + _local_14 = (_local_14 + ((_local_17 - _local_14) * _local_19)); + _local_15 = (_local_15 + ((_local_18 - _local_15) * _local_19)); + } else + { + if (((_local_18 <= _local_17) && (_local_15 > _local_14))) + { + _local_19 = ((_local_15 - _local_14) / (((_local_15 - _local_14) + _local_17) - _local_18)); + _local_16 = (_local_13 + ((_local_16 - _local_13) * _local_19)); + _local_17 = (_local_14 + ((_local_17 - _local_14) * _local_19)); + _local_18 = (_local_15 + ((_local_18 - _local_15) * _local_19)); + }; + }; + _local_8 = false; + }; + _local_11 = _local_11.create(); + _local_11.next = _local_6; + _local_7++; + _local_6 = _local_11; + _local_6.cameraX = ((_local_18 * _local_14) - (_local_17 * _local_15)); + _local_6.cameraY = ((_local_16 * _local_15) - (_local_18 * _local_13)); + _local_6.cameraZ = ((_local_17 * _local_13) - (_local_16 * _local_14)); + _local_6.x = _local_13; + _local_6.y = _local_14; + _local_6.z = _local_15; + _local_6.u = _local_16; + _local_6.v = _local_17; + _local_6.offset = _local_18; + }; + }; + if (_local_6 != null) + { + if (this.minSize > 0) + { + _local_21 = Vertex.createList(_local_7); + _local_11 = _local_6; + _local_12 = _local_21; + while (_local_11 != null) + { + _local_12.x = ((_local_11.x * _local_9) / _local_11.z); + _local_12.y = ((_local_11.y * _local_10) / _local_11.z); + _local_12.u = ((_local_11.u * _local_9) / _local_11.offset); + _local_12.v = ((_local_11.v * _local_10) / _local_11.offset); + _local_12.cameraX = (_local_12.y - _local_12.v); + _local_12.cameraY = (_local_12.u - _local_12.x); + _local_12.offset = ((_local_12.cameraX * _local_12.x) + (_local_12.cameraY * _local_12.y)); + _local_11 = _local_11.next; + _local_12 = _local_12.next; + }; + if (culling > 0) + { + if ((culling & 0x04)) + { + _local_13 = -(_arg_1.viewSizeX); + _local_14 = -(_arg_1.viewSizeY); + _local_16 = -(_arg_1.viewSizeX); + _local_17 = _arg_1.viewSizeY; + _local_11 = _local_21; + while (_local_11 != null) + { + _local_15 = (((_local_13 * _local_11.cameraX) + (_local_14 * _local_11.cameraY)) - _local_11.offset); + _local_18 = (((_local_16 * _local_11.cameraX) + (_local_17 * _local_11.cameraY)) - _local_11.offset); + if (((_local_15 < 0) || (_local_18 < 0))) + { + if (((_local_15 >= 0) && (_local_18 < 0))) + { + _local_19 = (_local_15 / (_local_15 - _local_18)); + _local_13 = (_local_13 + ((_local_16 - _local_13) * _local_19)); + _local_14 = (_local_14 + ((_local_17 - _local_14) * _local_19)); + } else + { + if (((_local_15 < 0) && (_local_18 >= 0))) + { + _local_19 = (_local_15 / (_local_15 - _local_18)); + _local_16 = (_local_13 + ((_local_16 - _local_13) * _local_19)); + _local_17 = (_local_14 + ((_local_17 - _local_14) * _local_19)); + }; + }; + } else + { + break; + }; + _local_11 = _local_11.next; + }; + if (_local_11 == null) + { + _local_12 = _local_6.create(); + _local_12.next = _local_22; + _local_22 = _local_12; + _local_22.x = _local_13; + _local_22.y = _local_14; + _local_22.u = _local_16; + _local_22.v = _local_17; + }; + }; + if ((culling & 0x08)) + { + _local_13 = _arg_1.viewSizeX; + _local_14 = _arg_1.viewSizeY; + _local_16 = _arg_1.viewSizeX; + _local_17 = -(_arg_1.viewSizeY); + _local_11 = _local_21; + while (_local_11 != null) + { + _local_15 = (((_local_13 * _local_11.cameraX) + (_local_14 * _local_11.cameraY)) - _local_11.offset); + _local_18 = (((_local_16 * _local_11.cameraX) + (_local_17 * _local_11.cameraY)) - _local_11.offset); + if (((_local_15 < 0) || (_local_18 < 0))) + { + if (((_local_15 >= 0) && (_local_18 < 0))) + { + _local_19 = (_local_15 / (_local_15 - _local_18)); + _local_13 = (_local_13 + ((_local_16 - _local_13) * _local_19)); + _local_14 = (_local_14 + ((_local_17 - _local_14) * _local_19)); + } else + { + if (((_local_15 < 0) && (_local_18 >= 0))) + { + _local_19 = (_local_15 / (_local_15 - _local_18)); + _local_16 = (_local_13 + ((_local_16 - _local_13) * _local_19)); + _local_17 = (_local_14 + ((_local_17 - _local_14) * _local_19)); + }; + }; + } else + { + break; + }; + _local_11 = _local_11.next; + }; + if (_local_11 == null) + { + _local_12 = _local_6.create(); + _local_12.next = _local_22; + _local_22 = _local_12; + _local_22.x = _local_13; + _local_22.y = _local_14; + _local_22.u = _local_16; + _local_22.v = _local_17; + }; + }; + if ((culling & 0x10)) + { + _local_13 = _arg_1.viewSizeX; + _local_14 = -(_arg_1.viewSizeY); + _local_16 = -(_arg_1.viewSizeX); + _local_17 = -(_arg_1.viewSizeY); + _local_11 = _local_21; + while (_local_11 != null) + { + _local_15 = (((_local_13 * _local_11.cameraX) + (_local_14 * _local_11.cameraY)) - _local_11.offset); + _local_18 = (((_local_16 * _local_11.cameraX) + (_local_17 * _local_11.cameraY)) - _local_11.offset); + if (((_local_15 < 0) || (_local_18 < 0))) + { + if (((_local_15 >= 0) && (_local_18 < 0))) + { + _local_19 = (_local_15 / (_local_15 - _local_18)); + _local_13 = (_local_13 + ((_local_16 - _local_13) * _local_19)); + _local_14 = (_local_14 + ((_local_17 - _local_14) * _local_19)); + } else + { + if (((_local_15 < 0) && (_local_18 >= 0))) + { + _local_19 = (_local_15 / (_local_15 - _local_18)); + _local_16 = (_local_13 + ((_local_16 - _local_13) * _local_19)); + _local_17 = (_local_14 + ((_local_17 - _local_14) * _local_19)); + }; + }; + } else + { + break; + }; + _local_11 = _local_11.next; + }; + if (_local_11 == null) + { + _local_12 = _local_6.create(); + _local_12.next = _local_22; + _local_22 = _local_12; + _local_22.x = _local_13; + _local_22.y = _local_14; + _local_22.u = _local_16; + _local_22.v = _local_17; + }; + }; + if ((culling & 0x20)) + { + _local_13 = -(_arg_1.viewSizeX); + _local_14 = _arg_1.viewSizeY; + _local_16 = _arg_1.viewSizeX; + _local_17 = _arg_1.viewSizeY; + _local_11 = _local_21; + while (_local_11 != null) + { + _local_15 = (((_local_13 * _local_11.cameraX) + (_local_14 * _local_11.cameraY)) - _local_11.offset); + _local_18 = (((_local_16 * _local_11.cameraX) + (_local_17 * _local_11.cameraY)) - _local_11.offset); + if (((_local_15 < 0) || (_local_18 < 0))) + { + if (((_local_15 >= 0) && (_local_18 < 0))) + { + _local_19 = (_local_15 / (_local_15 - _local_18)); + _local_13 = (_local_13 + ((_local_16 - _local_13) * _local_19)); + _local_14 = (_local_14 + ((_local_17 - _local_14) * _local_19)); + } else + { + if (((_local_15 < 0) && (_local_18 >= 0))) + { + _local_19 = (_local_15 / (_local_15 - _local_18)); + _local_16 = (_local_13 + ((_local_16 - _local_13) * _local_19)); + _local_17 = (_local_14 + ((_local_17 - _local_14) * _local_19)); + }; + }; + } else + { + break; + }; + _local_11 = _local_11.next; + }; + if (_local_11 == null) + { + _local_12 = _local_6.create(); + _local_12.next = _local_22; + _local_22 = _local_12; + _local_22.x = _local_13; + _local_22.y = _local_14; + _local_22.u = _local_16; + _local_22.v = _local_17; + }; + }; + }; + _local_23 = 0; + _local_15 = _local_21.x; + _local_18 = _local_21.y; + _local_11 = _local_21; + while (_local_11.next != null) + { + _local_11 = _local_11.next; + }; + _local_11.next = _local_22; + _local_11 = _local_21; + while (_local_11 != null) + { + _local_23 = (_local_23 + (((_local_11.u - _local_15) * (_local_11.y - _local_18)) - ((_local_11.v - _local_18) * (_local_11.x - _local_15)))); + if (_local_11.next == null) break; + _local_11 = _local_11.next; + }; + _local_11.next = Vertex.collector; + Vertex.collector = _local_21; + if ((_local_23 / ((_arg_1.viewSizeX * _arg_1.viewSizeY) * 8)) < this.minSize) + { + _local_11 = _local_6; + while (_local_11.next != null) + { + _local_11 = _local_11.next; + }; + _local_11.next = Vertex.collector; + Vertex.collector = _local_6; + return; + }; + }; + if (((_arg_1.debug) && ((_local_2 = _arg_1.checkInDebug(this)) > 0))) + { + if ((_local_2 & Debug.EDGES)) + { + _local_11 = _local_6; + while (_local_11 != null) + { + _local_13 = ((_local_11.x * _local_9) / _local_11.z); + _local_14 = ((_local_11.y * _local_10) / _local_11.z); + _local_16 = ((_local_11.u * _local_9) / _local_11.offset); + _local_17 = ((_local_11.v * _local_10) / _local_11.offset); + _local_3 = _arg_1.view.canvas; + _local_3.graphics.moveTo(_local_13, _local_14); + _local_3.graphics.lineStyle(3, 0xFF); + _local_3.graphics.lineTo((_local_13 + ((_local_16 - _local_13) * 0.8)), (_local_14 + ((_local_17 - _local_14) * 0.8))); + _local_3.graphics.lineStyle(3, 0xFF0000); + _local_3.graphics.lineTo(_local_16, _local_17); + _local_11 = _local_11.next; + }; + }; + if ((_local_2 & Debug.BOUNDS)) + { + Debug.drawBounds(_arg_1, this, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ); + }; + }; + _arg_1.occluders[_arg_1.numOccluders] = _local_6; + _arg_1.numOccluders++; + } else + { + if (_local_8) + { + if (((_arg_1.debug) && ((_local_2 = _arg_1.checkInDebug(this)) > 0))) + { + if ((_local_2 & Debug.EDGES)) + { + _local_19 = 1.5; + _local_3 = _arg_1.view.canvas; + _local_3.graphics.moveTo((-(_local_9) + _local_19), (-(_local_10) + _local_19)); + _local_3.graphics.lineStyle(3, 0xFF); + _local_3.graphics.lineTo((-(_local_9) + _local_19), (_local_10 * 0.6)); + _local_3.graphics.lineStyle(3, 0xFF0000); + _local_3.graphics.lineTo((-(_local_9) + _local_19), (_local_10 - _local_19)); + _local_3.graphics.lineStyle(3, 0xFF); + _local_3.graphics.lineTo((_local_9 * 0.6), (_local_10 - _local_19)); + _local_3.graphics.lineStyle(3, 0xFF0000); + _local_3.graphics.lineTo((_local_9 - _local_19), (_local_10 - _local_19)); + _local_3.graphics.lineStyle(3, 0xFF); + _local_3.graphics.lineTo((_local_9 - _local_19), (-(_local_10) * 0.6)); + _local_3.graphics.lineStyle(3, 0xFF0000); + _local_3.graphics.lineTo((_local_9 - _local_19), (-(_local_10) + _local_19)); + _local_3.graphics.lineStyle(3, 0xFF); + _local_3.graphics.lineTo((-(_local_9) * 0.6), (-(_local_10) + _local_19)); + _local_3.graphics.lineStyle(3, 0xFF0000); + _local_3.graphics.lineTo((-(_local_9) + _local_19), (-(_local_10) + _local_19)); + }; + if ((_local_2 & Debug.BOUNDS)) + { + Debug.drawBounds(_arg_1, this, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ); + }; + }; + _arg_1.clearOccluders(); + _arg_1.occludedAll = true; + }; + }; + } + + override alternativa3d function updateBounds(_arg_1:Object3D, _arg_2:Object3D=null):void + { + var _local_3:Vertex = this.vertexList; + while (_local_3 != null) + { + if (_arg_2 != null) + { + _local_3.cameraX = ((((_arg_2.ma * _local_3.x) + (_arg_2.mb * _local_3.y)) + (_arg_2.mc * _local_3.z)) + _arg_2.md); + _local_3.cameraY = ((((_arg_2.me * _local_3.x) + (_arg_2.mf * _local_3.y)) + (_arg_2.mg * _local_3.z)) + _arg_2.mh); + _local_3.cameraZ = ((((_arg_2.mi * _local_3.x) + (_arg_2.mj * _local_3.y)) + (_arg_2.mk * _local_3.z)) + _arg_2.ml); + } else + { + _local_3.cameraX = _local_3.x; + _local_3.cameraY = _local_3.y; + _local_3.cameraZ = _local_3.z; + }; + if (_local_3.cameraX < _arg_1.boundMinX) + { + _arg_1.boundMinX = _local_3.cameraX; + }; + if (_local_3.cameraX > _arg_1.boundMaxX) + { + _arg_1.boundMaxX = _local_3.cameraX; + }; + if (_local_3.cameraY < _arg_1.boundMinY) + { + _arg_1.boundMinY = _local_3.cameraY; + }; + if (_local_3.cameraY > _arg_1.boundMaxY) + { + _arg_1.boundMaxY = _local_3.cameraY; + }; + if (_local_3.cameraZ < _arg_1.boundMinZ) + { + _arg_1.boundMinZ = _local_3.cameraZ; + }; + if (_local_3.cameraZ > _arg_1.boundMaxZ) + { + _arg_1.boundMaxZ = _local_3.cameraZ; + }; + _local_3 = _local_3.next; + }; + } + + + } +}//package alternativa.engine3d.objects + +import alternativa.engine3d.core.Vertex; +import alternativa.engine3d.core.Face; + +class Edge +{ + + public var next:Edge; + public var a:Vertex; + public var b:Vertex; + public var left:Face; + public var right:Face; + + +} diff --git a/src/alternativa/engine3d/objects/Skin.as b/src/alternativa/engine3d/objects/Skin.as new file mode 100644 index 0000000..792f261 --- /dev/null +++ b/src/alternativa/engine3d/objects/Skin.as @@ -0,0 +1,1024 @@ +package alternativa.engine3d.objects +{ + import alternativa.engine3d.core.Face; + import __AS3__.vec.Vector; + import alternativa.engine3d.core.Vertex; + import alternativa.engine3d.materials.Material; + import flash.utils.Dictionary; + import alternativa.engine3d.core.RayIntersectionData; + import flash.geom.Vector3D; + import alternativa.engine3d.core.Camera3D; + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.core.Debug; + import alternativa.engine3d.core.VG; + import alternativa.engine3d.core.Wrapper; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class Skin extends Mesh + { + + alternativa3d var jointList:Joint; + alternativa3d var localList:Face; + + public function Skin() + { + shadowMapAlphaThreshold = 100; + } + + public function addJoint(_arg_1:Joint):Joint + { + var _local_2:Joint; + if (_arg_1 == null) + { + throw (new TypeError("Parameter joint must be non-null.")); + }; + if (_arg_1._parentJoint != null) + { + _arg_1._parentJoint.removeChild(_arg_1); + } else + { + if (_arg_1._skin != null) + { + _arg_1._skin.removeJoint(_arg_1); + }; + }; + _arg_1._parentJoint = null; + _arg_1.setSkin(this); + if (this.jointList == null) + { + this.jointList = _arg_1; + } else + { + _local_2 = this.jointList; + while (_local_2 != null) + { + if (_local_2.nextJoint == null) + { + _local_2.nextJoint = _arg_1; + break; + }; + _local_2 = _local_2.nextJoint; + }; + }; + return (_arg_1); + } + + public function removeJoint(_arg_1:Joint):Joint + { + var _local_2:Joint; + var _local_3:Joint; + if (_arg_1 == null) + { + throw (new TypeError("Parameter joint must be non-null.")); + }; + if (((!(_arg_1._parentJoint == null)) || (!(_arg_1._skin == this)))) + { + throw (new ArgumentError("The supplied Joint must be contained in the caller.")); + }; + _local_3 = this.jointList; + while (_local_3 != null) + { + if (_local_3 == _arg_1) + { + if (_local_2 != null) + { + _local_2.nextJoint = _local_3.nextJoint; + } else + { + this.jointList = _local_3.nextJoint; + }; + _local_3.nextJoint = null; + _local_3._parentJoint = null; + _local_3.setSkin(null); + return (_arg_1); + }; + _local_2 = _local_3; + _local_3 = _local_3.nextJoint; + }; + return (null); + } + + public function getJointAt(_arg_1:int):Joint + { + if (_arg_1 < 0) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + var _local_2:Joint = this.jointList; + var _local_3:int; + while (_local_3 < _arg_1) + { + if (_local_2 == null) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + _local_2 = _local_2.nextJoint; + _local_3++; + }; + if (_local_2 == null) + { + throw (new RangeError("The supplied index is out of bounds.")); + }; + return (_local_2); + } + + public function get numJoints():int + { + var _local_1:int; + var _local_2:Joint = this.jointList; + while (_local_2 != null) + { + _local_1++; + _local_2 = _local_2.nextJoint; + }; + return (_local_1); + } + + public function getJointByName(_arg_1:String):Joint + { + var _local_4:Joint; + var _local_6:int; + var _local_7:Vector.; + var _local_8:Joint; + if (_arg_1 == null) + { + throw (new TypeError("Parameter name must be non-null.")); + }; + var _local_2:Vector. = new Vector.(); + var _local_3:Vector. = new Vector.(); + _local_4 = this.jointList; + while (_local_4 != null) + { + if (_local_4.name == _arg_1) + { + return (_local_4); + }; + _local_2.push(_local_4); + _local_4 = _local_4.nextJoint; + }; + var _local_5:int = this.numJoints; + while (_local_5 > 0) + { + _local_6 = 0; + while (_local_6 < _local_5) + { + _local_4 = _local_2[_local_6]; + _local_8 = _local_4.childrenList; + while (_local_8 != null) + { + if (_local_8.name == _arg_1) + { + return (_local_8); + }; + if (_local_8.childrenList != null) + { + _local_3.push(_local_8); + }; + _local_8 = _local_8.nextJoint; + }; + _local_6++; + }; + _local_7 = _local_2; + _local_2 = _local_3; + _local_3 = _local_7; + _local_3.length = 0; + _local_5 = _local_2.length; + }; + return (null); + } + + override public function addVertex(_arg_1:Number, _arg_2:Number, _arg_3:Number, _arg_4:Number=0, _arg_5:Number=0, _arg_6:Object=null):Vertex + { + this.clearLocal(); + return (super.addVertex(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6)); + } + + override public function removeVertex(_arg_1:Vertex):Vertex + { + this.clearLocal(); + var _local_2:Vertex = super.removeVertex(_arg_1); + var _local_3:Joint = this.jointList; + while (_local_3 != null) + { + this.unbindVertex(_local_3, _local_2); + _local_3 = _local_3.nextJoint; + }; + return (_local_2); + } + + override public function removeVertexById(_arg_1:Object):Vertex + { + this.clearLocal(); + var _local_2:Vertex = super.removeVertexById(_arg_1); + var _local_3:Joint = this.jointList; + while (_local_3 != null) + { + this.unbindVertex(_local_3, _local_2); + _local_3 = _local_3.nextJoint; + }; + return (_local_2); + } + + private function unbindVertex(_arg_1:Joint, _arg_2:Vertex):void + { + _arg_1.unbindVertex(_arg_2); + var _local_3:Joint = _arg_1.childrenList; + while (_local_3 != null) + { + this.unbindVertex(_local_3, _arg_2); + _local_3 = _local_3.nextJoint; + }; + } + + override public function addFace(_arg_1:Vector., _arg_2:Material=null, _arg_3:Object=null):Face + { + this.clearLocal(); + return (super.addFace(_arg_1, _arg_2, _arg_3)); + } + + override public function addFaceByIds(_arg_1:Array, _arg_2:Material=null, _arg_3:Object=null):Face + { + this.clearLocal(); + return (super.addFaceByIds(_arg_1, _arg_2, _arg_3)); + } + + override public function addTriFace(_arg_1:Vertex, _arg_2:Vertex, _arg_3:Vertex, _arg_4:Material=null, _arg_5:Object=null):Face + { + this.clearLocal(); + return (super.addTriFace(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5)); + } + + override public function addQuadFace(_arg_1:Vertex, _arg_2:Vertex, _arg_3:Vertex, _arg_4:Vertex, _arg_5:Material=null, _arg_6:Object=null):Face + { + this.clearLocal(); + return (super.addQuadFace(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6)); + } + + override public function removeFace(_arg_1:Face):Face + { + this.clearLocal(); + return (super.removeFace(_arg_1)); + } + + override public function removeFaceById(_arg_1:Object):Face + { + this.clearLocal(); + return (super.removeFaceById(_arg_1)); + } + + override public function addVerticesAndFaces(_arg_1:Vector., _arg_2:Vector., _arg_3:Vector., _arg_4:Boolean=false, _arg_5:Material=null):void + { + this.clearLocal(); + super.addVerticesAndFaces(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5); + } + + override public function weldVertices(_arg_1:Number=0, _arg_2:Number=0):void + { + var _local_3:Vertex; + var _local_5:*; + var _local_6:Joint; + this.clearLocal(); + var _local_4:Dictionary = new Dictionary(); + _local_3 = vertexList; + while (_local_3 != null) + { + _local_4[_local_3] = true; + _local_3 = _local_3.next; + }; + super.weldVertices(_arg_1, _arg_2); + _local_3 = vertexList; + while (_local_3 != null) + { + delete _local_4[_local_3]; + _local_3 = _local_3.next; + }; + for (_local_5 in _local_4) + { + _local_3 = _local_5; + _local_6 = this.jointList; + while (_local_6 != null) + { + this.unbindVertex(_local_6, _local_3); + _local_6 = _local_6.nextJoint; + }; + }; + } + + override public function weldFaces(_arg_1:Number=0, _arg_2:Number=0, _arg_3:Number=0, _arg_4:Boolean=false):void + { + this.clearLocal(); + super.weldFaces(_arg_1, _arg_2, _arg_3, _arg_4); + } + + override public function optimizeForDynamicBSP(_arg_1:int=1):void + { + this.clearLocal(); + super.optimizeForDynamicBSP(_arg_1); + } + + public function calculateBindingMatrices():void + { + ma = 1; + mb = 0; + mc = 0; + md = 0; + me = 0; + mf = 1; + mg = 0; + mh = 0; + mi = 0; + mj = 0; + mk = 1; + ml = 0; + var _local_1:Joint = this.jointList; + while (_local_1 != null) + { + _local_1.calculateBindingMatrix(this); + _local_1 = _local_1.nextJoint; + }; + } + + public function normalizeWeights():void + { + var _local_2:Joint; + var _local_1:Vertex = vertexList; + while (_local_1 != null) + { + _local_1.offset = 0; + _local_1 = _local_1.next; + }; + _local_2 = this.jointList; + while (_local_2 != null) + { + _local_2.addWeights(); + _local_2 = _local_2.nextJoint; + }; + _local_2 = this.jointList; + while (_local_2 != null) + { + _local_2.normalizeWeights(); + _local_2 = _local_2.nextJoint; + }; + } + + override public function intersectRay(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Dictionary=null, _arg_4:Camera3D=null):RayIntersectionData + { + var _local_7:Face; + var _local_8:Face; + if (((!(_arg_3 == null)) && (_arg_3[this]))) + { + return (null); + }; + if ((!(boundIntersectRay(_arg_1, _arg_2, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ)))) + { + return (null); + }; + this.updateLocal(); + var _local_5:Face = faceList; + faceList = this.localList; + calculateFacesNormals(true); + var _local_6:RayIntersectionData = super.intersectRay(_arg_1, _arg_2, _arg_3, _arg_4); + faceList = _local_5; + if (_local_6 != null) + { + _local_7 = faceList; + _local_8 = this.localList; + while (_local_7 != null) + { + if (_local_8 == _local_6.face) + { + _local_6.face = _local_7; + break; + }; + _local_7 = _local_7.next; + _local_8 = _local_8.next; + }; + }; + return (_local_6); + } + + override alternativa3d function checkIntersection(_arg_1:Number, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Dictionary):Boolean + { + this.updateLocal(); + var _local_9:Face = faceList; + faceList = this.localList; + calculateFacesNormals(true); + var _local_10:Boolean = super.checkIntersection(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7, _arg_8); + faceList = _local_9; + return (_local_10); + } + + override alternativa3d function collectPlanes(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Vector3D, _arg_4:Vector3D, _arg_5:Vector3D, _arg_6:Vector., _arg_7:Dictionary=null):void + { + if (((!(_arg_7 == null)) && (_arg_7[this]))) + { + return; + }; + var _local_8:Vector3D = calculateSphere(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5); + if ((!(boundIntersectSphere(_local_8, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ)))) + { + return; + }; + var _local_9:Face = faceList; + faceList = this.localList; + calculateFacesNormals(true); + super.collectPlanes(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7); + faceList = _local_9; + } + + public function attach(_arg_1:Skin):void + { + var _local_3:Vertex; + var _local_4:Face; + var _local_5:Joint; + this.clearLocal(); + _arg_1.clearLocal(); + if (vertexList == null) + { + vertexList = _arg_1.vertexList; + } else + { + _local_3 = vertexList; + while (_local_3.next != null) + { + _local_3 = _local_3.next; + }; + _local_3.next = _arg_1.vertexList; + }; + _arg_1.vertexList = null; + if (faceList == null) + { + faceList = _arg_1.faceList; + } else + { + _local_4 = faceList; + while (_local_4.next != null) + { + _local_4 = _local_4.next; + }; + _local_4.next = _arg_1.faceList; + }; + _arg_1.faceList = null; + var _local_2:Joint = _arg_1.jointList; + while (_local_2 != null) + { + if (((_local_2.name == null) || (_local_2.name == ""))) + { + this.addJointFast(_local_2); + } else + { + _local_5 = this.getJointByName(_local_2.name); + if (_local_5 != null) + { + this.mergeJoints(_local_2, _local_5); + } else + { + this.addJointFast(_local_2); + }; + }; + _local_2 = _local_2.nextJoint; + }; + _arg_1.jointList = null; + } + + private function addJointFast(_arg_1:Joint):Joint + { + var _local_2:Joint; + _arg_1._parentJoint = null; + _arg_1.setSkinFast(this); + if (this.jointList == null) + { + this.jointList = _arg_1; + } else + { + _local_2 = this.jointList; + while (_local_2 != null) + { + if (_local_2.nextJoint == null) + { + _local_2.nextJoint = _arg_1; + break; + }; + _local_2 = _local_2.nextJoint; + }; + }; + return (_arg_1); + } + + private function mergeJoints(_arg_1:Joint, _arg_2:Joint):void + { + var _local_5:Joint; + var _local_3:VertexBinding = _arg_1.vertexBindingList; + if (_local_3 != null) + { + while (_local_3.next != null) + { + _local_3 = _local_3.next; + }; + _local_3.next = _arg_2.vertexBindingList; + _arg_2.vertexBindingList = _arg_1.vertexBindingList; + }; + _arg_1.vertexBindingList = null; + var _local_4:Joint = _arg_1.childrenList; + while (_local_4 != null) + { + if (((_local_4.name == null) || (_local_4.name.length == 0))) + { + _arg_2.addChildFast(_local_4); + } else + { + _local_5 = this.findJointChildByName(_local_4.name, _arg_2); + if (_local_5 != null) + { + this.mergeJoints(_local_4, _local_5); + } else + { + _arg_2.addChildFast(_local_4); + }; + }; + _local_4 = _local_4.nextJoint; + }; + _arg_1.childrenList = null; + } + + private function findJointChildByName(_arg_1:String, _arg_2:Joint):Joint + { + var _local_3:Joint = _arg_2.childrenList; + while (_local_3 != null) + { + if (_local_3.name == _arg_1) + { + return (_local_3); + }; + _local_3 = _local_3.nextJoint; + }; + return (null); + } + + override public function clone():Object3D + { + this.clearLocal(); + var _local_1:Skin = new Skin(); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + override protected function clonePropertiesFrom(_arg_1:Object3D):void + { + var _local_3:Vertex; + var _local_4:Vertex; + var _local_6:Joint; + var _local_7:Joint; + super.clonePropertiesFrom(_arg_1); + var _local_2:Skin = (_arg_1 as Skin); + _local_3 = _local_2.vertexList; + _local_4 = vertexList; + while (_local_3 != null) + { + _local_3.value = _local_4; + _local_3 = _local_3.next; + _local_4 = _local_4.next; + }; + var _local_5:Joint = _local_2.jointList; + while (_local_5 != null) + { + _local_7 = this.cloneJoint(_local_5); + if (this.jointList != null) + { + _local_6.nextJoint = _local_7; + } else + { + this.jointList = _local_7; + }; + _local_6 = _local_7; + _local_7._parentJoint = null; + _local_7.setSkinFast(this); + _local_5 = _local_5.nextJoint; + }; + _local_3 = _local_2.vertexList; + while (_local_3 != null) + { + _local_3.value = null; + _local_3 = _local_3.next; + }; + } + + override alternativa3d function draw(_arg_1:Camera3D):void + { + var _local_4:Vertex; + var _local_5:Joint; + if (faceList == null) + { + return; + }; + if (clipping == 0) + { + if ((culling & 0x01)) + { + return; + }; + culling = 0; + }; + var _local_2:int = ((_arg_1.debug) ? _arg_1.checkInDebug(this) : 0); + if ((_local_2 & Debug.BOUNDS)) + { + Debug.drawBounds(_arg_1, this, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ); + }; + if (transformId > 0x1DCD6500) + { + transformId = 0; + _local_4 = vertexList; + while (_local_4 != null) + { + _local_4.transformId = 0; + _local_4 = _local_4.next; + }; + }; + transformId++; + calculateInverseMatrix(); + var _local_3:Face = this.prepareFaces(_arg_1, this.localList); + if (_local_3 == null) + { + return; + }; + if (culling > 0) + { + if (clipping == 1) + { + _local_3 = _arg_1.cull(_local_3, culling); + } else + { + _local_3 = _arg_1.clip(_local_3, culling); + }; + if (_local_3 == null) + { + return; + }; + }; + if (_local_3.processNext != null) + { + if (sorting == 1) + { + _local_3 = _arg_1.sortByAverageZ(_local_3); + } else + { + if (sorting == 2) + { + _local_3 = _arg_1.sortByDynamicBSP(_local_3, threshold); + }; + }; + }; + if ((_local_2 & Debug.BONES)) + { + _local_5 = this.jointList; + while (_local_5 != null) + { + _local_5.drawDebug(_arg_1); + _local_5 = _local_5.nextJoint; + }; + }; + if ((_local_2 & Debug.EDGES)) + { + Debug.drawEdges(_arg_1, _local_3, 0xFFFFFF); + }; + drawFaces(_arg_1, _local_3); + } + + override alternativa3d function getVG(_arg_1:Camera3D):VG + { + var _local_4:Joint; + var _local_5:Vertex; + var _local_6:Face; + var _local_7:Face; + var _local_8:Face; + if (faceList == null) + { + return (null); + }; + if (clipping == 0) + { + if ((culling & 0x01)) + { + return (null); + }; + culling = 0; + }; + var _local_2:int = ((_arg_1.debug) ? _arg_1.checkInDebug(this) : 0); + if ((_local_2 & Debug.BONES)) + { + _local_4 = this.jointList; + while (_local_4 != null) + { + _local_4.drawDebug(_arg_1); + _local_4 = _local_4.nextJoint; + }; + }; + if (transformId > 0x1DCD6500) + { + transformId = 0; + _local_5 = vertexList; + while (_local_5 != null) + { + _local_5.transformId = 0; + _local_5 = _local_5.next; + }; + }; + transformId++; + calculateInverseMatrix(); + var _local_3:Face = this.prepareFaces(_arg_1, this.localList); + if (_local_3 == null) + { + return (null); + }; + if (culling > 0) + { + if (clipping == 1) + { + _local_3 = _arg_1.cull(_local_3, culling); + } else + { + _local_3 = _arg_1.clip(_local_3, culling); + }; + if (_local_3 == null) + { + return (null); + }; + }; + if (((concatenatedAlpha >= 1) && (concatenatedBlendMode == "normal"))) + { + _local_8 = null; + _local_6 = _local_3; + _local_3 = null; + while (_local_6 != null) + { + _local_7 = _local_6.processNext; + if (((!(_local_6.material == null)) && (!(_local_6.material.transparent)))) + { + _local_6.processNext = _local_8; + _local_8 = _local_6; + } else + { + _local_6.processNext = _local_3; + _local_3 = _local_6; + }; + _local_6 = _local_7; + }; + _local_6 = _local_8; + while (_local_6 != null) + { + _local_7 = _local_6.processNext; + if (((_local_7 == null) || (!(_local_7.material == _local_8.material)))) + { + _local_6.processNext = null; + _arg_1.addTransparentOpaque(_local_8, this); + _local_8 = _local_7; + }; + _local_6 = _local_7; + }; + if (_local_3 == null) + { + return (null); + }; + }; + return (VG.create(this, _local_3, sorting, _local_2, false)); + } + + override alternativa3d function prepareFaces(_arg_1:Camera3D, _arg_2:Face):Face + { + var _local_4:Wrapper; + var _local_5:Vertex; + var _local_6:Vertex; + var _local_7:Vertex; + var _local_8:Number; + var _local_9:Number; + var _local_10:Number; + var _local_11:Number; + var _local_12:Number; + var _local_13:Number; + var _local_14:Number; + var _local_15:Number; + var _local_16:Number; + this.updateLocal(); + var _local_3:Face = _arg_2; + while (_local_3 != null) + { + _local_4 = _local_3.wrapper; + _local_5 = _local_4.vertex; + _local_4 = _local_4.next; + _local_6 = _local_4.vertex; + _local_4 = _local_4.next; + _local_7 = _local_4.vertex; + _local_8 = (_local_6.x - _local_5.x); + _local_9 = (_local_6.y - _local_5.y); + _local_10 = (_local_6.z - _local_5.z); + _local_11 = (_local_7.x - _local_5.x); + _local_12 = (_local_7.y - _local_5.y); + _local_13 = (_local_7.z - _local_5.z); + _local_14 = ((_local_13 * _local_9) - (_local_12 * _local_10)); + _local_15 = ((_local_11 * _local_10) - (_local_13 * _local_8)); + _local_16 = ((_local_12 * _local_8) - (_local_11 * _local_9)); + _local_3.normalX = _local_14; + _local_3.normalY = _local_15; + _local_3.normalZ = _local_16; + _local_3.offset = (((_local_5.x * _local_14) + (_local_5.y * _local_15)) + (_local_5.z * _local_16)); + _local_3 = _local_3.next; + }; + return (super.prepareFaces(_arg_1, _arg_2)); + } + + override alternativa3d function prepareResources():void + { + } + + override alternativa3d function deleteResources():void + { + } + + alternativa3d function updateLocal():void + { + var _local_1:Vertex; + var _local_2:Face; + var _local_3:Face; + var _local_6:Face; + var _local_7:Wrapper; + var _local_8:Wrapper; + var _local_9:Wrapper; + var _local_10:Material; + var _local_11:Vertex; + if (this.localList == null) + { + _local_1 = vertexList; + while (_local_1 != null) + { + _local_1.value = new Vertex(); + _local_1 = _local_1.next; + }; + _local_2 = faceList; + while (_local_2 != null) + { + _local_3 = new Face(); + _local_7 = null; + _local_8 = _local_2.wrapper; + while (_local_8 != null) + { + _local_9 = new Wrapper(); + _local_9.vertex = _local_8.vertex.value; + if (_local_7 != null) + { + _local_7.next = _local_9; + } else + { + _local_3.wrapper = _local_9; + }; + _local_7 = _local_9; + _local_8 = _local_8.next; + }; + if (_local_6 != null) + { + _local_6.next = _local_3; + } else + { + this.localList = _local_3; + }; + _local_6 = _local_3; + _local_2 = _local_2.next; + }; + }; + var _local_4:Boolean; + _local_2 = faceList; + _local_3 = this.localList; + while (_local_2 != null) + { + _local_10 = _local_2.material; + _local_4 = ((_local_4) || ((!(_local_10 == null)) && (_local_10.useVerticesNormals))); + _local_3.material = _local_2.material; + _local_2 = _local_2.next; + _local_3 = _local_3.next; + }; + _local_1 = vertexList; + while (_local_1 != null) + { + _local_11 = _local_1.value; + _local_11.x = 0; + _local_11.y = 0; + _local_11.z = 0; + _local_11.u = _local_1.u; + _local_11.v = _local_1.v; + _local_11.normalX = 0; + _local_11.normalY = 0; + _local_11.normalZ = 0; + _local_11.drawId = 0; + _local_1 = _local_1.next; + }; + var _local_5:Joint = this.jointList; + while (_local_5 != null) + { + _local_5.composeMatrix(); + _local_5.calculateVertices(_local_4, false); + _local_5 = _local_5.nextJoint; + }; + } + + alternativa3d function clearLocal():void + { + var _local_1:Vertex = vertexList; + while (_local_1 != null) + { + _local_1.value = null; + _local_1 = _local_1.next; + }; + this.localList = null; + } + + override alternativa3d function updateBounds(_arg_1:Object3D, _arg_2:Object3D=null):void + { + this.updateLocal(); + var _local_3:Face = faceList; + faceList = this.localList; + super.updateBounds(_arg_1, _arg_2); + faceList = _local_3; + } + + override alternativa3d function split(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Vector3D, _arg_4:Number):Vector. + { + return (new Vector.(2)); + } + + private function cloneJoint(_arg_1:Joint):Joint + { + var _local_3:VertexBinding; + var _local_6:Joint; + var _local_7:VertexBinding; + var _local_8:Joint; + var _local_2:Joint = new Joint(); + _local_2.name = _arg_1.name; + _local_2.x = _arg_1.x; + _local_2.y = _arg_1.y; + _local_2.z = _arg_1.z; + _local_2.rotationX = _arg_1.rotationX; + _local_2.rotationY = _arg_1.rotationY; + _local_2.rotationZ = _arg_1.rotationZ; + _local_2.scaleX = _arg_1.scaleX; + _local_2.scaleY = _arg_1.scaleY; + _local_2.scaleZ = _arg_1.scaleZ; + _local_2.bma = _arg_1.bma; + _local_2.bmb = _arg_1.bmb; + _local_2.bmc = _arg_1.bmc; + _local_2.bmd = _arg_1.bmd; + _local_2.bme = _arg_1.bme; + _local_2.bmf = _arg_1.bmf; + _local_2.bmg = _arg_1.bmg; + _local_2.bmh = _arg_1.bmh; + _local_2.bmi = _arg_1.bmi; + _local_2.bmj = _arg_1.bmj; + _local_2.bmk = _arg_1.bmk; + _local_2.bml = _arg_1.bml; + if ((_arg_1 is Bone)) + { + Bone(_local_2).length = Bone(_arg_1).length; + Bone(_local_2).distance = Bone(_arg_1).distance; + Bone(_local_2).lx = Bone(_arg_1).lx; + Bone(_local_2).ly = Bone(_arg_1).ly; + Bone(_local_2).lz = Bone(_arg_1).lz; + Bone(_local_2).ldot = Bone(_arg_1).ldot; + }; + var _local_4:VertexBinding = _arg_1.vertexBindingList; + while (_local_4 != null) + { + _local_7 = new VertexBinding(); + _local_7.vertex = _local_4.vertex.value; + _local_7.weight = _local_4.weight; + if (_local_3 != null) + { + _local_3.next = _local_7; + } else + { + _local_2.vertexBindingList = _local_7; + }; + _local_3 = _local_7; + _local_4 = _local_4.next; + }; + var _local_5:Joint = _arg_1.childrenList; + while (_local_5 != null) + { + _local_8 = this.cloneJoint(_local_5); + if (_local_2.childrenList != null) + { + _local_6.nextJoint = _local_8; + } else + { + _local_2.childrenList = _local_8; + }; + _local_6 = _local_8; + _local_8._parentJoint = _local_2; + _local_5 = _local_5.nextJoint; + }; + return (_local_2); + } + + + } +}//package alternativa.engine3d.objects \ No newline at end of file diff --git a/src/alternativa/engine3d/objects/SkyBox.as b/src/alternativa/engine3d/objects/SkyBox.as new file mode 100644 index 0000000..eb76a02 --- /dev/null +++ b/src/alternativa/engine3d/objects/SkyBox.as @@ -0,0 +1,421 @@ +package alternativa.engine3d.objects +{ + import alternativa.engine3d.core.Face; + import __AS3__.vec.Vector; + import alternativa.engine3d.core.Vertex; + import alternativa.engine3d.core.Clipping; + import alternativa.engine3d.core.Sorting; + import alternativa.engine3d.materials.Material; + import alternativa.engine3d.core.Wrapper; + import flash.geom.Point; + import flash.geom.Matrix; + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.core.Debug; + import alternativa.engine3d.core.Camera3D; + import flash.utils.Dictionary; + import alternativa.gfx.core.VertexBufferResource; + import alternativa.gfx.core.IndexBufferResource; + import alternativa.engine3d.core.VG; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class SkyBox extends Mesh + { + + public static const LEFT:String = "left"; + public static const RIGHT:String = "right"; + public static const BACK:String = "back"; + public static const FRONT:String = "front"; + public static const BOTTOM:String = "bottom"; + public static const TOP:String = "top"; + + private var leftFace:Face; + private var rightFace:Face; + private var backFace:Face; + private var frontFace:Face; + private var bottomFace:Face; + private var topFace:Face; + public var autoSize:Boolean = true; + alternativa3d var reduceConst:Vector. = Vector.([0, 0, 0, 1]); + + public function SkyBox(_arg_1:Number, _arg_2:Material=null, _arg_3:Material=null, _arg_4:Material=null, _arg_5:Material=null, _arg_6:Material=null, _arg_7:Material=null, _arg_8:Number=0) + { + _arg_1 = (_arg_1 * 0.5); + var _local_9:Vertex = this.createVertex(-(_arg_1), -(_arg_1), _arg_1, _arg_8, _arg_8); + var _local_10:Vertex = this.createVertex(-(_arg_1), -(_arg_1), -(_arg_1), _arg_8, (1 - _arg_8)); + var _local_11:Vertex = this.createVertex(-(_arg_1), _arg_1, -(_arg_1), (1 - _arg_8), (1 - _arg_8)); + var _local_12:Vertex = this.createVertex(-(_arg_1), _arg_1, _arg_1, (1 - _arg_8), _arg_8); + this.leftFace = this.createQuad(_local_9, _local_10, _local_11, _local_12, _arg_2); + _local_9 = this.createVertex(_arg_1, _arg_1, _arg_1, _arg_8, _arg_8); + _local_10 = this.createVertex(_arg_1, _arg_1, -(_arg_1), _arg_8, (1 - _arg_8)); + _local_11 = this.createVertex(_arg_1, -(_arg_1), -(_arg_1), (1 - _arg_8), (1 - _arg_8)); + _local_12 = this.createVertex(_arg_1, -(_arg_1), _arg_1, (1 - _arg_8), _arg_8); + this.rightFace = this.createQuad(_local_9, _local_10, _local_11, _local_12, _arg_3); + _local_9 = this.createVertex(_arg_1, -(_arg_1), _arg_1, _arg_8, _arg_8); + _local_10 = this.createVertex(_arg_1, -(_arg_1), -(_arg_1), _arg_8, (1 - _arg_8)); + _local_11 = this.createVertex(-(_arg_1), -(_arg_1), -(_arg_1), (1 - _arg_8), (1 - _arg_8)); + _local_12 = this.createVertex(-(_arg_1), -(_arg_1), _arg_1, (1 - _arg_8), _arg_8); + this.backFace = this.createQuad(_local_9, _local_10, _local_11, _local_12, _arg_4); + _local_9 = this.createVertex(-(_arg_1), _arg_1, _arg_1, _arg_8, _arg_8); + _local_10 = this.createVertex(-(_arg_1), _arg_1, -(_arg_1), _arg_8, (1 - _arg_8)); + _local_11 = this.createVertex(_arg_1, _arg_1, -(_arg_1), (1 - _arg_8), (1 - _arg_8)); + _local_12 = this.createVertex(_arg_1, _arg_1, _arg_1, (1 - _arg_8), _arg_8); + this.frontFace = this.createQuad(_local_9, _local_10, _local_11, _local_12, _arg_5); + _local_9 = this.createVertex(-(_arg_1), _arg_1, -(_arg_1), _arg_8, _arg_8); + _local_10 = this.createVertex(-(_arg_1), -(_arg_1), -(_arg_1), _arg_8, (1 - _arg_8)); + _local_11 = this.createVertex(_arg_1, -(_arg_1), -(_arg_1), (1 - _arg_8), (1 - _arg_8)); + _local_12 = this.createVertex(_arg_1, _arg_1, -(_arg_1), (1 - _arg_8), _arg_8); + this.bottomFace = this.createQuad(_local_9, _local_10, _local_11, _local_12, _arg_6); + _local_9 = this.createVertex(-(_arg_1), -(_arg_1), _arg_1, _arg_8, _arg_8); + _local_10 = this.createVertex(-(_arg_1), _arg_1, _arg_1, _arg_8, (1 - _arg_8)); + _local_11 = this.createVertex(_arg_1, _arg_1, _arg_1, (1 - _arg_8), (1 - _arg_8)); + _local_12 = this.createVertex(_arg_1, -(_arg_1), _arg_1, (1 - _arg_8), _arg_8); + this.topFace = this.createQuad(_local_9, _local_10, _local_11, _local_12, _arg_7); + calculateBounds(); + calculateFacesNormals(true); + clipping = Clipping.FACE_CLIPPING; + sorting = Sorting.NONE; + shadowMapAlphaThreshold = 100; + } + + public function getSide(_arg_1:String):Face + { + switch (_arg_1) + { + case LEFT: + return (this.leftFace); + case RIGHT: + return (this.rightFace); + case BACK: + return (this.backFace); + case FRONT: + return (this.frontFace); + case BOTTOM: + return (this.bottomFace); + case TOP: + return (this.topFace); + }; + return (null); + } + + public function transformUV(_arg_1:String, _arg_2:Matrix):void + { + var _local_4:Wrapper; + var _local_5:Vertex; + var _local_6:Point; + var _local_3:Face = this.getSide(_arg_1); + if (_local_3 != null) + { + _local_4 = _local_3.wrapper; + while (_local_4 != null) + { + _local_5 = _local_4.vertex; + _local_6 = _arg_2.transformPoint(new Point(_local_5.u, _local_5.v)); + _local_5.u = _local_6.x; + _local_5.v = _local_6.y; + _local_4 = _local_4.next; + }; + }; + } + + override public function clone():Object3D + { + var _local_1:SkyBox = new SkyBox(0); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + override protected function clonePropertiesFrom(_arg_1:Object3D):void + { + super.clonePropertiesFrom(_arg_1); + var _local_2:SkyBox = (_arg_1 as SkyBox); + this.autoSize = _local_2.autoSize; + var _local_3:Face = _local_2.faceList; + var _local_4:Face = faceList; + while (_local_3 != null) + { + if (_local_3 == _local_2.leftFace) + { + this.leftFace = _local_4; + } else + { + if (_local_3 == _local_2.rightFace) + { + this.rightFace = _local_4; + } else + { + if (_local_3 == _local_2.backFace) + { + this.backFace = _local_4; + } else + { + if (_local_3 == _local_2.frontFace) + { + this.frontFace = _local_4; + } else + { + if (_local_3 == _local_2.bottomFace) + { + this.bottomFace = _local_4; + } else + { + if (_local_3 == _local_2.topFace) + { + this.topFace = _local_4; + }; + }; + }; + }; + }; + }; + _local_3 = _local_3.next; + _local_4 = _local_4.next; + }; + } + + private function createVertex(_arg_1:Number, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number):Vertex + { + var _local_6:Vertex = new Vertex(); + _local_6.next = vertexList; + vertexList = _local_6; + _local_6.x = _arg_1; + _local_6.y = _arg_2; + _local_6.z = _arg_3; + _local_6.u = _arg_4; + _local_6.v = _arg_5; + return (_local_6); + } + + private function createQuad(_arg_1:Vertex, _arg_2:Vertex, _arg_3:Vertex, _arg_4:Vertex, _arg_5:Material):Face + { + var _local_6:Face = new Face(); + _local_6.material = _arg_5; + _local_6.next = faceList; + faceList = _local_6; + _local_6.wrapper = new Wrapper(); + _local_6.wrapper.vertex = _arg_1; + _local_6.wrapper.next = new Wrapper(); + _local_6.wrapper.next.vertex = _arg_2; + _local_6.wrapper.next.next = new Wrapper(); + _local_6.wrapper.next.next.vertex = _arg_3; + _local_6.wrapper.next.next.next = new Wrapper(); + _local_6.wrapper.next.next.next.vertex = _arg_4; + return (_local_6); + } + + override alternativa3d function draw(_arg_1:Camera3D):void + { + if (faceList == null) + { + return; + }; + if (this.autoSize) + { + this.calculateTransform(_arg_1); + }; + if (clipping == 0) + { + if ((culling & 0x01)) + { + return; + }; + culling = 0; + }; + this.prepareResources(); + this.addOpaque(_arg_1); + transformConst[0] = ma; + transformConst[1] = mb; + transformConst[2] = mc; + transformConst[3] = md; + transformConst[4] = me; + transformConst[5] = mf; + transformConst[6] = mg; + transformConst[7] = mh; + transformConst[8] = mi; + transformConst[9] = mj; + transformConst[10] = mk; + transformConst[11] = ml; + var _local_2:int = ((_arg_1.debug) ? _arg_1.checkInDebug(this) : 0); + if ((_local_2 & Debug.BOUNDS)) + { + Debug.drawBounds(_arg_1, this, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ); + }; + } + + override alternativa3d function prepareResources():void + { + var _local_1:Vector.; + var _local_2:int; + var _local_3:int; + var _local_4:Vertex; + var _local_5:int; + var _local_6:int; + var _local_7:int; + var _local_8:Face; + var _local_9:Array; + var _local_10:Wrapper; + var _local_11:Dictionary; + var _local_12:Vector.; + var _local_13:int; + var _local_14:*; + if (vertexBuffer == null) + { + _local_1 = new Vector.(); + _local_2 = 0; + _local_3 = 0; + _local_4 = vertexList; + while (_local_4 != null) + { + _local_1[_local_2] = _local_4.x; + _local_2++; + _local_1[_local_2] = _local_4.y; + _local_2++; + _local_1[_local_2] = _local_4.z; + _local_2++; + _local_1[_local_2] = _local_4.u; + _local_2++; + _local_1[_local_2] = _local_4.v; + _local_2++; + _local_1[_local_2] = _local_4.normalX; + _local_2++; + _local_1[_local_2] = _local_4.normalY; + _local_2++; + _local_1[_local_2] = _local_4.normalZ; + _local_2++; + _local_4.index = _local_3; + _local_3++; + _local_4 = _local_4.next; + }; + if (_local_3 > 0) + { + vertexBuffer = new VertexBufferResource(_local_1, 8); + }; + _local_11 = new Dictionary(); + _local_8 = faceList; + while (_local_8 != null) + { + if (_local_8.material != null) + { + _local_9 = _local_11[_local_8.material]; + if (_local_9 == null) + { + _local_9 = new Array(); + _local_11[_local_8.material] = _local_9; + }; + _local_9.push(_local_8); + }; + _local_8 = _local_8.next; + }; + _local_12 = new Vector.(); + _local_13 = 0; + for (_local_14 in _local_11) + { + _local_9 = _local_11[_local_14]; + opaqueMaterials[opaqueLength] = _local_14; + opaqueBegins[opaqueLength] = (numTriangles * 3); + for each (_local_8 in _local_9) + { + _local_10 = _local_8.wrapper; + _local_5 = _local_10.vertex.index; + _local_10 = _local_10.next; + _local_6 = _local_10.vertex.index; + _local_10 = _local_10.next; + while (_local_10 != null) + { + _local_7 = _local_10.vertex.index; + _local_12[_local_13] = _local_5; + _local_13++; + _local_12[_local_13] = _local_6; + _local_13++; + _local_12[_local_13] = _local_7; + _local_13++; + _local_6 = _local_7; + numTriangles++; + _local_10 = _local_10.next; + }; + }; + opaqueNums[opaqueLength] = (numTriangles - (opaqueBegins[opaqueLength] / 3)); + opaqueLength++; + }; + if (_local_13 > 0) + { + indexBuffer = new IndexBufferResource(_local_12); + }; + }; + } + + override alternativa3d function addOpaque(_arg_1:Camera3D):void + { + var _local_2:int; + while (_local_2 < opaqueLength) + { + _arg_1.addSky(opaqueMaterials[_local_2], vertexBuffer, indexBuffer, opaqueBegins[_local_2], opaqueNums[_local_2], this); + _local_2++; + }; + } + + override alternativa3d function getVG(_arg_1:Camera3D):VG + { + this.draw(_arg_1); + return (null); + } + + override alternativa3d function cullingInCamera(_arg_1:Camera3D, _arg_2:int):int + { + return (super.cullingInCamera(_arg_1, (_arg_2 = (_arg_2 & (~(0x03)))))); + } + + private function calculateTransform(_arg_1:Camera3D):void + { + var _local_2:Number = ((((mi * boundMinX) + (mj * boundMinY)) + (mk * boundMinZ)) + ml); + var _local_3:Number = _local_2; + _local_2 = ((((mi * boundMaxX) + (mj * boundMinY)) + (mk * boundMinZ)) + ml); + if (_local_2 > _local_3) + { + _local_3 = _local_2; + }; + _local_2 = ((((mi * boundMaxX) + (mj * boundMaxY)) + (mk * boundMinZ)) + ml); + if (_local_2 > _local_3) + { + _local_3 = _local_2; + }; + _local_2 = ((((mi * boundMinX) + (mj * boundMaxY)) + (mk * boundMinZ)) + ml); + if (_local_2 > _local_3) + { + _local_3 = _local_2; + }; + _local_2 = ((((mi * boundMinX) + (mj * boundMinY)) + (mk * boundMaxZ)) + ml); + if (_local_2 > _local_3) + { + _local_3 = _local_2; + }; + _local_2 = ((((mi * boundMaxX) + (mj * boundMinY)) + (mk * boundMaxZ)) + ml); + if (_local_2 > _local_3) + { + _local_3 = _local_2; + }; + _local_2 = ((((mi * boundMaxX) + (mj * boundMaxY)) + (mk * boundMaxZ)) + ml); + if (_local_2 > _local_3) + { + _local_3 = _local_2; + }; + _local_2 = ((((mi * boundMinX) + (mj * boundMaxY)) + (mk * boundMaxZ)) + ml); + if (_local_2 > _local_3) + { + _local_3 = _local_2; + }; + var _local_4:Number = 1; + if (_local_3 > _arg_1.farClipping) + { + _local_4 = (_arg_1.farClipping / _local_3); + }; + this.reduceConst[0] = _local_4; + this.reduceConst[1] = _local_4; + this.reduceConst[2] = _local_4; + } + + + } +}//package alternativa.engine3d.objects \ No newline at end of file diff --git a/src/alternativa/engine3d/objects/Sprite3D.as b/src/alternativa/engine3d/objects/Sprite3D.as new file mode 100644 index 0000000..5614cd1 --- /dev/null +++ b/src/alternativa/engine3d/objects/Sprite3D.as @@ -0,0 +1,805 @@ +package alternativa.engine3d.objects +{ + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.materials.Material; + import __AS3__.vec.Vector; + import alternativa.engine3d.core.RayIntersectionData; + import alternativa.engine3d.core.Vertex; + import flash.geom.Vector3D; + import alternativa.engine3d.core.Face; + import alternativa.engine3d.core.Wrapper; + import flash.utils.Dictionary; + import alternativa.engine3d.core.Camera3D; + import alternativa.engine3d.core.Debug; + import alternativa.engine3d.core.VG; + import alternativa.engine3d.lights.OmniLight; + import alternativa.engine3d.lights.SpotLight; + import alternativa.engine3d.lights.TubeLight; + import flash.display.BitmapData; + import alternativa.engine3d.materials.TextureMaterial; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class Sprite3D extends Object3D + { + + public var material:Material; + public var originX:Number = 0.5; + public var originY:Number = 0.5; + public var sorting:int = 0; + public var clipping:int = 2; + public var rotation:Number = 0; + public var autoSize:Boolean = false; + public var width:Number; + public var height:Number; + public var perspectiveScale:Boolean = true; + public var topLeftU:Number = 0; + public var topLeftV:Number = 0; + public var bottomRightU:Number = 1; + public var bottomRightV:Number = 1; + public var depthTest:Boolean = true; + alternativa3d var lightConst:Vector. = Vector.([0, 0, 0, 1]); + alternativa3d var lighted:Boolean; + + public function Sprite3D(_arg_1:Number, _arg_2:Number, _arg_3:Material=null) + { + this.width = _arg_1; + this.height = _arg_2; + this.material = _arg_3; + shadowMapAlphaThreshold = 100; + } + + override public function intersectRay(_arg_1:Vector3D, _arg_2:Vector3D, _arg_3:Dictionary=null, _arg_4:Camera3D=null):RayIntersectionData + { + var _local_5:RayIntersectionData; + var _local_24:Vertex; + var _local_25:Number; + var _local_26:Number; + var _local_27:Number; + var _local_28:Number; + var _local_29:Number; + var _local_30:Vector3D; + if (((_arg_4 == null) || ((!(_arg_3 == null)) && (_arg_3[this])))) + { + return (null); + }; + _arg_4.composeCameraMatrix(); + var _local_6:Object3D = _arg_4; + while (_local_6._parent != null) + { + _local_6 = _local_6._parent; + _local_6.composeMatrix(); + _arg_4.appendMatrix(_local_6); + }; + _arg_4.invertMatrix(); + composeMatrix(); + _local_6 = this; + while (_local_6._parent != null) + { + _local_6 = _local_6._parent; + _local_6.composeMatrix(); + appendMatrix(_local_6); + }; + appendMatrix(_arg_4); + calculateInverseMatrix(); + var _local_7:Number = _arg_4.nearClipping; + var _local_8:Number = _arg_4.farClipping; + _arg_4.nearClipping = -(Number.MAX_VALUE); + _arg_4.farClipping = Number.MAX_VALUE; + culling = 0; + var _local_9:Face = this.calculateFace(_arg_4); + _arg_4.nearClipping = _local_7; + _arg_4.farClipping = _local_8; + var _local_10:Wrapper = _local_9.wrapper; + while (_local_10 != null) + { + _local_24 = _local_10.vertex; + _local_24.x = ((((ima * _local_24.cameraX) + (imb * _local_24.cameraY)) + (imc * _local_24.cameraZ)) + imd); + _local_24.y = ((((ime * _local_24.cameraX) + (imf * _local_24.cameraY)) + (img * _local_24.cameraZ)) + imh); + _local_24.z = ((((imi * _local_24.cameraX) + (imj * _local_24.cameraY)) + (imk * _local_24.cameraZ)) + iml); + _local_10 = _local_10.next; + }; + var _local_11:Wrapper = _local_9.wrapper; + var _local_12:Vertex = _local_11.vertex; + _local_11 = _local_11.next; + var _local_13:Vertex = _local_11.vertex; + _local_11 = _local_11.next; + var _local_14:Vertex = _local_11.vertex; + _local_11 = _local_11.next; + var _local_15:Vertex = _local_11.vertex; + _local_12.u = this.topLeftU; + _local_12.v = this.topLeftV; + _local_13.u = this.topLeftU; + _local_13.v = this.bottomRightV; + _local_14.u = this.bottomRightU; + _local_14.v = this.bottomRightV; + _local_15.u = this.bottomRightU; + _local_15.v = this.topLeftV; + var _local_16:Number = (_local_13.x - _local_12.x); + var _local_17:Number = (_local_13.y - _local_12.y); + var _local_18:Number = (_local_13.z - _local_12.z); + var _local_19:Number = (_local_14.x - _local_12.x); + var _local_20:Number = (_local_14.y - _local_12.y); + var _local_21:Number = (_local_14.z - _local_12.z); + _local_9.normalX = ((_local_21 * _local_17) - (_local_20 * _local_18)); + _local_9.normalY = ((_local_19 * _local_18) - (_local_21 * _local_16)); + _local_9.normalZ = ((_local_20 * _local_16) - (_local_19 * _local_17)); + var _local_22:Number = (1 / Math.sqrt((((_local_9.normalX * _local_9.normalX) + (_local_9.normalY * _local_9.normalY)) + (_local_9.normalZ * _local_9.normalZ)))); + _local_9.normalX = (_local_9.normalX * _local_22); + _local_9.normalY = (_local_9.normalY * _local_22); + _local_9.normalZ = (_local_9.normalZ * _local_22); + _local_9.offset = (((_local_12.x * _local_9.normalX) + (_local_12.y * _local_9.normalY)) + (_local_12.z * _local_9.normalZ)); + var _local_23:Number = (((_arg_2.x * _local_9.normalX) + (_arg_2.y * _local_9.normalY)) + (_arg_2.z * _local_9.normalZ)); + if (_local_23 < 0) + { + _local_25 = ((((_arg_1.x * _local_9.normalX) + (_arg_1.y * _local_9.normalY)) + (_arg_1.z * _local_9.normalZ)) - _local_9.offset); + if (_local_25 > 0) + { + _local_26 = (-(_local_25) / _local_23); + _local_27 = (_arg_1.x + (_arg_2.x * _local_26)); + _local_28 = (_arg_1.y + (_arg_2.y * _local_26)); + _local_29 = (_arg_1.z + (_arg_2.z * _local_26)); + _local_10 = _local_9.wrapper; + while (_local_10 != null) + { + _local_12 = _local_10.vertex; + _local_13 = ((_local_10.next != null) ? _local_10.next.vertex : _local_9.wrapper.vertex); + _local_16 = (_local_13.x - _local_12.x); + _local_17 = (_local_13.y - _local_12.y); + _local_18 = (_local_13.z - _local_12.z); + _local_19 = (_local_27 - _local_12.x); + _local_20 = (_local_28 - _local_12.y); + _local_21 = (_local_29 - _local_12.z); + if ((((((_local_21 * _local_17) - (_local_20 * _local_18)) * _local_9.normalX) + (((_local_19 * _local_18) - (_local_21 * _local_16)) * _local_9.normalY)) + (((_local_20 * _local_16) - (_local_19 * _local_17)) * _local_9.normalZ)) < 0) break; + _local_10 = _local_10.next; + }; + if (_local_10 == null) + { + _local_30 = new Vector3D(_local_27, _local_28, _local_29); + _local_5 = new RayIntersectionData(); + _local_5.object = this; + _local_5.face = null; + _local_5.point = _local_30; + _local_5.uv = _local_9.getUV(_local_30); + _local_5.time = _local_26; + }; + }; + }; + _arg_4.deferredDestroy(); + return (_local_5); + } + + override public function clone():Object3D + { + var _local_1:Sprite3D = new Sprite3D(this.width, this.height); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + override protected function clonePropertiesFrom(_arg_1:Object3D):void + { + super.clonePropertiesFrom(_arg_1); + var _local_2:Sprite3D = (_arg_1 as Sprite3D); + this.width = _local_2.width; + this.height = _local_2.height; + this.autoSize = _local_2.autoSize; + this.material = _local_2.material; + this.clipping = _local_2.clipping; + this.sorting = _local_2.sorting; + this.originX = _local_2.originX; + this.originY = _local_2.originY; + this.topLeftU = _local_2.topLeftU; + this.topLeftV = _local_2.topLeftV; + this.bottomRightU = _local_2.bottomRightU; + this.bottomRightV = _local_2.bottomRightV; + this.rotation = _local_2.rotation; + this.perspectiveScale = _local_2.perspectiveScale; + } + + override alternativa3d function draw(_arg_1:Camera3D):void + { + var _local_2:int; + if (this.material == null) + { + return; + }; + var _local_3:Face = this.calculateFace(_arg_1); + if (_local_3 != null) + { + this.lighted = false; + if (((((useLight) && (!(_arg_1.view.constrained))) && (_arg_1.deferredLighting)) && (_arg_1.deferredLightingStrength > 0))) + { + this.calculateLight(_arg_1); + }; + if (((_arg_1.debug) && ((_local_2 = _arg_1.checkInDebug(this)) > 0))) + { + if ((_local_2 & Debug.EDGES)) + { + Debug.drawEdges(_arg_1, _local_3, 0xFFFFFF); + }; + if ((_local_2 & Debug.BOUNDS)) + { + Debug.drawBounds(_arg_1, this, boundMinX, boundMinY, boundMinZ, boundMaxX, boundMaxY, boundMaxZ); + }; + }; + _arg_1.addTransparent(_local_3, this); + }; + } + + override alternativa3d function getVG(_arg_1:Camera3D):VG + { + if (this.material == null) + { + return (null); + }; + var _local_2:Face = this.calculateFace(_arg_1); + if (_local_2 != null) + { + this.lighted = false; + if (((((useLight) && (!(_arg_1.view.constrained))) && (_arg_1.deferredLighting)) && (_arg_1.deferredLightingStrength > 0))) + { + this.calculateLight(_arg_1); + }; + _local_2.normalX = 0; + _local_2.normalY = 0; + _local_2.normalZ = -1; + _local_2.offset = -(ml); + return (VG.create(this, _local_2, this.sorting, ((_arg_1.debug) ? _arg_1.checkInDebug(this) : 0), true)); + }; + return (null); + } + + private function calculateLight(_arg_1:Camera3D):void + { + var _local_4:int; + var _local_5:Number; + var _local_6:Number; + var _local_7:Number; + var _local_8:Number; + var _local_9:Number; + var _local_10:Number; + var _local_11:Number; + var _local_12:Number; + var _local_20:OmniLight; + var _local_21:SpotLight; + var _local_22:Number; + var _local_23:Number; + var _local_24:TubeLight; + var _local_25:Number; + var _local_26:Number; + var _local_27:Number; + var _local_28:Number; + var _local_29:Number; + var _local_30:Number; + var _local_2:Number = (_arg_1.viewSizeX / _arg_1.focalLength); + var _local_3:Number = (_arg_1.viewSizeY / _arg_1.focalLength); + if (((!(_arg_1.view.constrained)) && (((!(_arg_1.directionalLight == null)) && (_arg_1.directionalLightStrength > 0)) || ((!(_arg_1.shadowMap == null)) && (_arg_1.shadowMapStrength > 0))))) + { + this.lightConst[0] = 0; + this.lightConst[1] = 0; + this.lightConst[2] = 0; + } else + { + this.lightConst[0] = 1; + this.lightConst[1] = 1; + this.lightConst[2] = 1; + }; + var _local_13:Number = (md * _local_2); + var _local_14:Number = (mh * _local_3); + var _local_15:Number = ml; + var _local_16:Number = Math.sqrt((((_local_13 * _local_13) + (_local_14 * _local_14)) + (_local_15 * _local_15))); + var _local_17:Number = (-(_local_13) / _local_16); + var _local_18:Number = (-(_local_14) / _local_16); + var _local_19:Number = (-(_local_15) / _local_16); + _local_4 = 0; + while (_local_4 < _arg_1.omniesCount) + { + _local_20 = _arg_1.omnies[_local_4]; + _local_5 = (_local_20.cmd * _local_2); + _local_6 = (_local_20.cmh * _local_3); + _local_7 = _local_20.cml; + _local_8 = _local_20.attenuationEnd; + if ((((((((_local_5 - _local_8) < _local_13) && ((_local_5 + _local_8) > _local_13)) && ((_local_6 - _local_8) < _local_14)) && ((_local_6 + _local_8) > _local_14)) && ((_local_7 - _local_8) < _local_15)) && ((_local_7 + _local_8) > _local_15))) + { + _local_5 = (_local_5 - _local_13); + _local_6 = (_local_6 - _local_14); + _local_7 = (_local_7 - _local_15); + _local_16 = Math.sqrt((((_local_5 * _local_5) + (_local_6 * _local_6)) + (_local_7 * _local_7))); + if (((_local_16 > 0) && (_local_16 < _local_8))) + { + _local_5 = (_local_5 / _local_16); + _local_6 = (_local_6 / _local_16); + _local_7 = (_local_7 / _local_16); + _local_9 = ((_local_8 - _local_16) / (_local_20.attenuationEnd - _local_20.attenuationBegin)); + if (_local_9 > 1) + { + _local_9 = 1; + }; + if (_local_9 < 0) + { + _local_9 = 0; + }; + _local_9 = (_local_9 * _local_9); + _local_11 = (((_local_5 * _local_17) + (_local_6 * _local_18)) + (_local_7 * _local_19)); + _local_11 = (_local_11 * 0.5); + _local_11 = (_local_11 + 0.5); + _local_12 = ((((_local_9 * _local_11) * _local_20.intensity) * 2) * _arg_1.deferredLightingStrength); + this.lightConst[0] = (this.lightConst[0] + ((_local_12 * ((_local_20.color >> 16) & 0xFF)) / 0xFF)); + this.lightConst[1] = (this.lightConst[1] + ((_local_12 * ((_local_20.color >> 8) & 0xFF)) / 0xFF)); + this.lightConst[2] = (this.lightConst[2] + ((_local_12 * (_local_20.color & 0xFF)) / 0xFF)); + this.lighted = true; + }; + }; + _local_4++; + }; + _local_4 = 0; + while (_local_4 < _arg_1.spotsCount) + { + _local_21 = _arg_1.spots[_local_4]; + _local_5 = (_local_21.cmd * _local_2); + _local_6 = (_local_21.cmh * _local_3); + _local_7 = _local_21.cml; + _local_8 = _local_21.attenuationEnd; + if ((((((((_local_5 - _local_8) < _local_13) && ((_local_5 + _local_8) > _local_13)) && ((_local_6 - _local_8) < _local_14)) && ((_local_6 + _local_8) > _local_14)) && ((_local_7 - _local_8) < _local_15)) && ((_local_7 + _local_8) > _local_15))) + { + _local_5 = (_local_5 - _local_13); + _local_6 = (_local_6 - _local_14); + _local_7 = (_local_7 - _local_15); + _local_16 = Math.sqrt((((_local_5 * _local_5) + (_local_6 * _local_6)) + (_local_7 * _local_7))); + if (((_local_16 > 0) && (_local_16 < _local_8))) + { + _local_5 = (_local_5 / _local_16); + _local_6 = (_local_6 / _local_16); + _local_7 = (_local_7 / _local_16); + _local_22 = ((((-(_local_5) * _local_21.cmc) * _local_2) - ((_local_6 * _local_21.cmg) * _local_3)) - (_local_7 * _local_21.cmk)); + _local_23 = Math.cos((_local_21.falloff * 0.5)); + if (_local_22 > _local_23) + { + _local_11 = (((_local_5 * _local_17) + (_local_6 * _local_18)) + (_local_7 * _local_19)); + _local_11 = (_local_11 * 0.5); + _local_11 = (_local_11 + 0.5); + _local_9 = ((_local_8 - _local_16) / (_local_21.attenuationEnd - _local_21.attenuationBegin)); + if (_local_9 > 1) + { + _local_9 = 1; + }; + if (_local_9 < 0) + { + _local_9 = 0; + }; + _local_9 = (_local_9 * _local_9); + _local_10 = ((_local_22 - _local_23) / (Math.cos((_local_21.hotspot * 0.5)) - _local_23)); + if (_local_10 > 1) + { + _local_10 = 1; + }; + if (_local_10 < 0) + { + _local_10 = 0; + }; + _local_10 = (_local_10 * _local_10); + _local_12 = (((((_local_9 * _local_10) * _local_11) * _local_21.intensity) * 2) * _arg_1.deferredLightingStrength); + this.lightConst[0] = (this.lightConst[0] + ((_local_12 * ((_local_21.color >> 16) & 0xFF)) / 0xFF)); + this.lightConst[1] = (this.lightConst[1] + ((_local_12 * ((_local_21.color >> 8) & 0xFF)) / 0xFF)); + this.lightConst[2] = (this.lightConst[2] + ((_local_12 * (_local_21.color & 0xFF)) / 0xFF)); + this.lighted = true; + }; + }; + }; + _local_4++; + }; + _local_4 = 0; + while (_local_4 < _arg_1.tubesCount) + { + _local_24 = _arg_1.tubes[_local_4]; + _local_25 = (_local_24.length * 0.5); + _local_26 = (_local_25 + _local_24.falloff); + _local_27 = (_local_24.cmc * _local_2); + _local_28 = (_local_24.cmg * _local_2); + _local_29 = _local_24.cmk; + _local_5 = ((_local_24.cmd * _local_2) + (_local_27 * _local_25)); + _local_6 = ((_local_24.cmh * _local_3) + (_local_28 * _local_25)); + _local_7 = (_local_24.cml + (_local_29 * _local_25)); + _local_30 = (((_local_27 * (_local_13 - _local_5)) + (_local_28 * (_local_14 - _local_6))) + (_local_29 * (_local_15 - _local_7))); + if (((_local_30 > -(_local_26)) && (_local_30 < _local_26))) + { + _local_5 = (_local_5 + ((_local_27 * _local_30) - _local_13)); + _local_6 = (_local_6 + ((_local_28 * _local_30) - _local_14)); + _local_7 = (_local_7 + ((_local_29 * _local_30) - _local_15)); + _local_16 = Math.sqrt((((_local_5 * _local_5) + (_local_6 * _local_6)) + (_local_7 * _local_7))); + if (((_local_16 > 0) && (_local_16 < _local_24.attenuationEnd))) + { + _local_5 = (_local_5 / _local_16); + _local_6 = (_local_6 / _local_16); + _local_7 = (_local_7 / _local_16); + _local_11 = (((_local_5 * _local_17) + (_local_6 * _local_18)) + (_local_7 * _local_19)); + _local_11 = (_local_11 * 0.5); + _local_11 = (_local_11 + 0.5); + _local_9 = ((_local_24.attenuationEnd - _local_16) / (_local_24.attenuationEnd - _local_24.attenuationBegin)); + if (_local_9 > 1) + { + _local_9 = 1; + }; + if (_local_9 < 0) + { + _local_9 = 0; + }; + _local_9 = (_local_9 * _local_9); + if (_local_30 < 0) + { + _local_30 = -(_local_30); + }; + _local_10 = ((_local_26 - _local_30) / (_local_26 - _local_25)); + if (_local_10 > 1) + { + _local_10 = 1; + }; + if (_local_10 < 0) + { + _local_10 = 0; + }; + _local_10 = (_local_10 * _local_10); + _local_12 = (((((_local_9 * _local_10) * _local_11) * _local_24.intensity) * 2) * _arg_1.deferredLightingStrength); + this.lightConst[0] = (this.lightConst[0] + ((_local_12 * ((_local_24.color >> 16) & 0xFF)) / 0xFF)); + this.lightConst[1] = (this.lightConst[1] + ((_local_12 * ((_local_24.color >> 8) & 0xFF)) / 0xFF)); + this.lightConst[2] = (this.lightConst[2] + ((_local_12 * (_local_24.color & 0xFF)) / 0xFF)); + this.lighted = true; + }; + }; + _local_4++; + }; + } + + private function calculateFace(_arg_1:Camera3D):Face + { + var _local_3:Number; + var _local_4:Number; + var _local_5:Number; + var _local_6:Number; + var _local_7:Number; + var _local_8:Number; + var _local_9:Number; + var _local_10:Number; + var _local_11:Vertex; + var _local_12:Vertex; + var _local_22:Number; + var _local_25:BitmapData; + var _local_26:Number; + var _local_27:Number; + var _local_28:Number; + var _local_29:Number; + var _local_30:Number; + var _local_31:Number; + var _local_32:Number; + var _local_33:Number; + culling = (culling & 0x3C); + var _local_2:Number = ml; + if (((_local_2 <= _arg_1.nearClipping) || (_local_2 >= _arg_1.farClipping))) + { + return (null); + }; + var _local_13:Number = this.width; + var _local_14:Number = this.height; + var _local_15:Number = (this.bottomRightU - this.topLeftU); + var _local_16:Number = (this.bottomRightV - this.topLeftV); + if (((this.autoSize) && (this.material is TextureMaterial))) + { + _local_25 = (this.material as TextureMaterial).texture; + if (_local_25 != null) + { + _local_13 = (_local_25.width * _local_15); + _local_14 = (_local_25.height * _local_16); + }; + }; + var _local_17:Number = (_arg_1.viewSizeX / _local_2); + var _local_18:Number = (_arg_1.viewSizeY / _local_2); + var _local_19:Number = (_arg_1.focalLength / _local_2); + var _local_20:Number = (_arg_1.focalLength / _arg_1.viewSizeX); + var _local_21:Number = (_arg_1.focalLength / _arg_1.viewSizeY); + _local_3 = (ma / _local_20); + _local_4 = (me / _local_21); + _local_22 = Math.sqrt((((_local_3 * _local_3) + (_local_4 * _local_4)) + (mi * mi))); + _local_3 = (mb / _local_20); + _local_4 = (mf / _local_21); + _local_22 = (_local_22 + Math.sqrt((((_local_3 * _local_3) + (_local_4 * _local_4)) + (mj * mj)))); + _local_3 = (mc / _local_20); + _local_4 = (mg / _local_21); + _local_22 = (_local_22 + Math.sqrt((((_local_3 * _local_3) + (_local_4 * _local_4)) + (mk * mk)))); + _local_22 = (_local_22 / 3); + if ((!(this.perspectiveScale))) + { + _local_22 = (_local_22 / _local_19); + }; + if (this.rotation == 0) + { + _local_26 = ((_local_22 * _local_13) * _local_20); + _local_27 = ((_local_22 * _local_14) * _local_21); + _local_3 = (md - (this.originX * _local_26)); + _local_4 = (mh - (this.originY * _local_27)); + _local_7 = (_local_3 + _local_26); + _local_8 = (_local_4 + _local_27); + if (((culling > 0) && ((((_local_3 > _local_2) || (_local_4 > _local_2)) || (_local_7 < -(_local_2))) || (_local_8 < -(_local_2))))) + { + return (null); + }; + _local_11 = Vertex.createList(4); + _local_12 = _local_11; + _local_12.cameraX = _local_3; + _local_12.cameraY = _local_4; + _local_12.cameraZ = _local_2; + _local_12.u = this.topLeftU; + _local_12.v = this.topLeftV; + _local_12 = _local_12.next; + _local_12.cameraX = _local_3; + _local_12.cameraY = _local_8; + _local_12.cameraZ = _local_2; + _local_12.u = this.topLeftU; + _local_12.v = this.bottomRightV; + _local_12 = _local_12.next; + _local_12.cameraX = _local_7; + _local_12.cameraY = _local_8; + _local_12.cameraZ = _local_2; + _local_12.u = this.bottomRightU; + _local_12.v = this.bottomRightV; + _local_12 = _local_12.next; + _local_12.cameraX = _local_7; + _local_12.cameraY = _local_4; + _local_12.cameraZ = _local_2; + _local_12.u = this.bottomRightU; + _local_12.v = this.topLeftV; + } else + { + _local_28 = (-(Math.sin(this.rotation)) * _local_22); + _local_29 = (Math.cos(this.rotation) * _local_22); + _local_30 = ((_local_29 * _local_13) * _local_20); + _local_31 = ((-(_local_28) * _local_13) * _local_21); + _local_32 = ((_local_28 * _local_14) * _local_20); + _local_33 = ((_local_29 * _local_14) * _local_21); + _local_3 = ((md - (this.originX * _local_30)) - (this.originY * _local_32)); + _local_4 = ((mh - (this.originX * _local_31)) - (this.originY * _local_33)); + _local_5 = (_local_3 + _local_32); + _local_6 = (_local_4 + _local_33); + _local_7 = ((_local_3 + _local_30) + _local_32); + _local_8 = ((_local_4 + _local_31) + _local_33); + _local_9 = (_local_3 + _local_30); + _local_10 = (_local_4 + _local_31); + if (culling > 0) + { + if (this.clipping == 1) + { + if ((((((culling & 0x04) && (_local_2 <= -(_local_3))) && (_local_2 <= -(_local_5))) && (_local_2 <= -(_local_7))) && (_local_2 <= -(_local_9)))) + { + return (null); + }; + if ((((((culling & 0x08) && (_local_2 <= _local_3)) && (_local_2 <= _local_5)) && (_local_2 <= _local_7)) && (_local_2 <= _local_9))) + { + return (null); + }; + if ((((((culling & 0x10) && (_local_2 <= -(_local_4))) && (_local_2 <= -(_local_6))) && (_local_2 <= -(_local_8))) && (_local_2 <= -(_local_10)))) + { + return (null); + }; + if ((((((culling & 0x20) && (_local_2 <= _local_4)) && (_local_2 <= _local_6)) && (_local_2 <= _local_8)) && (_local_2 <= _local_10))) + { + return (null); + }; + _local_11 = Vertex.createList(4); + _local_12 = _local_11; + _local_12.cameraX = _local_3; + _local_12.cameraY = _local_4; + _local_12.cameraZ = _local_2; + _local_12.u = this.topLeftU; + _local_12.v = this.topLeftV; + _local_12 = _local_12.next; + _local_12.cameraX = (_local_3 + _local_32); + _local_12.cameraY = (_local_4 + _local_33); + _local_12.cameraZ = _local_2; + _local_12.u = this.topLeftU; + _local_12.v = this.bottomRightV; + _local_12 = _local_12.next; + _local_12.cameraX = ((_local_3 + _local_30) + _local_32); + _local_12.cameraY = ((_local_4 + _local_31) + _local_33); + _local_12.cameraZ = _local_2; + _local_12.u = this.bottomRightU; + _local_12.v = this.bottomRightV; + _local_12 = _local_12.next; + _local_12.cameraX = (_local_3 + _local_30); + _local_12.cameraY = (_local_4 + _local_31); + _local_12.cameraZ = _local_2; + _local_12.u = this.bottomRightU; + _local_12.v = this.topLeftV; + } else + { + if ((culling & 0x04)) + { + if (((((_local_2 <= -(_local_3)) && (_local_2 <= -(_local_5))) && (_local_2 <= -(_local_7))) && (_local_2 <= -(_local_9)))) + { + return (null); + }; + if (((((_local_2 > -(_local_3)) && (_local_2 > -(_local_5))) && (_local_2 > -(_local_7))) && (_local_2 > -(_local_9)))) + { + culling = (culling & 0x3B); + }; + }; + if ((culling & 0x08)) + { + if (((((_local_2 <= _local_3) && (_local_2 <= _local_5)) && (_local_2 <= _local_7)) && (_local_2 <= _local_9))) + { + return (null); + }; + if (((((_local_2 > _local_3) && (_local_2 > _local_5)) && (_local_2 > _local_7)) && (_local_2 > _local_9))) + { + culling = (culling & 0x37); + }; + }; + if ((culling & 0x10)) + { + if (((((_local_2 <= -(_local_4)) && (_local_2 <= -(_local_6))) && (_local_2 <= -(_local_8))) && (_local_2 <= -(_local_10)))) + { + return (null); + }; + if (((((_local_2 > -(_local_4)) && (_local_2 > -(_local_6))) && (_local_2 > -(_local_8))) && (_local_2 > -(_local_10)))) + { + culling = (culling & 0x2F); + }; + }; + if ((culling & 0x20)) + { + if (((((_local_2 <= _local_4) && (_local_2 <= _local_6)) && (_local_2 <= _local_8)) && (_local_2 <= _local_10))) + { + return (null); + }; + if (((((_local_2 > _local_4) && (_local_2 > _local_6)) && (_local_2 > _local_8)) && (_local_2 > _local_10))) + { + culling = (culling & 0x1F); + }; + }; + _local_11 = Vertex.createList(4); + _local_12 = _local_11; + _local_12.cameraX = _local_3; + _local_12.cameraY = _local_4; + _local_12.cameraZ = _local_2; + _local_12.u = this.topLeftU; + _local_12.v = this.topLeftV; + _local_12 = _local_12.next; + _local_12.cameraX = (_local_3 + _local_32); + _local_12.cameraY = (_local_4 + _local_33); + _local_12.cameraZ = _local_2; + _local_12.u = this.topLeftU; + _local_12.v = this.bottomRightV; + _local_12 = _local_12.next; + _local_12.cameraX = ((_local_3 + _local_30) + _local_32); + _local_12.cameraY = ((_local_4 + _local_31) + _local_33); + _local_12.cameraZ = _local_2; + _local_12.u = this.bottomRightU; + _local_12.v = this.bottomRightV; + _local_12 = _local_12.next; + _local_12.cameraX = (_local_3 + _local_30); + _local_12.cameraY = (_local_4 + _local_31); + _local_12.cameraZ = _local_2; + _local_12.u = this.bottomRightU; + _local_12.v = this.topLeftV; + }; + } else + { + _local_11 = Vertex.createList(4); + _local_12 = _local_11; + _local_12.cameraX = _local_3; + _local_12.cameraY = _local_4; + _local_12.cameraZ = _local_2; + _local_12.u = this.topLeftU; + _local_12.v = this.topLeftV; + _local_12 = _local_12.next; + _local_12.cameraX = (_local_3 + _local_32); + _local_12.cameraY = (_local_4 + _local_33); + _local_12.cameraZ = _local_2; + _local_12.u = this.topLeftU; + _local_12.v = this.bottomRightV; + _local_12 = _local_12.next; + _local_12.cameraX = ((_local_3 + _local_30) + _local_32); + _local_12.cameraY = ((_local_4 + _local_31) + _local_33); + _local_12.cameraZ = _local_2; + _local_12.u = this.bottomRightU; + _local_12.v = this.bottomRightV; + _local_12 = _local_12.next; + _local_12.cameraX = (_local_3 + _local_30); + _local_12.cameraY = (_local_4 + _local_31); + _local_12.cameraZ = _local_2; + _local_12.u = this.bottomRightU; + _local_12.v = this.topLeftV; + }; + }; + _arg_1.lastVertex.next = _local_11; + _arg_1.lastVertex = _local_12; + var _local_23:Face = Face.create(); + _local_23.material = this.material; + _arg_1.lastFace.next = _local_23; + _arg_1.lastFace = _local_23; + var _local_24:Wrapper = Wrapper.create(); + _local_23.wrapper = _local_24; + _local_24.vertex = _local_11; + _local_11 = _local_11.next; + while (_local_11 != null) + { + _local_24.next = _local_24.create(); + _local_24 = _local_24.next; + _local_24.vertex = _local_11; + _local_11 = _local_11.next; + }; + return (_local_23); + } + + override alternativa3d function updateBounds(_arg_1:Object3D, _arg_2:Object3D=null):void + { + var _local_11:BitmapData; + var _local_12:Number; + var _local_13:Number; + var _local_14:Number; + var _local_15:Number; + var _local_3:Number = this.width; + var _local_4:Number = this.height; + if (((this.autoSize) && (this.material is TextureMaterial))) + { + _local_11 = (this.material as TextureMaterial).texture; + if (_local_11 != null) + { + _local_3 = (_local_11.width * (this.bottomRightU - this.topLeftU)); + _local_4 = (_local_11.height * (this.bottomRightV - this.topLeftV)); + }; + }; + var _local_5:Number = (((this.originX >= 0.5) ? this.originX : (1 - this.originX)) * _local_3); + var _local_6:Number = (((this.originY >= 0.5) ? this.originY : (1 - this.originY)) * _local_4); + var _local_7:Number = Math.sqrt(((_local_5 * _local_5) + (_local_6 * _local_6))); + var _local_8:Number = 0; + var _local_9:Number = 0; + var _local_10:Number = 0; + if (_arg_2 != null) + { + _local_12 = _arg_2.ma; + _local_13 = _arg_2.me; + _local_14 = _arg_2.mi; + _local_15 = Math.sqrt((((_local_12 * _local_12) + (_local_13 * _local_13)) + (_local_14 * _local_14))); + _local_12 = _arg_2.mb; + _local_13 = _arg_2.mf; + _local_14 = _arg_2.mj; + _local_15 = (_local_15 + Math.sqrt((((_local_12 * _local_12) + (_local_13 * _local_13)) + (_local_14 * _local_14)))); + _local_12 = _arg_2.mc; + _local_13 = _arg_2.mg; + _local_14 = _arg_2.mk; + _local_15 = (_local_15 + Math.sqrt((((_local_12 * _local_12) + (_local_13 * _local_13)) + (_local_14 * _local_14)))); + _local_7 = (_local_7 * (_local_15 / 3)); + _local_8 = _arg_2.md; + _local_9 = _arg_2.mh; + _local_10 = _arg_2.ml; + }; + if ((_local_8 - _local_7) < _arg_1.boundMinX) + { + _arg_1.boundMinX = (_local_8 - _local_7); + }; + if ((_local_8 + _local_7) > _arg_1.boundMaxX) + { + _arg_1.boundMaxX = (_local_8 + _local_7); + }; + if ((_local_9 - _local_7) < _arg_1.boundMinY) + { + _arg_1.boundMinY = (_local_9 - _local_7); + }; + if ((_local_9 + _local_7) > _arg_1.boundMaxY) + { + _arg_1.boundMaxY = (_local_9 + _local_7); + }; + if ((_local_10 - _local_7) < _arg_1.boundMinZ) + { + _arg_1.boundMinZ = (_local_10 - _local_7); + }; + if ((_local_10 + _local_7) > _arg_1.boundMaxZ) + { + _arg_1.boundMaxZ = (_local_10 + _local_7); + }; + } + + + } +}//package alternativa.engine3d.objects \ No newline at end of file diff --git a/src/alternativa/engine3d/objects/VertexBinding.as b/src/alternativa/engine3d/objects/VertexBinding.as new file mode 100644 index 0000000..9ebbfe5 --- /dev/null +++ b/src/alternativa/engine3d/objects/VertexBinding.as @@ -0,0 +1,17 @@ +package alternativa.engine3d.objects +{ + import alternativa.engine3d.core.Vertex; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class VertexBinding + { + + alternativa3d var next:VertexBinding; + alternativa3d var vertex:Vertex; + alternativa3d var weight:Number = 0; + + + } +}//package alternativa.engine3d.objects \ No newline at end of file diff --git a/src/alternativa/engine3d/primitives/Box.as b/src/alternativa/engine3d/primitives/Box.as new file mode 100644 index 0000000..f7bdb07 --- /dev/null +++ b/src/alternativa/engine3d/primitives/Box.as @@ -0,0 +1,309 @@ +package alternativa.engine3d.primitives +{ + import alternativa.engine3d.objects.Mesh; + import alternativa.engine3d.core.Vertex; + import __AS3__.vec.Vector; + import alternativa.engine3d.materials.Material; + import alternativa.engine3d.core.Face; + import alternativa.engine3d.core.Wrapper; + import alternativa.engine3d.core.Object3D; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class Box extends Mesh + { + + public function Box(_arg_1:Number=100, _arg_2:Number=100, _arg_3:Number=100, _arg_4:uint=1, _arg_5:uint=1, _arg_6:uint=1, _arg_7:Boolean=false, _arg_8:Boolean=false, _arg_9:Material=null, _arg_10:Material=null, _arg_11:Material=null, _arg_12:Material=null, _arg_13:Material=null, _arg_14:Material=null) + { + var _local_15:int; + var _local_16:int; + var _local_17:int; + super(); + if (_arg_4 < 1) + { + throw (new ArgumentError((_arg_4 + " width segments not enough."))); + }; + if (_arg_5 < 1) + { + throw (new ArgumentError((_arg_5 + " length segments not enough."))); + }; + if (_arg_6 < 1) + { + throw (new ArgumentError((_arg_6 + " height segments not enough."))); + }; + var _local_18:int = (_arg_4 + 1); + var _local_19:int = (_arg_5 + 1); + var _local_20:int = (_arg_6 + 1); + var _local_21:Number = (_arg_1 * 0.5); + var _local_22:Number = (_arg_2 * 0.5); + var _local_23:Number = (_arg_3 * 0.5); + var _local_24:Number = (1 / _arg_4); + var _local_25:Number = (1 / _arg_5); + var _local_26:Number = (1 / _arg_6); + var _local_27:Number = (_arg_1 / _arg_4); + var _local_28:Number = (_arg_2 / _arg_5); + var _local_29:Number = (_arg_3 / _arg_6); + var _local_30:Vector. = new Vector.(); + var _local_31:int; + _local_15 = 0; + while (_local_15 < _local_18) + { + _local_16 = 0; + while (_local_16 < _local_19) + { + var _local_33:* = _local_31++; + _local_30[_local_33] = this.createVertex(((_local_15 * _local_27) - _local_21), ((_local_16 * _local_28) - _local_22), -(_local_23), ((_arg_4 - _local_15) * _local_24), ((_arg_5 - _local_16) * _local_25)); + _local_16++; + }; + _local_15++; + }; + _local_15 = 0; + while (_local_15 < _local_18) + { + _local_16 = 0; + while (_local_16 < _local_19) + { + if (((_local_15 < _arg_4) && (_local_16 < _arg_5))) + { + this.createFace(_local_30[((((_local_15 + 1) * _local_19) + _local_16) + 1)], _local_30[(((_local_15 + 1) * _local_19) + _local_16)], _local_30[((_local_15 * _local_19) + _local_16)], _local_30[(((_local_15 * _local_19) + _local_16) + 1)], 0, 0, -1, _local_23, _arg_7, _arg_8, _arg_13); + }; + _local_16++; + }; + _local_15++; + }; + var _local_32:uint = (_local_18 * _local_19); + _local_15 = 0; + while (_local_15 < _local_18) + { + _local_16 = 0; + while (_local_16 < _local_19) + { + _local_33 = _local_31++; + _local_30[_local_33] = this.createVertex(((_local_15 * _local_27) - _local_21), ((_local_16 * _local_28) - _local_22), _local_23, (_local_15 * _local_24), ((_arg_5 - _local_16) * _local_25)); + _local_16++; + }; + _local_15++; + }; + _local_15 = 0; + while (_local_15 < _local_18) + { + _local_16 = 0; + while (_local_16 < _local_19) + { + if (((_local_15 < _arg_4) && (_local_16 < _arg_5))) + { + this.createFace(_local_30[((_local_32 + (_local_15 * _local_19)) + _local_16)], _local_30[((_local_32 + ((_local_15 + 1) * _local_19)) + _local_16)], _local_30[(((_local_32 + ((_local_15 + 1) * _local_19)) + _local_16) + 1)], _local_30[(((_local_32 + (_local_15 * _local_19)) + _local_16) + 1)], 0, 0, 1, _local_23, _arg_7, _arg_8, _arg_14); + }; + _local_16++; + }; + _local_15++; + }; + _local_32 = (_local_32 + (_local_18 * _local_19)); + _local_15 = 0; + while (_local_15 < _local_18) + { + _local_17 = 0; + while (_local_17 < _local_20) + { + _local_33 = _local_31++; + _local_30[_local_33] = this.createVertex(((_local_15 * _local_27) - _local_21), -(_local_22), ((_local_17 * _local_29) - _local_23), (_local_15 * _local_24), ((_arg_6 - _local_17) * _local_26)); + _local_17++; + }; + _local_15++; + }; + _local_15 = 0; + while (_local_15 < _local_18) + { + _local_17 = 0; + while (_local_17 < _local_20) + { + if (((_local_15 < _arg_4) && (_local_17 < _arg_6))) + { + this.createFace(_local_30[((_local_32 + (_local_15 * _local_20)) + _local_17)], _local_30[((_local_32 + ((_local_15 + 1) * _local_20)) + _local_17)], _local_30[(((_local_32 + ((_local_15 + 1) * _local_20)) + _local_17) + 1)], _local_30[(((_local_32 + (_local_15 * _local_20)) + _local_17) + 1)], 0, -1, 0, _local_22, _arg_7, _arg_8, _arg_11); + }; + _local_17++; + }; + _local_15++; + }; + _local_32 = (_local_32 + (_local_18 * _local_20)); + _local_15 = 0; + while (_local_15 < _local_18) + { + _local_17 = 0; + while (_local_17 < _local_20) + { + _local_33 = _local_31++; + _local_30[_local_33] = this.createVertex(((_local_15 * _local_27) - _local_21), _local_22, ((_local_17 * _local_29) - _local_23), ((_arg_4 - _local_15) * _local_24), ((_arg_6 - _local_17) * _local_26)); + _local_17++; + }; + _local_15++; + }; + _local_15 = 0; + while (_local_15 < _local_18) + { + _local_17 = 0; + while (_local_17 < _local_20) + { + if (((_local_15 < _arg_4) && (_local_17 < _arg_6))) + { + this.createFace(_local_30[((_local_32 + (_local_15 * _local_20)) + _local_17)], _local_30[(((_local_32 + (_local_15 * _local_20)) + _local_17) + 1)], _local_30[(((_local_32 + ((_local_15 + 1) * _local_20)) + _local_17) + 1)], _local_30[((_local_32 + ((_local_15 + 1) * _local_20)) + _local_17)], 0, 1, 0, _local_22, _arg_7, _arg_8, _arg_12); + }; + _local_17++; + }; + _local_15++; + }; + _local_32 = (_local_32 + (_local_18 * _local_20)); + _local_16 = 0; + while (_local_16 < _local_19) + { + _local_17 = 0; + while (_local_17 < _local_20) + { + _local_33 = _local_31++; + _local_30[_local_33] = this.createVertex(-(_local_21), ((_local_16 * _local_28) - _local_22), ((_local_17 * _local_29) - _local_23), ((_arg_5 - _local_16) * _local_25), ((_arg_6 - _local_17) * _local_26)); + _local_17++; + }; + _local_16++; + }; + _local_16 = 0; + while (_local_16 < _local_19) + { + _local_17 = 0; + while (_local_17 < _local_20) + { + if (((_local_16 < _arg_5) && (_local_17 < _arg_6))) + { + this.createFace(_local_30[((_local_32 + (_local_16 * _local_20)) + _local_17)], _local_30[(((_local_32 + (_local_16 * _local_20)) + _local_17) + 1)], _local_30[(((_local_32 + ((_local_16 + 1) * _local_20)) + _local_17) + 1)], _local_30[((_local_32 + ((_local_16 + 1) * _local_20)) + _local_17)], -1, 0, 0, _local_21, _arg_7, _arg_8, _arg_9); + }; + _local_17++; + }; + _local_16++; + }; + _local_32 = (_local_32 + (_local_19 * _local_20)); + _local_16 = 0; + while (_local_16 < _local_19) + { + _local_17 = 0; + while (_local_17 < _local_20) + { + _local_33 = _local_31++; + _local_30[_local_33] = this.createVertex(_local_21, ((_local_16 * _local_28) - _local_22), ((_local_17 * _local_29) - _local_23), (_local_16 * _local_25), ((_arg_6 - _local_17) * _local_26)); + _local_17++; + }; + _local_16++; + }; + _local_16 = 0; + while (_local_16 < _local_19) + { + _local_17 = 0; + while (_local_17 < _local_20) + { + if (((_local_16 < _arg_5) && (_local_17 < _arg_6))) + { + this.createFace(_local_30[((_local_32 + (_local_16 * _local_20)) + _local_17)], _local_30[((_local_32 + ((_local_16 + 1) * _local_20)) + _local_17)], _local_30[(((_local_32 + ((_local_16 + 1) * _local_20)) + _local_17) + 1)], _local_30[(((_local_32 + (_local_16 * _local_20)) + _local_17) + 1)], 1, 0, 0, _local_21, _arg_7, _arg_8, _arg_10); + }; + _local_17++; + }; + _local_16++; + }; + boundMinX = -(_local_21); + boundMinY = -(_local_22); + boundMinZ = -(_local_23); + boundMaxX = _local_21; + boundMaxY = _local_22; + boundMaxZ = _local_23; + } + + private function createVertex(_arg_1:Number, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number):Vertex + { + var _local_6:Vertex = new Vertex(); + _local_6.x = _arg_1; + _local_6.y = _arg_2; + _local_6.z = _arg_3; + _local_6.u = _arg_4; + _local_6.v = _arg_5; + _local_6.next = vertexList; + vertexList = _local_6; + return (_local_6); + } + + private function createFace(_arg_1:Vertex, _arg_2:Vertex, _arg_3:Vertex, _arg_4:Vertex, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Number, _arg_9:Boolean, _arg_10:Boolean, _arg_11:Material):void + { + var _local_12:Vertex; + var _local_13:Face; + if (_arg_9) + { + _arg_5 = -(_arg_5); + _arg_6 = -(_arg_6); + _arg_7 = -(_arg_7); + _arg_8 = -(_arg_8); + _local_12 = _arg_1; + _arg_1 = _arg_4; + _arg_4 = _local_12; + _local_12 = _arg_2; + _arg_2 = _arg_3; + _arg_3 = _local_12; + }; + if (_arg_10) + { + _local_13 = new Face(); + _local_13.material = _arg_11; + _local_13.wrapper = new Wrapper(); + _local_13.wrapper.vertex = _arg_1; + _local_13.wrapper.next = new Wrapper(); + _local_13.wrapper.next.vertex = _arg_2; + _local_13.wrapper.next.next = new Wrapper(); + _local_13.wrapper.next.next.vertex = _arg_3; + _local_13.normalX = _arg_5; + _local_13.normalY = _arg_6; + _local_13.normalZ = _arg_7; + _local_13.offset = _arg_8; + _local_13.next = faceList; + faceList = _local_13; + _local_13 = new Face(); + _local_13.material = _arg_11; + _local_13.wrapper = new Wrapper(); + _local_13.wrapper.vertex = _arg_1; + _local_13.wrapper.next = new Wrapper(); + _local_13.wrapper.next.vertex = _arg_3; + _local_13.wrapper.next.next = new Wrapper(); + _local_13.wrapper.next.next.vertex = _arg_4; + _local_13.normalX = _arg_5; + _local_13.normalY = _arg_6; + _local_13.normalZ = _arg_7; + _local_13.offset = _arg_8; + _local_13.next = faceList; + faceList = _local_13; + } else + { + _local_13 = new Face(); + _local_13.material = _arg_11; + _local_13.wrapper = new Wrapper(); + _local_13.wrapper.vertex = _arg_1; + _local_13.wrapper.next = new Wrapper(); + _local_13.wrapper.next.vertex = _arg_2; + _local_13.wrapper.next.next = new Wrapper(); + _local_13.wrapper.next.next.vertex = _arg_3; + _local_13.wrapper.next.next.next = new Wrapper(); + _local_13.wrapper.next.next.next.vertex = _arg_4; + _local_13.normalX = _arg_5; + _local_13.normalY = _arg_6; + _local_13.normalZ = _arg_7; + _local_13.offset = _arg_8; + _local_13.next = faceList; + faceList = _local_13; + }; + } + + override public function clone():Object3D + { + var _local_1:Box = new Box(); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + + } +}//package alternativa.engine3d.primitives \ No newline at end of file diff --git a/src/alternativa/engine3d/primitives/GeoSphere.as b/src/alternativa/engine3d/primitives/GeoSphere.as new file mode 100644 index 0000000..cf10664 --- /dev/null +++ b/src/alternativa/engine3d/primitives/GeoSphere.as @@ -0,0 +1,474 @@ +package alternativa.engine3d.primitives +{ + import alternativa.engine3d.objects.Mesh; + import alternativa.engine3d.core.Vertex; + import __AS3__.vec.Vector; + import alternativa.engine3d.materials.Material; + import alternativa.engine3d.core.Face; + import alternativa.engine3d.core.Wrapper; + import alternativa.engine3d.core.Object3D; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class GeoSphere extends Mesh + { + + public function GeoSphere(_arg_1:Number=100, _arg_2:uint=2, _arg_3:Boolean=false, _arg_4:Material=null) + { + var _local_9:uint; + var _local_10:uint; + var _local_11:Number; + var _local_12:Number; + var _local_13:Number; + var _local_16:uint; + var _local_17:uint; + var _local_18:uint; + var _local_19:uint; + var _local_20:uint; + var _local_21:Vertex; + var _local_22:Vertex; + var _local_23:Vertex; + var _local_24:Number; + var _local_25:Number; + var _local_26:Number; + var _local_27:Number; + var _local_28:Number; + var _local_29:Number; + super(); + if (_arg_2 < 1) + { + throw (new ArgumentError((_arg_2 + " segments not enough."))); + }; + _arg_1 = ((_arg_1 < 0) ? 0 : _arg_1); + var _local_5:uint = 20; + var _local_6:Number = Math.PI; + var _local_7:Number = (Math.PI * 2); + var _local_8:Vector. = new Vector.(); + var _local_14:Number = (0.4472136 * _arg_1); + var _local_15:Number = (2 * _local_14); + _local_8.push(this.createVertex(0, 0, _arg_1)); + _local_9 = 0; + while (_local_9 < 5) + { + _local_11 = ((_local_7 * _local_9) / 5); + _local_12 = Math.sin(_local_11); + _local_13 = Math.cos(_local_11); + _local_8.push(this.createVertex((_local_15 * _local_13), (_local_15 * _local_12), _local_14)); + _local_9++; + }; + _local_9 = 0; + while (_local_9 < 5) + { + _local_11 = ((_local_6 * ((_local_9 << 1) + 1)) / 5); + _local_12 = Math.sin(_local_11); + _local_13 = Math.cos(_local_11); + _local_8.push(this.createVertex((_local_15 * _local_13), (_local_15 * _local_12), -(_local_14))); + _local_9++; + }; + _local_8.push(this.createVertex(0, 0, -(_arg_1))); + _local_9 = 1; + while (_local_9 < 6) + { + this.interpolate(0, _local_9, _arg_2, _local_8); + _local_9++; + }; + _local_9 = 1; + while (_local_9 < 6) + { + this.interpolate(_local_9, ((_local_9 % 5) + 1), _arg_2, _local_8); + _local_9++; + }; + _local_9 = 1; + while (_local_9 < 6) + { + this.interpolate(_local_9, (_local_9 + 5), _arg_2, _local_8); + _local_9++; + }; + _local_9 = 1; + while (_local_9 < 6) + { + this.interpolate(_local_9, (((_local_9 + 3) % 5) + 6), _arg_2, _local_8); + _local_9++; + }; + _local_9 = 1; + while (_local_9 < 6) + { + this.interpolate((_local_9 + 5), ((_local_9 % 5) + 6), _arg_2, _local_8); + _local_9++; + }; + _local_9 = 6; + while (_local_9 < 11) + { + this.interpolate(11, _local_9, _arg_2, _local_8); + _local_9++; + }; + _local_10 = 0; + while (_local_10 < 5) + { + _local_9 = 1; + while (_local_9 <= (_arg_2 - 2)) + { + this.interpolate(((12 + (_local_10 * (_arg_2 - 1))) + _local_9), ((12 + (((_local_10 + 1) % 5) * (_arg_2 - 1))) + _local_9), (_local_9 + 1), _local_8); + _local_9++; + }; + _local_10++; + }; + _local_10 = 0; + while (_local_10 < 5) + { + _local_9 = 1; + while (_local_9 <= (_arg_2 - 2)) + { + this.interpolate(((12 + ((_local_10 + 15) * (_arg_2 - 1))) + _local_9), ((12 + ((_local_10 + 10) * (_arg_2 - 1))) + _local_9), (_local_9 + 1), _local_8); + _local_9++; + }; + _local_10++; + }; + _local_10 = 0; + while (_local_10 < 5) + { + _local_9 = 1; + while (_local_9 <= (_arg_2 - 2)) + { + this.interpolate(((((12 + ((((_local_10 + 1) % 5) + 15) * (_arg_2 - 1))) + _arg_2) - 2) - _local_9), ((((12 + ((_local_10 + 10) * (_arg_2 - 1))) + _arg_2) - 2) - _local_9), (_local_9 + 1), _local_8); + _local_9++; + }; + _local_10++; + }; + _local_10 = 0; + while (_local_10 < 5) + { + _local_9 = 1; + while (_local_9 <= (_arg_2 - 2)) + { + this.interpolate(((12 + ((((_local_10 + 1) % 5) + 25) * (_arg_2 - 1))) + _local_9), ((12 + ((_local_10 + 25) * (_arg_2 - 1))) + _local_9), (_local_9 + 1), _local_8); + _local_9++; + }; + _local_10++; + }; + _local_10 = 0; + while (_local_10 < _local_5) + { + _local_16 = 0; + while (_local_16 < _arg_2) + { + _local_17 = 0; + while (_local_17 <= _local_16) + { + _local_18 = this.findVertices(_arg_2, _local_10, _local_16, _local_17); + _local_19 = this.findVertices(_arg_2, _local_10, (_local_16 + 1), _local_17); + _local_20 = this.findVertices(_arg_2, _local_10, (_local_16 + 1), (_local_17 + 1)); + _local_21 = _local_8[_local_18]; + _local_22 = _local_8[_local_19]; + _local_23 = _local_8[_local_20]; + if ((((_local_21.y >= 0) && (_local_21.x < 0)) && ((_local_22.y < 0) || (_local_23.y < 0)))) + { + _local_24 = ((Math.atan2(_local_21.y, _local_21.x) / _local_7) - 0.5); + } else + { + _local_24 = ((Math.atan2(_local_21.y, _local_21.x) / _local_7) + 0.5); + }; + _local_25 = ((-(Math.asin((_local_21.z / _arg_1))) / _local_6) + 0.5); + if ((((_local_22.y >= 0) && (_local_22.x < 0)) && ((_local_21.y < 0) || (_local_23.y < 0)))) + { + _local_26 = ((Math.atan2(_local_22.y, _local_22.x) / _local_7) - 0.5); + } else + { + _local_26 = ((Math.atan2(_local_22.y, _local_22.x) / _local_7) + 0.5); + }; + _local_27 = ((-(Math.asin((_local_22.z / _arg_1))) / _local_6) + 0.5); + if ((((_local_23.y >= 0) && (_local_23.x < 0)) && ((_local_21.y < 0) || (_local_22.y < 0)))) + { + _local_28 = ((Math.atan2(_local_23.y, _local_23.x) / _local_7) - 0.5); + } else + { + _local_28 = ((Math.atan2(_local_23.y, _local_23.x) / _local_7) + 0.5); + }; + _local_29 = ((-(Math.asin((_local_23.z / _arg_1))) / _local_6) + 0.5); + if (((_local_18 == 0) || (_local_18 == 11))) + { + _local_24 = (_local_26 + ((_local_28 - _local_26) * 0.5)); + }; + if (((_local_19 == 0) || (_local_19 == 11))) + { + _local_26 = (_local_24 + ((_local_28 - _local_24) * 0.5)); + }; + if (((_local_20 == 0) || (_local_20 == 11))) + { + _local_28 = (_local_24 + ((_local_26 - _local_24) * 0.5)); + }; + if (((_local_21.offset > 0) && (!(_local_21.u == _local_24)))) + { + _local_21 = this.createVertex(_local_21.x, _local_21.y, _local_21.z); + }; + _local_21.u = _local_24; + _local_21.v = _local_25; + _local_21.offset = 1; + if (((_local_22.offset > 0) && (!(_local_22.u == _local_26)))) + { + _local_22 = this.createVertex(_local_22.x, _local_22.y, _local_22.z); + }; + _local_22.u = _local_26; + _local_22.v = _local_27; + _local_22.offset = 1; + if (((_local_23.offset > 0) && (!(_local_23.u == _local_28)))) + { + _local_23 = this.createVertex(_local_23.x, _local_23.y, _local_23.z); + }; + _local_23.u = _local_28; + _local_23.v = _local_29; + _local_23.offset = 1; + if (_arg_3) + { + this.createFace(_local_21, _local_23, _local_22, _arg_4); + } else + { + this.createFace(_local_21, _local_22, _local_23, _arg_4); + }; + if (_local_17 < _local_16) + { + _local_19 = this.findVertices(_arg_2, _local_10, _local_16, (_local_17 + 1)); + _local_22 = _local_8[_local_19]; + if ((((_local_21.y >= 0) && (_local_21.x < 0)) && ((_local_22.y < 0) || (_local_23.y < 0)))) + { + _local_24 = ((Math.atan2(_local_21.y, _local_21.x) / _local_7) - 0.5); + } else + { + _local_24 = ((Math.atan2(_local_21.y, _local_21.x) / _local_7) + 0.5); + }; + _local_25 = ((-(Math.asin((_local_21.z / _arg_1))) / _local_6) + 0.5); + if ((((_local_22.y >= 0) && (_local_22.x < 0)) && ((_local_21.y < 0) || (_local_23.y < 0)))) + { + _local_26 = ((Math.atan2(_local_22.y, _local_22.x) / _local_7) - 0.5); + } else + { + _local_26 = ((Math.atan2(_local_22.y, _local_22.x) / _local_7) + 0.5); + }; + _local_27 = ((-(Math.asin((_local_22.z / _arg_1))) / _local_6) + 0.5); + if ((((_local_23.y >= 0) && (_local_23.x < 0)) && ((_local_21.y < 0) || (_local_22.y < 0)))) + { + _local_28 = ((Math.atan2(_local_23.y, _local_23.x) / _local_7) - 0.5); + } else + { + _local_28 = ((Math.atan2(_local_23.y, _local_23.x) / _local_7) + 0.5); + }; + _local_29 = ((-(Math.asin((_local_23.z / _arg_1))) / _local_6) + 0.5); + if (((_local_18 == 0) || (_local_18 == 11))) + { + _local_24 = (_local_26 + ((_local_28 - _local_26) * 0.5)); + }; + if (((_local_19 == 0) || (_local_19 == 11))) + { + _local_26 = (_local_24 + ((_local_28 - _local_24) * 0.5)); + }; + if (((_local_20 == 0) || (_local_20 == 11))) + { + _local_28 = (_local_24 + ((_local_26 - _local_24) * 0.5)); + }; + if (((_local_21.offset > 0) && (!(_local_21.u == _local_24)))) + { + _local_21 = this.createVertex(_local_21.x, _local_21.y, _local_21.z); + }; + _local_21.u = _local_24; + _local_21.v = _local_25; + _local_21.offset = 1; + if (((_local_22.offset > 0) && (!(_local_22.u == _local_26)))) + { + _local_22 = this.createVertex(_local_22.x, _local_22.y, _local_22.z); + }; + _local_22.u = _local_26; + _local_22.v = _local_27; + _local_22.offset = 1; + if (((_local_23.offset > 0) && (!(_local_23.u == _local_28)))) + { + _local_23 = this.createVertex(_local_23.x, _local_23.y, _local_23.z); + }; + _local_23.u = _local_28; + _local_23.v = _local_29; + _local_23.offset = 1; + if (_arg_3) + { + this.createFace(_local_21, _local_22, _local_23, _arg_4); + } else + { + this.createFace(_local_21, _local_23, _local_22, _arg_4); + }; + }; + _local_17++; + }; + _local_16++; + }; + _local_10++; + }; + calculateFacesNormals(true); + boundMinX = -(_arg_1); + boundMinY = -(_arg_1); + boundMinZ = -(_arg_1); + boundMaxX = _arg_1; + boundMaxY = _arg_1; + boundMaxZ = _arg_1; + } + + private function createVertex(_arg_1:Number, _arg_2:Number, _arg_3:Number):Vertex + { + var _local_4:Vertex = new Vertex(); + _local_4.x = _arg_1; + _local_4.y = _arg_2; + _local_4.z = _arg_3; + _local_4.offset = -1; + _local_4.next = vertexList; + vertexList = _local_4; + return (_local_4); + } + + private function createFace(_arg_1:Vertex, _arg_2:Vertex, _arg_3:Vertex, _arg_4:Material):void + { + var _local_5:Face = new Face(); + _local_5.material = _arg_4; + _local_5.wrapper = new Wrapper(); + _local_5.wrapper.vertex = _arg_1; + _local_5.wrapper.next = new Wrapper(); + _local_5.wrapper.next.vertex = _arg_2; + _local_5.wrapper.next.next = new Wrapper(); + _local_5.wrapper.next.next.vertex = _arg_3; + _local_5.next = faceList; + faceList = _local_5; + } + + private function interpolate(_arg_1:uint, _arg_2:uint, _arg_3:uint, _arg_4:Vector.):void + { + var _local_11:Number; + var _local_12:Number; + var _local_13:Number; + var _local_14:Number; + if (_arg_3 < 2) + { + return; + }; + var _local_5:Vertex = Vertex(_arg_4[_arg_1]); + var _local_6:Vertex = Vertex(_arg_4[_arg_2]); + var _local_7:Number = ((((_local_5.x * _local_6.x) + (_local_5.y * _local_6.y)) + (_local_5.z * _local_6.z)) / (((_local_5.x * _local_5.x) + (_local_5.y * _local_5.y)) + (_local_5.z * _local_5.z))); + _local_7 = ((_local_7 < -1) ? -1 : ((_local_7 > 1) ? 1 : _local_7)); + var _local_8:Number = Math.acos(_local_7); + var _local_9:Number = Math.sin(_local_8); + var _local_10:uint = 1; + while (_local_10 < _arg_3) + { + _local_11 = ((_local_8 * _local_10) / _arg_3); + _local_12 = ((_local_8 * (_arg_3 - _local_10)) / _arg_3); + _local_13 = Math.sin(_local_11); + _local_14 = Math.sin(_local_12); + _arg_4.push(this.createVertex((((_local_5.x * _local_14) + (_local_6.x * _local_13)) / _local_9), (((_local_5.y * _local_14) + (_local_6.y * _local_13)) / _local_9), (((_local_5.z * _local_14) + (_local_6.z * _local_13)) / _local_9))); + _local_10++; + }; + } + + private function findVertices(_arg_1:uint, _arg_2:uint, _arg_3:uint, _arg_4:uint):uint + { + if (_arg_3 == 0) + { + if (_arg_2 < 5) + { + return (0); + }; + if (_arg_2 > 14) + { + return (11); + }; + return (_arg_2 - 4); + }; + if (((_arg_3 == _arg_1) && (_arg_4 == 0))) + { + if (_arg_2 < 5) + { + return (_arg_2 + 1); + }; + if (_arg_2 < 10) + { + return (((_arg_2 + 4) % 5) + 6); + }; + if (_arg_2 < 15) + { + return (((_arg_2 + 1) % 5) + 1); + }; + return (((_arg_2 + 1) % 5) + 6); + }; + if (((_arg_3 == _arg_1) && (_arg_4 == _arg_1))) + { + if (_arg_2 < 5) + { + return (((_arg_2 + 1) % 5) + 1); + }; + if (_arg_2 < 10) + { + return (_arg_2 + 1); + }; + if (_arg_2 < 15) + { + return (_arg_2 - 9); + }; + return (_arg_2 - 9); + }; + if (_arg_3 == _arg_1) + { + if (_arg_2 < 5) + { + return (((12 + ((5 + _arg_2) * (_arg_1 - 1))) + _arg_4) - 1); + }; + if (_arg_2 < 10) + { + return (((12 + ((20 + ((_arg_2 + 4) % 5)) * (_arg_1 - 1))) + _arg_4) - 1); + }; + if (_arg_2 < 15) + { + return ((((12 + ((_arg_2 - 5) * (_arg_1 - 1))) + _arg_1) - 1) - _arg_4); + }; + return ((((12 + ((5 + _arg_2) * (_arg_1 - 1))) + _arg_1) - 1) - _arg_4); + }; + if (_arg_4 == 0) + { + if (_arg_2 < 5) + { + return (((12 + (_arg_2 * (_arg_1 - 1))) + _arg_3) - 1); + }; + if (_arg_2 < 10) + { + return (((12 + (((_arg_2 % 5) + 15) * (_arg_1 - 1))) + _arg_3) - 1); + }; + if (_arg_2 < 15) + { + return ((((12 + ((((_arg_2 + 1) % 5) + 15) * (_arg_1 - 1))) + _arg_1) - 1) - _arg_3); + }; + return (((12 + ((((_arg_2 + 1) % 5) + 25) * (_arg_1 - 1))) + _arg_3) - 1); + }; + if (_arg_4 == _arg_3) + { + if (_arg_2 < 5) + { + return (((12 + (((_arg_2 + 1) % 5) * (_arg_1 - 1))) + _arg_3) - 1); + }; + if (_arg_2 < 10) + { + return (((12 + (((_arg_2 % 5) + 10) * (_arg_1 - 1))) + _arg_3) - 1); + }; + if (_arg_2 < 15) + { + return ((((12 + (((_arg_2 % 5) + 10) * (_arg_1 - 1))) + _arg_1) - _arg_3) - 1); + }; + return (((12 + (((_arg_2 % 5) + 25) * (_arg_1 - 1))) + _arg_3) - 1); + }; + return (((((12 + (30 * (_arg_1 - 1))) + (((_arg_2 * (_arg_1 - 1)) * (_arg_1 - 2)) / 2)) + (((_arg_3 - 1) * (_arg_3 - 2)) / 2)) + _arg_4) - 1); + } + + override public function clone():Object3D + { + var _local_1:GeoSphere = new GeoSphere(); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + + } +}//package alternativa.engine3d.primitives \ No newline at end of file diff --git a/src/alternativa/engine3d/primitives/Plane.as b/src/alternativa/engine3d/primitives/Plane.as new file mode 100644 index 0000000..71e035c --- /dev/null +++ b/src/alternativa/engine3d/primitives/Plane.as @@ -0,0 +1,196 @@ +package alternativa.engine3d.primitives +{ + import alternativa.engine3d.objects.Mesh; + import alternativa.engine3d.core.Vertex; + import __AS3__.vec.Vector; + import alternativa.engine3d.materials.Material; + import alternativa.engine3d.core.Face; + import alternativa.engine3d.core.Wrapper; + import alternativa.engine3d.core.Object3D; + import __AS3__.vec.*; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class Plane extends Mesh + { + + public function Plane(_arg_1:Number=100, _arg_2:Number=100, _arg_3:uint=1, _arg_4:uint=1, _arg_5:Boolean=true, _arg_6:Boolean=false, _arg_7:Boolean=false, _arg_8:Material=null, _arg_9:Material=null) + { + var _local_10:int; + var _local_11:int; + var _local_12:int; + super(); + if (_arg_3 < 1) + { + throw (new ArgumentError((_arg_3 + " width segments not enough."))); + }; + if (_arg_4 < 1) + { + throw (new ArgumentError((_arg_4 + " length segments not enough."))); + }; + var _local_13:int = (_arg_3 + 1); + var _local_14:int = (_arg_4 + 1); + var _local_15:Number = (_arg_1 * 0.5); + var _local_16:Number = (_arg_2 * 0.5); + var _local_17:Number = (1 / _arg_3); + var _local_18:Number = (1 / _arg_4); + var _local_19:Number = (_arg_1 / _arg_3); + var _local_20:Number = (_arg_2 / _arg_4); + var _local_21:Vector. = new Vector.(); + var _local_22:int; + _local_10 = 0; + while (_local_10 < _local_13) + { + _local_11 = 0; + while (_local_11 < _local_14) + { + var _local_23:* = _local_22++; + _local_21[_local_23] = this.createVertex(((_local_10 * _local_19) - _local_15), ((_local_11 * _local_20) - _local_16), 0, (_local_10 * _local_17), ((_arg_4 - _local_11) * _local_18)); + _local_11++; + }; + _local_10++; + }; + _local_10 = 0; + while (_local_10 < _local_13) + { + _local_11 = 0; + while (_local_11 < _local_14) + { + if (((_local_10 < _arg_3) && (_local_11 < _arg_4))) + { + this.createFace(_local_21[((_local_10 * _local_14) + _local_11)], _local_21[(((_local_10 + 1) * _local_14) + _local_11)], _local_21[((((_local_10 + 1) * _local_14) + _local_11) + 1)], _local_21[(((_local_10 * _local_14) + _local_11) + 1)], 0, 0, 1, 0, _arg_6, _arg_7, _arg_9); + }; + _local_11++; + }; + _local_10++; + }; + if (_arg_5) + { + _local_22 = 0; + _local_10 = 0; + while (_local_10 < _local_13) + { + _local_11 = 0; + while (_local_11 < _local_14) + { + _local_23 = _local_22++; + _local_21[_local_23] = this.createVertex(((_local_10 * _local_19) - _local_15), ((_local_11 * _local_20) - _local_16), 0, ((_arg_3 - _local_10) * _local_17), ((_arg_4 - _local_11) * _local_18)); + _local_11++; + }; + _local_10++; + }; + _local_10 = 0; + while (_local_10 < _local_13) + { + _local_11 = 0; + while (_local_11 < _local_14) + { + if (((_local_10 < _arg_3) && (_local_11 < _arg_4))) + { + this.createFace(_local_21[((((_local_10 + 1) * _local_14) + _local_11) + 1)], _local_21[(((_local_10 + 1) * _local_14) + _local_11)], _local_21[((_local_10 * _local_14) + _local_11)], _local_21[(((_local_10 * _local_14) + _local_11) + 1)], 0, 0, -1, 0, _arg_6, _arg_7, _arg_8); + }; + _local_11++; + }; + _local_10++; + }; + }; + boundMinX = -(_local_15); + boundMinY = -(_local_16); + boundMinZ = 0; + boundMaxX = _local_15; + boundMaxY = _local_16; + boundMaxZ = 0; + } + + private function createVertex(_arg_1:Number, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number):Vertex + { + var _local_6:Vertex = new Vertex(); + _local_6.x = _arg_1; + _local_6.y = _arg_2; + _local_6.z = _arg_3; + _local_6.u = _arg_4; + _local_6.v = _arg_5; + _local_6.next = vertexList; + vertexList = _local_6; + return (_local_6); + } + + private function createFace(_arg_1:Vertex, _arg_2:Vertex, _arg_3:Vertex, _arg_4:Vertex, _arg_5:Number, _arg_6:Number, _arg_7:Number, _arg_8:Number, _arg_9:Boolean, _arg_10:Boolean, _arg_11:Material):void + { + var _local_12:Vertex; + var _local_13:Face; + if (_arg_9) + { + _arg_5 = -(_arg_5); + _arg_6 = -(_arg_6); + _arg_7 = -(_arg_7); + _arg_8 = -(_arg_8); + _local_12 = _arg_1; + _arg_1 = _arg_4; + _arg_4 = _local_12; + _local_12 = _arg_2; + _arg_2 = _arg_3; + _arg_3 = _local_12; + }; + if (_arg_10) + { + _local_13 = new Face(); + _local_13.material = _arg_11; + _local_13.wrapper = new Wrapper(); + _local_13.wrapper.vertex = _arg_1; + _local_13.wrapper.next = new Wrapper(); + _local_13.wrapper.next.vertex = _arg_2; + _local_13.wrapper.next.next = new Wrapper(); + _local_13.wrapper.next.next.vertex = _arg_3; + _local_13.normalX = _arg_5; + _local_13.normalY = _arg_6; + _local_13.normalZ = _arg_7; + _local_13.offset = _arg_8; + _local_13.next = faceList; + faceList = _local_13; + _local_13 = new Face(); + _local_13.material = _arg_11; + _local_13.wrapper = new Wrapper(); + _local_13.wrapper.vertex = _arg_1; + _local_13.wrapper.next = new Wrapper(); + _local_13.wrapper.next.vertex = _arg_3; + _local_13.wrapper.next.next = new Wrapper(); + _local_13.wrapper.next.next.vertex = _arg_4; + _local_13.normalX = _arg_5; + _local_13.normalY = _arg_6; + _local_13.normalZ = _arg_7; + _local_13.offset = _arg_8; + _local_13.next = faceList; + faceList = _local_13; + } else + { + _local_13 = new Face(); + _local_13.material = _arg_11; + _local_13.wrapper = new Wrapper(); + _local_13.wrapper.vertex = _arg_1; + _local_13.wrapper.next = new Wrapper(); + _local_13.wrapper.next.vertex = _arg_2; + _local_13.wrapper.next.next = new Wrapper(); + _local_13.wrapper.next.next.vertex = _arg_3; + _local_13.wrapper.next.next.next = new Wrapper(); + _local_13.wrapper.next.next.next.vertex = _arg_4; + _local_13.normalX = _arg_5; + _local_13.normalY = _arg_6; + _local_13.normalZ = _arg_7; + _local_13.offset = _arg_8; + _local_13.next = faceList; + faceList = _local_13; + }; + } + + override public function clone():Object3D + { + var _local_1:Plane = new Plane(); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + + } +}//package alternativa.engine3d.primitives \ No newline at end of file diff --git a/src/alternativa/engine3d/primitives/Sphere.as b/src/alternativa/engine3d/primitives/Sphere.as new file mode 100644 index 0000000..93f5724 --- /dev/null +++ b/src/alternativa/engine3d/primitives/Sphere.as @@ -0,0 +1,139 @@ +package alternativa.engine3d.primitives +{ + import alternativa.engine3d.objects.Mesh; + import alternativa.engine3d.core.Vertex; + import alternativa.engine3d.materials.Material; + import alternativa.engine3d.core.Face; + import alternativa.engine3d.core.Wrapper; + import alternativa.engine3d.core.Object3D; + import alternativa.engine3d.alternativa3d; + + use namespace alternativa3d; + + public class Sphere extends Mesh + { + + public function Sphere(_arg_1:Number=100, _arg_2:uint=8, _arg_3:uint=8, _arg_4:Boolean=false, _arg_5:Material=null) + { + var _local_9:uint; + var _local_10:uint; + var _local_12:Vertex; + var _local_13:Vertex; + var _local_14:Vertex; + var _local_15:Number; + var _local_16:Number; + var _local_17:Number; + var _local_18:Number; + super(); + if (_arg_2 < 3) + { + throw (new ArgumentError((_arg_2 + " radial segments not enough."))); + }; + if (_arg_3 < 2) + { + throw (new ArgumentError((_arg_3 + " height segments not enough."))); + }; + _arg_1 = ((_arg_1 < 0) ? 0 : _arg_1); + var _local_6:Object = new Object(); + var _local_7:Number = ((Math.PI * 2) / _arg_2); + var _local_8:Number = ((Math.PI * 2) / (_arg_3 << 1)); + _local_10 = 0; + while (_local_10 <= _arg_3) + { + _local_15 = (_local_8 * _local_10); + _local_16 = (Math.sin(_local_15) * _arg_1); + _local_17 = (Math.cos(_local_15) * _arg_1); + _local_9 = 0; + while (_local_9 <= _arg_2) + { + _local_18 = (_local_7 * _local_9); + this.createVertex((-(Math.sin(_local_18)) * _local_16), (Math.cos(_local_18) * _local_16), _local_17, (_local_9 / _arg_2), (_local_10 / _arg_3), ((_local_9 + "_") + _local_10), _local_6); + _local_9++; + }; + _local_10++; + }; + var _local_11:uint; + _local_9 = 1; + while (_local_9 <= _arg_2) + { + _local_10 = 0; + while (_local_10 < _arg_3) + { + if (_local_10 < (_arg_3 - 1)) + { + _local_12 = _local_6[((_local_11 + "_") + _local_10)]; + _local_13 = _local_6[((_local_11 + "_") + (_local_10 + 1))]; + _local_14 = _local_6[((_local_9 + "_") + (_local_10 + 1))]; + if (_arg_4) + { + this.createFace(_local_12, _local_14, _local_13, _arg_5); + } else + { + this.createFace(_local_12, _local_13, _local_14, _arg_5); + }; + }; + if (_local_10 > 0) + { + _local_12 = _local_6[((_local_9 + "_") + (_local_10 + 1))]; + _local_13 = _local_6[((_local_9 + "_") + _local_10)]; + _local_14 = _local_6[((_local_11 + "_") + _local_10)]; + if (_arg_4) + { + this.createFace(_local_12, _local_14, _local_13, _arg_5); + } else + { + this.createFace(_local_12, _local_13, _local_14, _arg_5); + }; + }; + _local_10++; + }; + _local_11 = _local_9; + _local_9++; + }; + calculateFacesNormals(true); + boundMinX = -(_arg_1); + boundMinY = -(_arg_1); + boundMinZ = -(_arg_1); + boundMaxX = _arg_1; + boundMaxY = _arg_1; + boundMaxZ = _arg_1; + } + + private function createVertex(_arg_1:Number, _arg_2:Number, _arg_3:Number, _arg_4:Number, _arg_5:Number, _arg_6:String, _arg_7:Object):Vertex + { + var _local_8:Vertex = new Vertex(); + _local_8.x = _arg_1; + _local_8.y = _arg_2; + _local_8.z = _arg_3; + _local_8.u = _arg_4; + _local_8.v = _arg_5; + _local_8.next = vertexList; + vertexList = _local_8; + _arg_7[_arg_6] = _local_8; + return (_local_8); + } + + private function createFace(_arg_1:Vertex, _arg_2:Vertex, _arg_3:Vertex, _arg_4:Material):void + { + var _local_5:Face = new Face(); + _local_5.material = _arg_4; + _local_5.wrapper = new Wrapper(); + _local_5.wrapper.vertex = _arg_1; + _local_5.wrapper.next = new Wrapper(); + _local_5.wrapper.next.vertex = _arg_2; + _local_5.wrapper.next.next = new Wrapper(); + _local_5.wrapper.next.next.vertex = _arg_3; + _local_5.next = faceList; + faceList = _local_5; + } + + override public function clone():Object3D + { + var _local_1:Sphere = new Sphere(); + _local_1.clonePropertiesFrom(this); + return (_local_1); + } + + + } +}//package alternativa.engine3d.primitives \ No newline at end of file diff --git a/src/alternativa/gfx/agal/CommonRegister.as b/src/alternativa/gfx/agal/CommonRegister.as new file mode 100644 index 0000000..8049a99 --- /dev/null +++ b/src/alternativa/gfx/agal/CommonRegister.as @@ -0,0 +1,34 @@ +package alternativa.gfx.agal{ + public class CommonRegister extends Register { + + protected static const X:int = 0; + protected static const Y:int = 1; + protected static const Z:int = 2; + protected static const W:int = 3; + + public var x:Register; + public var y:Register; + public var z:Register; + public var w:Register; + public var xyz:Register; + public var xy:Register; + public var xw:Register; + public var xz:Register; + public var zw:Register; + + public function CommonRegister(_arg_1:int, _arg_2:int){ + this.index = _arg_1; + this.emitCode = _arg_2; + this.x = Register.get(getSwizzle(X, X, X, X), getDestMask(true, false, false, false), this); + this.y = Register.get(getSwizzle(Y, Y, Y, Y), getDestMask(false, true, false, false), this); + this.z = Register.get(getSwizzle(Z, Z, Z, Z), getDestMask(false, false, true, false), this); + this.w = Register.get(getSwizzle(W, W, W, W), getDestMask(false, false, false, true), this); + this.xyz = Register.get(getSwizzle(X, Y, Z, Z), getDestMask(true, true, true, false), this); + this.xy = Register.get(getSwizzle(X, Y, Y, Y), getDestMask(true, true, false, false), this); + this.xz = Register.get(getSwizzle(X, Z, Z, Z), getDestMask(true, false, true, false), this); + this.xw = Register.get(getSwizzle(X, W, W, W), getDestMask(true, false, false, true), this); + this.zw = Register.get(getSwizzle(Z, W, W, W), getDestMask(false, false, true, true), this); + } + + } +}//package alternativa.gfx.agal \ No newline at end of file diff --git a/src/alternativa/gfx/agal/FragmentShader.as b/src/alternativa/gfx/agal/FragmentShader.as new file mode 100644 index 0000000..a04004c --- /dev/null +++ b/src/alternativa/gfx/agal/FragmentShader.as @@ -0,0 +1,45 @@ +package alternativa.gfx.agal{ + import __AS3__.vec.Vector; + + public class FragmentShader extends Shader { + + public static const fc:Vector. = VertexShader.vc; + public static const ft0:CommonRegister = VertexShader.vt0; + public static const ft1:CommonRegister = VertexShader.vt1; + public static const ft2:CommonRegister = VertexShader.vt2; + public static const ft3:CommonRegister = VertexShader.vt3; + public static const ft4:CommonRegister = VertexShader.vt4; + public static const ft5:CommonRegister = VertexShader.vt5; + public static const ft6:CommonRegister = VertexShader.vt6; + public static const ft7:CommonRegister = VertexShader.vt7; + public static const oc:CommonRegister = VertexShader.op; + public static const fs0:SamplerRegister = new SamplerRegister(0); + public static const fs1:SamplerRegister = new SamplerRegister(1); + public static const fs2:SamplerRegister = new SamplerRegister(2); + public static const fs3:SamplerRegister = new SamplerRegister(3); + public static const fs4:SamplerRegister = new SamplerRegister(4); + public static const fs5:SamplerRegister = new SamplerRegister(5); + public static const fs6:SamplerRegister = new SamplerRegister(6); + public static const fs7:SamplerRegister = new SamplerRegister(7); + + public function FragmentShader(){ + data.writeByte(1); + } + + public function kil(_arg_1:Register):void{ + data.writeUnsignedInt(KIL); + data.position = (data.position + 4); + _arg_1.writeSource(data); + data.position = (data.position + 8); + } + + public function tex(_arg_1:Register, _arg_2:Register, _arg_3:SamplerRegister):void{ + data.writeUnsignedInt(TEX); + _arg_1.writeDest(data); + _arg_2.writeSource(data); + _arg_3.writeSource(data); + } + + + } +}//package alternativa.gfx.agal \ No newline at end of file diff --git a/src/alternativa/gfx/agal/Register.as b/src/alternativa/gfx/agal/Register.as new file mode 100644 index 0000000..99b3122 --- /dev/null +++ b/src/alternativa/gfx/agal/Register.as @@ -0,0 +1,84 @@ +package alternativa.gfx.agal{ + import flash.utils.ByteArray; + + public class Register { + + protected var parent:Register; + protected var swizzle:int = 228; + protected var destMask:int = 15; + protected var index:int; + protected var emitCode:int; + protected var relOffset:int; + protected var relType:int; + protected var relSel:uint; + + + public static function get(_arg_1:int=228, _arg_2:int=15, _arg_3:Register=null):Register{ + var _local_4:Register = new (Register)(); + _local_4.parent = _arg_3; + if (_arg_3 != null) + { + _local_4.index = _arg_3.index; + _local_4.emitCode = _arg_3.emitCode; + }; + _local_4.swizzle = _arg_1; + _local_4.destMask = _arg_2; + return (_local_4); + } + + protected static function getSwizzle(_arg_1:int=0, _arg_2:int=1, _arg_3:int=2, _arg_4:int=3):int{ + return (((_arg_1 | (_arg_2 << 2)) | (_arg_3 << 4)) | (_arg_4 << 6)); + } + + protected static function getDestMask(_arg_1:Boolean, _arg_2:Boolean, _arg_3:Boolean, _arg_4:Boolean):int{ + var _local_5:int; + if (_arg_1) + { + _local_5 = (_local_5 | 0x01); + }; + if (_arg_2) + { + _local_5 = (_local_5 | 0x02); + }; + if (_arg_3) + { + _local_5 = (_local_5 | 0x04); + }; + if (_arg_4) + { + _local_5 = (_local_5 | 0x08); + }; + return (_local_5); + } + + + public function writeDest(_arg_1:ByteArray):void{ + _arg_1.writeShort(((!(this.parent == null)) ? this.parent.index : this.index)); + _arg_1.writeByte(this.destMask); + _arg_1.writeByte(((!(this.parent == null)) ? this.parent.emitCode : this.emitCode)); + } + + public function writeSource(_arg_1:ByteArray):void{ + _arg_1.writeShort(((!(this.parent == null)) ? this.parent.index : this.index)); + _arg_1.writeByte(((!(this.parent == null)) ? this.parent.relOffset : this.relOffset)); + _arg_1.writeByte(this.swizzle); + _arg_1.writeByte(((!(this.parent == null)) ? this.parent.emitCode : this.emitCode)); + _arg_1.writeByte(((!(this.parent == null)) ? this.parent.relType : this.relType)); + _arg_1.writeShort(((!(this.parent == null)) ? this.parent.relSel : this.relSel)); + } + + protected function relate(_arg_1:Register, _arg_2:uint):void{ + this.relType = _arg_1.emitCode; + this.index = _arg_1.index; + if ((_arg_1.destMask & (_arg_1.destMask - 1)) != 0) + { + throw (new Error("Register must has simple swizzle: .x, .y, .z, .w")); + }; + this.relSel = (Math.log(_arg_1.destMask) / Math.LN2); + this.relSel = (this.relSel | (1 << 15)); + this.relOffset = _arg_2; + } + + + } +}//package alternativa.gfx.agal \ No newline at end of file diff --git a/src/alternativa/gfx/agal/RelativeRegister.as b/src/alternativa/gfx/agal/RelativeRegister.as new file mode 100644 index 0000000..419bdce --- /dev/null +++ b/src/alternativa/gfx/agal/RelativeRegister.as @@ -0,0 +1,15 @@ +package alternativa.gfx.agal{ + public class RelativeRegister extends CommonRegister { + + public function RelativeRegister(_arg_1:int, _arg_2:int){ + super(_arg_1, _arg_2); + } + + public function rel(_arg_1:Register, _arg_2:uint):CommonRegister{ + relate(_arg_1, _arg_2); + return (this); + } + + + } +}//package alternativa.gfx.agal \ No newline at end of file diff --git a/src/alternativa/gfx/agal/SamplerDim.as b/src/alternativa/gfx/agal/SamplerDim.as new file mode 100644 index 0000000..9840f60 --- /dev/null +++ b/src/alternativa/gfx/agal/SamplerDim.as @@ -0,0 +1,14 @@ +package alternativa.gfx.agal{ + public class SamplerDim extends SamplerOption { + + private static const SAMPLER_TEXTURE_TYPE_SHIFT:int = 12; + public static const D2:SamplerDim = new SamplerDim(0); + public static const CUBE:SamplerDim = new SamplerDim(1); + public static const D3:SamplerDim = new SamplerDim(2); + + public function SamplerDim(_arg_1:uint){ + super(_arg_1, SAMPLER_TEXTURE_TYPE_SHIFT); + } + + } +}//package alternativa.gfx.agal \ No newline at end of file diff --git a/src/alternativa/gfx/agal/SamplerFilter.as b/src/alternativa/gfx/agal/SamplerFilter.as new file mode 100644 index 0000000..82fc7f9 --- /dev/null +++ b/src/alternativa/gfx/agal/SamplerFilter.as @@ -0,0 +1,13 @@ +package alternativa.gfx.agal{ + public class SamplerFilter extends SamplerOption { + + private static const SAMPLER_FILTER_SHIFT:uint = 28; + public static const NEAREST:SamplerFilter = new SamplerFilter(0); + public static const LINEAR:SamplerFilter = new SamplerFilter(1); + + public function SamplerFilter(_arg_1:uint){ + super(_arg_1, SAMPLER_FILTER_SHIFT); + } + + } +}//package alternativa.gfx.agal \ No newline at end of file diff --git a/src/alternativa/gfx/agal/SamplerMipMap.as b/src/alternativa/gfx/agal/SamplerMipMap.as new file mode 100644 index 0000000..ae0ec98 --- /dev/null +++ b/src/alternativa/gfx/agal/SamplerMipMap.as @@ -0,0 +1,14 @@ +package alternativa.gfx.agal{ + public class SamplerMipMap extends SamplerOption { + + private static const SAMPLER_MIPMAP_SHIFT:uint = 24; + public static const NONE:SamplerMipMap = new SamplerMipMap(0); + public static const NEAREST:SamplerMipMap = new SamplerMipMap(1); + public static const LINEAR:SamplerMipMap = new SamplerMipMap(2); + + public function SamplerMipMap(_arg_1:uint){ + super(_arg_1, SAMPLER_MIPMAP_SHIFT); + } + + } +}//package alternativa.gfx.agal \ No newline at end of file diff --git a/src/alternativa/gfx/agal/SamplerOption.as b/src/alternativa/gfx/agal/SamplerOption.as new file mode 100644 index 0000000..f7048a2 --- /dev/null +++ b/src/alternativa/gfx/agal/SamplerOption.as @@ -0,0 +1,19 @@ +package alternativa.gfx.agal{ + public class SamplerOption { + + public var mask:uint; + public var flag:uint; + + public function SamplerOption(_arg_1:uint, _arg_2:uint){ + this.mask = _arg_1; + this.flag = _arg_2; + } + + public function apply(_arg_1:int):int{ + _arg_1 = (_arg_1 & (~(15 << this.flag))); + return (_arg_1 | (this.mask << this.flag)); + } + + + } +}//package alternativa.gfx.agal \ No newline at end of file diff --git a/src/alternativa/gfx/agal/SamplerRegister.as b/src/alternativa/gfx/agal/SamplerRegister.as new file mode 100644 index 0000000..bec9fa3 --- /dev/null +++ b/src/alternativa/gfx/agal/SamplerRegister.as @@ -0,0 +1,55 @@ +package alternativa.gfx.agal{ + import flash.utils.ByteArray; + + public class SamplerRegister extends Register { + + protected var samplerbits:int = 5; + + public function SamplerRegister(_arg_1:int){ + this.index = _arg_1; + } + + public function dim(_arg_1:SamplerDim):SamplerRegister{ + this.addSamplerOption(_arg_1); + return (this); + } + + public function type(_arg_1:SamplerType):SamplerRegister{ + this.addSamplerOption(_arg_1); + return (this); + } + + public function special(_arg_1:SamplerSpecial):SamplerRegister{ + this.addSamplerOption(_arg_1); + return (this); + } + + public function repeat(_arg_1:SamplerRepeat):SamplerRegister{ + this.addSamplerOption(_arg_1); + return (this); + } + + public function mipmap(_arg_1:SamplerMipMap):SamplerRegister{ + this.addSamplerOption(_arg_1); + return (this); + } + + public function filter(_arg_1:SamplerFilter):SamplerRegister{ + this.addSamplerOption(_arg_1); + return (this); + } + + private function addSamplerOption(_arg_1:SamplerOption):void{ + this.samplerbits = _arg_1.apply(this.samplerbits); + } + + override public function writeSource(_arg_1:ByteArray):void{ + _arg_1.writeShort(index); + _arg_1.writeShort(0); + _arg_1.writeUnsignedInt(this.samplerbits); + this.samplerbits = 5; + } + + + } +}//package alternativa.gfx.agal \ No newline at end of file diff --git a/src/alternativa/gfx/agal/SamplerRepeat.as b/src/alternativa/gfx/agal/SamplerRepeat.as new file mode 100644 index 0000000..5eeede8 --- /dev/null +++ b/src/alternativa/gfx/agal/SamplerRepeat.as @@ -0,0 +1,14 @@ +package alternativa.gfx.agal{ + public class SamplerRepeat extends SamplerOption { + + private static const SAMPLER_REPEAT_SHIFT:uint = 20; + public static const CLAMP:SamplerRepeat = new SamplerRepeat(0); + public static const REPEAT:SamplerRepeat = new SamplerRepeat(1); + public static const WRAP:SamplerRepeat = REPEAT; + + public function SamplerRepeat(_arg_1:uint){ + super(_arg_1, SAMPLER_REPEAT_SHIFT); + } + + } +}//package alternativa.gfx.agal \ No newline at end of file diff --git a/src/alternativa/gfx/agal/SamplerSpecial.as b/src/alternativa/gfx/agal/SamplerSpecial.as new file mode 100644 index 0000000..dd72034 --- /dev/null +++ b/src/alternativa/gfx/agal/SamplerSpecial.as @@ -0,0 +1,19 @@ +package alternativa.gfx.agal{ + public class SamplerSpecial extends SamplerOption { + + private static const SAMPLER_SPECIAL_SHIFT:uint = 16; + public static const CENTROID:SamplerSpecial = new SamplerSpecial(1); + public static const SINGLE:SamplerSpecial = new SamplerSpecial(2); + public static const IGNORESAMPLER:SamplerSpecial = new SamplerSpecial(4); + + public function SamplerSpecial(_arg_1:int){ + super(_arg_1, SAMPLER_SPECIAL_SHIFT); + } + + override public function apply(_arg_1:int):int{ + return (_arg_1 | (uint(mask) << uint(flag))); + } + + + } +}//package alternativa.gfx.agal \ No newline at end of file diff --git a/src/alternativa/gfx/agal/SamplerType.as b/src/alternativa/gfx/agal/SamplerType.as new file mode 100644 index 0000000..7459327 --- /dev/null +++ b/src/alternativa/gfx/agal/SamplerType.as @@ -0,0 +1,15 @@ +package alternativa.gfx.agal{ + public class SamplerType extends SamplerOption { + + private static const SAMPLER_TYPE_SHIFT:uint = 8; + public static const RGBA:SamplerType = new SamplerType(0); + public static const DXT1:SamplerType = new SamplerType(1); + public static const DXT5:SamplerType = new SamplerType(2); + public static const VIDEO:SamplerType = new SamplerType(3); + + public function SamplerType(_arg_1:int){ + super(_arg_1, SAMPLER_TYPE_SHIFT); + } + + } +}//package alternativa.gfx.agal \ No newline at end of file diff --git a/src/alternativa/gfx/agal/Shader.as b/src/alternativa/gfx/agal/Shader.as new file mode 100644 index 0000000..62cd568 --- /dev/null +++ b/src/alternativa/gfx/agal/Shader.as @@ -0,0 +1,214 @@ +package alternativa.gfx.agal{ + import flash.utils.ByteArray; + import flash.utils.Endian; + + public class Shader { + + public static const v0:CommonRegister = new CommonRegister(0, 4); + public static const v1:CommonRegister = new CommonRegister(1, 4); + public static const v2:CommonRegister = new CommonRegister(2, 4); + public static const v3:CommonRegister = new CommonRegister(3, 4); + public static const v4:CommonRegister = new CommonRegister(4, 4); + public static const v5:CommonRegister = new CommonRegister(5, 4); + public static const v6:CommonRegister = new CommonRegister(6, 4); + public static const v7:CommonRegister = new CommonRegister(7, 4); + public static const cc:RelativeRegister = new RelativeRegister(0, 1); + protected static const MOV:int = 0; + protected static const ADD:int = 1; + protected static const SUB:int = 2; + protected static const MUL:int = 3; + protected static const DIV:int = 4; + protected static const RCP:int = 5; + protected static const MIN:int = 6; + protected static const MAX:int = 7; + protected static const FRC:int = 8; + protected static const SQT:int = 9; + protected static const RSQ:int = 10; + protected static const POW:int = 11; + protected static const LOG:int = 12; + protected static const EXP:int = 13; + protected static const NRM:int = 14; + protected static const SIN:int = 15; + protected static const COS:int = 16; + protected static const CRS:int = 17; + protected static const DP3:int = 18; + protected static const DP4:int = 19; + protected static const ABS:int = 20; + protected static const NEG:int = 21; + protected static const SAT:int = 22; + protected static const M33:int = 23; + protected static const M44:int = 24; + protected static const M34:int = 25; + protected static const DDX:int = 26; + protected static const DDY:int = 27; + protected static const IFE:int = 28; + protected static const INE:int = 29; + protected static const IFG:int = 30; + protected static const IFL:int = 31; + protected static const ELS:int = 32; + protected static const EIF:int = 33; + protected static const TED:int = 38; + protected static const KIL:int = 39; + protected static const TEX:int = 40; + protected static const SGE:int = 41; + protected static const SLT:int = 42; + protected static const SGN:int = 43; + protected static const SEQ:int = 44; + protected static const SNE:int = 45; + + protected var data:ByteArray; + + public function Shader(){ + this.data = new ByteArray(); + this.data.endian = Endian.LITTLE_ENDIAN; + this.data.writeByte(160); + this.data.writeUnsignedInt(1); + this.data.writeByte(161); + } + + public function mov(_arg_1:Register, _arg_2:Register):void{ + this.op2(MOV, _arg_1, _arg_2); + } + + public function add(_arg_1:Register, _arg_2:Register, _arg_3:Register):void{ + this.op3(ADD, _arg_1, _arg_2, _arg_3); + } + + public function sub(_arg_1:Register, _arg_2:Register, _arg_3:Register):void{ + this.op3(SUB, _arg_1, _arg_2, _arg_3); + } + + public function mul(_arg_1:Register, _arg_2:Register, _arg_3:Register):void{ + this.op3(MUL, _arg_1, _arg_2, _arg_3); + } + + public function div(_arg_1:Register, _arg_2:Register, _arg_3:Register):void{ + this.op3(DIV, _arg_1, _arg_2, _arg_3); + } + + public function rcp(_arg_1:Register, _arg_2:Register):void{ + this.op2(RCP, _arg_1, _arg_2); + } + + public function min(_arg_1:Register, _arg_2:Register, _arg_3:Register):void{ + this.op3(MIN, _arg_1, _arg_2, _arg_3); + } + + public function max(_arg_1:Register, _arg_2:Register, _arg_3:Register):void{ + this.op3(MAX, _arg_1, _arg_2, _arg_3); + } + + public function frc(_arg_1:Register, _arg_2:Register):void{ + this.op2(FRC, _arg_1, _arg_2); + } + + public function sqt(_arg_1:Register, _arg_2:Register):void{ + this.op2(SQT, _arg_1, _arg_2); + } + + public function rsq(_arg_1:Register, _arg_2:Register):void{ + this.op2(RSQ, _arg_1, _arg_2); + } + + public function pow(_arg_1:Register, _arg_2:Register, _arg_3:Register):void{ + this.op3(POW, _arg_1, _arg_2, _arg_3); + } + + public function log(_arg_1:Register, _arg_2:Register):void{ + this.op2(LOG, _arg_1, _arg_2); + } + + public function exp(_arg_1:Register, _arg_2:Register):void{ + this.op2(EXP, _arg_1, _arg_2); + } + + public function nrm(_arg_1:Register, _arg_2:Register):void{ + this.op2(NRM, _arg_1, _arg_2); + } + + public function sin(_arg_1:Register, _arg_2:Register):void{ + this.op2(SIN, _arg_1, _arg_2); + } + + public function cos(_arg_1:Register, _arg_2:Register):void{ + this.op2(COS, _arg_1, _arg_2); + } + + public function crs(_arg_1:Register, _arg_2:Register, _arg_3:Register):void{ + this.op3(CRS, _arg_1, _arg_2, _arg_3); + } + + public function dp3(_arg_1:Register, _arg_2:Register, _arg_3:Register):void{ + this.op3(DP3, _arg_1, _arg_2, _arg_3); + } + + public function dp4(_arg_1:Register, _arg_2:Register, _arg_3:Register):void{ + this.op3(DP4, _arg_1, _arg_2, _arg_3); + } + + public function abs(_arg_1:Register, _arg_2:Register):void{ + this.op2(ABS, _arg_1, _arg_2); + } + + public function neg(_arg_1:Register, _arg_2:Register):void{ + this.op2(NEG, _arg_1, _arg_2); + } + + public function sat(_arg_1:Register, _arg_2:Register):void{ + this.op2(SAT, _arg_1, _arg_2); + } + + public function m33(_arg_1:Register, _arg_2:Register, _arg_3:Register):void{ + this.op3(M33, _arg_1, _arg_2, _arg_3); + } + + public function m44(_arg_1:Register, _arg_2:Register, _arg_3:Register):void{ + this.op3(M44, _arg_1, _arg_2, _arg_3); + } + + public function m34(_arg_1:Register, _arg_2:Register, _arg_3:Register):void{ + this.op3(M34, _arg_1, _arg_2, _arg_3); + } + + public function sge(_arg_1:Register, _arg_2:Register, _arg_3:Register):void{ + this.op3(SGE, _arg_1, _arg_2, _arg_3); + } + + public function slt(_arg_1:Register, _arg_2:Register, _arg_3:Register):void{ + this.op3(SLT, _arg_1, _arg_2, _arg_3); + } + + public function sgn(_arg_1:Register, _arg_2:Register, _arg_3:Register):void{ + this.op3(SGN, _arg_1, _arg_2, _arg_3); + } + + public function seq(_arg_1:Register, _arg_2:Register, _arg_3:Register):void{ + this.op3(SEQ, _arg_1, _arg_2, _arg_3); + } + + public function sne(_arg_1:Register, _arg_2:Register, _arg_3:Register):void{ + this.op3(SNE, _arg_1, _arg_2, _arg_3); + } + + protected function op2(_arg_1:int, _arg_2:Register, _arg_3:Register):void{ + this.data.writeUnsignedInt(_arg_1); + _arg_2.writeDest(this.data); + _arg_3.writeSource(this.data); + this.data.writeUnsignedInt(0); + this.data.writeUnsignedInt(0); + } + + protected function op3(_arg_1:int, _arg_2:Register, _arg_3:Register, _arg_4:Register):void{ + this.data.writeUnsignedInt(_arg_1); + _arg_2.writeDest(this.data); + _arg_3.writeSource(this.data); + _arg_4.writeSource(this.data); + } + + public function get agalcode():ByteArray{ + return (this.data); + } + + + } +}//package alternativa.gfx.agal \ No newline at end of file diff --git a/src/alternativa/gfx/agal/VertexShader.as b/src/alternativa/gfx/agal/VertexShader.as new file mode 100644 index 0000000..6c94c97 --- /dev/null +++ b/src/alternativa/gfx/agal/VertexShader.as @@ -0,0 +1,43 @@ +package alternativa.gfx.agal{ + import __AS3__.vec.Vector; + import __AS3__.vec.*; + + public class VertexShader extends Shader { + + public static const va0:CommonRegister = new CommonRegister(0, 0); + public static const va1:CommonRegister = new CommonRegister(1, 0); + public static const va2:CommonRegister = new CommonRegister(2, 0); + public static const va3:CommonRegister = new CommonRegister(3, 0); + public static const va4:CommonRegister = new CommonRegister(4, 0); + public static const va5:CommonRegister = new CommonRegister(5, 0); + public static const va6:CommonRegister = new CommonRegister(6, 0); + public static const va7:CommonRegister = new CommonRegister(7, 0); + public static const vt0:CommonRegister = new CommonRegister(0, 2); + public static const vt1:CommonRegister = new CommonRegister(1, 2); + public static const vt2:CommonRegister = new CommonRegister(2, 2); + public static const vt3:CommonRegister = new CommonRegister(3, 2); + public static const vt4:CommonRegister = new CommonRegister(4, 2); + public static const vt5:CommonRegister = new CommonRegister(5, 2); + public static const vt6:CommonRegister = new CommonRegister(6, 2); + public static const vt7:CommonRegister = new CommonRegister(7, 2); + public static const vc:Vector. = getConsts(); + public static const op:CommonRegister = new CommonRegister(0, 3); + + public function VertexShader(){ + data.writeByte(0); + } + + private static function getConsts():Vector.{ + var _local_1:Vector. = new Vector.(); + var _local_2:int; + while (_local_2 < 127) + { + _local_1[_local_2] = new CommonRegister(_local_2, 1); + _local_2++; + }; + return (_local_1); + } + + + } +}//package alternativa.gfx.agal \ No newline at end of file diff --git a/src/alternativa/gfx/alternativagfx.as b/src/alternativa/gfx/alternativagfx.as new file mode 100644 index 0000000..6cb5677 --- /dev/null +++ b/src/alternativa/gfx/alternativagfx.as @@ -0,0 +1,4 @@ +package alternativa.gfx +{ + public namespace alternativagfx = "http://alternativaplatform.com/en/alternativagfx"; +} diff --git a/src/alternativa/gfx/core/BitmapTextureResource.as b/src/alternativa/gfx/core/BitmapTextureResource.as new file mode 100644 index 0000000..268fd5c --- /dev/null +++ b/src/alternativa/gfx/core/BitmapTextureResource.as @@ -0,0 +1,244 @@ +package alternativa.gfx.core{ + import flash.geom.Point; + import flash.geom.Rectangle; + import flash.geom.Matrix; + import flash.display3D.textures.Texture; + import flash.display3D.Context3D; + import flash.display.BitmapData; + import alternativa.engine3d.materials.TextureResourcesRegistry; + import flash.display3D.Context3DTextureFormat; + import alternativa.gfx.alternativagfx; + + use namespace alternativagfx; + + public class BitmapTextureResource extends TextureResource { + + private static const point:Point = new Point(); + private static const rectangle:Rectangle = new Rectangle(); + private static const matrix:Matrix = new Matrix(); + private static var nullTexture:Texture; + private static var nullTextureContext:Context3D; + + private var referencesCount:int = 1; + private var _bitmapData:BitmapData; + private var _mipMapping:Boolean; + private var _stretchNotPowerOf2Textures:Boolean; + private var _calculateMipMapsUsingGPU:Boolean; + private var _correctionU:Number = 1; + private var _correctionV:Number = 1; + private var correctedWidth:int; + private var correctedHeight:int; + + public function BitmapTextureResource(_arg_1:BitmapData, _arg_2:Boolean, _arg_3:Boolean=false, _arg_4:Boolean=false){ + this._bitmapData = _arg_1; + this._mipMapping = _arg_2; + this._stretchNotPowerOf2Textures = _arg_3; + this._calculateMipMapsUsingGPU = _arg_4; + this.correctedWidth = Math.pow(2, Math.ceil((Math.log(this._bitmapData.width) / Math.LN2))); + this.correctedHeight = Math.pow(2, Math.ceil((Math.log(this._bitmapData.height) / Math.LN2))); + if (this.correctedWidth > 0x0800) + { + this.correctedWidth = 0x0800; + }; + if (this.correctedHeight > 0x0800) + { + this.correctedHeight = 0x0800; + }; + if ((((((!(this._bitmapData.width == this.correctedWidth)) || (!(this._bitmapData.height == this.correctedHeight))) && (!(this._stretchNotPowerOf2Textures))) && (this._bitmapData.width <= 0x0800)) && (this._bitmapData.height <= 0x0800))) + { + this._correctionU = (this._bitmapData.width / this.correctedWidth); + this._correctionV = (this._bitmapData.height / this.correctedHeight); + }; + } + + public function get bitmapData():BitmapData{ + return (this._bitmapData); + } + + public function get mipMapping():Boolean{ + return (this._mipMapping); + } + + public function get stretchNotPowerOf2Textures():Boolean{ + return (this._stretchNotPowerOf2Textures); + } + + public function get correctionU():Number{ + return (this._correctionU); + } + + public function get correctionV():Number{ + return (this._correctionV); + } + + public function get calculateMipMapsUsingGPU():Boolean{ + return (this._calculateMipMapsUsingGPU); + } + + public function set calculateMipMapsUsingGPU(_arg_1:Boolean):void{ + this._calculateMipMapsUsingGPU = _arg_1; + } + + public function forceDispose():void{ + this.referencesCount = 1; + this.dispose(); + this._bitmapData = null; + } + + override public function dispose():void{ + if (this.referencesCount == 0) + { + return; + }; + this.referencesCount--; + if (this.referencesCount == 0) + { + TextureResourcesRegistry.release(this._bitmapData); + this._bitmapData = null; + super.dispose(); + }; + } + + override public function get available():Boolean{ + return (!(this._bitmapData == null)); + } + + override protected function getNullTexture():Texture{ + return (nullTexture); + } + + private function freeMemory():void{ + useNullTexture = true; + this._mipMapping = false; + this.forceDispose(); + } + + override alternativagfx function create(context:Context3D):void{ + super.create(context); + if (((nullTexture == null) || (!(nullTextureContext == context)))) + { + nullTexture = context.createTexture(1, 1, Context3DTextureFormat.BGRA, false); + nullTexture.uploadFromBitmapData(new BitmapData(1, 1, true, 1439485132)); + nullTextureContext = context; + }; + if ((!(useNullTexture))) + { + try + { + texture = context.createTexture(this.correctedWidth, this.correctedHeight, Context3DTextureFormat.BGRA, false); + } catch(e:Error) + { + freeMemory(); + }; + }; + } + + override alternativagfx function upload():void{ + var _local_1:BitmapData; + var _local_2:BitmapData; + var _local_3:int; + var _local_4:int; + var _local_5:int; + var _local_6:BitmapData; + if (useNullTexture) + { + return; + }; + if (((this._bitmapData.width == this.correctedWidth) && (this._bitmapData.height == this.correctedHeight))) + { + _local_1 = this._bitmapData; + } else + { + _local_1 = new BitmapData(this.correctedWidth, this.correctedHeight, this._bitmapData.transparent, 0); + if ((((this._bitmapData.width <= 0x0800) && (this._bitmapData.height <= 0x0800)) && (!(this._stretchNotPowerOf2Textures)))) + { + _local_1.copyPixels(this._bitmapData, this._bitmapData.rect, point); + if (this._bitmapData.width < _local_1.width) + { + _local_2 = new BitmapData(1, this._bitmapData.height, this._bitmapData.transparent, 0); + rectangle.setTo((this._bitmapData.width - 1), 0, 1, this._bitmapData.height); + _local_2.copyPixels(this._bitmapData, rectangle, point); + matrix.setTo((_local_1.width - this._bitmapData.width), 0, 0, 1, this._bitmapData.width, 0); + _local_1.draw(_local_2, matrix, null, null, null, false); + _local_2.dispose(); + }; + if (this._bitmapData.height < _local_1.height) + { + _local_2 = new BitmapData(this._bitmapData.width, 1, this._bitmapData.transparent, 0); + rectangle.setTo(0, (this._bitmapData.height - 1), this._bitmapData.width, 1); + _local_2.copyPixels(this._bitmapData, rectangle, point); + matrix.setTo(1, 0, 0, (_local_1.height - this._bitmapData.height), 0, this._bitmapData.height); + _local_1.draw(_local_2, matrix, null, null, null, false); + _local_2.dispose(); + }; + if (((this._bitmapData.width < _local_1.width) && (this._bitmapData.height < _local_1.height))) + { + _local_2 = new BitmapData(1, 1, this._bitmapData.transparent, 0); + rectangle.setTo((this._bitmapData.width - 1), (this._bitmapData.height - 1), 1, 1); + _local_2.copyPixels(this._bitmapData, rectangle, point); + matrix.setTo((_local_1.width - this._bitmapData.width), 0, 0, (_local_1.height - this._bitmapData.height), this._bitmapData.width, this._bitmapData.height); + _local_1.draw(_local_2, matrix, null, null, null, false); + _local_2.dispose(); + }; + } else + { + matrix.setTo((this.correctedWidth / this._bitmapData.width), 0, 0, (this.correctedHeight / this._bitmapData.height), 0, 0); + _local_1.draw(this._bitmapData, matrix, null, null, null, true); + }; + }; + if (this._mipMapping > 0) + { + this.uploadTexture(_local_1, 0); + matrix.identity(); + _local_3 = 1; + _local_4 = _local_1.width; + _local_5 = _local_1.height; + while ((((_local_4 % 2) == 0) || ((_local_5 % 2) == 0))) + { + _local_4 = (_local_4 >> 1); + _local_5 = (_local_5 >> 1); + if (_local_4 == 0) + { + _local_4 = 1; + }; + if (_local_5 == 0) + { + _local_5 = 1; + }; + _local_6 = new BitmapData(_local_4, _local_5, _local_1.transparent, 0); + matrix.a = (_local_4 / _local_1.width); + matrix.d = (_local_5 / _local_1.height); + _local_6.draw(_local_1, matrix, null, null, null, false); + this.uploadTexture(_local_6, _local_3++); + _local_6.dispose(); + }; + } else + { + this.uploadTexture(_local_1, 0); + }; + if (_local_1 != this._bitmapData) + { + _local_1.dispose(); + }; + } + + protected function uploadTexture(source:BitmapData, mipLevel:uint):void{ + try + { + if (texture != nullTexture) + { + texture.uploadFromBitmapData(source, mipLevel); + }; + } catch(e:Error) + { + freeMemory(); + }; + } + + public function increaseReferencesCount():void{ + this.referencesCount++; + } + + + } +}//package alternativa.gfx.core \ No newline at end of file diff --git a/src/alternativa/gfx/core/CompressedTextureResource.as b/src/alternativa/gfx/core/CompressedTextureResource.as new file mode 100644 index 0000000..2d004d2 --- /dev/null +++ b/src/alternativa/gfx/core/CompressedTextureResource.as @@ -0,0 +1,60 @@ +package alternativa.gfx.core{ + import flash.utils.ByteArray; + import flash.utils.Endian; + import flash.display3D.Context3DTextureFormat; + import flash.display3D.Context3D; + import alternativa.gfx.alternativagfx; + + use namespace alternativagfx; + + public class CompressedTextureResource extends TextureResource { + + private var _byteArray:ByteArray; + private var _width:int; + private var _height:int; + + public function CompressedTextureResource(_arg_1:ByteArray){ + this._byteArray = _arg_1; + this._byteArray.endian = Endian.LITTLE_ENDIAN; + this._byteArray.position = 7; + this._width = (1 << this._byteArray.readByte()); + this._height = (1 << this._byteArray.readByte()); + this._byteArray.position = 0; + } + + public function get byteArray():ByteArray{ + return (this._byteArray); + } + + public function get width():int{ + return (this._width); + } + + public function get height():int{ + return (this._height); + } + + override public function dispose():void{ + super.dispose(); + this._byteArray = null; + this._width = 0; + this._height = 0; + } + + override public function get available():Boolean{ + return (!(this._byteArray == null)); + } + + override alternativagfx function create(_arg_1:Context3D):void{ + super.create(_arg_1); + texture = _arg_1.createTexture(this._width, this._height, Context3DTextureFormat.COMPRESSED, false); + } + + override alternativagfx function upload():void{ + super.upload(); + texture.uploadCompressedTextureFromByteArray(this._byteArray, 0); + } + + + } +}//package alternativa.gfx.core \ No newline at end of file diff --git a/src/alternativa/gfx/core/Device.as b/src/alternativa/gfx/core/Device.as new file mode 100644 index 0000000..5386deb --- /dev/null +++ b/src/alternativa/gfx/core/Device.as @@ -0,0 +1,684 @@ +package alternativa.gfx.core{ + import flash.events.EventDispatcher; + import flash.display.Stage; + import flash.display.Stage3D; + import flash.utils.Dictionary; + import flash.events.Event; + import flash.display3D.Context3D; + import flash.display3D.Context3DProgramType; + import flash.geom.Rectangle; + import __AS3__.vec.Vector; + import flash.display.BitmapData; + import alternativa.gfx.alternativagfx; + + use namespace alternativagfx; + + [Event(name="context3DCreate", type="flash.events.Event")] + public class Device extends EventDispatcher { + + private static const RESOURCE_NOT_AVAILABLE_ERROR:String = "Resource is not available."; + + private var _stage:Stage; + private var _renderMode:String; + private var _profile:String; + private var _x:int; + private var _y:int; + private var _width:int; + private var _height:int; + private var _antiAlias:int; + private var _enableDepthAndStencil:Boolean; + private var _enableErrorChecking:Boolean; + private var _stage3D:Stage3D; + private var _available:Boolean = true; + private var _renderState:RenderState = new RenderState(); + private var configured:Boolean = false; + private var backBufferWidth:int = -1; + private var backBufferHeight:int = -1; + private var backBufferAntiAlias:int = -1; + private var backBufferEnableDepthAndStencil:Boolean = false; + private var resourcesToUpload:Dictionary = new Dictionary(); + + public function Device(_arg_1:Stage, _arg_2:String="auto", _arg_3:String="baseline"){ + this._stage = _arg_1; + this._renderMode = _arg_2; + this._profile = _arg_3; + this._stage3D = this._stage.stage3Ds[0]; + this._x = this._stage3D.x; + this._y = this._stage3D.y; + this._width = _arg_1.stageWidth; + this._height = _arg_1.stageHeight; + this._antiAlias = 0; + this._enableDepthAndStencil = true; + this._enableErrorChecking = false; + this._stage3D.addEventListener(Event.CONTEXT3D_CREATE, this.onContext3DCreate); + if (this._stage3D.requestContext3D.length > 1) + { + this._stage3D.requestContext3D(_arg_2, _arg_3); + } else + { + this._stage3D.requestContext3D(_arg_2); + }; + } + + private function onContext3DCreate(_arg_1:Event):void{ + var _local_3:*; + var _local_5:TextureResource; + var _local_6:VertexBufferResource; + this.configured = false; + this.backBufferWidth = -1; + this.backBufferHeight = -1; + this.backBufferAntiAlias = -1; + this.backBufferEnableDepthAndStencil = false; + var _local_2:Context3D = this._stage3D.context3D; + _local_2.enableErrorChecking = this._enableErrorChecking; + for (_local_3 in this.resourcesToUpload) + { + this.uploadResource(_local_3); + delete this.resourcesToUpload[_local_3]; + }; + _local_2.setBlendFactors(this._renderState.blendSourceFactor, this._renderState.blendDestinationFactor); + _local_2.setColorMask(this._renderState.colorMaskRed, this._renderState.colorMaskGreen, this._renderState.colorMaskBlue, this._renderState.colorMaskAlpha); + _local_2.setCulling(this._renderState.culling); + _local_2.setDepthTest(this._renderState.depthTestMask, this._renderState.depthTestPassCompareMode); + if (this._renderState.program != null) + { + if ((!(this._renderState.program.available))) + { + throw (new Error(RESOURCE_NOT_AVAILABLE_ERROR)); + }; + this.prepareResource(_local_2, this._renderState.program); + _local_2.setProgram(this._renderState.program.program); + }; + if (this._renderState.renderTarget != null) + { + if ((!(this._renderState.renderTarget.available))) + { + throw (new Error(RESOURCE_NOT_AVAILABLE_ERROR)); + }; + this.prepareResource(_local_2, this._renderState.renderTarget); + _local_2.setRenderToTexture(this._renderState.renderTarget.texture, this._renderState.renderTargetEnableDepthAndStencil, this._renderState.renderTargetAntiAlias, this._renderState.renderTargetSurfaceSelector); + }; + if (this._renderState.scissor) + { + _local_2.setScissorRectangle(this._renderState.scissorRectangle); + } else + { + _local_2.setScissorRectangle(null); + }; + _local_2.setStencilActions(this._renderState.stencilActionTriangleFace, this._renderState.stencilActionCompareMode, this._renderState.stencilActionOnBothPass, this._renderState.stencilActionOnDepthFail, this._renderState.stencilActionOnDepthPassStencilFail); + _local_2.setStencilReferenceValue(this._renderState.stencilReferenceValue, this._renderState.stencilReadMask, this._renderState.stencilWriteMask); + var _local_4:int; + while (_local_4 < 8) + { + _local_5 = this._renderState.textures[_local_4]; + if (_local_5 != null) + { + if ((!(_local_5.available))) + { + throw (new Error(RESOURCE_NOT_AVAILABLE_ERROR)); + }; + this.prepareResource(_local_2, _local_5); + _local_2.setTextureAt(_local_4, _local_5.texture); + }; + _local_6 = this._renderState.vertexBuffers[_local_4]; + if (_local_6 != null) + { + if ((!(_local_6.available))) + { + throw (new Error(RESOURCE_NOT_AVAILABLE_ERROR)); + }; + this.prepareResource(_local_2, _local_6); + _local_2.setVertexBufferAt(_local_4, _local_6.buffer, this._renderState.vertexBuffersOffsets[_local_4], this._renderState.vertexBuffersFormats[_local_4]); + }; + _local_4++; + }; + _local_2.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 0, this._renderState.vertexConstants, 128); + _local_2.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 0, this._renderState.fragmentConstants, 28); + dispatchEvent(new Event(Event.CONTEXT3D_CREATE)); + } + + public function dispose():void{ + var _local_1:*; + this._stage3D.removeEventListener(Event.CONTEXT3D_CREATE, this.onContext3DCreate); + if (this._stage3D.context3D != null) + { + this._stage3D.context3D.dispose(); + }; + for (_local_1 in this.resourcesToUpload) + { + delete this.resourcesToUpload[_local_1]; + }; + this._renderState = new RenderState(); + this._available = false; + } + + public function reset():void{ + var _local_1:*; + if (this._stage3D.context3D != null) + { + this._stage3D.context3D.dispose(); + } else + { + for (_local_1 in this.resourcesToUpload) + { + delete this.resourcesToUpload[_local_1]; + }; + }; + this._renderState = new RenderState(); + } + + public function get available():Boolean{ + return (this._available); + } + + public function get ready():Boolean{ + return (!(this._stage3D.context3D == null)); + } + + public function get stage():Stage{ + return (this._stage); + } + + public function get stage3DIndex():int{ + return (0); + } + + public function get renderMode():String{ + return (this._renderMode); + } + + public function get profile():String{ + return (this._profile); + } + + public function get x():int{ + return (this._x); + } + + public function set x(_arg_1:int):void{ + this._x = _arg_1; + } + + public function get y():int{ + return (this._y); + } + + public function set y(_arg_1:int):void{ + this._y = _arg_1; + } + + public function get width():int{ + return (this._width); + } + + public function set width(_arg_1:int):void{ + this._width = _arg_1; + } + + public function get height():int{ + return (this._height); + } + + public function set height(_arg_1:int):void{ + this._height = _arg_1; + } + + public function get antiAlias():int{ + return (this._antiAlias); + } + + public function set antiAlias(_arg_1:int):void{ + if (((((!(_arg_1 == 0)) && (!(_arg_1 == 2))) && (!(_arg_1 == 4))) && (!(_arg_1 == 16)))) + { + throw (new Error("Invalid antialiasing value.")); + }; + this._antiAlias = _arg_1; + } + + public function get enableDepthAndStencil():Boolean{ + return (this._enableDepthAndStencil); + } + + public function set enableDepthAndStencil(_arg_1:Boolean):void{ + this._enableDepthAndStencil = _arg_1; + } + + public function get enableErrorChecking():Boolean{ + return (this._enableErrorChecking); + } + + public function set enableErrorChecking(_arg_1:Boolean):void{ + this._enableErrorChecking = _arg_1; + var _local_2:Context3D = this._stage3D.context3D; + if (((!(_local_2 == null)) && (!(_local_2.enableErrorChecking == this._enableErrorChecking)))) + { + _local_2.enableErrorChecking = this._enableErrorChecking; + }; + } + + public function uploadResource(_arg_1:Resource):void{ + if ((!(_arg_1.available))) + { + throw (new Error(RESOURCE_NOT_AVAILABLE_ERROR)); + }; + var _local_2:Context3D = this._stage3D.context3D; + if (_local_2 != null) + { + if ((!(_arg_1.isCreated(_local_2)))) + { + _arg_1.create(_local_2); + }; + _arg_1.upload(); + } else + { + this.resourcesToUpload[_arg_1] = true; + }; + } + + private function prepareResource(_arg_1:Context3D, _arg_2:Resource):void{ + if ((!(_arg_2.isCreated(_arg_1)))) + { + _arg_2.create(_arg_1); + _arg_2.upload(); + }; + } + + public function setBlendFactors(_arg_1:String, _arg_2:String):void{ + var _local_3:Context3D; + if (((!(_arg_1 == this._renderState.blendSourceFactor)) || (!(_arg_2 == this._renderState.blendDestinationFactor)))) + { + this._renderState.blendSourceFactor = _arg_1; + this._renderState.blendDestinationFactor = _arg_2; + _local_3 = this._stage3D.context3D; + if (_local_3 != null) + { + _local_3.setBlendFactors(_arg_1, _arg_2); + }; + }; + } + + public function setColorMask(_arg_1:Boolean, _arg_2:Boolean, _arg_3:Boolean, _arg_4:Boolean):void{ + var _local_5:Context3D; + if (((((!(_arg_1 == this._renderState.colorMaskRed)) || (!(_arg_2 == this._renderState.colorMaskGreen))) || (!(_arg_3 == this._renderState.colorMaskBlue))) || (!(_arg_4 == this._renderState.colorMaskAlpha)))) + { + this._renderState.colorMaskRed = _arg_1; + this._renderState.colorMaskGreen = _arg_2; + this._renderState.colorMaskBlue = _arg_3; + this._renderState.colorMaskAlpha = _arg_4; + _local_5 = this._stage3D.context3D; + if (_local_5 != null) + { + _local_5.setColorMask(_arg_1, _arg_2, _arg_3, _arg_4); + }; + }; + } + + public function setCulling(_arg_1:String):void{ + var _local_2:Context3D; + if (_arg_1 != this._renderState.culling) + { + this._renderState.culling = _arg_1; + _local_2 = this._stage3D.context3D; + if (_local_2 != null) + { + _local_2.setCulling(_arg_1); + }; + }; + } + + public function setDepthTest(_arg_1:Boolean, _arg_2:String):void{ + var _local_3:Context3D; + if (((!(_arg_1 == this._renderState.depthTestMask)) || (!(_arg_2 == this._renderState.depthTestPassCompareMode)))) + { + this._renderState.depthTestMask = _arg_1; + this._renderState.depthTestPassCompareMode = _arg_2; + _local_3 = this._stage3D.context3D; + if (_local_3 != null) + { + _local_3.setDepthTest(_arg_1, _arg_2); + }; + }; + } + + public function setProgram(_arg_1:ProgramResource):void{ + var _local_2:Context3D; + if (_arg_1 != this._renderState.program) + { + if ((!(_arg_1.available))) + { + throw (new Error(RESOURCE_NOT_AVAILABLE_ERROR)); + }; + this._renderState.program = _arg_1; + _local_2 = this._stage3D.context3D; + if (_local_2 != null) + { + this.prepareResource(_local_2, _arg_1); + _local_2.setProgram(_arg_1.program); + }; + }; + } + + public function setRenderToBackBuffer():void{ + var _local_1:Context3D; + if (this._renderState.renderTarget != null) + { + this._renderState.renderTarget = null; + _local_1 = this._stage3D.context3D; + if (_local_1 != null) + { + _local_1.setRenderToBackBuffer(); + }; + }; + } + + public function setRenderToTexture(_arg_1:TextureResource, _arg_2:Boolean=false, _arg_3:int=0, _arg_4:int=0):void{ + var _local_5:Context3D; + if (((((!(_arg_1 == this._renderState.renderTarget)) || (!(_arg_2 == this._renderState.renderTargetEnableDepthAndStencil))) || (!(_arg_3 == this._renderState.renderTargetAntiAlias))) || (!(_arg_4 == this._renderState.renderTargetSurfaceSelector)))) + { + if (((!(_arg_1 == null)) && (!(_arg_1.available)))) + { + throw (new Error(RESOURCE_NOT_AVAILABLE_ERROR)); + }; + this._renderState.renderTarget = _arg_1; + this._renderState.renderTargetEnableDepthAndStencil = _arg_2; + this._renderState.renderTargetAntiAlias = _arg_3; + this._renderState.renderTargetSurfaceSelector = _arg_4; + _local_5 = this._stage3D.context3D; + if (_local_5 != null) + { + if (_arg_1 != null) + { + this.prepareResource(_local_5, _arg_1); + _local_5.setRenderToTexture(_arg_1.texture, _arg_2, _arg_3, _arg_4); + } else + { + _local_5.setRenderToBackBuffer(); + }; + }; + }; + } + + public function setScissorRectangle(_arg_1:Rectangle):void{ + var _local_2:Context3D = this._stage3D.context3D; + if (_arg_1 != null) + { + if (this._renderState.scissor) + { + if (((((!(_arg_1.x == this._renderState.scissorRectangle.x)) || (!(_arg_1.y == this._renderState.scissorRectangle.y))) || (!(_arg_1.width == this._renderState.scissorRectangle.width))) || (!(_arg_1.height == this._renderState.scissorRectangle.height)))) + { + this._renderState.scissorRectangle.x = _arg_1.x; + this._renderState.scissorRectangle.y = _arg_1.y; + this._renderState.scissorRectangle.width = _arg_1.width; + this._renderState.scissorRectangle.height = _arg_1.height; + if (_local_2 != null) + { + _local_2.setScissorRectangle(_arg_1); + }; + }; + } else + { + this._renderState.scissor = true; + this._renderState.scissorRectangle.x = _arg_1.x; + this._renderState.scissorRectangle.y = _arg_1.y; + this._renderState.scissorRectangle.width = _arg_1.width; + this._renderState.scissorRectangle.height = _arg_1.height; + if (_local_2 != null) + { + _local_2.setScissorRectangle(_arg_1); + }; + }; + } else + { + this._renderState.scissor = false; + if (_local_2 != null) + { + _local_2.setScissorRectangle(null); + }; + }; + } + + public function setStencilActions(_arg_1:String="frontAndBack", _arg_2:String="always", _arg_3:String="keep", _arg_4:String="keep", _arg_5:String="keep"):void{ + var _local_6:Context3D; + if ((((((!(_arg_1 == this._renderState.stencilActionTriangleFace)) || (!(_arg_2 == this._renderState.stencilActionCompareMode))) || (!(_arg_3 == this._renderState.stencilActionOnBothPass))) || (!(_arg_4 == this._renderState.stencilActionOnDepthFail))) || (!(_arg_5 == this._renderState.stencilActionOnDepthPassStencilFail)))) + { + this._renderState.stencilActionTriangleFace = _arg_1; + this._renderState.stencilActionCompareMode = _arg_2; + this._renderState.stencilActionOnBothPass = _arg_3; + this._renderState.stencilActionOnDepthFail = _arg_4; + this._renderState.stencilActionOnDepthPassStencilFail = _arg_5; + _local_6 = this._stage3D.context3D; + if (_local_6 != null) + { + _local_6.setStencilActions(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5); + }; + }; + } + + public function setStencilReferenceValue(_arg_1:uint, _arg_2:uint=0xFF, _arg_3:uint=0xFF):void{ + var _local_4:Context3D; + if ((((!(_arg_1 == this._renderState.stencilReferenceValue)) || (!(_arg_2 == this._renderState.stencilReadMask))) || (!(_arg_3 == this._renderState.stencilWriteMask)))) + { + this._renderState.stencilReferenceValue = _arg_1; + this._renderState.stencilReadMask = _arg_2; + this._renderState.stencilWriteMask = _arg_3; + _local_4 = this._stage3D.context3D; + if (_local_4 != null) + { + _local_4.setStencilReferenceValue(_arg_1, _arg_2, _arg_3); + }; + }; + } + + public function setTextureAt(_arg_1:int, _arg_2:TextureResource):void{ + var _local_3:Context3D; + if (_arg_2 != this._renderState.textures[_arg_1]) + { + if (((!(_arg_2 == null)) && (!(_arg_2.available)))) + { + throw (new Error(RESOURCE_NOT_AVAILABLE_ERROR)); + }; + this._renderState.textures[_arg_1] = _arg_2; + _local_3 = this._stage3D.context3D; + if (_local_3 != null) + { + if (_arg_2 != null) + { + this.prepareResource(_local_3, _arg_2); + _local_3.setTextureAt(_arg_1, _arg_2.texture); + } else + { + _local_3.setTextureAt(_arg_1, null); + }; + }; + }; + } + + public function setVertexBufferAt(_arg_1:int, _arg_2:VertexBufferResource, _arg_3:int=0, _arg_4:String="float4"):void{ + var _local_5:Context3D; + if ((((!(_arg_2 == this._renderState.vertexBuffers[_arg_1])) || (!(_arg_3 == this._renderState.vertexBuffersOffsets[_arg_1]))) || (!(_arg_4 == this._renderState.vertexBuffersFormats[_arg_1])))) + { + if (((!(_arg_2 == null)) && (!(_arg_2.available)))) + { + throw (new Error(RESOURCE_NOT_AVAILABLE_ERROR)); + }; + this._renderState.vertexBuffers[_arg_1] = _arg_2; + this._renderState.vertexBuffersOffsets[_arg_1] = _arg_3; + this._renderState.vertexBuffersFormats[_arg_1] = _arg_4; + _local_5 = this._stage3D.context3D; + if (_local_5 != null) + { + if (_arg_2 != null) + { + this.prepareResource(_local_5, _arg_2); + _local_5.setVertexBufferAt(_arg_1, _arg_2.buffer, _arg_3, _arg_4); + } else + { + _local_5.setVertexBufferAt(_arg_1, null); + }; + }; + }; + } + + public function setProgramConstantsFromVector(_arg_1:String, _arg_2:int, _arg_3:Vector., _arg_4:int=-1, _arg_5:Boolean=true):void{ + var _local_6:Context3D; + var _local_11:Boolean; + var _local_12:Number; + var _local_7:int; + var _local_8:int = (_arg_2 << 2); + var _local_9:int = ((_arg_4 < 0) ? _arg_3.length : (_arg_4 << 2)); + var _local_10:Vector. = ((_arg_1 == "vertex") ? this._renderState.vertexConstants : this._renderState.fragmentConstants); + if (_arg_5) + { + _local_11 = false; + while (_local_7 < _local_9) + { + _local_12 = _arg_3[_local_7]; + if (_local_12 != _local_10[_local_8]) + { + _local_10[_local_8] = _local_12; + _local_11 = true; + }; + _local_7++; + _local_8++; + }; + if (_local_11) + { + _local_6 = this._stage3D.context3D; + if (_local_6 != null) + { + _local_6.setProgramConstantsFromVector(_arg_1, _arg_2, _arg_3, _arg_4); + }; + }; + } else + { + while (_local_7 < _local_9) + { + _local_10[_local_8] = _arg_3[_local_7]; + _local_7++; + _local_8++; + }; + _local_6 = this._stage3D.context3D; + if (_local_6 != null) + { + _local_6.setProgramConstantsFromVector(_arg_1, _arg_2, _arg_3, _arg_4); + }; + }; + } + + public function clear(_arg_1:Number=0, _arg_2:Number=0, _arg_3:Number=0, _arg_4:Number=1, _arg_5:Number=1, _arg_6:uint=0, _arg_7:uint=0xFFFFFFFF):void{ + var _local_9:int; + var _local_10:int; + var _local_11:int; + var _local_12:int; + var _local_13:int; + var _local_8:Context3D = this._stage3D.context3D; + if (_local_8 != null) + { + if ((!(this.configured))) + { + _local_9 = 50; + _local_10 = this._width; + _local_11 = this._height; + if (this._profile == "baselineConstrained") + { + _local_12 = this._x; + _local_13 = this._y; + if (_local_12 < 0) + { + _local_12 = 0; + }; + if (_local_13 < 0) + { + _local_13 = 0; + }; + if ((_local_12 + _local_10) > this.stage.stageWidth) + { + _local_10 = (this.stage.stageWidth - _local_12); + }; + if ((_local_13 + _local_11) > this.stage.stageHeight) + { + _local_11 = (this.stage.stageHeight - _local_13); + }; + if ((((((!(_local_12 == this._stage3D.x)) || (!(_local_13 == this._stage3D.y))) || (!(_local_10 == this.backBufferWidth))) || (!(_local_11 == this.backBufferHeight))) || (!(this._enableDepthAndStencil == this.backBufferEnableDepthAndStencil)))) + { + _local_8.configureBackBuffer(_local_9, _local_9, 0, this._enableDepthAndStencil); + this._stage3D.x = _local_12; + this._stage3D.y = _local_13; + _local_8.configureBackBuffer(_local_10, _local_11, 0, this._enableDepthAndStencil); + this.backBufferWidth = _local_10; + this.backBufferHeight = _local_11; + this.backBufferAntiAlias = this._antiAlias; + this.backBufferEnableDepthAndStencil = this._enableDepthAndStencil; + }; + } else + { + if (this._stage3D.x != this._x) + { + this._stage3D.x = this._x; + }; + if (this._stage3D.y != this._y) + { + this._stage3D.y = this._y; + }; + if (_local_10 < _local_9) + { + _local_10 = _local_9; + }; + if (_local_11 < _local_9) + { + _local_11 = _local_9; + }; + if (((((!(_local_10 == this.backBufferWidth)) || (!(_local_11 == this.backBufferHeight))) || (!(this._antiAlias == this.backBufferAntiAlias))) || (!(this._enableDepthAndStencil == this.backBufferEnableDepthAndStencil)))) + { + _local_8.configureBackBuffer(_local_10, _local_11, this._antiAlias, this._enableDepthAndStencil); + this.backBufferWidth = _local_10; + this.backBufferHeight = _local_11; + this.backBufferAntiAlias = this._antiAlias; + this.backBufferEnableDepthAndStencil = this._enableDepthAndStencil; + }; + }; + this.configured = true; + }; + _local_8.clear(_arg_1, _arg_2, _arg_3, _arg_4, _arg_5, _arg_6, _arg_7); + }; + } + + public function drawToBitmapData(_arg_1:BitmapData):void{ + var _local_2:Context3D = this._stage3D.context3D; + if (_local_2 != null) + { + _local_2.drawToBitmapData(_arg_1); + }; + } + + public function drawTriangles(_arg_1:IndexBufferResource, _arg_2:int=0, _arg_3:int=-1):void{ + if ((!(_arg_1.available))) + { + throw (new Error(RESOURCE_NOT_AVAILABLE_ERROR)); + }; + var _local_4:Context3D = this._stage3D.context3D; + if (_local_4 != null) + { + this.prepareResource(_local_4, _arg_1); + try + { + _local_4.drawTriangles(_arg_1.buffer, _arg_2, _arg_3); + } catch(e:Error) + { + }; + }; + } + + public function present():void{ + this._renderState.renderTarget = null; + var _local_1:Context3D = this._stage3D.context3D; + if (_local_1 != null) + { + _local_1.present(); + }; + this.configured = false; + } + + + } +}//package alternativa.gfx.core \ No newline at end of file diff --git a/src/alternativa/gfx/core/IndexBufferResource.as b/src/alternativa/gfx/core/IndexBufferResource.as new file mode 100644 index 0000000..f9a437b --- /dev/null +++ b/src/alternativa/gfx/core/IndexBufferResource.as @@ -0,0 +1,68 @@ +package alternativa.gfx.core +{ + import flash.display3D.IndexBuffer3D; + import __AS3__.vec.Vector; + import flash.display3D.Context3D; + import alternativa.gfx.alternativagfx; + + use namespace alternativagfx; + + public class IndexBufferResource extends Resource + { + + alternativagfx var buffer:IndexBuffer3D; + private var _indices:Vector.; + private var _numIndices:int; + + public function IndexBufferResource(_arg_1:Vector.) + { + this._indices = _arg_1; + this._numIndices = this._indices.length; + } + + public function get indices():Vector. + { + return (this._indices); + } + + override public function dispose():void + { + super.dispose(); + if (this.buffer != null) + { + this.buffer.dispose(); + this.buffer = null; + }; + this._indices = null; + } + + override public function reset():void + { + super.reset(); + if (this.buffer != null) + { + this.buffer.dispose(); + this.buffer = null; + }; + } + + override public function get available():Boolean + { + return (!(this._indices == null)); + } + + override alternativagfx function create(_arg_1:Context3D):void + { + super.create(_arg_1); + this.buffer = _arg_1.createIndexBuffer(this._numIndices); + } + + override alternativagfx function upload():void + { + super.upload(); + this.buffer.uploadFromVector(this._indices, 0, this._numIndices); + } + + + } +}//package alternativa.gfx.core \ No newline at end of file diff --git a/src/alternativa/gfx/core/ProgramResource.as b/src/alternativa/gfx/core/ProgramResource.as new file mode 100644 index 0000000..4e7aa20 --- /dev/null +++ b/src/alternativa/gfx/core/ProgramResource.as @@ -0,0 +1,74 @@ +package alternativa.gfx.core +{ + import flash.display3D.Program3D; + import flash.utils.ByteArray; + import flash.display3D.Context3D; + import alternativa.gfx.alternativagfx; + + use namespace alternativagfx; + + public class ProgramResource extends Resource + { + + alternativagfx var program:Program3D; + private var _vertexProgram:ByteArray; + private var _fragmentProgram:ByteArray; + + public function ProgramResource(_arg_1:ByteArray, _arg_2:ByteArray) + { + this._vertexProgram = _arg_1; + this._fragmentProgram = _arg_2; + } + + public function get vertexProgram():ByteArray + { + return (this._vertexProgram); + } + + public function get fragmentProgram():ByteArray + { + return (this._fragmentProgram); + } + + override public function dispose():void + { + super.dispose(); + if (this.program != null) + { + this.program.dispose(); + this.program = null; + }; + this._vertexProgram = null; + this._fragmentProgram = null; + } + + override public function reset():void + { + super.reset(); + if (this.program != null) + { + this.program.dispose(); + this.program = null; + }; + } + + override public function get available():Boolean + { + return ((!(this._vertexProgram == null)) && (!(this._fragmentProgram == null))); + } + + override alternativagfx function create(_arg_1:Context3D):void + { + super.create(_arg_1); + this.program = _arg_1.createProgram(); + } + + override alternativagfx function upload():void + { + super.upload(); + this.program.upload(this.vertexProgram, this.fragmentProgram); + } + + + } +}//package alternativa.gfx.core \ No newline at end of file diff --git a/src/alternativa/gfx/core/RenderState.as b/src/alternativa/gfx/core/RenderState.as new file mode 100644 index 0000000..b06434c --- /dev/null +++ b/src/alternativa/gfx/core/RenderState.as @@ -0,0 +1,41 @@ +package alternativa.gfx.core{ + import flash.geom.Rectangle; + import __AS3__.vec.Vector; + import __AS3__.vec.*; + + public class RenderState { + + public var blendSourceFactor:String = "one"; + public var blendDestinationFactor:String = "zero"; + public var colorMaskRed:Boolean = true; + public var colorMaskGreen:Boolean = true; + public var colorMaskBlue:Boolean = true; + public var colorMaskAlpha:Boolean = true; + public var culling:String = "none"; + public var depthTestMask:Boolean = true; + public var depthTestPassCompareMode:String = "less"; + public var program:ProgramResource = null; + public var renderTarget:TextureResource = null; + public var renderTargetEnableDepthAndStencil:Boolean = false; + public var renderTargetAntiAlias:int = 0; + public var renderTargetSurfaceSelector:int = 0; + public var scissor:Boolean = false; + public var scissorRectangle:Rectangle = new Rectangle(); + public var stencilActionTriangleFace:String = "frontAndBack"; + public var stencilActionCompareMode:String = "always"; + public var stencilActionOnBothPass:String = "keep"; + public var stencilActionOnDepthFail:String = "keep"; + public var stencilActionOnDepthPassStencilFail:String = "keep"; + public var stencilReferenceValue:uint = 0; + public var stencilReadMask:uint = 0xFF; + public var stencilWriteMask:uint = 0xFF; + public var textures:Vector. = new Vector.(8, true); + public var vertexBuffers:Vector. = new Vector.(8, true); + public var vertexBuffersOffsets:Vector. = new Vector.(8, true); + public var vertexBuffersFormats:Vector. = new Vector.(8, true); + public var vertexConstants:Vector. = new Vector.((128 * 4), true); + public var fragmentConstants:Vector. = new Vector.((28 * 4), true); + + + } +}//package alternativa.gfx.core \ No newline at end of file diff --git a/src/alternativa/gfx/core/RenderTargetTextureResource.as b/src/alternativa/gfx/core/RenderTargetTextureResource.as new file mode 100644 index 0000000..88a0a44 --- /dev/null +++ b/src/alternativa/gfx/core/RenderTargetTextureResource.as @@ -0,0 +1,43 @@ +package alternativa.gfx.core{ + import flash.display3D.Context3DTextureFormat; + import flash.display3D.Context3D; + import alternativa.gfx.alternativagfx; + + use namespace alternativagfx; + + public class RenderTargetTextureResource extends TextureResource { + + private var _width:int; + private var _height:int; + private var _available:Boolean = true; + + public function RenderTargetTextureResource(_arg_1:int, _arg_2:int){ + this._width = _arg_1; + this._height = _arg_2; + } + + public function get width():int{ + return (this._width); + } + + public function get height():int{ + return (this._height); + } + + override public function dispose():void{ + super.dispose(); + this._available = false; + } + + override public function get available():Boolean{ + return (this._available); + } + + override alternativagfx function create(_arg_1:Context3D):void{ + super.create(_arg_1); + texture = _arg_1.createTexture(this._width, this._height, Context3DTextureFormat.BGRA, true); + } + + + } +}//package alternativa.gfx.core \ No newline at end of file diff --git a/src/alternativa/gfx/core/Resource.as b/src/alternativa/gfx/core/Resource.as new file mode 100644 index 0000000..0f3e2d7 --- /dev/null +++ b/src/alternativa/gfx/core/Resource.as @@ -0,0 +1,37 @@ +package alternativa.gfx.core{ + import flash.display3D.Context3D; + import alternativa.gfx.alternativagfx; + + use namespace alternativagfx; + + public class Resource { + + public var context:Context3D = null; + + + public function dispose():void{ + this.context = null; + } + + public function reset():void{ + this.context = null; + } + + public function get available():Boolean{ + return (false); + } + + alternativagfx function create(_arg_1:Context3D):void{ + this.context = _arg_1; + } + + alternativagfx function upload():void{ + } + + public function isCreated(_arg_1:Context3D):Boolean{ + return ((!(this.context == null)) && (this.context == _arg_1)); + } + + + } +}//package alternativa.gfx.core \ No newline at end of file diff --git a/src/alternativa/gfx/core/TextureResource.as b/src/alternativa/gfx/core/TextureResource.as new file mode 100644 index 0000000..ad4bc57 --- /dev/null +++ b/src/alternativa/gfx/core/TextureResource.as @@ -0,0 +1,37 @@ +package alternativa.gfx.core{ + import flash.display3D.textures.Texture; + + public class TextureResource extends Resource { + + protected var useNullTexture:Boolean = false; + private var _texture:Texture = null; + + + override public function dispose():void{ + super.dispose(); + if (this._texture != null) + { + this._texture.dispose(); + this._texture = null; + }; + } + + public function get texture():Texture{ + if (this.useNullTexture) + { + return (this.getNullTexture()); + }; + return (this._texture); + } + + public function set texture(_arg_1:Texture):void{ + this._texture = _arg_1; + } + + protected function getNullTexture():Texture{ + return (null); + } + + + } +}//package alternativa.gfx.core \ No newline at end of file diff --git a/src/alternativa/gfx/core/VertexBufferResource.as b/src/alternativa/gfx/core/VertexBufferResource.as new file mode 100644 index 0000000..04d7e25 --- /dev/null +++ b/src/alternativa/gfx/core/VertexBufferResource.as @@ -0,0 +1,69 @@ +package alternativa.gfx.core{ + import flash.display3D.VertexBuffer3D; + import __AS3__.vec.Vector; + import flash.display3D.Context3D; + import alternativa.gfx.alternativagfx; + + use namespace alternativagfx; + + public class VertexBufferResource extends Resource { + + alternativagfx var buffer:VertexBuffer3D; + protected var _vertices:Vector.; + protected var _numVertices:int; + protected var _data32PerVertex:int; + + public function VertexBufferResource(_arg_1:Vector., _arg_2:int){ + this._vertices = _arg_1; + this._data32PerVertex = _arg_2; + this._numVertices = (this._vertices.length / this._data32PerVertex); + } + + public function get vertices():Vector.{ + return (this._vertices); + } + + public function get numVertices():int{ + return (this._numVertices); + } + + public function get data32PerVertex():int{ + return (this._data32PerVertex); + } + + override public function dispose():void{ + super.dispose(); + if (this.buffer != null) + { + this.buffer.dispose(); + this.buffer = null; + }; + this._vertices = null; + } + + override public function reset():void{ + super.reset(); + if (this.buffer != null) + { + this.buffer.dispose(); + this.buffer = null; + }; + } + + override public function get available():Boolean{ + return (!(this._vertices == null)); + } + + override alternativagfx function create(_arg_1:Context3D):void{ + super.create(_arg_1); + this.buffer = _arg_1.createVertexBuffer(this._numVertices, this._data32PerVertex); + } + + override alternativagfx function upload():void{ + super.upload(); + this.buffer.uploadFromVector(this._vertices, 0, this._numVertices); + } + + + } +}//package alternativa.gfx.core \ No newline at end of file diff --git a/src/alternativa/types/Matrix3D.as b/src/alternativa/types/Matrix4.as similarity index 88% rename from src/alternativa/types/Matrix3D.as rename to src/alternativa/types/Matrix4.as index d1ee5a0..57b2d0a 100644 --- a/src/alternativa/types/Matrix3D.as +++ b/src/alternativa/types/Matrix4.as @@ -1,6 +1,6 @@ package alternativa.types { - public final class Matrix3D + public final class Matrix4 { public var a:Number; @@ -26,7 +26,7 @@ package alternativa.types public var l:Number; - public function Matrix3D(param1:Number = 1, param2:Number = 0, param3:Number = 0, param4:Number = 0, param5:Number = 0, param6:Number = 1, param7:Number = 0, param8:Number = 0, param9:Number = 0, param10:Number = 0, param11:Number = 1, param12:Number = 0) + public function Matrix4(param1:Number = 1, param2:Number = 0, param3:Number = 0, param4:Number = 0, param5:Number = 0, param6:Number = 1, param7:Number = 0, param8:Number = 0, param9:Number = 0, param10:Number = 0, param11:Number = 1, param12:Number = 0) { super(); this.a = param1; @@ -43,17 +43,17 @@ package alternativa.types this.l = param12; } - public static function inverseTranslationMatrix(param1:Number = 0, param2:Number = 0, param3:Number = 0) : Matrix3D + public static function inverseTranslationMatrix(param1:Number = 0, param2:Number = 0, param3:Number = 0) : Matrix4 { - return new Matrix3D(1,0,0,-param1,0,1,0,-param2,0,0,1,-param3); + return new Matrix4(1,0,0,-param1,0,1,0,-param2,0,0,1,-param3); } - public static function translationMatrix(param1:Number = 0, param2:Number = 0, param3:Number = 0) : Matrix3D + public static function translationMatrix(param1:Number = 0, param2:Number = 0, param3:Number = 0) : Matrix4 { - return new Matrix3D(1,0,0,param1,0,1,0,param2,0,0,1,param3); + return new Matrix4(1,0,0,param1,0,1,0,param2,0,0,1,param3); } - public static function axisAngleToMatrix(param1:Point3D, param2:Number = 0) : Matrix3D + public static function axisAngleToMatrix(param1:Point3D, param2:Number = 0) : Matrix4 { var loc3:Number = Math.cos(param2); var loc4:Number = Math.sin(param2); @@ -61,10 +61,10 @@ package alternativa.types var loc6:Number = param1.x; var loc7:Number = param1.y; var loc8:Number = param1.z; - return new Matrix3D(loc5 * loc6 * loc6 + loc3,loc5 * loc6 * loc7 - loc8 * loc4,loc5 * loc6 * loc8 + loc7 * loc4,0,loc5 * loc6 * loc7 + loc8 * loc4,loc5 * loc7 * loc7 + loc3,loc5 * loc7 * loc8 - loc6 * loc4,0,loc5 * loc6 * loc8 - loc7 * loc4,loc5 * loc7 * loc8 + loc6 * loc4,loc5 * loc8 * loc8 + loc3,0); + return new Matrix4(loc5 * loc6 * loc6 + loc3,loc5 * loc6 * loc7 - loc8 * loc4,loc5 * loc6 * loc8 + loc7 * loc4,0,loc5 * loc6 * loc7 + loc8 * loc4,loc5 * loc7 * loc7 + loc3,loc5 * loc7 * loc8 - loc6 * loc4,0,loc5 * loc6 * loc8 - loc7 * loc4,loc5 * loc7 * loc8 + loc6 * loc4,loc5 * loc8 * loc8 + loc3,0); } - public static function inverseRotationMatrix(param1:Number = 0, param2:Number = 0, param3:Number = 0) : Matrix3D + public static function inverseRotationMatrix(param1:Number = 0, param2:Number = 0, param3:Number = 0) : Matrix4 { var loc4:Number = Math.cos(param1); var loc5:Number = Math.sin(-param1); @@ -73,10 +73,10 @@ package alternativa.types var loc8:Number = Math.cos(param3); var loc9:Number = Math.sin(-param3); var loc10:Number = loc5 * loc7; - return new Matrix3D(loc6 * loc8,-loc6 * loc9,loc7,0,loc4 * loc9 + loc10 * loc8,loc4 * loc8 - loc10 * loc9,-loc5 * loc6,0,loc5 * loc9 - loc4 * loc8 * loc7,loc5 * loc8 + loc4 * loc7 * loc9,loc4 * loc6,0); + return new Matrix4(loc6 * loc8,-loc6 * loc9,loc7,0,loc4 * loc9 + loc10 * loc8,loc4 * loc8 - loc10 * loc9,-loc5 * loc6,0,loc5 * loc9 - loc4 * loc8 * loc7,loc5 * loc8 + loc4 * loc7 * loc9,loc4 * loc6,0); } - public static function inverseTransformationMatrix(param1:Number = 0, param2:Number = 0, param3:Number = 0, param4:Number = 0, param5:Number = 0, param6:Number = 0, param7:Number = 1, param8:Number = 1, param9:Number = 1) : Matrix3D + public static function inverseTransformationMatrix(param1:Number = 0, param2:Number = 0, param3:Number = 0, param4:Number = 0, param5:Number = 0, param6:Number = 0, param7:Number = 1, param8:Number = 1, param9:Number = 1) : Matrix4 { var loc10:Number = Math.cos(-param4); var loc11:Number = Math.sin(-param4); @@ -101,10 +101,10 @@ package alternativa.types var loc30:Number = loc15 * loc22 - loc14 * loc13 * loc23; var loc31:Number = loc14 * loc22 + loc13 * loc15 * loc23; var loc32:Number = loc12 * loc23; - return new Matrix3D(loc24,loc25,loc26,-(loc24 * param1 + loc25 * param2 + loc26 * param3),loc27,loc28,loc29,-(loc27 * param1 + loc28 * param2 + loc29 * param3),loc30,loc31,loc32,-(loc30 * param1 + loc31 * param2 + loc32 * param3)); + return new Matrix4(loc24,loc25,loc26,-(loc24 * param1 + loc25 * param2 + loc26 * param3),loc27,loc28,loc29,-(loc27 * param1 + loc28 * param2 + loc29 * param3),loc30,loc31,loc32,-(loc30 * param1 + loc31 * param2 + loc32 * param3)); } - public static function inverseMatrix(param1:Matrix3D) : Matrix3D + public static function inverseMatrix(param1:Matrix4) : Matrix4 { var loc2:Number = -param1.c * param1.f * param1.i + param1.b * param1.g * param1.i + param1.c * param1.e * param1.j - param1.a * param1.g * param1.j - param1.b * param1.e * param1.k + param1.a * param1.f * param1.k; var loc3:Number = (-param1.g * param1.j + param1.f * param1.k) / loc2; @@ -119,20 +119,20 @@ package alternativa.types var loc12:Number = (param1.b * param1.i - param1.a * param1.j) / loc2; var loc13:Number = (-param1.b * param1.e + param1.a * param1.f) / loc2; var loc14:Number = (param1.d * param1.f * param1.i - param1.b * param1.h * param1.i - param1.d * param1.e * param1.j + param1.a * param1.h * param1.j + param1.b * param1.e * param1.l - param1.a * param1.f * param1.l) / loc2; - return new Matrix3D(loc3,loc4,loc5,loc6,loc7,loc8,loc9,loc10,loc11,loc12,loc13,loc14); + return new Matrix4(loc3,loc4,loc5,loc6,loc7,loc8,loc9,loc10,loc11,loc12,loc13,loc14); } - public static function inverseScaleMatrix(param1:Number = 1, param2:Number = 1, param3:Number = 1) : Matrix3D + public static function inverseScaleMatrix(param1:Number = 1, param2:Number = 1, param3:Number = 1) : Matrix4 { - return new Matrix3D(1 / param1,0,0,0,0,1 / param2,0,0,0,0,1 / param3,0); + return new Matrix4(1 / param1,0,0,0,0,1 / param2,0,0,0,0,1 / param3,0); } - public static function scaleMatrix(param1:Number = 1, param2:Number = 1, param3:Number = 1) : Matrix3D + public static function scaleMatrix(param1:Number = 1, param2:Number = 1, param3:Number = 1) : Matrix4 { - return new Matrix3D(param1,0,0,0,0,param2,0,0,0,0,param3,0); + return new Matrix4(param1,0,0,0,0,param2,0,0,0,0,param3,0); } - public static function transformationMatrix(param1:Number = 0, param2:Number = 0, param3:Number = 0, param4:Number = 0, param5:Number = 0, param6:Number = 0, param7:Number = 1, param8:Number = 1, param9:Number = 1) : Matrix3D + public static function transformationMatrix(param1:Number = 0, param2:Number = 0, param3:Number = 0, param4:Number = 0, param5:Number = 0, param6:Number = 0, param7:Number = 1, param8:Number = 1, param9:Number = 1) : Matrix4 { var loc10:Number = Math.cos(param4); var loc11:Number = Math.sin(param4); @@ -147,15 +147,15 @@ package alternativa.types var loc20:Number = loc10 * param8; var loc21:Number = loc10 * param9; var loc22:Number = loc11 * param9; - return new Matrix3D(loc14 * loc18,loc16 * loc19 - loc15 * loc20,loc16 * loc21 + loc15 * loc22,param1,loc15 * loc18,loc17 * loc19 + loc14 * loc20,loc17 * loc21 - loc14 * loc22,param2,-loc13 * param7,loc12 * loc19,loc12 * loc21,param3); + return new Matrix4(loc14 * loc18,loc16 * loc19 - loc15 * loc20,loc16 * loc21 + loc15 * loc22,param1,loc15 * loc18,loc17 * loc19 + loc14 * loc20,loc17 * loc21 - loc14 * loc22,param2,-loc13 * param7,loc12 * loc19,loc12 * loc21,param3); } - public static function product(param1:Matrix3D, param2:Matrix3D) : Matrix3D + public static function product(param1:Matrix4, param2:Matrix4) : Matrix4 { - return new Matrix3D(param1.a * param2.a + param1.b * param2.e + param1.c * param2.i,param1.a * param2.b + param1.b * param2.f + param1.c * param2.j,param1.a * param2.c + param1.b * param2.g + param1.c * param2.k,param1.a * param2.d + param1.b * param2.h + param1.c * param2.l + param1.d,param1.e * param2.a + param1.f * param2.e + param1.g * param2.i,param1.e * param2.b + param1.f * param2.f + param1.g * param2.j,param1.e * param2.c + param1.f * param2.g + param1.g * param2.k,param1.e * param2.d + param1.f * param2.h + param1.g * param2.l + param1.h,param1.i * param2.a + param1.j * param2.e + param1.k * param2.i,param1.i * param2.b + param1.j * param2.f + param1.k * param2.j,param1.i * param2.c + param1.j * param2.g + param1.k * param2.k,param1.i * param2.d + param1.j * param2.h + param1.k * param2.l + param1.l); + return new Matrix4(param1.a * param2.a + param1.b * param2.e + param1.c * param2.i,param1.a * param2.b + param1.b * param2.f + param1.c * param2.j,param1.a * param2.c + param1.b * param2.g + param1.c * param2.k,param1.a * param2.d + param1.b * param2.h + param1.c * param2.l + param1.d,param1.e * param2.a + param1.f * param2.e + param1.g * param2.i,param1.e * param2.b + param1.f * param2.f + param1.g * param2.j,param1.e * param2.c + param1.f * param2.g + param1.g * param2.k,param1.e * param2.d + param1.f * param2.h + param1.g * param2.l + param1.h,param1.i * param2.a + param1.j * param2.e + param1.k * param2.i,param1.i * param2.b + param1.j * param2.f + param1.k * param2.j,param1.i * param2.c + param1.j * param2.g + param1.k * param2.k,param1.i * param2.d + param1.j * param2.h + param1.k * param2.l + param1.l); } - public static function rotationMatrix(param1:Number = 0, param2:Number = 0, param3:Number = 0) : Matrix3D + public static function rotationMatrix(param1:Number = 0, param2:Number = 0, param3:Number = 0) : Matrix4 { var loc4:Number = Math.cos(param1); var loc5:Number = Math.sin(param1); @@ -165,7 +165,7 @@ package alternativa.types var loc9:Number = Math.sin(param3); var loc10:Number = loc8 * loc7; var loc11:Number = loc9 * loc7; - return new Matrix3D(loc8 * loc6,loc10 * loc5 - loc9 * loc4,loc10 * loc4 + loc9 * loc5,0,loc9 * loc6,loc11 * loc5 + loc8 * loc4,loc11 * loc4 - loc8 * loc5,0,-loc7,loc6 * loc5,loc6 * loc4,0); + return new Matrix4(loc8 * loc6,loc10 * loc5 - loc9 * loc4,loc10 * loc4 + loc9 * loc5,0,loc9 * loc6,loc11 * loc5 + loc8 * loc4,loc11 * loc4 - loc8 * loc5,0,-loc7,loc6 * loc5,loc6 * loc4,0); } public function transform(param1:Number = 0, param2:Number = 0, param3:Number = 0, param4:Number = 0, param5:Number = 0, param6:Number = 0, param7:Number = 1, param8:Number = 1, param9:Number = 1) : void @@ -311,7 +311,7 @@ package alternativa.types l = loc32 * loc39 + loc33 * loc43 + loc34 * loc47 + loc35; } - public function add(param1:Matrix3D) : void + public function add(param1:Matrix4) : void { a += param1.a; b += param1.b; @@ -442,7 +442,7 @@ package alternativa.types l += i * param1 + j * param2 + k * param3; } - public function equals(param1:Matrix3D, param2:Number = 0) : Boolean + public function equals(param1:Matrix4, param2:Number = 0) : Boolean { var loc3:Number = a - param1.a; var loc4:Number = b - param1.b; @@ -494,7 +494,7 @@ package alternativa.types l += param3; } - public function combine(param1:Matrix3D) : void + public function combine(param1:Matrix4) : void { var loc2:Number = a; var loc3:Number = b; @@ -573,9 +573,9 @@ package alternativa.types l = loc18 * loc24 + loc19 * loc28 + loc20 * loc32; } - public function clone() : Matrix3D + public function clone() : Matrix4 { - return new Matrix3D(a,b,c,d,e,f,g,h,i,j,k,l); + return new Matrix4(a,b,c,d,e,f,g,h,i,j,k,l); } public function invert() : void @@ -612,7 +612,7 @@ package alternativa.types return "[Matrix3D " + "[" + a.toFixed(3) + " " + b.toFixed(3) + " " + c.toFixed(3) + " " + d.toFixed(3) + "] [" + e.toFixed(3) + " " + f.toFixed(3) + " " + g.toFixed(3) + " " + h.toFixed(3) + "] [" + i.toFixed(3) + " " + j.toFixed(3) + " " + k.toFixed(3) + " " + l.toFixed(3) + "]]"; } - public function inverseCombine(param1:Matrix3D) : void + public function inverseCombine(param1:Matrix4) : void { var loc2:Number = a; var loc3:Number = b; @@ -672,7 +672,7 @@ package alternativa.types l *= param1; } - public function copy(param1:Matrix3D) : void + public function copy(param1:Matrix4) : void { a = param1.a; b = param1.b; diff --git a/src/alternativa/types/Point3D.as b/src/alternativa/types/Point3D.as index 1683f66..358078e 100644 --- a/src/alternativa/types/Point3D.as +++ b/src/alternativa/types/Point3D.as @@ -1,6 +1,9 @@ package alternativa.types { import flash.geom.Point; + import flash.geom.Vector3D; + import alternativa.engine3d.core.Vertex; + import alternativa.engine3d.core.Object3D; public final class Point3D { @@ -17,6 +20,42 @@ package alternativa.types this.y = param2; this.z = param3; } + + public function toVector3D() : Vector3D + { + return new Vector3D(this.x,this.y,this.z); + } + public function copyToVector3D(vec:Vector3D) : Vector3D + { + vec.x = this.x; + vec.y = this.y; + vec.z = this.z; + return vec; + } + + public function copyFromVector3D(vec:Vector3D) : Point3D + { + this.x = vec.x; + this.y = vec.y; + this.z = vec.z; + return this; + } + + public function copyFromVertex(v:Vertex) : Point3D + { + this.x = v.x; + this.y = v.y; + this.z = v.z; + return this; + } + + public function copyFromObject3D(obj:Object3D) : Point3D + { + this.x = obj.x; + this.y = obj.y; + this.z = obj.z; + return this; + } public static function cross(param1:Point3D, param2:Point3D) : Point3D { @@ -102,7 +141,7 @@ package alternativa.types z = loc4; } - public function transformOrientation(param1:Matrix3D) : void + public function transformOrientation(param1:Matrix4) : void { var loc2:Number = x; var loc3:Number = y; @@ -159,7 +198,7 @@ package alternativa.types this.z = param3; } - public function createSkewSymmetricMatrix(param1:Matrix3D) : void + public function createSkewSymmetricMatrix(param1:Matrix4) : void { param1.a = param1.f = param1.k = param1.d = param1.h = param1.l = 0; param1.b = -z; @@ -205,7 +244,7 @@ package alternativa.types z = -z; } - public function inverseTransform(param1:Matrix3D) : void + public function inverseTransform(param1:Matrix4) : void { x -= param1.d; y -= param1.h; @@ -247,7 +286,7 @@ package alternativa.types return "[Point3D X: " + x.toFixed(3) + " Y:" + y.toFixed(3) + " Z:" + z.toFixed(3) + "]"; } - public function transformTranspose(param1:Matrix3D) : void + public function transformTranspose(param1:Matrix4) : void { var loc2:Number = x * param1.a + y * param1.e + z * param1.i; var loc3:Number = x * param1.b + y * param1.f + z * param1.j; @@ -257,7 +296,7 @@ package alternativa.types z = loc4; } - public function transform(param1:Matrix3D) : void + public function transform(param1:Matrix4) : void { var loc2:Number = x; var loc3:Number = y; @@ -292,6 +331,10 @@ package alternativa.types { return x - param1.x <= param2 && x - param1.x >= -param2 && y - param1.y <= param2 && y - param1.y >= -param2 && z - param1.z <= param2 && z - param1.z >= -param2; } + public function equalsXYZ(vX:Number,vY:Number,vZ:Number, epsilon:Number = 0) : Boolean + { + return x - vZ <= epsilon && x - vZ >= -epsilon && y - vY <= epsilon && y - vY >= -epsilon && z - vZ <= epsilon && z - vZ >= -epsilon; + } } }