Babylon.js/Exporters/Blender/io_export_babylon.py

bl_info = {
    "name": "Babylon.js",
    "author": "David Catuhe",
    "version": (1, 0),
    "blender": (2, 67, 0),
    "location": "File > Export > Babylon.js (.babylon)",
    "description": "Export Babylon.js scenes (.babylon)",
    "warning": "",
    "wiki_url": "",
    "tracker_url": "",
    "category": "Import-Export"}
    
import math
import os
import bpy
import string
import bpy_extras.io_utils
from bpy.props import *
import mathutils, math
import struct
import shutil
from os import remove
from bpy_extras.io_utils import (ExportHelper, axis_conversion)
from bpy.props import (BoolProperty, FloatProperty, StringProperty, EnumProperty, FloatVectorProperty)

class SubMesh:
	materialIndex = 0
	verticesStart = 0
	verticesCount = 0
	indexStart = 0
	indexCount = 0
	
class MultiMaterial:
	name = ""
	materials = []

class Export_babylon(bpy.types.Operator, ExportHelper):  
	"""Export Babylon.js scene (.babylon)""" 
	bl_idname = "scene.babylon"
	bl_label = "Export Babylon.js scene"

	filename_ext = ".babylon"
	filepath = ""
	
	# global_scale = FloatProperty(name="Scale", min=0.01, max=1000.0, default=1.0)

	def execute(self, context):
	       return Export_babylon.save(self, context, **self.as_keywords(ignore=("check_existing", "filter_glob", "global_scale")))
		   
	def mesh_triangulate(mesh):
		import bmesh
		bm = bmesh.new()
		bm.from_mesh(mesh)
		bmesh.ops.triangulate(bm, faces=bm.faces)
		bm.to_mesh(mesh)
		mesh.calc_tessface()
		bm.free()

	def write_array3(file_handler, name, array):
		file_handler.write(",\""+name+"\":[" + "%.4f,%.4f,%.4f"%(array[0],array[1],array[2]) + "]")		
	
	def write_color(file_handler, name, color):
		file_handler.write(",\""+name+"\":[" + "%.4f,%.4f,%.4f"%(color.r,color.g,color.b) + "]")

	def write_vector(file_handler, name, vector):
		file_handler.write(",\""+name+"\":[" + "%.4f,%.4f,%.4f"%(vector.x,vector.z,vector.y) + "]")
	
	def write_string(file_handler, name, string, noComma=False):
		if noComma == False:
			file_handler.write(",")
		file_handler.write("\""+name+"\":\"" + string + "\"")
	
	def write_float(file_handler, name, float):
		file_handler.write(",\""+name+"\":" + "%.4f"%(float))
		
	def write_int(file_handler, name, int, noComma=False):
		if noComma == False:
			file_handler.write(",")
		file_handler.write("\""+name+"\":" + str(int))
		
	def write_bool(file_handler, name, bool):	
		if bool:
			file_handler.write(",\""+name+"\":" + "true")
		else:
			file_handler.write(",\""+name+"\":" + "false")
			
	def export_camera(object, scene, file_handler):		
		invWorld = object.matrix_world.copy()
		invWorld.invert()
		
		target = mathutils.Vector((0, 1, 0)) * invWorld
	
		file_handler.write("{")
		Export_babylon.write_string(file_handler, "name", object.name, True)		
		Export_babylon.write_string(file_handler, "id", object.name)
		Export_babylon.write_vector(file_handler, "position", object.location)
		Export_babylon.write_vector(file_handler, "target", target)
		Export_babylon.write_float(file_handler, "fov", object.data.angle)
		Export_babylon.write_float(file_handler, "minZ", object.data.clip_start)
		Export_babylon.write_float(file_handler, "maxZ", object.data.clip_end)
		Export_babylon.write_float(file_handler, "speed", 1.0)
		Export_babylon.write_float(file_handler, "inertia", 0.9)
		Export_babylon.write_bool(file_handler, "checkCollisions", object.data.checkCollisions)
		Export_babylon.write_bool(file_handler, "applyGravity", object.data.applyGravity)
		Export_babylon.write_array3(file_handler, "ellipsoid", object.data.ellipsoid)
		file_handler.write("}")
		
	def export_light(object, scene, file_handler):		
		light_type_items = {'POINT': 0, 'SUN': 1, 'SPOT': 2, 'HEMI': 3, 'AREA': 0}
		light_type = light_type_items[object.data.type]
		
		file_handler.write("{")
		Export_babylon.write_string(file_handler, "name", object.name, True)		
		Export_babylon.write_string(file_handler, "id", object.name)		
		Export_babylon.write_float(file_handler, "type", light_type)
		if light_type == 0:
			Export_babylon.write_vector(file_handler, "data", object.location)
		elif light_type == 1:
			matrix_world = object.matrix_world.copy()
			matrix_world.translation = mathutils.Vector((0, 0, 0))
			direction = mathutils.Vector((0, 0, -1)) * matrix_world
			Export_babylon.write_vector(file_handler, "data", direction)
		elif light_type == 2:
			Export_babylon.write_vector(file_handler, "data", object.location)
			matrix_world = object.matrix_world.copy()
			matrix_world.translation = mathutils.Vector((0, 0, 0))
			direction = mathutils.Vector((0, 0, -1)) * matrix_world
			Export_babylon.write_vector(file_handler, "direction", direction)
			Export_babylon.write_float(file_handler, "angle", object.data.spot_size)
			Export_babylon.write_float(file_handler, "exponent", object.data.spot_blend * 2)
		else:
			matrix_world = object.matrix_world.copy()
			matrix_world.translation = mathutils.Vector((0, 0, 0))
			direction = mathutils.Vector((0, 0, -1)) * matrix_world
			Export_babylon.write_vector(file_handler, "data", -direction)
			Export_babylon.write_color(file_handler, "groundColor", mathutils.Color((0, 0, 0)))
			
		Export_babylon.write_float(file_handler, "intensity", object.data.energy)
		
		if object.data.use_diffuse:
			Export_babylon.write_color(file_handler, "diffuse", object.data.color)
		else:
			Export_babylon.write_color(file_handler, "diffuse", mathutils.Color((0, 0, 0)))

		if object.data.use_specular:
			Export_babylon.write_color(file_handler, "specular", object.data.color)
		else:
			Export_babylon.write_color(file_handler, "specular", mathutils.Color((0, 0, 0)))
			
		file_handler.write("}")		
	
	def export_texture(slot, level, texture, scene, file_handler, filepath):	
		# Copy image to output
		try:
			image = texture.texture.image
			imageFilepath = os.path.normpath(bpy.path.abspath(image.filepath))
			basename = os.path.basename(imageFilepath)
			targetdir = os.path.dirname(filepath)
			targetpath = os.path.join(targetdir, basename)
			
			if image.packed_file:
				image.save_render(targetpath)
			else:
				sourcepath = bpy.path.abspath(image.filepath)
				shutil.copy(sourcepath, targetdir)
		except:
			pass
		
		# Export
		file_handler.write(",\""+slot+"\":{")
		Export_babylon.write_string(file_handler, "name", basename, True)
		Export_babylon.write_float(file_handler, "level", level)
		Export_babylon.write_float(file_handler, "hasAlpha", texture.texture.use_alpha)
		
		coordinatesMode = 0;
		if (texture.mapping == "CUBE"):
			coordinatesMode = 3;
		if (texture.mapping == "SPHERE"):
			coordinatesMode = 1;		
		Export_babylon.write_int(file_handler, "coordinatesMode", coordinatesMode)
		Export_babylon.write_float(file_handler, "uOffset", texture.offset.x)
		Export_babylon.write_float(file_handler, "vOffset", texture.offset.y)
		Export_babylon.write_float(file_handler, "uScale", texture.scale.x)
		Export_babylon.write_float(file_handler, "vScale", texture.scale.y)
		Export_babylon.write_float(file_handler, "uAng", 0)
		Export_babylon.write_float(file_handler, "vAng", 0)		
		Export_babylon.write_float(file_handler, "wAng", 0)
		
		if (texture.texture.extension == "REPEAT"):
			Export_babylon.write_bool(file_handler, "wrapU", True)		
			Export_babylon.write_bool(file_handler, "wrapV", True)
		else:
			Export_babylon.write_bool(file_handler, "wrapU", False)		
			Export_babylon.write_bool(file_handler, "wrapV", False)
			
		Export_babylon.write_int(file_handler, "coordinatesIndex", 0)
		
		file_handler.write("}")	
		
	def export_material(material, scene, file_handler, filepath):		
		file_handler.write("{")
		Export_babylon.write_string(file_handler, "name", material.name, True)		
		Export_babylon.write_string(file_handler, "id", material.name)
		Export_babylon.write_color(file_handler, "ambient", material.ambient * material.diffuse_color)
		Export_babylon.write_color(file_handler, "diffuse", material.diffuse_intensity * material.diffuse_color)
		Export_babylon.write_color(file_handler, "specular", material.specular_intensity * material.specular_color)
		Export_babylon.write_float(file_handler, "specularPower", material.specular_hardness)
		Export_babylon.write_color(file_handler, "emissive", material.emit * material.diffuse_color)		
		Export_babylon.write_float(file_handler, "alpha", material.alpha)
		Export_babylon.write_bool(file_handler, "backFaceCulling", material.game_settings.use_backface_culling)
				
		# Textures
		for mtex in material.texture_slots:
			if mtex and mtex.texture and mtex.texture.type == 'IMAGE':
				if mtex.texture.image:
					if (mtex.use_map_color_diffuse and(mtex.texture_coords != 'REFLECTION')):
						# Diffuse
						Export_babylon.export_texture("diffuseTexture", mtex.diffuse_color_factor, mtex, scene, file_handler, filepath)
					if mtex.use_map_ambient:
						# Ambient
						Export_babylon.export_texture("ambientTexture", mtex.ambient_factor, mtex, scene, file_handler, filepath)
					if mtex.use_map_alpha:
						# Opacity
						Export_babylon.export_texture("opacityTexture", mtex.alpha_factor, mtex, scene, file_handler, filepath)
					if mtex.use_map_color_diffuse and (mtex.texture_coords == 'REFLECTION'):
						# Reflection
						Export_babylon.export_texture("reflectionTexture", mtex.diffuse_color_factor, mtex, scene, file_handler, filepath)
					if mtex.use_map_emit:
						# Emissive
						Export_babylon.export_texture("emissiveTexture", mtex.emit_factor, mtex, scene, file_handler, filepath)						
		
		file_handler.write("}")			
	
	def export_multimaterial(multimaterial, scene, file_handler):		
		file_handler.write("{")
		Export_babylon.write_string(file_handler, "name", multimaterial.name, True)
		Export_babylon.write_string(file_handler, "id", multimaterial.name)
		
		file_handler.write(",\"materials\":[")
		first = True
		for materialName in multimaterial.materials:
			if first != True:
				file_handler.write(",")
			file_handler.write("\"" + materialName +"\"")
			first = False
		file_handler.write("]")
		file_handler.write("}")
	
	def export_mesh(object, scene, file_handler, multiMaterials):
		# Get mesh	
		mesh = object.to_mesh(scene, True, "PREVIEW")
		
		# Transform
		matrix_world = object.matrix_world.copy()
		matrix_world.translation = mathutils.Vector((0, 0, 0))
		mesh.transform(matrix_world)		
								
		# Triangulate mesh if required
		Export_babylon.mesh_triangulate(mesh)
		
		# Getting vertices and indices
		vertices=",\"vertices\":["
		indices=",\"indices\":["	
		hasUV = True;
		hasUV2 = True;
		
		if len(mesh.tessface_uv_textures) > 0:
			UVmap=mesh.tessface_uv_textures[0].data	
		else:
			hasUV = False
			
		if len(mesh.tessface_uv_textures) > 1:
			UV2map=mesh.tessface_uv_textures[1].data
		else:
			hasUV2 = False
			
		alreadySavedVertices = []
		vertices_UVs=[]
		vertices_UV2s=[]
		vertices_indices=[]
		subMeshes = []
				
		for v in range(0, len(mesh.vertices)):
			alreadySavedVertices.append(False)
			vertices_UVs.append([])
			vertices_UV2s.append([])
			vertices_indices.append([])
		
		
		materialsCount = max(1, len(object.material_slots))
		verticesCount = 0
		indicesCount = 0
		
		for materialIndex in range(materialsCount):
			subMeshes.append(SubMesh())
			subMeshes[materialIndex].materialIndex = materialIndex
			subMeshes[materialIndex].verticesStart = verticesCount
			subMeshes[materialIndex].indexStart = indicesCount
		
			for face in mesh.tessfaces:  # For each face
				
				if face.material_index != materialIndex:
					continue
				
				for v in range(3): # For each vertex in face
					vertex_index = face.vertices[v]
					vertex = mesh.vertices[vertex_index]
					position = vertex.co
					normal = vertex.normal	
					
					if hasUV:
						vertex_UV = UVmap[face.index].uv[v]
						
					if hasUV2:
						vertex_UV2 = UV2map[face.index].uv[v]
						
					# Check if the current vertex is already saved					
					alreadySaved = alreadySavedVertices[vertex_index]
					index_UV = 0
					if alreadySaved:
						alreadySaved=False						
						
						if hasUV:
							for vUV in vertices_UVs[vertex_index]:
								if (vUV[0]==vertex_UV[0] and vUV[1]==vertex_UV[1]):
									if hasUV2:
										vUV2 = vertices_UV2s[vertex_index][index_UV]
										if (vUV2[0]==vertex_UV2[0] and vUV2[1]==vertex_UV2[1]):
											if vertices_indices[vertex_index][index_UV] >= subMeshes[materialIndex].verticesStart:
												alreadySaved=True
												break
									else:
										alreadySaved=True
										break
								index_UV+=1
						else:
							for savedIndex in vertices_indices[vertex_index]:
								if savedIndex >= subMeshes[materialIndex].verticesStart:
									alreadySaved=True
									break
								index_UV+=1
					  
					if (alreadySaved):
						# Reuse vertex
						index=vertices_indices[vertex_index][index_UV]
					else:
						# Export new one
						index=verticesCount
						alreadySavedVertices[vertex_index]=True
						if hasUV:
							vertices_UVs[vertex_index].append(vertex_UV)
						if hasUV2:
							vertices_UV2s[vertex_index].append(vertex_UV2)
						vertices_indices[vertex_index].append(index)
						
						vertices+="%.4f,%.4f,%.4f,"%(position.x,position.z,position.y)				
						vertices+="%.4f,%.4f,%.4f,"%(normal.x,normal.z,normal.y)
						if hasUV:
							vertices+="%.4f,%.4f,"%(vertex_UV[0], vertex_UV[1])
							
						if hasUV2:
							vertices+="%.4f,%.4f,"%(vertex_UV2[0], vertex_UV2[1])
						
						verticesCount += 1
					indices+="%i,"%(index)
					indicesCount += 1			
					
			subMeshes[materialIndex].verticesCount = verticesCount - subMeshes[materialIndex].verticesStart
			subMeshes[materialIndex].indexCount = indicesCount - subMeshes[materialIndex].indexStart
				
		vertices=vertices.rstrip(',')
		indices=indices.rstrip(',')
			
		vertices+="]\n"
		indices+="]\n"	
				
		# Writing mesh		
		file_handler.write("{")
		
		Export_babylon.write_string(file_handler, "name", object.name, True)		
		Export_babylon.write_string(file_handler, "id", object.name)		
		if object.parent != None:
			Export_babylon.write_string(file_handler, "parentId", object.parent.name)
		
		if len(object.material_slots) == 1:
			material = object.material_slots[0].material
			Export_babylon.write_string(file_handler, "materialId", object.material_slots[0].name)
			
			if material.game_settings.face_orientation != "BILLBOARD":
				billboardMode = 0
			else:
				billboardMode = 7
		elif len(object.material_slots) > 1:
			multimat = MultiMaterial()
			multimat.name = "Multimaterial#" + str(len(multiMaterials))
			Export_babylon.write_string(file_handler, "materialId", multimat.name)
			for mat in object.material_slots:
				multimat.materials.append(mat.name)
				
			multiMaterials.append(multimat)
			billboardMode = 0
		else:
			billboardMode = 0
			
		Export_babylon.write_vector(file_handler, "position", object.location)
		Export_babylon.write_vector(file_handler, "rotation", mathutils.Vector((0, 0, 0)))
		Export_babylon.write_vector(file_handler, "scaling", mathutils.Vector((1, 1, 1)))
		Export_babylon.write_bool(file_handler, "isVisible", object.is_visible(scene))
		Export_babylon.write_bool(file_handler, "isEnabled", True)
		Export_babylon.write_bool(file_handler, "checkCollisions", object.data.checkCollisions)
		Export_babylon.write_int(file_handler, "billboardMode", billboardMode)
		
		if hasUV and hasUV2:
			Export_babylon.write_int(file_handler, "uvCount", 2)
		elif hasUV:
			Export_babylon.write_int(file_handler, "uvCount", 1)
		else:
			Export_babylon.write_int(file_handler, "uvCount", 0)
			
		file_handler.write(vertices)	
		file_handler.write(indices)	
		
		# Sub meshes
		file_handler.write(",\"subMeshes\":[")
		first = True
		for subMesh in subMeshes:
			if first == False:
				file_handler.write(",")
			file_handler.write("{")
			Export_babylon.write_int(file_handler, "materialIndex", subMesh.materialIndex, True)
			Export_babylon.write_int(file_handler, "verticesStart", subMesh.verticesStart)
			Export_babylon.write_int(file_handler, "verticesCount", subMesh.verticesCount)
			Export_babylon.write_int(file_handler, "indexStart", subMesh.indexStart)
			Export_babylon.write_int(file_handler, "indexCount", subMesh.indexCount)
			file_handler.write("}")
			first = False
		file_handler.write("]")
		
		# Closing
		file_handler.write("}")
		

	def save(operator, context, filepath="",
		use_apply_modifiers=False,
		use_triangulate=True,
		use_compress=False):

		# Open file
		file_handler = open(filepath, 'w')	
			
		if bpy.ops.object.mode_set.poll():
			bpy.ops.object.mode_set(mode='OBJECT')		

		# Writing scene
		scene=context.scene
		
		world = scene.world
		if world:
			world_ambient = world.ambient_color
		else:
			world_ambient = Color((0.0, 0.0, 0.0))
	
		file_handler.write("{")
		file_handler.write("\"autoClear\":true")
		Export_babylon.write_color(file_handler, "clearColor", world_ambient)
		Export_babylon.write_color(file_handler, "ambientColor", world_ambient)
		Export_babylon.write_vector(file_handler, "gravity", scene.gravity)
		
		# Cameras
		file_handler.write(",\"cameras\":[")
		first = True
		for object in [object for object in scene.objects if object.is_visible(scene)]:
			if (object.type == 'CAMERA'):
				if first != True:
					file_handler.write(",")

				first = False
				data_string = Export_babylon.export_camera(object, scene, file_handler)
		file_handler.write("]")
						
		# Active camera
		if scene.camera != None:
			Export_babylon.write_string(file_handler, "activeCamera", scene.camera.name)
			
		# Lights
		file_handler.write(",\"lights\":[")
		first = True
		for object in [object for object in scene.objects if object.is_visible(scene)]:
			if (object.type == 'LAMP'):
				if first != True:
					file_handler.write(",")

				first = False
				data_string = Export_babylon.export_light(object, scene, file_handler)
		file_handler.write("]")
		
		# Materials
		materials = [mat for mat in bpy.data.materials if mat.users >= 1]
		file_handler.write(",\"materials\":[")
		first = True
		for material in materials:
			if first != True:
				file_handler.write(",")

			first = False
			data_string = Export_babylon.export_material(material, scene, file_handler, filepath)
		file_handler.write("]")
		
		# Meshes
		file_handler.write(",\"meshes\":[")
		multiMaterials = []
		first = True
		for object in [object for object in scene.objects]:
			if (object.type == 'MESH'):
				if first != True:
					file_handler.write(",")

				first = False
				data_string = Export_babylon.export_mesh(object, scene, file_handler, multiMaterials)
		file_handler.write("]")
		
		# Multi-materials
		file_handler.write(",\"multiMaterials\":[")
		first = True
		for multimaterial in multiMaterials:
			if first != True:
				file_handler.write(",")

			first = False
			data_string = Export_babylon.export_multimaterial(multimaterial, scene, file_handler)
		file_handler.write("]")
		
		# Closing
		file_handler.write("}")
		file_handler.close()
		
		return {'FINISHED'}

# UI
bpy.types.Mesh.checkCollisions = BoolProperty(
    name="Check collisions", 
    default = False)
	
bpy.types.Camera.checkCollisions = BoolProperty(
    name="Check collisions", 
    default = False)
	
bpy.types.Camera.applyGravity = BoolProperty(
    name="Apply Gravity", 
    default = False)	
	
bpy.types.Camera.ellipsoid = FloatVectorProperty(
    name="Ellipsoid", 
	default = mathutils.Vector((0.2, 0.9, 0.2)))		

class ObjectPanel(bpy.types.Panel):
	bl_label = "Babylon.js"
	bl_space_type = "PROPERTIES"
	bl_region_type = "WINDOW"
	bl_context = "data"
	
	def draw(self, context):
		ob = context.object
		if not ob or not ob.data:
			return
			
		layout = self.layout
		isMesh = isinstance(ob.data, bpy.types.Mesh)
		isCamera = isinstance(ob.data, bpy.types.Camera)
		
		if isMesh:
			layout.prop(ob.data, 'checkCollisions')		
		elif isCamera:
			layout.prop(ob.data, 'checkCollisions')
			layout.prop(ob.data, 'applyGravity')
			layout.prop(ob.data, 'ellipsoid')
			
### REGISTER ###

def menu_func(self, context):
    self.layout.operator(Export_babylon.bl_idname, text="Babylon.js (.babylon)")

def register():
    bpy.utils.register_module(__name__)
    bpy.types.INFO_MT_file_export.append(menu_func)

def unregister():
    bpy.utils.unregister_module(__name__)
    bpy.types.INFO_MT_file_export.remove(menu_func)

    
if __name__ == "__main__":
    register()