From Jim Burrows comes  his online  portfolio built  using PV3D a reall cool site,clean,slick,site.

Be sure to check it out at : Link

From Eric Weber at Dabber comes ilovepocket

In Eric’s own words:-

“Created by digital agency Dabber in September 2009, ilovepocket is a PV3D-powered interface for Natur&Kultur, one of Sweden’s largest publishing houses. The site features a 3D timeline with N&K’s recent and upcoming book releases, and provides an alternative way for customers to find new titles.”

Be sure to check it our here :Link

From Ha-py.com comes Ha-py island. A cute walk around and good use of pv3D

Check it out for yourself here: Link

中文人學pv3d 真係有些難度,因為中文的教學實在是少得可憐
就算找到教學或源檔,也時常不能運作.有幾點真係要注意

1.pv3d的ver問 題
eq: 如果你是用 pv3d 2
你download的code有包含
import org.papervision3d.cameras.FreeCamera3D
那就不能運作了,pv3d 2的是
import org.papervision3d.cameras.Camera3D;

2.有沒有使用其他的class.

如果你下載的code中的import有些不是以下2句..
import flash……………
import org.papervision3d……………

這樣就好有機會使用了一些其他的class了…常見有
import caurina.transitions.Tweener;

3.注意你的使用環境..
你用的code是否配合的的使用環境

flex,flash cs3,flas cs4,
不配合時也會出現不能運作的情況

FLARToolKit

• http://saqoosha.net/en/flartoolkit/
• http://saqoosha.net/en/flartoolkit/start-up-guide/
• http://pv3d.org/
• http://www.mikkoh.com/blog/2008/12/05/flartoolkitflash-augmented-realitygetting-started/
• http://milkmidi.blogspot.com/2009/02/flartoolkit.html

Creator

• http://flash.tarotaro.org/blog/2008/12/14/artoolkit-marker-generator-online-released/

Further Learning of FLARToolKit

• http://www.hitl.washington.edu/artoolkit/publications/
• http://groups.google.com/group/flartoolkit-userz
• http://www.marcpelland.com/2009/01/29/using-papervision-object-parsers/

FlarManager

• http://words.transmote.com/wp/

Interactive Designer Blog:

• http://jerromy-gamestart.blogspot.com/

A algum tempo os publicitários estão pirando com as criações em realidade aumentada, eu comecei a pesquisar a fundo sobre o e percebi que não é tão dificil assim quando temos uma biblioteca no jeito de ser editada.

Eu encontrei um pacote muito bom chamado FLARToolkit de um site japonês vou disponibilizar o link para download diretamente deles. ( Download FLARToolkit ), só que para utilizar este pacote é necessário ter o pacote Papervision 3D na sua máquina ( Download Papervision 3d ).
Se você estiver familiarizado com Papervision3D, este FLARToolKit será fácil de controlar. Você pode fazer o que quiser, como se você controla Papervision 3D.
Se você é usuário não Papervision3D, não tenha muito medo, não é um bicho de sete cabeças! Mas precisa de um pouco mais de dedicação para começar a programar.

Imagem:

Fonte: http://saqoosha.net/

Agora é só experimentar!

I’ve been experimenting a bit with using Papervision for flash.  Here i’ve created a 3d gallery using papervisions cube class.   Click the image to view the example.

Olá Pessoal, Para nosso tutorial de hoje, preparei exemplo muito simples, utilização do mouse ma interação de um objeto primitivo do papervision, assim poderemos possamos montar um menu num futuro.

Ao se trabalhar com Orientação a Objetos devemos sempre estar atendendo a instância do objeto, ao utilizar o papervision, para alterar algumas propriedades de um simples material instanciado para um plane devemos alterar o movieclip no qual o nosso material recebe de instancia.

movie = new MovieClip();
material = new MovieMaterial(movie,true,true);

Seguindo a lógica, o nosso material armazena a instancia de “movie” ou seja, se alterarmos o alpha ou o posicionamento do frame de nosso movie o nosso material sofrerá a mesma alteração.

Em nosso exemplo teremos um movieclip aonde a propriedade linkage dele será “MovieButton”.

Iniciaremos nosso plane com as rotações em 25 e alpha 0.8, e em nosso enterframe colocaremos o nosso plane para ficar rotacionando para exemplificar melhor que aquele plane é um objeto do papervision. Ao passar o mouse em nosso plane, alteraremos o alpha para 1, reposicionaremos as rotações em 0 e bloquearemos o enterframe. Vamos para o código completo.

package
{
    import flash.display.MovieClip;
    import flash.events.Event;
    import org.papervision3d.materials.MovieMaterial;
    import org.papervision3d.objects.primitives.Plane;
    import org.papervision3d.events.InteractiveScene3DEvent;
    import org.papervision3d.view.BasicView;

    public class Menu extends BasicView
    {
        private var mov1:MovieClip;
        private var mat1:MovieMaterial;
        private var plane1:Plane;
        private var MOVE:Boolean = true;

        public function Menu()
        {
            viewport.buttonMode = true;
            viewport.interactive = true;

            camera.zoom = 5;
            camera.focus = 200;

            mov1 = new MovieButton();
            mat1 = new MovieMaterial(mov1, true, true)

            mat1.interactive = true;
            mat1.smooth = true;
            mat1.doubleSided = true;

            plane1 = new Plane(mat1, 130, 100)
            scene.addChild(plane1);
            plane1.rotationY = 25;
            plane1.rotationZ = 25;
            plane1.rotationX = 25;

            plane1.addEventListener(InteractiveScene3DEvent.OBJECT_OVER, _mouseOver);
            plane1.addEventListener(InteractiveScene3DEvent.OBJECT_OUT, _mouseOut);
            startRendering();
            mov1.alpha = 0.8;
            addEventListener(Event.ENTER_FRAME, _loop);

        }
        public function _loop(e:Event) {
            if (MOVE){
                plane1.yaw(3);
                plane1.roll(3);
                plane1.pitch(3);
            }
        }
        public function _mouseOver(e:InteractiveScene3DEvent):void
        {
            MOVE = false;
            mov1.alpha = 1;
            e.target.rotationY = 0;
            e.target.rotationZ = 0;
            e.target.rotationX = 0;

        }
        public function _mouseOut(e:InteractiveScene3DEvent):void
        {
            MOVE = true;
            mov1.alpha = 0.8;
        }

    }

}

Para dar um toque interessante ao seu menu aconselho a usar transições de tweeners, caurina, green sock ou ate mesmo o tweener do flash. Agora que eu já lhe mostrei a escada só falta vocês subirem ^^ até aproxima.

Today , I am going to present you the cocktail of AIR , Flash Builder 4 and PV3D called as ‘Simple Image Gallery‘. It is just a basic application applying the mixture of 3d carousel in pv3d , FileSystemTree class in Air and some container classes of Spark platform.In this application, you have to click on directory entry of the left panel to see the images in carousel effect.The selected directory entry should have .jpg or .gif images for display.

I have used Lee Brimelow’s absolutely wonderful 3d carousel component for this gallery. It follows ‘KISS’ principle. 3D code uses trigonometry to achieve circular effect in pv3d.

Download the application’s source code . Run the application in FB 4.

Future additions desired for this code
1. 3d image gallery to be constructed as a custom component.
2. Left panel should have tree with checkboxes with multiple selection ability.
3. Gallery should be able to display not just images but a custom-component.
Hope you guys help me to incorporate these features in the future version of the application.

Petite expérimentation avec la réalisation d’un analyseur de sons créé avec papervision3D et la méthode computeSpectrum qui comme son nom l’indique réalise l’analyse du spectre d’un signal sonore. Au cours de la démo, 10 vues différentes se succèdent.

Olá pessoal, Muitos de vocês já se perguntaram como trocar o material de um objeto sua durante sua execução, o material de um plane, cylinder ou até mesmo a face de um cubo. Pois bem para fazermos esta mágica utilizamos o método replaceMaterialByName.

Este método consiste em substituir a instância de material que possui o nome indicado.

objeto.replaceMaterialbyName(material:Material,name:String);

Uma das divergências deste método é que o nome deste método deveria se chamar replaceMaterialByInstancia. Para vocês entenderem melhor este problema vou descrever um exemplo com um cubo.

    blue  = new ColorMaterial(0x0000FF);
    red   = new ColorMaterial(0xFF0000);
    lista = new MaterialsList()

    lista.addMaterial(blue, 'front');
    lista.addMaterial(blue, 'back');
    lista.addMaterial(blue, 'top');
    lista.addMaterial(blue, 'bottom');
    lista.addMaterial(blue, 'left');
    lista.addMaterial(blue, 'right');
    cube = new Cube(lista,100,100,100);
    cubo.replaceMaterialByName(red, 'right');

Teoricamente este código deveria criar um cubo com todas as faces ‘Azul’ e ao final ele colocaria a face da direita com a cor ‘Vermelho’. Porém ele no final deixa todas as faces ‘vermelho’, pois a instancia de material do lado direito ‘right’ é igual a instancia de material utilizado para as outras faces. Para que não aconteça isso é recomendado que cada face tenha sua própria instancia. Agora vamos ao código de nosso tutorial.

Tutorial replaceMaterialbyName

Neste tutorial decidi brincar um pouco mais. Vamos utilizar um pouco de ReflectionView e o componente ColorPicker (componente do próprio Flash)

Criaremos 3 ColorPicker que será responsável por 2 lados diferentes do cubo e um botão para resetar para o estado utilizando os MovieMaterial.

Logica:

package
{
    import fl.controls.ColorPicker;
    import fl.events.ColorPickerEvent;
    import flash.display.SimpleButton;
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import org.papervision3d.core.effects.view.ReflectionView;
    import org.papervision3d.materials.ColorMaterial;
    import org.papervision3d.materials.MovieAssetMaterial;
    import org.papervision3d.materials.utils.MaterialsList;
    import org.papervision3d.objects.primitives.Cube;

    public class ppv_changeMaterial extends ReflectionView
    {
        public var matsmile:MovieAssetMaterial;
        public var matface:MovieAssetMaterial;
        public var matLeftRight:MovieAssetMaterial;
        public var cubo:Cube;
        public var lista:MaterialsList;
        public var color1:ColorPicker;
        public var color2:ColorPicker;
        public var color3:ColorPicker;
        public var reset:SimpleButton;

        public function ppv_changeMaterial() {
            setChildIndex(viewportReflection, 1);
            viewportReflection.alpha = 0.8;

            matsmile  = new MovieAssetMaterial("smile");
            matface  = new MovieAssetMaterial("face");
            matLeftRight  = new MovieAssetMaterial("face");
            lista = new MaterialsList()

            lista.addMaterial(matface, 'front');
            lista.addMaterial(matsmile, 'back');
            lista.addMaterial(new ColorMaterial(0xF9EAAD), 'top');
            lista.addMaterial(new ColorMaterial(0x000000), 'bottom');
            lista.addMaterial(matLeftRight, 'left');
            lista.addMaterial(matLeftRight, 'right');

            cubo  = new Cube(lista, 200, 200, 250);
            scene.addChild(cubo);

            cubo.y = 150;

            color1 = new ColorPicker();
            color1.x = 20;
            color1.y = 100;

            color2 = new ColorPicker();
            color2.x = 20;
            color2.y = 140;

            color3 = new ColorPicker();
            color3.x = 20;
            color3.y = 180;

            reset = new Reset();
            reset.x = 20;
            reset.y = 220;
            addChild(reset);

            addChild(color1);
            addChild(color2);
            addChild(color3);

            color1.addEventListener(ColorPickerEvent.CHANGE, changeLeftRight);
            color2.addEventListener(ColorPickerEvent.CHANGE, changeTopBottom);
            color3.addEventListener(ColorPickerEvent.CHANGE, changeFrontBack);
            reset.addEventListener(MouseEvent.CLICK, clickReset);
            addEventListener(Event.ENTER_FRAME, onEnterFrame);
        }
        private function changeLeftRight(e:ColorPickerEvent) {
            cubo.replaceMaterialByName(new ColorMaterial(e.target.selectedColor), 'left');
            cubo.replaceMaterialByName(new ColorMaterial(e.target.selectedColor), 'right');
        }
        private function changeTopBottom(e:ColorPickerEvent) {
            cubo.replaceMaterialByName(new ColorMaterial(e.target.selectedColor), 'top');
            cubo.replaceMaterialByName(new ColorMaterial(e.target.selectedColor), 'bottom');
        }
        private function changeFrontBack(e:ColorPickerEvent) {
            cubo.replaceMaterialByName(new ColorMaterial(e.target.selectedColor), 'front');
            cubo.replaceMaterialByName(new ColorMaterial(e.target.selectedColor), 'back');
        }
        public function clickReset(e:MouseEvent):void
        {
            cubo.replaceMaterialByName(matface, 'front');
            cubo.replaceMaterialByName(matsmile, 'back');
            cubo.replaceMaterialByName(new ColorMaterial(0xF9EAAD), 'top');
            cubo.replaceMaterialByName(new ColorMaterial(0x000000), 'bottom');
            cubo.replaceMaterialByName(matface, 'left');
            cubo.replaceMaterialByName(matface, 'right');

        }

        private function onEnterFrame(e:Event):void {
            singleRender();
            camera.orbit(Math.abs(mouseY+1 / 2), Math.abs(mouseX+1));
        }

    }

}

Pode ter certeza que este método será muito útil em diversas de suas aplicações,  até a próxima.

Olá pessoal , Hoje falarei sobre uma classe muito interessante e simples, ReflectionView. Uma classe que faz com que o viewport se transforme em um espelho tanto para cima do eixo y:0 quanto para baixo.

A classe ReflectionView é uma classe extendida da classe BasicView que por sua vez é extendido da classe AbstractView, o que eu quero dizer com tudo isso, que ao extender uma classe a RelectionView ele vai possuira atributos instanciados como:

AbstractView:
scene:Scene3D;
viewport:Viewport3D;
renderer:BasicRenderEngine;

startRendering();
stopRendering();
singleRender();

ReflectionView
viewportReflection : Viewport3D;
cameraReflection : CameraObject3D;
singleRender() (override - sobrescrevido)

Quando criávamos nosso BasicView ativávamos a função startRendering() para renderizar nossa aplicação, porem quando criamos um ReflectionView também podemos utilizar esta função para renderizar, porém não irá criar reflexo pois a função responsável pelo reflexo é a singleRender() que esta reescrita nesta classe para poder ativar o reflexo. Esta parecendo complicado mas as coisas são bem simples vamos analisar nosso código. Em resumo para funcionar precisamos apenas colocar dentro de um bloco ENTER_FRAME a função singleRender();

Como de custume trabalharemos com 2 arquivos. ppv_reflection.fla e ppv_reflection.as. Certifique de possuir 2 movieclip em sua biblioteca com os seguintes linkage: “smile” e “face”.

ppv_reflection.as

package
{
    import flash.display.Sprite;
    import flash.events.Event;
    import org.papervision3d.core.effects.view.ReflectionView;
    import org.papervision3d.materials.ColorMaterial;
    import org.papervision3d.materials.MovieAssetMaterial;
    import org.papervision3d.materials.utils.MaterialsList;
    import org.papervision3d.objects.primitives.Cube;

    public class ppv_reflection extends ReflectionView
    {
        public var matsmile:MovieAssetMaterial;
        public var matface:MovieAssetMaterial;
        public var cubo:Cube;
        public var lista:MaterialsList;

        public function ppv_reflection() {
            setChildIndex(viewportReflection, 1);
            viewportReflection.alpha = 0.8;
            matsmile  = new MovieAssetMaterial("smile");
            matface  = new MovieAssetMaterial("face");
            lista = new MaterialsList(
                {front: matface,
                  back: matsmile,
                  top: new ColorMaterial(0xF9EAAD),
                  bottom: new ColorMaterial(0x000000),
                  left: matface,
                  right: matface} );
            cubo  = new Cube(lista, 200, 200, 250);
            scene.addChild(cubo);

            cubo.y = 150;
            addEventListener(Event.ENTER_FRAME, onEnterFrame);

        }
        private function onEnterFrame(e:Event):void {
            cubo.rotationY = mouseX - stage.stageWidth / 2;
            cubo.rotationX = mouseY - stage.stageHeight / 2;
            singleRender();
        }

    }

}

Uma classe simples que possui uma imagem de fundo com um cubo personalizado, aonde este cubo se movimenta respondendo os comandos do mouse.Na primeira linha de nosso construtor utilizamos o seguinte código:

    setChildIndex(viewportReflection, 1);

Quando criamos nossa classe extendida de ReflectionView automaticamente nosso viewport refletor é criado no índex 0 porem se eu quiser deixar uma imagem de background desenhado em alguma layer da time line esse background entrará em um índex acima de nosso viewport fazendo com que o viewport refletor fique por trás do background, este é o motive desta linha de comando, estamos trocando o posicionamento índex de nosso viewport.

Nosso viewport refletor ele funciona da seguinte maneira, tudo que esta do eixo y:0 para cima será refletido para baixo o eixo y:0 e vice versa, a imagem a seguir ilustra um cubo desenhado abaixo do eixo y:0.

Espero que tenham gostado deste tutorial, não precisam se preocupar que teremos mais coisas interessantes no decorrer da semana, até a próxima.

I’m fairly new to working with Papervision. After picking my way through numerous tutorials, blogs and such, I had a custom class that did all the basic things a good papervision class should do. I noticed at one point that I was using several different classes each with their own “load-then-onComplete” systems. I had a DAE* instance loading a collada file. I was overriding the inherit materials with my own via the optional MaterialsList parameter. All the materials in the MaterialsList were instances of BitmapFileMaterial.
(* I recommend the DAEMC class (http://code.google.com/p/daeanim/) as an alternate to Collada animation support.)

Then I decided to try implementing the ShadowCaster (http://blog.zupko.info/?p=146). To comply with one of its dependencies I needed to have a Plane primitive that used a MovieMaterial. I am getting very comfortable with my Eclipse-and-Flex-Plugin development environment, and I usually do my papervision experiments using an ActionScript project. I’ve grown reluctant to fire up CS4 to make any sort of Library symbol, SWF or SWC to use as my MovieMaterial. I’d rather just load an image. Which means I face the potential of implementing yet another class with yet another “load-then-onComplete” system. For me this just seemed a little too over-complicated. There must be someway to consolidate some of this loading.

Looking at what was already being loaded I decided BitmapFileMaterial was the only real candidate. I did some obligatory Googling, but none of the results I found mentioned any quick, simplistic usage that figured would help me accomplish what I was after. I would have guessed that using BitmapFileMaterial as a basis for a MovieMaterial would be in common practice. Maybe it is, but it wasn’t evident to me. Maybe my Google is weak.

Although I was a bit weary of going down some worm-hole-in-time over the issue I figured it wouldn’t be too tough to brush up on the flash.display package and figure out some simple syntactical voodoo. Happily it ended up being extremely quick and easy to figure out. Nothing too high on the Hero-scale but helpful nonetheless.

So my custom class’s logic-flow is something like this:


Constructor()
init()
draw()
drawPapervision()
loadMaterials()
onMaterialsLoaded()
createMaterials()
createObjects()
...


The initial details of the custom class are fairly standard and quite inconsequential. We can skip over the init, draw, and drawPapervision methods. We’ll just look at code starting with the loadmaterials method. Here’s a code snippet from the custom class:

// some properties
private var groundPlane_bmpMat:BitmapFileMaterial;
private var groundPlane_mcMat:MovieMaterial;
private var plane:Plane;

// some methods
private function loadMaterials():void{
	// set static callback for loading of bitmap(s) via BitmapFileMaterial
	BitmapFileMaterial.callback = onMaterialsLoaded;
	// load bitmap(s) directly into BitmapFileMaterial(s)
	groundPlane_bmpMat = new BitmapFileMaterial( IMAGE_PATH + "groundTexture.jpg" , true);
}

private function onMaterialsLoaded():void{
	// material(s)
	createMaterials();
}

private function createMaterials():void{
	// MovieMaterial(s)
	var groundPlane_mc:MovieClip = new MovieClip();
	groundPlane_mc.addChild(new Bitmap(groundPlane_bmpMat.bitmap));
	groundPlane_mcMat = new MovieMaterial(groundPlane_mc, false, false, true);
	// objects
	createObjects();
}

private function createObjects():void{
	// plane
	plane = new Plane(groundPlane_mcMat, 500, 500, 1, 1);
	this.addChild(plane);
}

So the trick was to create an instance of a flash.display.Bitmap, passing in a reference to the bitmap property of the BitmapFileMaterial. Now you have the bitmap loaded by the material class within a DisplayObject, which can then be passed into a MovieClip via the addChild method. Then finally we have a MovieClip with our external asset that we pass into a MovieMaterial instance.

Hurray, we win! However it is a bit questionable to create an instance of a BitmapFileMaterial solely for the purpose of hijacking its load functionality. It would probably be better to use instead the flash.display.Loader class. If you did need to use both the MovieMaterial instance and the BitmapFileMaterial instance, say as materials for different DisplayObject3Ds, that would be perfectly acceptable. The only other thing I will say is, if you were to create a BitmapFileMaterial simply for fetching an image for a MovieMaterial, remember to clean up any unused instances after their usefulness ends.

- ddb
20 Jan 2009

It seems as though I’m trying to work out the odds of all the dice throws. I’ve been going through all the variations in making a normal map to suit my dice in the away3d scene. I’ve eventually succeeded in getting a version that works out of 3dsMax. Harder than I thought it would be, but maybe I should have thought through the maths rather than just guess at the right checkboxes.

This is my resulting test, with a correct version of the dice and the old version for comparison. It shows the effect of getting it slightly out. The die on the right has the wrong shading at certain angles. Use the arrow keys to rotate them.

The problem with my attempt at getting a normal map for the dice was that I asumed that I just needed to create the object space version of the map. Sounded simple, but then I found that the render in away3d didn’t quite work with any of the variations. The effect was that a face of the cube, when rotated around its perpendicular, would change the lighting that it had. It should stay constant. Because of the normal map being wrong, the rendering system thinks that the face is pointing in a different direction and so should change lighting as the object rotates around. I needed to investigate further.

Being a dice, the easiest way was to use Photoshop to cut and paste the different sides until we got the correct result. Then all (?) I had to do was to get the same rendering out of 3dsMax. It took a route through all the variations of LocalXYZ which should give an object space normals map. None of those variations fitted. World space is just the same, because my object is sat around the origin; X, Y and Z axes are the same for both. So I then tried Screen modes. After several combinations I discovered that turning the front view around by 180 degress gave the result that I was looking for. I finally had a normals map that worked with away3d. The following pics show the colours required by faces whose normals point along the 3 axes. Faces at other angles would be on a graduaton between them. The first image is the LocalXYZ normal map that I first tried; the second image is the correct version.

So a few points to note,

If it’s of any use to anyone, the last picture is an image of the cube within 3dsMax as I created the normals map. It’s front facing but rotated around 180 degrees. Is that because of the Z-up in Max, compared to the Y-up in away3d or Papervision. I don’t want to take the time to think about the maths too much at this time of night.

[Edit - If you're into normal maps in away3d, do look at Fabrice's blog. He's the one doing the clever stuff underneath.]

Teste de modelagem randomica.

Flores modeladas randomicamente com planos e textura.