I had a hard time recreating this with python, I’d never used python before starting using Blender so my understanding was still fairly new and most examples online I failed to understand or struggled to implement.

Finally I cobbled together something that works from different examples online and got the results I wanted. Like most things on my site I felt the need to share this with anyone else who may be trying a similar thing.

Here is my class in python

class Float16Compressor:
	def __init__(self):
		self.temp = 0

	def compress(self,float32):
		F16_EXPONENT_BITS = 0x1F
		F16_EXPONENT_SHIFT = 10
		F16_EXPONENT_BIAS = 15
		F16_MANTISSA_BITS = 0x3ff
		F16_MANTISSA_SHIFT =  (23 - F16_EXPONENT_SHIFT)
		F16_MAX_EXPONENT =  (F16_EXPONENT_BITS << F16_EXPONENT_SHIFT)

		a = struct.pack('>f',float32)
		b = binascii.hexlify(a)

		f32 = int(b,16)
		f16 = 0
		sign = (f32 >> 16) & 0x8000
		exponent = ((f32 >> 23) & 0xff) - 127
		mantissa = f32 & 0x007fffff

		if exponent == 128:
			f16 = sign | F16_MAX_EXPONENT
			if mantissa:
				f16 |= (mantissa & F16_MANTISSA_BITS)
		elif exponent > 15:
			f16 = sign | F16_MAX_EXPONENT
		elif exponent > -15:
			exponent += F16_EXPONENT_BIAS
			mantissa >>= F16_MANTISSA_SHIFT
			f16 = sign | exponent << F16_EXPONENT_SHIFT | mantissa
		else:
			f16 = sign
		return f16

	def decompress(self,float16):
		s = int((float16 >> 15) & 0x00000001)    # sign
		e = int((float16 >> 10) & 0x0000001f)    # exponent
		f = int(float16 & 0x000003ff)            # fraction

		if e == 0:
			if f == 0:
				return int(s << 31)
			else:
				while not (f & 0x00000400):
					f = f << 1
					e -= 1
				e += 1
				f &= ~0x00000400
				#print(s,e,f)
		elif e == 31:
			if f == 0:
				return int((s << 31) | 0x7f800000)
			else:
				return int((s << 31) | 0x7f800000 | (f << 13))

		e = e + (127 -15)
		f = f << 13
		return int((s << 31) | (e << 23) | f)

and here is how to use it

#read half float from file and print float
h = struct.unpack(">H",file.read(struct.calcsize(">H")))[0]
fcomp = Float16Compressor()
temp = fcomp.decompress(h)
str = struct.pack('I',temp)
f = struct.unpack('f',str)[0]
print(f)

#write half float to file from float
fcomp = Float16Compressor()
f16 = fcomp.compress(float32)
file.write(struct.pack(">H",f16))

Anyway with this big change that means there are more changes to the python api. Which means i have to update my addons again sigh. I’m learning what the new changes are and thought i’d post a little code snippet on how to access some of the usual data through this now.

The below code i used just on a simple triangulated cube, it may help point you in the right direction if you are having similar problems as I was.

import bpy

obj = bpy.data.objects['Cube']
mesh = obj.data

normals = []
indices = []
for face in mesh.polygons:
    indices.append(face.vertices[0])
    indices.append(face.vertices[1])
    indices.append(face.vertices[2])
    for i in range(len(face.vertices)):
        v = mesh.vertices[face.vertices[i]]
        normals.append([v.normal[0],v.normal[1],v.normal[2]])

verts = []
for vert in mesh.vertices:
    verts.append(vert.co.xyz)

uvs = []
for uv_layer in mesh.uv_layers:
    for x in range(len(uv_layer.data)):
        uvs.append(uv_layer.data[x].uv)

print(indices)
print(verts)
print(uvs)
print(normals)

You may recognise the swf from the alternativa3d bunker demo that was created in version 5

The usage is the same as most materials just pass in the movieclip and apply the material and the rest is done. Here is a snippet of the usage…

[Embed(source="screen.swf")] static private const TestSWF:Class;

mybox = new Box();
var mat:MovieMaterial = new MovieMaterial(new TestSWF());
mybox.setMaterialToAllSurfaces(mat);
scene.addChild(mybox);
uploadResources(mybox.getResources(true));

and here is the actual class.. it’s pretty similar to others except for the need to upload the new image resource as well.

package
{
	import alternativa.engine3d.materials.TextureMaterial;
	import alternativa.engine3d.resources.TextureResource;
	import alternativa.engine3d.resources.BitmapTextureResource;
	import alternativa.engine3d.core.Camera3D;
	import alternativa.engine3d.objects.Surface;
	import alternativa.engine3d.resources.Geometry;
	import alternativa.engine3d.core.Light3D;
	import flash.display.MovieClip;
	import flash.display.BitmapData;
	import flash.events.Event;

	import alternativa.engine3d.alternativa3d;
	use namespace alternativa3d;

	public class MovieMaterial extends TextureMaterial
	{
		protected var mc:MovieClip;
		protected var bd:BitmapData;

		public function MovieMaterial(clip:MovieClip):void
		{
			mc = clip;
			this.diffuseMap = getDiffuse();
			this.alpha = 1;
			super(diffuseMap,null,alpha);
			mc.addEventListener(Event.ENTER_FRAME, updateTexture);
		}

		private function getDiffuse():TextureResource {
			bd = new BitmapData (mc.width, mc.height, true);
			return new BitmapTextureResource(bd);
		}

		protected function updateTexture(e:Event = null):void {
			if(mc) { bd.draw(mc); }
		}

		override alternativa3d function collectDraws(camera:Camera3D, surface:Surface, geometry:Geometry, lights:Vector., lightsLength:int, objectRenderPriority:int = -1):void
		{
			if(diffuseMap) { diffuseMap.upload(camera.context3D); }
			super.collectDraws(camera, surface, geometry, lights, lightsLength, objectRenderPriority);
		}
	}
}

Its not perfect I can see that it lights up white just before the swf starts playing. I’m guessing this is just the stage background colour of the embedded swf but i’m not 100% sure as I haven’t tested any other swfs. Its also worth noting that the bitmap data or swf still needs to be a power of 2 to be uploaded successfully. The example swf I used was 256×256.

You can download the source files here or see the demo here

The first thing that bugged me with version 8 is that I couldn’t turn off the smoothing of images. In version 7 you could easily do this by setting material.smooth to false and get that pixelated look. So I thought now the source is released I’d put together a little example of how to get this same effect.

To create this I duplicated the TextureMaterial class from the alternativa source code and made my own PixelTextureMaterial.

In this class there are 2 constants that contain AGAL code that is for the diffuse and diffuse with alpha rendering. If you aren’t familar with AGAL, I guess it can be described as sort of gpu assembly code. Anyway there is a line in the AGAL code that begins with “tex” and then has some various registers and flag options.

Here is an example of code

tex t0, v0, s0 <2d, linear,linear,miplinear>

The flag options between the arrows are what we are interested in, these options represent this data

<dimension,mipmapping,filtering,repeat>

The texture dimension can be : 2d, cube
The texture mipmapping can be : nomip, mipnone, mipnearest, miplinear
The texture filtering can be : nearest, linear
The texture repeat can be : repeat, wrap, clamp

The texture filtering is responsible for the way our image is sampled and the current TextureMaterial is set to use linear filtering, if we change this to say nearest we can get that pixelated look we want.

Here is what my changed code looks like, you can of course alter the other flag options to remove mipmapping or change the repeat etc if you desire. The full source code is available here or see the demo here.

static alternativa3d const getDiffuseProcedure:Procedure = new Procedure([
	"#v0=vUV",
	"#s0=sDiffuse",
	"#c0=cThresholdAlpha",
	"tex t0, v0, s0 <2d, linear,nearest, miplinear>",
	"mul t0.w, t0.w, c0.w",
	"mov o0, t0"
], "getDiffuseProcedure");

static alternativa3d const getDiffuseOpacityProcedure:Procedure = new Procedure([
	"#v0=vUV",
	"#s0=sDiffuse",
	"#s1=sOpacity",
	"#c0=cThresholdAlpha",
	"tex t0, v0, s0 <2d, linear,nearest, miplinear>",
	"tex t1, v0, s1 <2d, linear,nearest, miplinear>",
	"mul t0.w, t1.x, c0.w",
	"mov o0, t0"
], "getDiffuseOpacityProcedure");

I’ve recently taken the fluid water simulation for version 7 and set it up for version 8 which works a lot better with the standard material and lighting effects.

To get it to work I had to create a Vertex class to assign the x y z values and then use version 8′s new geometry and streams to set the data back.

Here is my document class

package
{
	import alternativa.engine3d.controllers.SimpleObjectController;
	import alternativa.engine3d.core.Camera3D;
	import alternativa.engine3d.core.Object3D;
	import alternativa.engine3d.core.Resource;
	import alternativa.engine3d.core.View;
	import alternativa.engine3d.materials.StandardMaterial;
	import alternativa.engine3d.resources.BitmapTextureResource;
	import alternativa.engine3d.lights.*;

	import flash.display.Sprite;
	import flash.display.Stage3D;
	import flash.display.StageAlign;
	import flash.display.StageScaleMode;
	import flash.events.Event;
	import flash.geom.Vector3D;

	import FluidPlane;

	[SWF(backgroundColor="#000000", frameRate="100", width="800", height="600")]

	public class test extends Sprite
	{
		[Embed(source="465-diffuse.jpg")] static private const FluidDiffuse:Class;
		[Embed(source="465-normal.jpg")] static private const FluidNormal:Class;
		[Embed(source="465-bump.jpg")] static private const FluidSpec:Class;

		private var rootContainer:Object3D = new Object3D();
		private var camera:Camera3D;
		private var controller:SimpleObjectController;
		private var fplane:FluidPlane;
		private var stage3D:Stage3D;
		private var dl2:DirectionalLight;

		public function test():void
		{
			//setup stage
			stage.align = StageAlign.TOP_LEFT;
			stage.scaleMode = StageScaleMode.NO_SCALE;

			camera = new Camera3D(0.1, 10000);
			camera.view = new View(stage.stageWidth, stage.stageHeight);
			addChild(camera.view);
			addChild(camera.diagram);
			camera.y = 100;
			camera.z = 100;
			camera.x = -50;
			controller = new SimpleObjectController(stage, camera, 200);
			controller.lookAt(new Vector3D(0,0,0));
			rootContainer.addChild(camera);

			//setup material
			var mat:StandardMaterial = new StandardMaterial(new BitmapTextureResource(new FluidDiffuse().bitmapData),new BitmapTextureResource(new FluidNormal().bitmapData),null,new BitmapTextureResource(new FluidSpec().bitmapData));

			dl2 = new DirectionalLight(0xFFFFFF);
            dl2.intensity = 0.5;
            dl2.lookAt(0,0,0);
			dl2.rotationX = -2.26893;
            dl2.rotationY = 0;
            dl2.rotationZ = 0.698132;
            rootContainer.addChild(dl2);

			var al:AmbientLight = new AmbientLight(0xFFFFFF);
			al.intensity = 0.5;
			al.z = 100;
            rootContainer.addChild(al);

			//create fluidplane and apply material
			fplane = new FluidPlane(camera);
			fplane.setMaterialToAllSurfaces(mat);
			rootContainer.addChild(fplane);

			stage3D = stage.stage3Ds[0];
			stage3D.addEventListener(Event.CONTEXT3D_CREATE, onContextCreate);
			stage3D.requestContext3D();
		}

		private function onContextCreate(e:Event):void {
			for each (var resource:Resource in rootContainer.getResources(true)) {
				resource.upload(stage3D.context3D);
			}

			//start a splash
			fplane.makeSplash(2);

			stage.addEventListener(Event.ENTER_FRAME, onEnterFrame);
		}

		private function onEnterFrame(e:Event):void
		{
			controller.update();
			camera.render(stage3D);
			fplane.draw(stage3D);
		}

		private function onResize(e:Event = null):void {
			camera.view.width = stage.stageWidth;
			camera.view.height = stage.stageHeight;
		}

	}

}

and here is the revised fluid plane class.

// A conversion of the papervision and away3d example
// http://exey.ru/blog/home/fluid-simulation-pv3d-and-away3d

package
{
	import alternativa.engine3d.primitives.Plane;
	import alternativa.engine3d.materials.Material;
	import flash.geom.Vector3D;
	import alternativa.engine3d.core.Camera3D;
	import alternativa.engine3d.core.VertexAttributes;
	import flash.display.Stage3D;

	public class FluidPlane extends Plane
	{
		private var theta:Number = 0;
		private var buffer:Array = new Array(2);
		private var renderBuffer:int = 0;
		private var k1:Number;
		private var k2:Number;
		private var k3:Number;

		private var range:int = 20;
		private var waterSegsX:int = range;
		private var waterSegsY:int = range;
		private var waterSegsXreal:int = waterSegsX+1;
		private var waterSegsYreal:int = waterSegsY+1;
		private var waterXcenter:int = range/2;
		private var waterYcenter:int= range/2;
		private var isPause:Boolean = false;

		private var camera:Camera3D;
		private var vertices:Vector. = new Vector.();
		private var verts:Vector. = new Vector.();

		public function FluidPlane(camera:Camera3D,width:Number = 100, length:Number = 100, widthSegments:uint = 1, lengthSegments:uint = 1, twoSided:Boolean = true, reverse:Boolean = false, bottom:Material = null, top:Material = null)
		{
			this.camera = camera;
			widthSegments = waterSegsX;
			lengthSegments = waterSegsY;
			super(width, length, widthSegments, lengthSegments, twoSided, reverse, bottom, top);

			setupVertices();
			prepareMath();
		}

		private function setupVertices():void
		{
			verts =  this.geometry.getAttributeValues(VertexAttributes.POSITION);
			var x:int = 0;
			for(var i:int = 0; i < verts.length/3; i++)
			{
				var v:Vertex = new Vertex();
				v.x = verts[i + x]; x++;
				v.y = verts[i + x]; x++;
				v.z = verts[i + x];
				this.vertices.push(v);
			}
		}

		private function resaveVertices():void
		{
			this.verts = new Vector.();
			for(var i:int = 0; i < this.vertices.length; i++)
			{
				this.verts.push(this.vertices[i].x);
				this.verts.push(this.vertices[i].y);
				this.verts.push(this.vertices[i].z);
			}
		}

		public function draw(stage3D:Stage3D):void
		{
			theta += 0.05;
			var verCounter:uint = 0;
			for(var x:int = 0 ; x < waterSegsXreal ; x++){
				for(var z:int = 0 ; z < waterSegsYreal ; z++){
					this.vertices[verCounter].z = buffer[renderBuffer][x][z].y * 3;
					verCounter++;
				}
			}
			evaluate();

			resaveVertices();

            this.geometry.setAttributeValues(VertexAttributes.POSITION, verts);
			this.geometry.calculateNormals();
			this.geometry.calculateTangents(0);
			this.calculateBoundBox();
            this.geometry.upload(stage3D.context3D);
		}

		public function makeSplash(splashHeight:int):void
		{
			populateBuffer();
			buffer[renderBuffer][waterXcenter][waterYcenter].y = splashHeight;
		}

		public function prepareMath():void
		{
			populateBuffer();
			//trace(buffer[0].length, buffer[1].length)
			var d:Number = 1;
			var t:Number = 0.1;
			var c:Number = 2.1;
			var mu:Number = 0.001;
			var f1:Number = c*c*t*t/(d*d);
			var f2:Number = 1/(mu*t+2);
			k1 = (4 - 8*f1)*f2;
			k2 = (mu*t-2)*f2;
			k3 = 2 * f1 * f2;
		}

		public function populateBuffer():void
		{
			var x:int,y:int,z:int;
			// 3-d displacement will be stored in the array(2*w*h)
			for(var i:int = 0 ; i < 2; i++)
			{
				var a:Array = new Array();
				for(var j:int = 0 ; j < waterSegsYreal; j++)
				{
					var aa:Array = new Array();
					for(var k:int = 0 ; k < waterSegsXreal; k++)
						aa.push(new Vector3D(j,0,k));
					a.push(aa);
				}
				buffer[i] = a;
			}
		}

		private function evaluate():void
		{
			for(var j:int = 1 ; j < waterSegsYreal-1; j++)
			{
				var crnt:Array = buffer[renderBuffer][j];
				var prev:Array = buffer[1-renderBuffer][j];
				for (var i:int = 1 ; i < waterSegsXreal-1; i++)
				{
					//  trace(j, i);
					var currentN:Vector3D = (Vector3D)(buffer[renderBuffer][j + 1][i]);
					var currentP:Vector3D = (Vector3D)(buffer[renderBuffer][j - 1][i]);
					((Vector3D)(prev[i])).y = k1*((Vector3D)(crnt[i])).y + k2*((Vector3D)(prev[i])).y + k3*(((Vector3D)(crnt[i+1])).y + ((Vector3D)(crnt[i-1])).y + currentN.y + currentP.y);
				}
			}
			renderBuffer = 1-renderBuffer;
		}

	}
}

import flash.geom.Vector3D;
class Vertex extends Object
{

	public var x:Number;
	public var y:Number;
	public var z:Number;

	function Vertex()
	{
		return;
	}
}

You can download the source files here or see the demo here

Along with this update I have moved the project over to github. Why github? it’s a preference thing it feels more comfortable, its easy for others to fork the code and do their own thing with it and I generally find it more intuitive browsing the source code.

The new version allows you to export 3d models that have textures or diffuse colours to actionscript alternativa3d compatible classes. I’ve created a quick demo just to show what it can do.

In the demo i’ve created 3 objects a cube, suzanne the monkey and lastly the torus. The cube is just a simple pink diffuse material applied to all faces. Suzanne the monkey is an example of uv wrapping and a single image texture. The last example is of applying multiple diffuse materials to faces, multiple uv image textures also work like this.

The code uses the geometry class as seen in previous version but uses the different streams for position coordinates, normals, uvs, indices and tangents. I’m still not sure how to export the tangents from blender so this doesn’t actually work right now but if you are using version 8.27.0 you can call the calculateTangents() function.

Click here to view the demo
Download the demo files including blender sourcefile

Seen as its currently undocumented I thought I’d spend a brief moment explaining how to use it.

I’m taking the parsersexample that comes with the alternativa files to illustrate how to use this new class. You should be able to find it at Alternativa3d_8.27.0\Alternativa3DExamples\src\parsersexample.

Once we have access to the file we need to add 2 new includes to it, so add these somewhere at the top.

import alternativa.engine3d.loaders.ResourceLoader;
import flash.events.ProgressEvent;

Then add these variables that we are going to use to get the percentage loaded.

private var itemsTotal:Number = 0;
private var itemsLoaded:Number = 0;

Once thats done we need to switch out the TextureLoader and use our new ResourceLoader. So find the following lines and comment them out or remove them.

//var texturesLoader:TexturesLoader = new TexturesLoader(stage3D.context3D);
//texturesLoader.loadResources(textures);

Then just below this add the following

itemsTotal = textures.length;
var resldr:ResourceLoader = new ResourceLoader();
resldr.addEventListener(ProgressEvent.PROGRESS, onProgress);
resldr.addEventListener(Event.COMPLETE, onComplete);
resldr.addResources(textures);
resldr.load(stage3D.context3D);

This will setup a new instance of the resourceloader and listen for a couple of events. We then pass in the vector of our textures this is the same one that was used in texturesloader, then we just run load to get things moving.

Before we run this code we need the 2 functions for the events too so add these somewhere in the parsersexample.

private function onProgress(e:ProgressEvent):void
{
	itemsLoaded++;
	var percentLoaded:Number = itemsLoaded / itemsTotal;
	percentLoaded = Math.round(percentLoaded * 100);
	trace(percentLoaded + "%");
}

private function onComplete():void
{
	trace("done");
}

Normally I would do something like this code below to get the percentage but the bytesloaded and bytestotal always returned 0 so I scrapped that used the above solution.

var percentLoaded:Number = e.bytesLoaded / e.bytesTotal;
percentLoaded = Math.round(percentLoaded * 100);
trace(percentLoaded + "%");

I’ve put this code into a seperate “Examples” folder that you can use with the other alternativa3d examples to try this out. Download the files here

$("li").mousover(function(){
	//do something over
}).mouseout(function() {
	//do something out
});

$("li").hover(
  function () {
    //do something enter
  },
  function () {
    //do something exit
  }
);

Its only until I recently encountered a problem that I really spent the time to check what the difference was. It turns out that mouseover and mouseout fire events for the children of that element. Where as hover actually works with mouseenter and mouseleave without firing for children.

In the project I was working on I setup a container div to use mouseover and mouseout which added some html tabs to the container. This seemed perfectly fine but I discovered that using mouseover/mouseout meant the added html kept disappearing when I tried to interact with it along with the other jquery I had in place that was conflicting with it.

In the end my particular solution required me to use mouseenter and mouseleave with the live function rather than using hover because I was working with generated html.

The easiest way to imagine this working is to actually think of click events in javascript. Lets say you have a href link with an onClick event attached to it. Clicking this triggers some javascript to show a div somewhere in the page. To do this in javascript you might have some code like this

<a href="#" onClick="document.getElementById('box1').style.display='block'">Click Me</a>
<div id="box1" style="display:none;">test test</div>

Well this very same functionality is available using just the :target css and to great effect. Take this code below as an example, here we can do exactly the same as the javascript but now just with css.

<style type="text/css">
	#box1 {
		display:none;
	}
	#box1:target {
		display:block;
	}
</style>

<a href="#box1">Click Me</a>
<div id="box1">test test</div>

Of course there are the usual browser limitations but consider combining this with javascript as a fallback and you can have a more future proof native version of your code. Combine this with some of the css animation effects and you can have something that would easily fool others into thinking its made with javascript when in fact its css.

The physics engine has its own set of classes that seem to integrate or extend alternativa3D 8. This means that all the scene and camera creation is already done and you can just override the setScene() and then concentrate on handling of the physics and the rest of the code. Its setup is familiar to me and reminds me of the jiglib flash libraries so its quite easy to get up and running with.

The examples that come with the physics engine don’t actually show the loading of a 3d model and then applying physics to it but it is very simple task. Just load the .3ds file or .a3d file as you would as per the examples from the alternativa3d 8 library. Once its all loaded you setup a transform, a physical object and a collision area then add it to the scene.

override protected function setScene():void
{
	//add fps
	addChild(camera.diagram);

	//create and add light source
	var light:Light3D;
	light = new OmniLight(0xFFFFFF, 1, 7000);
	light.x = 0;
	light.y = 200;
	light.z = 1000;
	light.intensity = 0.8;
	addObject3D(light);
	light = new AmbientLight(0xFFFFFF);
	light.intensity = 0.2;
	addObject3D(light);

	//create a loader to load the pin
	var loader3DS:URLLoader = new URLLoader();
	loader3DS.dataFormat = URLLoaderDataFormat.BINARY;
	loader3DS.load(new URLRequest("pin.3ds"));
	loader3DS.addEventListener(Event.COMPLETE, on3DSLoad);
}

private function on3DSLoad(e:Event):void
{
	var parser:Parser3DS = new Parser3DS();
	parser.parse((e.target as URLLoader).data);
	var mesh:Mesh;
	for each (var object:Object3D in parser.objects) {
		if (object.name == "Mesh.007") {
			mesh = object as Mesh;
			break;
		}
	}
	uploadResources(mesh.getResources(false, Geometry));

	// Setup materials
	var textures:Vector. = new Vector.();
	for (var i:int = 0; i < mesh.numSurfaces; i++) {
		var surface:Surface = mesh.getSurface(i);
		var material:ParserMaterial = surface.material as ParserMaterial;
		if (material != null) {
			var diffuse:ExternalTextureResource = material.textures["diffuse"];
			if (diffuse != null) {
				diffuse.url = "" + diffuse.url;
				textures.push(diffuse);
				surface.material = new TextureMaterial(diffuse);
			}
		}
	}

	// Loading of textures
	var texturesLoader:TexturesLoader = new TexturesLoader(stage3d.context3D);
	texturesLoader.loadResources(textures);

	// setup loaded model in this case bowling pin
	var transform:Matrix4 = new Matrix4();
	transform.setPositionXYZ(0, 0, 1);
	var pin1:PhysicalSimObject = new DynamicObject(transform, new Vector3(0, 0, 2));
	pin1.addPhysicsPrimitive(
		new PhysicsPrimitive(new CollisionTriangleMesh(MeshUtils.createGeometryMeshFromMesh3d(mesh), CollisionType.DYNAMIC), 1)
	);
	pin1.addAppearanceComponent(mesh);
	addSimObject(pin1);
}

private function uploadResources(resources:Vector.):void {
	for each (var resource:Resource in resources) {
		resource.upload(stage3d.context3D);
	}
}

The boundaries for the collision are taken from the actual mesh this time instead of using a rectangle or other primitive shape. To do this we use the CollisionTriangleMesh and the meshutility to convert the mesh class to the accepted parameter class geometrymesh.

pin1.addPhysicsPrimitive(
	new PhysicsPrimitive(new CollisionTriangleMesh(MeshUtils.createGeometryMeshFromMesh3d(mesh), CollisionType.DYNAMIC), 1)
);

While this did work I had some issues with the bowling pins sinking through the floor I created. Its like the origin point for the mesh had changed once it was run through the meshutility. So to get the effect i wanted I switched it around and used a cone shape for collision.

pin1.addPhysicsPrimitive(
	new PhysicsPrimitive(new CollisionCone(0.1, 0.3, 3, CollisionType.DYNAMIC), 0.5)
);

You can download the files here or view it on the demo page here.