Tag Archive for 'Papervision'

Papervision Isometric View & Pathfinding with as3isolib and A* (A Star)

Published

on February 22, 2010

in A Star, A*, AS3, Actionscript 3.0, Papervision, Papervision 3D, Pathfinding, Source Code, Tutorials and as3isolib

. 4 Comments

This week's example / tutorial is how to mix Papervision with as3isolib and A* (pronounced A Star) for a nice 3D isometric pathfinding experience. The version of A* that I am using comes straight out of Keith Peters book AdvancedEd ActionScript 3.0 Animation. Anyone looking to cover advanced animation topics in Flash should buy a copy of this book. It is excellent.

This tutorial will not cover how to create the A* classes but rather show you how to blend 3 things together; Papervision, as3isolib, and A* (the Keith Peters version). If you're just getting started using as3IsoLib take a look at these great tutorials and download the code: http://code.google.com/p/as3isolib/w/list

We will cover a few of the things that you need to successfully merge the pathfinding and 3D experience.

First item is our camera setting. We are setting ortho to true because this actually gives us a true isometric camera feel.

PLAIN TEXT

Actionscript:

camera.ortho = true;

Inside of our makeGrid function we are setting up the groundwork for our pathfinding and isometric world. This grid has no information about the cellsize, just which parts of it are walkable and not walkable.

PLAIN TEXT

Actionscript:

protected function makeGrid():void
{
pathGrid = new Grid(10, 10);
for(var i:int = 0; i <20; i++)
{
pathGrid.setWalkable(Math.floor(Math.random() * 8) + 2,
Math.floor(Math.random() * 8)+ 2,
false);
}
drawGrid();
}

Next we move on to drawGrid() which begins to connect the pathfinding and as3isolib

One of the great thing about as3isolib which is similar to papervision is that it has native objects that you can skin, such as boxes and polygons.

Here inside of drawGrid we run through the columns and rows that we setup in our makeGrid function. From the information in these loops we can get back the node information of the grid and check if an item is walkable or not walkable. If it is walkable we create a standard size box with a height of 0, if it is not walkable we create that same standard box but with a height of 40 so we can start to define our available paths. If the box is walkable we also want to set a mouseEvent so that we can select it. Finally we add these items to our isoScene.

PLAIN TEXT

Actionscript:

for(var i:int = 0; i <pathGrid.numCols; i++)
{
for(var j:int = 0; j <pathGrid.numRows; j++)
{
var node:Node = pathGrid.getNode(i, j);
var box:IsoBox = new IsoBox();
if (node.walkable)
{
box.setSize(cellSize, cellSize, 0);
box.addEventListener(MouseEvent.CLICK, onGridItemClick);
}
else
{
box.setSize(cellSize, cellSize, 40);
}
box.moveTo(i * cellSize, j * cellSize, 0);
isoScene.addChild(box);
}
}

Another item within the drawGrid function is our playerHelper. We are only using this playerHelper so that we can get it's coordinates to follow along in papervision. We set him to the same size as our box items.

PLAIN TEXT

Actionscript:

playerHelper.setSize(cellSize, cellSize, 10);

The next important step is setting up a way to have our viewport inside of our isoScene. We first create a nice wrapper for our viewport which is a native IsoSprite object. We then associate our viewport as one of the sprites inside of our isoSprite.

PLAIN TEXT

Actionscript:

isoSprite = new IsoSprite();
isoSprite.sprites = [viewport];
isoScene.addChild(isoSprite);

Notice that we add our sprites kind of like we add filters for a movieclip. We are passing it an array.

PLAIN TEXT

Actionscript:

//isoSprite.sprites = [viewport,moreStuff] - pass in an array of objects

Now lets see what happens when a grid item is clicked. First we gather the information about where we want to go. We gather that by getting the item that was clicked and getting its x & y positions divided by the cellSize. Then we give pathGrid.setEndNode those coordinates. Next we gather the information about where our playerHelper currently is divided by the cellSize and pass that information to pathGrid.setStartNode.

PLAIN TEXT

Actionscript:

protected function onGridItemClick(evt:ProxyEvent):void
{
var box:IsoBox = evt.target as IsoBox;
//Get and set End Nodes (where are we going)
var xpos:int = (box.x)/cellSize
var ypos:int = Math.floor(box.y / cellSize)
pathGrid.setEndNode(xpos,ypos );
//Get and set Start Node (where are we now)
xpos = Math.floor(playerHelper.x / cellSize);
ypos = Math.floor(playerHelper.y / cellSize);
pathGrid.setStartNode(xpos, ypos);
//Find our path
findPath();
}

Finally we call findPath(). This is the fun part. First we create a new instance of AStar and gather the path information that we gathered when we ran the onGridItemClick function.

We can now run through that loop and get each x and y portion of that loop. We simply add a tween with a delay that is the same time as our speed. This will allow you to see each move and when it is complete it will start it's next move.

PLAIN TEXT

Actionscript:

protected function findPath():void
{
var astar:AStar = new AStar();
var speed:Number = .3;
if(astar.findPath(pathGrid))
{
path = astar.path;
}
for (var i:int = 0; i <path.length; i++)
{
var targetX:Number = path[i].x * cellSize;
var targetY:Number = path[i].y * cellSize;
Tweener.addTween(playerHelper, { x:targetX, y:targetY, delay:speed * i , time:speed, transition:"linear" } );
}
}

We now just need to look at how to sort the papervision with the as3isolib objects

Inside of our onRenderTick function which is an override from BasicView we use this to render our isoScene which is part of as3isolib and change the x,y coordinates of our sphere. We are basically following around the screenX and screenY of our playerHelper. The next and very important part of this is the depth sorting. We are pulling the depth at all times from the playerHelper object and assigning our isoSprite (which has our viewport in it) to that depth. Now we can watch as our 3D objects find their pretty little paths and sort without issue.

PLAIN TEXT

Actionscript:

override protected function onRenderTick(event:Event = null):void
{
super.onRenderTick(event);
isoScene.render();
sphere.x = playerHelper.screenX;
sphere.y = -playerHelper.screenY - 15;
isoScene.setChildIndex(isoSprite, isoScene.getChildIndex(playerHelper));
}

Here is the full code:

PLAIN TEXT

Actionscript:

package
{
import as3isolib.display.IsoSprite;
import as3isolib.display.IsoView;
import as3isolib.display.primitive.IsoBox;
import as3isolib.display.primitive.IsoPrimitive;
import as3isolib.display.scene.IsoGrid;
import as3isolib.display.scene.IsoScene;
import bit101.AStar;
import bit101.Grid;
import bit101.Node;
import caurina.transitions.Tweener;
import flash.display.StageAlign;
import flash.display.StageScaleMode;
import flash.events.Event;
import eDpLib.events.ProxyEvent;
import flash.display.Sprite;
import flash.events.MouseEvent;
import org.papervision3d.materials.WireframeMaterial;
import org.papervision3d.objects.primitives.Sphere;
import org.papervision3d.view.BasicView;
public class Main extends BasicView
{
protected var cellSize:int = 50;
protected var pathGrid:Grid;
protected var playerHelper:IsoPrimitive;
protected var path:Array;
protected var isoSprite:IsoSprite;
protected var isoView:IsoView;
protected var isoScene:IsoScene;
protected var sphere:Sphere;
public function Main()
{
super(800, 600, false);
stage.align = StageAlign.TOP_LEFT;
stage.scaleMode = StageScaleMode.NO_SCALE;
create3D();
makeGrid();
startRendering();
}
protected function create3D():void
{
sphere = new Sphere(new WireframeMaterial(),20);
scene.addChild(sphere);
camera.ortho = true;
}
protected function makeGrid():void
{
pathGrid = new Grid(10, 10);
for(var i:int = 0; i <20; i++)
{
pathGrid.setWalkable(Math.floor(Math.random() * 8) + 2,
Math.floor(Math.random() * 8)+ 2,
false);
}
drawGrid();
}
protected function drawGrid():void
{
isoScene = new IsoScene();
playerHelper = new IsoPrimitive();
isoSprite = new IsoSprite();
isoView = new IsoView();
for(var i:int = 0; i <pathGrid.numCols; i++)
{
for(var j:int = 0; j <pathGrid.numRows; j++)
{
var node:Node = pathGrid.getNode(i, j);
var box:IsoBox = new IsoBox();
if (node.walkable)
{
box.setSize(cellSize, cellSize, 0);
box.addEventListener(MouseEvent.CLICK, onGridItemClick);
}
else
{
box.setSize(cellSize, cellSize, 40);
}
box.moveTo(i * cellSize, j * cellSize, 0);
isoScene.addChild(box);
}
}
//Set properties for player helper
playerHelper.setSize(cellSize, cellSize, 10);
//Set properties for isoView
isoView.setSize(stage.stageWidth, stage.stageHeight);
//Set proper position for viewport
viewport.x = -stage.stageWidth / 2;
viewport.y = -stage.stageHeight / 2;
//Add viewport to the isoSprite
isoSprite.sprites = [viewport];
//Add the isoSprite and playerHelper to the isoScene
isoScene.addChild(isoSprite);
isoScene.addChild(playerHelper);
//Add the isoScene to the isoView
isoView.addScene(isoScene);
//Add the isoView to the stage
addChild(isoView);
}
protected function onGridItemClick(evt:ProxyEvent):void
{
var box:IsoBox = evt.target as IsoBox;
//Get and set End Nodes (where are we going)
var xpos:int = (box.x)/cellSize
var ypos:int = Math.floor(box.y / cellSize)
pathGrid.setEndNode(xpos,ypos );
//Get and set Start Node (where are we now)
xpos = Math.floor(playerHelper.x / cellSize);
ypos = Math.floor(playerHelper.y / cellSize);
pathGrid.setStartNode(xpos, ypos);
//Find our path
findPath();
}
protected function findPath():void
{
var astar:AStar = new AStar();
var speed:Number = .3;
if(astar.findPath(pathGrid))
{
path = astar.path;
}
for (var i:int = 0; i <path.length; i++)
{
var targetX:Number = path[i].x * cellSize;
var targetY:Number = path[i].y * cellSize;
Tweener.addTween(playerHelper, { x:targetX, y:targetY, delay:speed * i , time:speed, transition:"linear" } );
}
}
override protected function onRenderTick(event:Event = null):void
{
super.onRenderTick(event);
//Render the isoScene
isoScene.render();
//Place our 3D object at the correct location (following our playerHelper)
sphere.x = playerHelper.screenX;
sphere.y = -playerHelper.screenY - 15;
/*
Set the depth of our isoSprite which holds our viewport to the proper depth.
NOTE: as3isolib objects - the depth sorting is done automatically,
we just need to tap into that
*/
isoScene.setChildIndex(isoSprite, isoScene.getChildIndex(playerHelper));
}
}
}

Delicious Digg This Post Facebook Stumble This Post

Papervision Explode Image / Rebuild

Published

Charlie

on December 24, 2009

in Actionscript 3 Papervision, Actionscript 3.0, Papervision 3D, Source Code, Tutorials and TweenLite

. 2 Comments

In early 2008 I wrote a blog article on how to explode an image and rebuild it again. Recently this effect has been used in some amazing ways. Site's like Audi have taken this concept much further with the rows of these tiny boxes swimming in formation.

Today I decided to re-create that simple effect using the latest papervision code and provide a much needed update.

Creating this effect is actually fairly simple. You take an image, use some code to break it into smaller bitmaps which then are used as the materials for your planes. Then you just place the planes in a grid to re-create your image.

Here is a sample of the code that get's our image blocks to be used for our materials:

PLAIN TEXT

Actionscript:

//Creates a 30 x 18 bitmapData block
var bitmap_data:BitmapData = new BitmapData(cellWidth, cellHeight, true, 0x00FFFF);
//Create a new Matrix - A matrix is a rectangular array / table
//of numbers with any number of rows / columns.
var matrix:Matrix = new Matrix();
//Get's our desired x / y location information where we will
//pull a block of our image
matrix.translate( -cellWidth * cellX, -cellHeight * cellY);
//Write the data to our bitmap data object with our source and
//matrix / block info
bitmap_data.draw(imageMC, matrix);

Once you've created your grid you just need to store the locations of all your x,y,z,rotation etc so that when you break apart the image you can easily piece it back together.

PLAIN TEXT

Actionscript:

planeVO.origX = pl.x;
planeVO.origY = pl.y;
planeVO.origZ = pl.z;
planeVO.origRotationY = pl.rotationY;
planeVO.origRotationX = pl.rotationX;
planeVO.origRotationZ = pl.rotationZ;
planeVO.planeRef = pl;

PlaneVO is nothing more than a simple value object. A value object gives us a nice strongly typed object to store the variables we want to access later.

PlaneVO.as

PLAIN TEXT

Actionscript:

package
{
import org.papervision3d.objects.primitives.Plane;
/**
* ...
* @author Charlie Schulze, Woven Interactive, LLC
*/
public class PlaneVO
{
public var origX:Number;
public var origY:Number
public var origZ:Number
public var origRotationY:Number
public var origRotationX:Number
public var origRotationZ:Number
public var planeRef:Plane;
}
}

Now on to the full code. I have left comments throughout to explain what is happening. Try changing some of the math or swapping the image with your own. Once you mess with it for a little while you'll find it's easy to create some amazing effects.

PLAIN TEXT

Actionscript:

package
{
import br.com.stimuli.loading.BulkLoader;
import br.com.stimuli.loading.BulkProgressEvent;
import com.foomonger.utils.Later;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.DisplayObject;
import flash.display.MovieClip;
import flash.geom.Matrix;
import gs.easing.Quint;
import gs.TweenMax;
import org.papervision3d.materials.MovieMaterial;
import org.papervision3d.objects.DisplayObject3D;
import org.papervision3d.objects.primitives.Plane;
import org.papervision3d.view.BasicView;
/**
* ...
* @author Charlie Schulze, charlie[at]woveninteractive[dot]com
*/
public class Main extends BasicView
{
protected var bulkInstance:BulkLoader;
protected var imageMC:MovieClip;
protected var imageString:String
protected var planeVOs:Array = [];
protected var planesContainer:DisplayObject3D;
public function Main():void
{
super();
//Set the image we want to load
imageString = "images/king.gif";
//Load our image
loadImage();
}
protected function loadImage():void
{
//BulkLoader is complete overkill for this but thought it would be a
//nice extra for everyone to see in action. Extremely useful set of classes.
//Create our unique bulkInstance / available anywhere in our app by
//that name "bulkImageLoader"
bulkInstance = new BulkLoader("bulkImageLoader");
//Add our image
bulkInstance.add(imageString);
//Add our listeners
bulkInstance.addEventListener(BulkProgressEvent.COMPLETE, onImageLoaded);
//Start Loading
bulkInstance.start();
}
protected function onImageLoaded(evt:BulkProgressEvent):void
{
init();
}
protected function init():void
{
createChildren();
explode();
startRendering();
}
protected function createChildren():void
{
//Create the clip we will be getting our bitmap data from
imageMC = new MovieClip();
//add our bitmap
imageMC.addChild(bulkInstance.getBitmap(imageString));
//Optional - Create a container to hold our planes
planesContainer = new DisplayObject3D();
//Array to store our value objects
planeVOs = [];
for (var i:int = 0; i <65; i++)
{
/**
* Here is how we get our loop / colunm / cellWidth / cellHeight numbers
*
* 5 columns * 13 rows = 65 (number of loops)
* 5 columns divided by the width (150) of our image = 30 pixels
* 13 rows divided by the height (234) of our image = 18 pixels
*/
var columns:uint = 5;
var cellWidth:int = 30;
var cellHeight:int = 18;
var cellX:int = (i % columns)
var cellY:int = Math.floor(i / columns);
//Creates a 30 x 18 bitmapData block
var bitmap_data:BitmapData = new BitmapData(cellWidth, cellHeight, true, 0x00FFFF);
//Create a new Matrix - A matrix is a rectangular array / table
//of numbers with any number of rows / columns.
var matrix:Matrix = new Matrix();
//Get's our desired x / y location information where we will
//pull a block of our image
matrix.translate( -cellWidth * cellX, -cellHeight * cellY);
//Write the data to our bitmap data object with our source and
//matrix / block info
bitmap_data.draw(imageMC, matrix);
//Create a bitmap with our bitmapData and add it to a movieclip
var bitmap:Bitmap = new Bitmap(bitmap_data);
var myMovie:MovieClip = new MovieClip();
myMovie.addChild(bitmap);
//Use the movieclip with our bitmap inside as our movieMaterial
//needs to be cast as a DisplayObject to work
var movieMat:MovieMaterial = new MovieMaterial(myMovie as DisplayObject, true);
movieMat.smooth = true;
//Create a plane with our moviemat the size of our cellWidth/Height
var pl:Plane = new Plane(movieMat, cellWidth, cellHeight, 0, 0);
//Create a value object to store our origianl infomation
//for when we animate we can then rebuild easily
var planeVO:PlaneVO = new PlaneVO();
//We want to place the planes to re-create our original image
pl.x = ((cellX * cellWidth) + cellWidth) -(imageMC.width / 2);
pl.y = -((cellY * cellHeight) + cellHeight) +(imageMC.height / 2);
//Set the original properties of our value object
planeVO.origX = pl.x;
planeVO.origY = pl.y;
planeVO.origZ = pl.z;
planeVO.origRotationY = pl.rotationY;
planeVO.origRotationX = pl.rotationX;
planeVO.origRotationZ = pl.rotationZ;
planeVO.planeRef = pl;
//Add our planeVO to our array
planeVOs.push(planeVO)
//Add planes to our container
planesContainer.addChild(pl);
}
//Add our container to our scene
scene.addChild(planesContainer);
camera.zoom = 100;
//rotate our container for an skewed effect
planesContainer.rotationY = 30;
planesContainer.rotationX = 30;
}
protected function explode():void
{
//Create a for loop of our plane objects set random numbers to explode our image
for (var i:int = 0; i <planeVOs.length; i++)
{
var planeVO:PlaneVO = planeVOs[i];
var plane:Plane = planeVO.planeRef;
var ranNumber:Number = Math.round(Math.random() * 200 - 200);
var delayAmount:Number = i * .05;
var shortDelayAmount:Number = delayAmount * .6;
var randomX:Number = (Math.random() * 4000) - 6000;
var randomY:Number = (Math.random() * 8000) - 1000;
var randomZ:Number = (Math.random() * 1000) + 5000;
TweenMax.to(plane, 2, { x:planeVO.origX + randomX, delay:shortDelayAmount,
z:randomZ, y:150 + planeVO.origY + randomY,
rotationY:180,ease:Quint.easeInOut} );
}
//In 3 seconds rebuild
Later.call(this, rebuild, 3000, true);
}
protected function rebuild():void
{
//Rebuild our image with the locations we stored in our VO
for (var i:int = 0; i <planeVOs.length; i++)
{
var planeVO:PlaneVO = planeVOs[i];
var plane:Plane = planeVO.planeRef;
var delayAmount:Number = i * .005;
TweenMax.to(plane, 1.8, { x:planeVO.origX, delay:delayAmount,
z:planeVO.origZ, y:planeVO.origY,
rotationY:planeVO.origRotationY,ease:Quint.easeInOut} );
}
//In 5 seconds explode the image again
Later.call(this, explode, 5000, true);
}
}
}

Delicious Digg This Post Facebook Stumble This Post

Basic Texturing (v2)

Published

Charlie

on November 22, 2009

in Actionscript 3 Papervision, Actionscript 3.0, Papervision, Papervision 3D, Source Code and Tutorials

. 1 Comment

basic-texturing

Even if you had a chance to look at Getting started using BasicView.as this tutorial provides another example of basic texturing in Papervision.

In Papervision for the most part you have objects (planes, cubes, cones, 3D Models, etc) and then you have the textures or materials that you add to these objects. Think of it as getting a brand new iPhone and then buying a case or skin for that iPhone. We are essentially doing the same thing in principle - we have our object a cone (iPhone) and a material a bitmapMaterial (iPhone skin).

PLAIN TEXT

Actionscript:

package
{
import flash.events.Event;
import org.papervision3d.view.BasicView;
import org.papervision3d.objects.primitives.Cone;
import org.papervision3d.materials.BitmapFileMaterial;
public class Main extends BasicView
{
protected var cone:Cone
protected var bitmapMaterial:BitmapFileMaterial;
public function Main()
{
super();
createChildren();
startRendering();
}
public function createChildren():void
{
//Create a new 3D object
bitmapMaterial = new BitmapFileMaterial("images/ourtex.jpg")
cone = new Cone(bitmapMaterial, 20, 200);
//Set some properties
cone.scale = 4;
cone.pitch( -10);
//Add to scene
scene.addChild(cone);
}
override protected function onRenderTick(event:Event = null):void
{
super.onRenderTick(event);
//Rotate
cone.yaw(3);
}
}
}

As you can see from the code above we have a cone and a bitmap texture.

Delicious Digg This Post Facebook Stumble This Post

Getting started using BasicView.as

Published

Charlie

on November 22, 2009

in Actionscript 3 Papervision, Actionscript 3.0, Papervision, Papervision 3D, Source Code and Tutorials

. 4 Comments

basicview-image

In a previous tutorial (Creating a Papervision Base Template) we created a base Papervision template that we could re-use. Now however Papervision includes a form of this base template called BasicView.as

With just a few lines of code you're up and running. Here is the very simple / basic use of BasicView.as:

PLAIN TEXT

Actionscript:

package
{
import flash.events.Event;
import org.papervision3d.materials.ColorMaterial;
import org.papervision3d.objects.primitives.Plane;
import org.papervision3d.view.BasicView;
/**
* ...
* @author Charlie Schulze, charlie[at]woveninteractive[dot]com
*/
public class Main extends BasicView
{
protected var plane:Plane;
protected var colorMaterial:ColorMaterial;
public function Main():void
{
super();
//Create one material and make it doublesided
colorMaterial = new ColorMaterial(0xFF0000, .5);
colorMaterial.doubleSided = true;
//Create a plane using the colorMaterial
plane = new Plane(colorMaterial, 100, 100);
scene.addChild(plane);
//Start the rendering
startRendering();
}
override protected function onRenderTick(event:Event = null):void
{
super.onRenderTick(event);
//Rotate the plane
plane.yaw(2);
}
}
}

This very simple example you will just see a single light red plane rotating.

That is all you need to do to get started in Papervision. Test it out. Don't forget to add your 3D objects to the scene.

PLAIN TEXT

Actionscript:

scene.addChild(plane);

Here is what the BasicView.as class looks like:

PLAIN TEXT

Actionscript:

package org.papervision3d.view
{
import org.papervision3d.cameras.SpringCamera3D;
import org.papervision3d.cameras.Camera3D;
import org.papervision3d.cameras.CameraType;
import org.papervision3d.cameras.DebugCamera3D;
import org.papervision3d.core.view.IView;
import org.papervision3d.objects.DisplayObject3D;
import org.papervision3d.render.BasicRenderEngine;
import org.papervision3d.scenes.Scene3D;
/**
*
* BasicView provides a simple template for quickly setting up
* basic Papervision3D projects by creating a viewport, scene,
* camera, and renderer for you. Because BasicView is a subclass of
* Sprite, it can be added to any DisplayObject.
*
*
*
*
*
* Example:
*
* <pre><code>
* var width:Number = 640;
* var heigth:Number = 480;
* var scaleToStage:Boolean = true;
* var interactive:Boolean = true;
* var cameraType:String = Camera3D.TYPE;
*
* var myBasicView:BasicView = new BasicView(width, height, scaleToStage, interactive, cameraType);
* myDisplayObject.addChild(myBasicView);
* </code></pre>
*
* @author Ralph Hauwert
*/
public class BasicView extends AbstractView implements IView
{
/**
* @param viewportWidth Width of the viewport
* @param viewportHeight Height of the viewport
* @param scaleToStage Whether you viewport should scale with the stage
* @param interactive Whether your scene should be interactive
* @param cameraType A String for the type of camera. @see org.papervision3d.cameras.CameraType
*
*/
public function BasicView(viewportWidth:Number = 640, viewportHeight:Number = 480, scaleToStage:Boolean = true, interactive:Boolean = false, cameraType:String = "Target")
{
super();
scene = new Scene3D();
viewport = new Viewport3D(viewportWidth, viewportHeight, scaleToStage, interactive);
addChild(viewport);
renderer = new BasicRenderEngine();
switch(cameraType)
{
case CameraType.DEBUG:
_camera = new DebugCamera3D(viewport);
break;
case CameraType.TARGET:
_camera = new Camera3D(60);
_camera.target = DisplayObject3D.ZERO;
break;
case CameraType.SPRING:
_camera = new SpringCamera3D();
_camera.target = DisplayObject3D.ZERO;
break;
case CameraType.FREE:
default:
_camera = new Camera3D(60);
break;
}
cameraAsCamera3D.update(viewport.sizeRectangle);
}
/**
* Exposes the camera as a <code>Camera3D</code>
*/
public function get cameraAsCamera3D():Camera3D
{
return _camera as Camera3D;
}
/**
* Exposes the camera as a <code>DebugCamera3D</code>
*/
public function get cameraAsDebugCamera3D():DebugCamera3D
{
return _camera as DebugCamera3D;
}
}
}

Since BasicView.as extends AbstractView.as you can see a few more of the methods available to you just by extending BasicView.as

PLAIN TEXT

Actionscript:

package org.papervision3d.view
{
import flash.display.Sprite;
import flash.events.Event;
import org.papervision3d.core.proto.CameraObject3D;
import org.papervision3d.core.view.IView;
import org.papervision3d.render.BasicRenderEngine;
import org.papervision3d.scenes.Scene3D;
/**
* @Author Ralph Hauwert
*/
public class AbstractView extends Sprite implements IView
{
protected var _camera:CameraObject3D;
protected var _height:Number;
protected var _width:Number;
public var scene:Scene3D;
public var viewport:Viewport3D;
public var renderer:BasicRenderEngine;
public function AbstractView()
{
super();
}
public function startRendering():void
{
addEventListener(Event.ENTER_FRAME, onRenderTick);
viewport.containerSprite.cacheAsBitmap = false;
}
public function stopRendering(reRender:Boolean = false, cacheAsBitmap:Boolean = false):void
{
removeEventListener(Event.ENTER_FRAME, onRenderTick);
if(reRender){
onRenderTick();
}
if(cacheAsBitmap){
viewport.containerSprite.cacheAsBitmap = true;
}else{
viewport.containerSprite.cacheAsBitmap = false;
}
}
public function singleRender():void
{
onRenderTick();
}
protected function onRenderTick(event:Event = null):void
{
renderer.renderScene(scene, _camera, viewport);
}
public function get camera():CameraObject3D
{
return _camera;
}
public function set viewportWidth(width:Number):void
{
_width = width;
viewport.width = width;
}
public function get viewportWidth():Number
{
return _width;
}
public function set viewportHeight(height:Number):void
{
_height = height;
viewport.height = height;
}
public function get viewportHeight():Number
{
return _height;
}
}
}

Delicious Digg This Post Facebook Stumble This Post

Time for an upgrade. Updated tutorials coming soon!

Published

Charlie

on November 22, 2009

in Actionscript 3 Papervision, Releases and Tutorials

. 0 Comments

upgrade
In an effort to keep the information on this site up to date over the next few weeks we will be re-writing the majority of the tutorials on this site.

All new tutorials will include:

1) More up to date PV3D code.
2) A version that can be compiled with the Flash IDE
3) A version that can be compiled with FlashDevelop, Flex etc.
4) Full source code.

Having two versions of the code, as well as full source (including pv3d code) will hopefully cut down on the confusion when getting started.

Please feel free to leave comments here for other requests. If we get several requests for features other than what has been mentioned we will do my best to incorporate them.

Enjoy and have fun.

Charlie

Delicious Digg This Post Facebook Stumble This Post

Code / Programs it’s hard to live without

Published

Admin

on January 2, 2009

in Papervision and Tutorials

. 6 Comments

p_package_custom_built

Here is a quick list of Classes / Packages and programs that seem to make life just that much easier. This is a list based off of things we use daily for quick development of agency type Flash sites. This is in no way a complete list but anyone just wanting to increase their productivity can start here.

Programs:

1) FlashDevelop (PC only - or via VMWare) :/

Use this and easily literally shave days off your coding time. If you don't use this go with FlexBuilder.

2) Charles (Mac or PC)

Find the root of the real issues when you load dynamic content.

3) Smart FTP (PC only) :/

Quick uploads

Code:

1) Foomonger (Later)

Call a method / function a second later or a frame later. Also has a LoadWatcher for loadProgress

2) Tweener

Some use TweenLite I like Tweener. It always seems to yield the best results. I could be wrong but that's my opinion.

2) I was wrong - TweenLite/Max

The results speak for themselves - TweenLite/Max vs other Tween Engines

3) BulkLoader (unless you're using Gaia - see below)

The hotness for loading multiple files and having access to them across your whole project.

4) Papervision

Of course. :-D

* Added from Comments *

5)SWFObject

Frameworks:

1) Gaia

Steven Sacks has created one of the best frameworks that is to be used on agency style Flash sites. You can have an entire simple flash site up in about 5 minutes or less. (not joking). Site scaffolding, asset loading, browser navigation, page loading, SEO, a place for your transitions (code or timeline) and much more. AS2 and AS3 supported. Check it out!

Are there any programs or code bases you can't live without?

Let us know.

Delicious Digg This Post Facebook Stumble This Post

2010 Flash And The City Speaker

RSS Feed

Tag Archive for 'Papervision'