Rozengain.com - Creative Technology Blog http://www.rozengain.com/blog Tue, 23 Feb 2010 17:03:02 +0000 http://wordpress.org/?v=2.7.1 en hourly 1 Blender Exporter Updated: ActionScript Vectors Support (FP10) http://www.rozengain.com/blog/2010/02/23/blender-exporter-updated-actionscript-vectors-support-fp10/ http://www.rozengain.com/blog/2010/02/23/blender-exporter-updated-actionscript-vectors-support-fp10/#comments Tue, 23 Feb 2010 17:03:02 +0000 Dennis http://www.rozengain.com/blog/?p=520 Another update to the Blender to ActionScript exporter. I’ve added the option to export to ActionScript Vectors. This way you can use the exported data with native Flash Player 10 3D. The export is quite basic, there’s still stuff you have to do yourself. This is the data that is exported:

  • vertices
  • indices
  • texture coordinates
  • scaling
  • translation
  • rotation

This example source code is a quick & dirty example of how it can be used:


package
{
	import __AS3__.vec.Vector;
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.geom.Matrix3D;
	import flash.geom.PerspectiveProjection;
	import flash.geom.Utils3D;
	import flash.geom.Vector3D;

	public class TestScene extends Sprite
	{
		private var sphere : Sphere;
		private var pp : PerspectiveProjection;
		private var proj : Vector.<Number>;

		public function TestScene()
		{
			super();
			init();
		}
		private function init() : void
		{
			sphere = new Sphere();
			pp = new PerspectiveProjection();
			pp.fieldOfView = 45;
			proj = new Vector.<Number>();
			addEventListener(Event.ENTER_FRAME, draw);
		}
		private var ry:Number=0;
		private function draw(event:Event):void
		{
			var tr : Matrix3D = new Matrix3D();
			tr.appendRotation(ry++, Vector3D.Y_AXIS);
			tr.appendTranslation(10,14,70);
			tr.append(pp.toMatrix3D());

			Utils3D.projectVectors(tr, sphere.v, proj, sphere.u);
			graphics.clear();
			graphics.lineStyle(0.1, 0x000000 );
			graphics.drawTriangles(proj, sphere.i );
		}
	}
}

The updated exporter script can be downloaded from the usual location here.

]]> http://www.rozengain.com/blog/2010/02/23/blender-exporter-updated-actionscript-vectors-support-fp10/feed/ Beginning WebGL step-by-step tutorial http://www.rozengain.com/blog/2010/02/22/beginning-webgl-step-by-step-tutorial/ http://www.rozengain.com/blog/2010/02/22/beginning-webgl-step-by-step-tutorial/#comments Mon, 22 Feb 2010 14:15:18 +0000 Dennis http://www.rozengain.com/blog/?p=508 I’ve put together this very basic WebGL tutorial that takes you through the process of initialising WebGL, creating shaders, creating a triangle and then showing it on the screen as a one-off render. I haven’t used external JavaScript libraries like sylvester because I wanted this tutorial to be self-contained. Because I don’t apply translations or rotations there’s no need for further Matrix operations.

All functions calls link to the OpenGL ES documentation for easy reference.

The source file for this tutorial can be found here.

<!--
Define a simple GLSL (OpenGL Shading Language) fragment shader.
More info: http://en.wikipedia.org/wiki/GLSL
–>
<script id=”shader-fs” type=”x-shader/x-fragment”>
void main(void) {
gl_FragColor = vec4(0.6, 0.0, 0.0, 1.0);
}
</script>
<!–
Define a simple GLSL (OpenGL Shading Language) vertex shader.
More info: http://en.wikipedia.org/wiki/GLSL
–>
<script id=”shader-vs” type=”x-shader/x-vertex”>
attribute vec3 vertexPosition;

uniform mat4 modelViewMatrix;
uniform mat4 perspectiveMatrix;

void main(void) {
gl_Position = perspectiveMatrix * modelViewMatrix * vec4(vertexPosition, 1.0);
}
</script>
<script type="text/javascript">
window.onload = loadScene;

/**
* Initialises WebGL and creates the 3D scene.
*/
function loadScene()
{
// Get the canvas element
var canvas = document.getElementById("webGLCanvas");
// Get the WebGL context
var gl = canvas.getContext("experimental-webgl");
// Check whether the WebGL context is available or not
// if it's not available exit
if(!gl)
{
alert("There's no WebGL context available.");
return;
}
// Set the viewport to the canvas width and height
gl.viewport(0, 0, canvas.width, canvas.height);

// Load the vertex shader that's defined in a separate script
// block at the top of this page.
// More info about shaders: http://en.wikipedia.org/wiki/Shader_Model
// More info about GLSL: http://en.wikipedia.org/wiki/GLSL
// More info about vertex shaders: http://en.wikipedia.org/wiki/Vertex_shader

// Grab the script element
var vertexShaderScript = document.getElementById("shader-vs");
// Create a vertex shader object
var vertexShader = gl.createShader(gl.VERTEX_SHADER);
// Load the shader with the source strings from the script element
gl.shaderSource(vertexShader, vertexShaderScript.text);
// Compile the shader source code string
gl.compileShader(vertexShader);
// Check if the shader has compiled without errors
if(!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
alert(”Couldn’t compile the vertex shader”);
// Clean up
gl.deleteShader(vertexShader);
return;
}

// Load the fragment shader that's defined in a separate script
// block at the top of this page.
// More info about fragment shaders: http://en.wikipedia.org/wiki/Fragment_shader
var fragmentShaderScript = document.getElementById(”shader-fs”);
// Create a fragment shader object
var fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
// Load the shader with the source strings from the script element
gl.shaderSource(fragmentShader, fragmentShaderScript.text);
// Compile the shader source code string
gl.compileShader(fragmentShader);
// Check if the shader has compiled without errors
if(!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
alert(”Couldn’t compile the fragment shader”);
// Clean up
gl.deleteShader(fragmentShader);
return;
}

// Create a shader program. From the OpenGL documentation:
// A program object is an object to which shader objects can be attached.
// This provides a mechanism to specify the shader objects that will be linked to
// create a program. It also provides a means for checking the compatibility of the
// shaders that will be used to create a program (for instance, checking the
// compatibility between a vertex shader and a fragment shader).
gl.program = gl.createProgram();
// Attach the vertex shader to the program
gl.attachShader(gl.program, vertexShader);
// Attach the fragment shader to the program
gl.attachShader(gl.program, fragmentShader);
// Before we can use the shaders for rendering, we have to link the program
// object.
gl.linkProgram(gl.program);
// Check the status of the link operation to see if it was linked without
// errors.
if (!gl.getProgramParameter(gl.program, gl.LINK_STATUS)) {
alert(”Unable to initialise shaders”);
// Clean up
gl.deleteProgram(gl.program);
gl.deleteProgram(vertexShader);
gl.deleteProgram(fragmentShader);
return;
}
// Install the program as part of the current rendering state
gl.useProgram(gl.program);
// Get the vertexPosition attribute from the linked shader program
var vertexPosition = gl.getAttribLocation(gl.program, “vertexPosition”);
// Enable the vertexPosition vertex attribute array. If enabled, the array
// will be accessed an used for rendering when calls are made to commands like
// gl.drawArrays, gl.drawElements, etc.
gl.enableVertexAttribArray(vertexPosition);

// Clear the color buffer (r, g, b, a) with the specified color
gl.clearColor(0.0, 0.0, 0.0, 1.0);
// Clear the depth buffer. The value specified is clamped to the range [0,1].
// More info about depth buffers: http://en.wikipedia.org/wiki/Depth_buffer
gl.clearDepth(1.0);
// Enable depth testing. This is a technique used for hidden surface removal.
// It assigns a value (z) to each pixel that represents the distance from this
// pixel to the viewer. When another pixel is drawn at the same location the z
// values are compared in order to determine which pixel should be drawn.
gl.enable(gl.DEPTH_TEST);
// Specify which function to use for depth buffer comparisons. It compares the
// value of the incoming pixel against the one stored in the depth buffer.
// Possible values are (from the OpenGL documentation):
// GL_NEVER - Never passes.
// GL_LESS - Passes if the incoming depth value is less than the stored depth value.
// GL_EQUAL - Passes if the incoming depth value is equal to the stored depth value.
// GL_LEQUAL - Passes if the incoming depth value is less than or equal to the stored depth value.
// GL_GREATER - Passes if the incoming depth value is greater than the stored depth value.
// GL_NOTEQUAL - Passes if the incoming depth value is not equal to the stored depth value.
// GL_GEQUAL - Passes if the incoming depth value is greater than or equal to the stored depth value.
// GL_ALWAYS - Always passes.
gl.depthFunc(gl.LEQUAL);

// Now create a shape.
// First create a vertex buffer in which we can store our data.
var vertexBuffer = gl.createBuffer();
// Bind the buffer object to the ARRAY_BUFFER target.
gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);
// Specify the vertex positions (x, y, z)
var vertices = new WebGLFloatArray([
0.0, 1.0, 4.0,
-1.0, -1.0, 4.0,
1.0, -1.0, 4.0
]);

// Creates a new data store for the vertices array which is bound to the ARRAY_BUFFER.
// The third paramater indicates the usage pattern of the data store. Possible values are
// (from the OpenGL documentation):
// The frequency of access may be one of these:
// STREAM - The data store contents will be modified once and used at most a few times.
// STATIC - The data store contents will be modified once and used many times.
// DYNAMIC - The data store contents will be modified repeatedly and used many times.
// The nature of access may be one of these:
// DRAW - The data store contents are modified by the application, and used as the source for
// GL drawing and image specification commands.
// READ - The data store contents are modified by reading data from the GL, and used to return
// that data when queried by the application.
// COPY - The data store contents are modified by reading data from the GL, and used as the source
// for GL drawing and image specification commands.
gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW);

// Clear the color buffer and the depth buffer
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);

// Define the viewing frustum parameters
// More info: http://en.wikipedia.org/wiki/Viewing_frustum
// More info: http://knol.google.com/k/view-frustum
var fieldOfView = 30.0;
var aspectRatio = canvas.width / canvas.height;
var nearPlane = 1.0;
var farPlane = 10000.0;
var top = nearPlane * Math.tan(fieldOfView * Math.PI / 360.0);
var bottom = -top;
var right = top * aspectRatio;
var left = -right;

// Create the perspective matrix. The OpenGL function that’s normally used for this,
// glFrustum() is not included in the WebGL API. That’s why we have to do it manually here.
// More info: http://www.cs.utk.edu/~vose/c-stuff/opengl/glFrustum.html
var a = (right + left) / (right - left);
var b = (top + bottom) / (top - bottom);
var c = (farPlane + nearPlane) / (farPlane - nearPlane);
var d = (2 * farPlane * nearPlane) / (farPlane - nearPlane);
var x = (2 * nearPlane) / (right - left);
var y = (2 * nearPlane) / (top - bottom);
var perspectiveMatrix = [
x, 0, a, 0,
0, y, b, 0,
0, 0, c, d,
0, 0, -1, 0
];

// Create the modelview matrix
// More info about the modelview matrix: http://3dengine.org/Modelview_matrix
// More info about the identity matrix: http://en.wikipedia.org/wiki/Identity_matrix
var modelViewMatrix = [
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1
];
// Get the vertex position attribute location from the shader program
var vertexPosAttribLocation = gl.getAttribLocation(gl.program, “vertexPosition”);
// Specify the location and format of the vertex position attribute
gl.vertexAttribPointer(vertexPosAttribLocation, 3.0, gl.FLOAT, false, 0, 0);
// Get the location of the “modelViewMatrix” uniform variable from the
// shader program
var uModelViewMatrix = gl.getUniformLocation(gl.program, “modelViewMatrix”);
// Get the location of the “perspectiveMatrix” uniform variable from the
// shader program
var uPerspectiveMatrix = gl.getUniformLocation(gl.program, “perspectiveMatrix”);
// Set the values
gl.uniformMatrix4fv(uModelViewMatrix, false, new WebGLFloatArray(perspectiveMatrix));
gl.uniformMatrix4fv(uPerspectiveMatrix, false, new WebGLFloatArray(modelViewMatrix));
// Draw the triangles in the vertex buffer. The first parameter specifies what
// drawing mode to use. This can be GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP,
// GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP,
// GL_QUADS, and GL_POLYGON
gl.drawArrays(gl.TRIANGLES, 0, vertices.length / 3.0);
gl.flush();
}
</script>

]]> http://www.rozengain.com/blog/2010/02/22/beginning-webgl-step-by-step-tutorial/feed/ Blender to WebGL JavaScript Exporter http://www.rozengain.com/blog/2010/02/04/blender-to-webgl-javascript-exporter/ http://www.rozengain.com/blog/2010/02/04/blender-to-webgl-javascript-exporter/#comments Thu, 04 Feb 2010 21:24:22 +0000 Dennis http://www.rozengain.com/blog/?p=502 I’ve been playing with this technology lately and I have to say: WebGL is hot stuff. Through the HTML5 <canvas> element you can add hardware-accelerated 3D graphics to web pages. There’s no need to install a separate plug-in. It isn’t available in current browser versions however. You’ll need to install nightly builds of Firefox, Chrome or Safari in order to view WebGL.

Its worth playing around with WebGL even though it’ll take a fair bit of time until it becomes mainstream technology. WebGL a binding for JavaScript to native OpenGL ES 2.0
which means that if you learn the API you can use it for iPhone (Objective-C) and Android (Java) development as well.

You can also write shaders using GLSL (OpenGL Shading Language). To see what you can do with shaders take a look at this page.

If you don’t want to get your hands dirty with the low-level stuff then there are a couple of excellent libraries that do a lot of work for you. A very powerful one is GLGE. There’s also a fairly new one called SceneJS.

During my presentation at LFPUG last week I briefly touched WebGL to show how easy it is to write exporter scripts for Blender. I’m still working on the script but here are some preliminary results:

The script exports to SceneJS for now but I will add the option to export to pure WebGL and GLGE. I will make it available soon :-)

]]> http://www.rozengain.com/blog/2010/02/04/blender-to-webgl-javascript-exporter/feed/ Blender to ActionScript Exporter Updated: Away3D Lite 1.0.2 http://www.rozengain.com/blog/2010/01/28/blender-to-actionscript-exporter-updated-away3d-lite-102/ http://www.rozengain.com/blog/2010/01/28/blender-to-actionscript-exporter-updated-away3d-lite-102/#comments Thu, 28 Jan 2010 11:08:01 +0000 Dennis http://www.rozengain.com/blog/?p=500 Another update to the Blender to ActionScript exporter. Away3D Lite 1.02. has been added to the list. Download it from the usual place here.

]]> http://www.rozengain.com/blog/2010/01/28/blender-to-actionscript-exporter-updated-away3d-lite-102/feed/ Book Review: Unity Game Development Essentials http://www.rozengain.com/blog/2009/12/08/book-review-unity-game-development-essentials/ http://www.rozengain.com/blog/2009/12/08/book-review-unity-game-development-essentials/#comments Tue, 08 Dec 2009 16:07:54 +0000 Dennis http://www.rozengain.com/blog/?p=494 Flash offers a lot of cool features to play with. The last few years we’ve seen an abundance of 3D engines which have all been optimised to run on a very limited platform. The results are very impressive and have spawned many ground breaking and visually stunning online experiences.

Despite all this many developers are frustrated with the weak performance. The latest Flash Player version (10) offers some native 3D methods like Utils3D.projectVectors(), Graphics.drawTriangles(), Matrix3D and TriangleCulling but no support for hardware rendering.

This is where Danish Unity steps in to fill the void. Their web player takes you into the third dimension properly. If you have never installed the plugin I highly recommend you do so right now :-)

Unity has a complete development environment that allows you to create games easily. There are three programming languages that you can use: JavaScript, C# and one of their own creations called Boo (a Python dialect).

Packt Publishing have published a Unity book that teaches you how to create games using JavaScript. It is written by Will Goldstone, an English interactive designer and tutor.

The book takes you through the process of building a First-Person-viewed 3D game, from start to finish. You don’t have to be an experienced programmer to be able to grasp the concepts presented in this book. You don’t even have to be a 3D expert. Everything is well explained, from basic 3D concepts to collision detection, terrain generation, ray casting, prefabs, particles, deployment, testing, etc.

Anyone who is tired of Flash 3D should make a start with Unity to be able to fully express their creativity. This book is a proper introduction to this exciting new platform.

The only downside to this book is the layout. All of the illustrations are printed in black & white and the text layout could be organised in a better way. This is a minor thing though. I highly recommend this book as the proper way to start exploring Unity.

More information about this book can be found on the Packt Publishing website: http://www.packtpub.com/unity-game-development-essentials/book

]]> http://www.rozengain.com/blog/2009/12/08/book-review-unity-game-development-essentials/feed/ Blender to ActionScript Exporter Updated: haXe Support http://www.rozengain.com/blog/2009/10/28/blender-to-actionscript-exporter-updated-haxe-support/ http://www.rozengain.com/blog/2009/10/28/blender-to-actionscript-exporter-updated-haxe-support/#comments Wed, 28 Oct 2009 14:33:52 +0000 Dennis http://www.rozengain.com/blog/?p=488 The haXe port has become the main focus of the Sandy 3D engine. Why use haXe? According to the Sandy website:

“There are some good reasons why you might want to use haXe: performance, ability to cross language boundaries, a language packed with features. Sandy provides a native implementation, bringing with it all the cross-platform and performance advantages over using extern wrappers.”

The Blender to ActionScript exporter now supports Sandy/haXe. Paul Fitzpatrick has been kind enough to update the code. Thanks alot!

Download the new version here!

]]> http://www.rozengain.com/blog/2009/10/28/blender-to-actionscript-exporter-updated-haxe-support/feed/ Download AS3 libraries to Eclipse/FDT/Flash Builder/Flex Builder plugin updated http://www.rozengain.com/blog/2009/10/19/download-as3-libraries-to-eclipsefdtflash-builderflex-builder-plugin-updated/ http://www.rozengain.com/blog/2009/10/19/download-as3-libraries-to-eclipsefdtflash-builderflex-builder-plugin-updated/#comments Mon, 19 Oct 2009 14:29:33 +0000 Dennis http://www.rozengain.com/blog/?p=479 Many people who downloaded and installed the plugin asked me if I could add the option to add frameworks and repositories.

I just uploaded a new version that enables you to do so. I added a dialog in the Eclipse Preferences window where you can select which frameworks you want to see in the context menu. All the frameworks from the previous version are there and you can also add any subversion URL or swc URL.

I also fixed an issue with source folders. In Flash Builder beta the download option wasn’t visible when right-clicking on a source folder.

Please give me a shout if you have any ideas about Eclipse plugins that could be useful.

The download page is here.

The new Preferences dialog:

]]> http://www.rozengain.com/blog/2009/10/19/download-as3-libraries-to-eclipsefdtflash-builderflex-builder-plugin-updated/feed/ Book Review: Papervision3D Essentials http://www.rozengain.com/blog/2009/10/15/book-review-papervision3d-essentials/ http://www.rozengain.com/blog/2009/10/15/book-review-papervision3d-essentials/#comments Thu, 15 Oct 2009 15:34:02 +0000 Dennis http://www.rozengain.com/blog/?p=463

Packt Publishing sent me book for review. So here we go …

Authors: Paul Tondeur (www.paultondeur.com) and Jeff Winder (www.jeffwinder.nl)
Publisher: Packt publishing (www.packtpub.com)
Pages: 407

Finally there is a book about the most popular 3D engine for Flash, Papervision3D. With a lot of information scattered about on the internet there is a huge need for something coherent. This book will please a lot of people because it covers a lot of ground.

When I first opened the book, I was immediately disappointed by the layout of the table of contents. It looks a bit cheapish and very similar to something that Microsoft Word auto-generates. Unfortunately that applies more or less to the rest of the book. All the images are printed in black & white and sometimes it is hard to see what’s going on in the pictures. A few color pages would’ve been a great addition to this book. Especially because the topic at hand is 3D graphics and not something like database programming.

Fortunately, the book’s contents are great. If you have no experience with 3D programming then this book will tell you all you need to know to get started. It even covers basic topics like Object Oriented Programming, how to use Subversion and how to configure Flash. The Papervision3D part starts with an explanation about basic concepts like Scene, Camera, Viewport, etc and then moves on to primitives, the rendering pipeline and materials. The pace is good and the reader should be able to grasp the basics after reading these chapters.

Don’t get me wrong, this book is not only for beginners. After getting the basics out of the way the more advanced topics are presented. The chapters about cameras, culling, clipping and importing external models are essential and the chapter about z-sorting clarifies some interesting things (like the painter’s algorithm z sort, origin sort, index sort, quadtree rendering).

The last three chapters are about particles, filters, effects, 3D vector drawing, text and performance optimization, very useful if you want to take things a bit further. These topics are also described in detail with some good examples for further clarification. The pace in these chapters is also very good.

Conclusion: this book is definitely an essential resource if you’re a serious Papervision3D developer. Despite the annoying layout quirks I can highly recommend this book. The authors have succeeded in explaining complex matter in a simple way. The text is not too verbose, nor is it too compact. Like I said before, the pace is right throughout the book.

Apart from the paper version, there is also a PDF version available. Go to Packt’s site to get more info.

]]> http://www.rozengain.com/blog/2009/10/15/book-review-papervision3d-essentials/feed/ Eclipse Plug-in: Download AS3 libraries straight to your Eclipse/Flex Builder/FDT project http://www.rozengain.com/blog/2009/10/09/eclipse-plug-in-download-as3-libraries-straight-to-your-eclipseflex-builderfdt-project/ http://www.rozengain.com/blog/2009/10/09/eclipse-plug-in-download-as3-libraries-straight-to-your-eclipseflex-builderfdt-project/#comments Fri, 09 Oct 2009 15:21:47 +0000 Dennis http://www.rozengain.com/blog/?p=455 Do you use ActionScript frameworks a lot? Are you tired of always downloading each framework from different websites when setting up a new project in Eclipse, Flex Builder or FDT? Well, be tired no more :-)

I was getting sick of this myself so I wrote a plug-in that makes this a lot easier. Just right-click on a folder in your Eclipse project and select “Download ActionScript Framework Here”. A dialog will appear listing the ActionScript frameworks that you selected. It can also be a framework you added yourself. Just select the ones you’re after and press “Finish”. It will then either download from Subversion or from another URL. The download progress is then shown in the Eclipse console. When it’s finished refresh your project and you’re done!

What do you need for this to work?
- Eclipse 3.2 or higher
- Subversion command line tools (Windows: http://subversion.tigris.org/servlets/ProjectDocumentList?folderID=8100 Mac: http://subversion.tigris.org/getting.html#osx). To check if this is set up properly: open up a command prompt, type “svn” and hit enter. If it says “Type ’svn help’ for usage.” you’re good to go.

If you have this properly set up then download this jar file and place it in Eclipse’s plugin folder.

To check if it has been installed properly, right click on any folder and see if the “Download ActionScript Framework Here” option is there. By default there are no frameworks. You need to add them in Window > Preferences > ActionScript Framework Downloader.

The plugin has been tested on Windows, Mac, Flexbuilder standalone, FDT standalone. If for some reason it is not working on your machine, then please send me your Eclipse version, Java version and OS name/version.

If you know a framework that you’d like to see added to the list, just give me a shout and I’ll add it. Also, if you have an idea for an Eclipse plug-in, just let me know!

Download ActionScript Frameworks Preference Window

Download ActionScript Frameworks Preference Window

Add your own framework

Add your own framework

Right click on a folder and select "Download ActionScript Framework Here"

Choose the frameworks to download

The progress is shown in a console.

]]> http://www.rozengain.com/blog/2009/10/09/eclipse-plug-in-download-as3-libraries-straight-to-your-eclipseflex-builderfdt-project/feed/ Collada to ActionScript 3.0 exporter BETA: Testers needed! http://www.rozengain.com/blog/2009/10/05/collada-to-actionscript-30-exporter-beta-testers-needed/ http://www.rozengain.com/blog/2009/10/05/collada-to-actionscript-30-exporter-beta-testers-needed/#comments Mon, 05 Oct 2009 12:06:15 +0000 Dennis http://www.rozengain.com/blog/?p=448 There are a lot of people who use Blender and the Blender to ActionScript exporter. However, there are a lot of people who use Maya, SketchUp, DAZ Studio or any other 3D program who aren’t able to export to ActionScript classes. Some people came to me with the question “why don’t you create a COLLADA to ActionScript exporter?”. Almost all 3D programs have a COLLADA exporter so it makes sense to convert from this format to ActionScript.

So, here it is. I found some time to write a little AIR app that does just this. However, since I’m strapped for time and since I don’t own all these 3D programs, I haven’t been able to do a lot of testing.
So I’m looking for people who can test this application by exporting COLLADA files from different 3D programs and then use the generated class in one of the Flash 3D engines.

The only 3D program I used for testing is Blender. Then I tested the classes in all the 3D engines (Sandy, Away3D, Alternativa3D, Papervision3D). I only tested it with simple primitives though.

Important thing: this version does NOT YET support animation. Animation support will be added soon.

So if you’re up for it go ahead and DOWNLOAD the COLLADA to ActionScript 3.0 exporter!

]]> http://www.rozengain.com/blog/2009/10/05/collada-to-actionscript-30-exporter-beta-testers-needed/feed/