# ##### BEGIN GPL LICENSE BLOCK ##### # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. # # ##### END GPL LICENSE BLOCK ##### import os import json import logging import bpy from bpy_extras.io_utils import ExportHelper from bpy.props import ( EnumProperty, BoolProperty, FloatProperty, IntProperty, StringProperty ) from . import constants logging.basicConfig( format='%(levelname)s:THREE:%(message)s', level=logging.DEBUG) bl_info = { 'name': "Three.js Format", 'author': "repsac, mrdoob, yomotsu, mpk, jpweeks, rkusa", 'version': (1, 4, 0), 'blender': (2, 7, 3), 'location': "File > Export", 'description': "Export Three.js formatted JSON files.", 'warning': "Importer not included.", 'wiki_url': "https://github.com/mrdoob/three.js/tree/"\ "master/utils/exporters/blender", 'tracker_url': "https://github.com/mrdoob/three.js/issues", 'category': 'Import-Export' } def _geometry_types(): """The valid geometry types that are supported by Three.js :return: list of tuples """ keys = (constants.GLOBAL, constants.GEOMETRY, constants.BUFFER_GEOMETRY) types = [] for key in keys: types.append((key, key.title(), key)) return types bpy.types.Mesh.THREE_geometry_type = EnumProperty( name="Geometry type", description="Geometry type", items=_geometry_types(), default=constants.GLOBAL) class ThreeMesh(bpy.types.Panel): """Creates custom properties on a mesh node""" bl_label = 'THREE' bl_space_type = 'PROPERTIES' bl_region_type = 'WINDOW' bl_context = 'data' def draw(self, context): """ :param context: """ row = self.layout.row() if context.mesh: row.prop(context.mesh, 'THREE_geometry_type', text="Type") def _blending_types(index): """Supported blending types for Three.js :param index: :type index: int :returns: tuple if types (str, str, str) """ types = (constants.BLENDING_TYPES.NONE, constants.BLENDING_TYPES.NORMAL, constants.BLENDING_TYPES.ADDITIVE, constants.BLENDING_TYPES.SUBTRACTIVE, constants.BLENDING_TYPES.MULTIPLY, constants.BLENDING_TYPES.CUSTOM) return (types[index], types[index], types[index]) bpy.types.Material.THREE_blending_type = EnumProperty( name="Blending type", description="Blending type", items=[_blending_types(x) for x in range(5)], default=constants.BLENDING_TYPES.NORMAL) bpy.types.Material.THREE_depth_write = BoolProperty(default=True) bpy.types.Material.THREE_depth_test = BoolProperty(default=True) class ThreeMaterial(bpy.types.Panel): """Adds custom properties to the Materials of an object""" bl_label = 'THREE' bl_space_type = 'PROPERTIES' bl_region_type = 'WINDOW' bl_context = 'material' def draw(self, context): """ :param context: """ layout = self.layout mat = context.material if mat is not None: row = layout.row() row.label(text="Selected material: %s" % mat.name) row = layout.row() row.prop(mat, 'THREE_blending_type', text="Blending type") row = layout.row() row.prop(mat, 'THREE_depth_write', text="Enable depth writing") row = layout.row() row.prop(mat, 'THREE_depth_test', text="Enable depth testing") def _mag_filters(index): """Three.js mag filters :param index: :type index: int :returns: tuple with the filter values """ types = (constants.LINEAR_FILTERS.LINEAR, constants.NEAREST_FILTERS.NEAREST) return (types[index], types[index], types[index]) bpy.types.Texture.THREE_mag_filter = EnumProperty( name="Mag Filter", items=[_mag_filters(x) for x in range(2)], default=constants.LINEAR_FILTERS.LINEAR) def _min_filters(index): """Three.js min filters :param index: :type index: int :returns: tuple with the filter values """ types = (constants.LINEAR_FILTERS.LINEAR, constants.LINEAR_FILTERS.MIP_MAP_NEAREST, constants.LINEAR_FILTERS.MIP_MAP_LINEAR, constants.NEAREST_FILTERS.NEAREST, constants.NEAREST_FILTERS.MIP_MAP_NEAREST, constants.NEAREST_FILTERS.MIP_MAP_LINEAR) return (types[index], types[index], types[index]) bpy.types.Texture.THREE_min_filter = EnumProperty( name="Min Filter", items=[_min_filters(x) for x in range(6)], default=constants.LINEAR_FILTERS.MIP_MAP_LINEAR) def _mapping(index): """Three.js texture mappings types :param index: :type index: int :returns: tuple with the mapping values """ types = (constants.MAPPING_TYPES.UV, constants.MAPPING_TYPES.CUBE_REFLECTION, constants.MAPPING_TYPES.CUBE_REFRACTION, constants.MAPPING_TYPES.SPHERICAL_REFLECTION) return (types[index], types[index], types[index]) bpy.types.Texture.THREE_mapping = EnumProperty( name="Mapping", items=[_mapping(x) for x in range(4)], default=constants.MAPPING_TYPES.UV) class ThreeTexture(bpy.types.Panel): """Adds custom properties to a texture""" bl_label = 'THREE' bl_space_type = 'PROPERTIES' bl_region_type = 'WINDOW' bl_context = 'texture' #@TODO: possible to make cycles compatible? def draw(self, context): """ :param context: """ layout = self.layout tex = context.texture if tex is not None: row = layout.row() row.prop(tex, 'THREE_mapping', text="Mapping") row = layout.row() row.prop(tex, 'THREE_mag_filter', text="Mag Filter") row = layout.row() row.prop(tex, 'THREE_min_filter', text="Min Filter") bpy.types.Object.THREE_export = bpy.props.BoolProperty(default=True) class ThreeObject(bpy.types.Panel): """Adds custom properties to an object""" bl_label = 'THREE' bl_space_type = 'PROPERTIES' bl_region_type = 'WINDOW' bl_context = 'object' def draw(self, context): """ :param context: """ layout = self.layout obj = context.object row = layout.row() row.prop(obj, 'THREE_export', text='Export') class ThreeExportSettings(bpy.types.Operator): """Save the current export settings (gets saved in .blend)""" bl_label = "Save Settings" bl_idname = "scene.three_export_settings_set" def execute(self, context): cycles = context.scene.cycles cycles.use_samples_final = True context.scene[constants.EXPORT_SETTINGS_KEY] = set_settings(context.active_operator.properties) self.report({"INFO"}, "Three Export Settings Saved") return {"FINISHED"} def restore_export_settings(properties, settings): """Restore the settings :param properties: """ ## Geometry { properties.option_vertices = settings.get( constants.VERTICES, constants.EXPORT_OPTIONS[constants.VERTICES]) properties.option_faces = settings.get( constants.FACES, constants.EXPORT_OPTIONS[constants.FACES]) properties.option_normals = settings.get( constants.NORMALS, constants.EXPORT_OPTIONS[constants.NORMALS]) properties.option_skinning = settings.get( constants.SKINNING, constants.EXPORT_OPTIONS[constants.SKINNING]) properties.option_bones = settings.get( constants.BONES, constants.EXPORT_OPTIONS[constants.BONES]) properties.option_influences = settings.get( constants.INFLUENCES_PER_VERTEX, constants.EXPORT_OPTIONS[constants.INFLUENCES_PER_VERTEX]) properties.option_geometry_type = settings.get( constants.GEOMETRY_TYPE, constants.EXPORT_OPTIONS[constants.GEOMETRY_TYPE]) ## } ## Materials { properties.option_materials = settings.get( constants.MATERIALS, constants.EXPORT_OPTIONS[constants.MATERIALS]) properties.option_uv_coords = settings.get( constants.UVS, constants.EXPORT_OPTIONS[constants.UVS]) properties.option_face_materials = settings.get( constants.FACE_MATERIALS, constants.EXPORT_OPTIONS[constants.FACE_MATERIALS]) properties.option_maps = settings.get( constants.MAPS, constants.EXPORT_OPTIONS[constants.MAPS]) properties.option_colors = settings.get( constants.COLORS, constants.EXPORT_OPTIONS[constants.COLORS]) properties.option_mix_colors = settings.get( constants.MIX_COLORS, constants.EXPORT_OPTIONS[constants.MIX_COLORS]) ## } ## Settings { properties.option_scale = settings.get( constants.SCALE, constants.EXPORT_OPTIONS[constants.SCALE]) properties.option_round_off = settings.get( constants.ENABLE_PRECISION, constants.EXPORT_OPTIONS[constants.ENABLE_PRECISION]) properties.option_round_value = settings.get( constants.PRECISION, constants.EXPORT_OPTIONS[constants.PRECISION]) properties.option_logging = settings.get( constants.LOGGING, constants.EXPORT_OPTIONS[constants.LOGGING]) properties.option_compression = settings.get( constants.COMPRESSION, constants.NONE) properties.option_indent = settings.get( constants.INDENT, constants.EXPORT_OPTIONS[constants.INDENT]) properties.option_copy_textures = settings.get( constants.COPY_TEXTURES, constants.EXPORT_OPTIONS[constants.COPY_TEXTURES]) properties.option_texture_folder = settings.get( constants.TEXTURE_FOLDER, constants.EXPORT_OPTIONS[constants.TEXTURE_FOLDER]) properties.option_embed_animation = settings.get( constants.EMBED_ANIMATION, constants.EXPORT_OPTIONS[constants.EMBED_ANIMATION]) ## } ## Scene { properties.option_export_scene = settings.get( constants.SCENE, constants.EXPORT_OPTIONS[constants.SCENE]) #properties.option_embed_geometry = settings.get( # constants.EMBED_GEOMETRY, # constants.EXPORT_OPTIONS[constants.EMBED_GEOMETRY]) properties.option_lights = settings.get( constants.LIGHTS, constants.EXPORT_OPTIONS[constants.LIGHTS]) properties.option_cameras = settings.get( constants.CAMERAS, constants.EXPORT_OPTIONS[constants.CAMERAS]) properties.option_hierarchy = settings.get( constants.HIERARCHY, constants.EXPORT_OPTIONS[constants.HIERARCHY]) ## } ## Animation { properties.option_animation_morph = settings.get( constants.MORPH_TARGETS, constants.EXPORT_OPTIONS[constants.MORPH_TARGETS]) properties.option_animation_skeletal = settings.get( constants.ANIMATION, constants.EXPORT_OPTIONS[constants.ANIMATION]) properties.option_frame_step = settings.get( constants.FRAME_STEP, constants.EXPORT_OPTIONS[constants.FRAME_STEP]) properties.option_frame_index_as_time = settings.get( constants.FRAME_INDEX_AS_TIME, constants.EXPORT_OPTIONS[constants.FRAME_INDEX_AS_TIME]) ## } def set_settings(properties): """Set the export settings to the correct keys. :param properties: :returns: settings :rtype: dict """ settings = { constants.VERTICES: properties.option_vertices, constants.FACES: properties.option_faces, constants.NORMALS: properties.option_normals, constants.SKINNING: properties.option_skinning, constants.BONES: properties.option_bones, constants.GEOMETRY_TYPE: properties.option_geometry_type, constants.MATERIALS: properties.option_materials, constants.UVS: properties.option_uv_coords, constants.FACE_MATERIALS: properties.option_face_materials, constants.MAPS: properties.option_maps, constants.COLORS: properties.option_colors, constants.MIX_COLORS: properties.option_mix_colors, constants.SCALE: properties.option_scale, constants.ENABLE_PRECISION: properties.option_round_off, constants.PRECISION: properties.option_round_value, constants.LOGGING: properties.option_logging, constants.COMPRESSION: properties.option_compression, constants.INDENT: properties.option_indent, constants.COPY_TEXTURES: properties.option_copy_textures, constants.TEXTURE_FOLDER: properties.option_texture_folder, constants.SCENE: properties.option_export_scene, #constants.EMBED_GEOMETRY: properties.option_embed_geometry, constants.EMBED_ANIMATION: properties.option_embed_animation, constants.LIGHTS: properties.option_lights, constants.CAMERAS: properties.option_cameras, constants.HIERARCHY: properties.option_hierarchy, constants.MORPH_TARGETS: properties.option_animation_morph, constants.ANIMATION: properties.option_animation_skeletal, constants.FRAME_STEP: properties.option_frame_step, constants.FRAME_INDEX_AS_TIME: properties.option_frame_index_as_time, constants.INFLUENCES_PER_VERTEX: properties.option_influences } return settings def compression_types(): """Supported compression formats :rtype: tuple """ types = [(constants.NONE, constants.NONE, constants.NONE)] try: import msgpack types.append((constants.MSGPACK, constants.MSGPACK, constants.MSGPACK)) except ImportError: pass return types def animation_options(): """The supported skeletal animation types :returns: list of tuples """ anim = [ (constants.OFF, constants.OFF.title(), constants.OFF), (constants.POSE, constants.POSE.title(), constants.POSE), (constants.REST, constants.REST.title(), constants.REST) ] return anim class ExportThree(bpy.types.Operator, ExportHelper): """Class that handles the export properties""" bl_idname = 'export.three' bl_label = 'Export THREE' bl_options = {'PRESET'} filename_ext = constants.EXTENSION option_vertices = BoolProperty( name="Vertices", description="Export vertices", default=constants.EXPORT_OPTIONS[constants.VERTICES]) option_faces = BoolProperty( name="Faces", description="Export faces", default=constants.EXPORT_OPTIONS[constants.FACES]) option_normals = BoolProperty( name="Normals", description="Export normals", default=constants.EXPORT_OPTIONS[constants.NORMALS]) option_colors = BoolProperty( name="Vertex Colors", description="Export vertex colors", default=constants.EXPORT_OPTIONS[constants.COLORS]) option_mix_colors = BoolProperty( name="Mix Colors", description="Mix material and vertex colors", default=constants.EXPORT_OPTIONS[constants.MIX_COLORS]) option_uv_coords = BoolProperty( name="UVs", description="Export texture coordinates", default=constants.EXPORT_OPTIONS[constants.UVS]) option_materials = BoolProperty( name="Materials", description="Export materials", default=constants.EXPORT_OPTIONS[constants.MATERIALS]) option_face_materials = BoolProperty( name="Face Materials", description="Face mapping materials", default=constants.EXPORT_OPTIONS[constants.FACE_MATERIALS]) option_maps = BoolProperty( name="Textures", description="Include texture maps", default=constants.EXPORT_OPTIONS[constants.MAPS]) option_skinning = BoolProperty( name="Skinning", description="Export skin data", default=constants.EXPORT_OPTIONS[constants.SKINNING]) option_bones = BoolProperty( name="Bones", description="Export bones", default=constants.EXPORT_OPTIONS[constants.BONES]) option_scale = FloatProperty( name="Scale", description="Scale vertices", min=0.01, max=1000.0, soft_min=0.01, soft_max=1000.0, default=constants.EXPORT_OPTIONS[constants.SCALE]) option_round_off = BoolProperty( name="Enable Precision", description="Round off floating point values", default=constants.EXPORT_OPTIONS[constants.ENABLE_PRECISION]) option_round_value = IntProperty( name="Precision", min=0, max=16, description="Floating point precision", default=constants.EXPORT_OPTIONS[constants.PRECISION]) logging_types = [ (constants.DEBUG, constants.DEBUG, constants.DEBUG), (constants.INFO, constants.INFO, constants.INFO), (constants.WARNING, constants.WARNING, constants.WARNING), (constants.ERROR, constants.ERROR, constants.ERROR), (constants.CRITICAL, constants.CRITICAL, constants.CRITICAL)] option_logging = EnumProperty( name="", description="Logging verbosity level", items=logging_types, default=constants.DEBUG) option_geometry_type = EnumProperty( name="Type", description="Geometry type", items=_geometry_types()[1:], default=constants.GEOMETRY) option_export_scene = BoolProperty( name="Scene", description="Export scene", default=constants.EXPORT_OPTIONS[constants.SCENE]) #@TODO: removing this option since the ObjectLoader doesn't have # support for handling external geometry data #option_embed_geometry = BoolProperty( # name="Embed geometry", # description="Embed geometry", # default=constants.EXPORT_OPTIONS[constants.EMBED_GEOMETRY]) option_embed_animation = BoolProperty( name="Embed animation", description="Embed animation data with the geometry data", default=constants.EXPORT_OPTIONS[constants.EMBED_ANIMATION]) option_copy_textures = BoolProperty( name="Copy textures", description="Copy textures", default=constants.EXPORT_OPTIONS[constants.COPY_TEXTURES]) option_texture_folder = StringProperty( name="Texture folder", description="add this folder to textures path", default=constants.EXPORT_OPTIONS[constants.TEXTURE_FOLDER]) option_lights = BoolProperty( name="Lights", description="Export default scene lights", default=False) option_cameras = BoolProperty( name="Cameras", description="Export default scene cameras", default=False) option_hierarchy = BoolProperty( name="Hierarchy", description="Export object hierarchy", default=False) option_animation_morph = BoolProperty( name="Morph animation", description="Export animation (morphs)", default=constants.EXPORT_OPTIONS[constants.MORPH_TARGETS]) option_animation_skeletal = EnumProperty( name="", description="Export animation (skeletal)", items=animation_options(), default=constants.OFF) option_frame_index_as_time = BoolProperty( name="Frame index as time", description="Use (original) frame index as frame time", default=constants.EXPORT_OPTIONS[constants.FRAME_INDEX_AS_TIME]) option_frame_step = IntProperty( name="Frame step", description="Animation frame step", min=1, max=1000, soft_min=1, soft_max=1000, default=1) option_indent = BoolProperty( name="Indent JSON", description="Disable this to reduce the file size", default=constants.EXPORT_OPTIONS[constants.INDENT]) option_compression = EnumProperty( name="", description="Compression options", items=compression_types(), default=constants.NONE) option_influences = IntProperty( name="Influences", description="Maximum number of bone influences", min=1, max=4, default=2) def invoke(self, context, event): settings = context.scene.get(constants.EXPORT_SETTINGS_KEY) if settings: try: restore_export_settings(self.properties, settings) except AttributeError as e: logging.error("Loading export settings failed:") logging.exception(e) logging.debug("Removed corrupted settings") del context.scene[constants.EXPORT_SETTINGS_KEY] return ExportHelper.invoke(self, context, event) @classmethod def poll(cls, context): """ :param context: """ return context.active_object is not None def execute(self, context): """ :param context: """ if not self.properties.filepath: raise Exception("filename not set") settings = set_settings(self.properties) settings['addon_version'] = bl_info['version'] filepath = self.filepath if settings[constants.COMPRESSION] == constants.MSGPACK: filepath = "%s%s" % (filepath[:-4], constants.PACK) from io_three import exporter if settings[constants.SCENE]: exporter.export_scene(filepath, settings) else: exporter.export_geometry(filepath, settings) return {'FINISHED'} def draw(self, context): """ :param context: """ layout = self.layout ## Geometry { row = layout.row() row.label(text="GEOMETRY:") row = layout.row() row.prop(self.properties, 'option_vertices') row.prop(self.properties, 'option_faces') row = layout.row() row.prop(self.properties, 'option_normals') row.prop(self.properties, 'option_uv_coords') row = layout.row() row.prop(self.properties, 'option_bones') row.prop(self.properties, 'option_skinning') row = layout.row() row.prop(self.properties, 'option_geometry_type') ## } layout.separator() ## Materials { row = layout.row() row.label(text="- Shading:") row = layout.row() row.prop(self.properties, 'option_face_materials') row = layout.row() row.prop(self.properties, 'option_colors') row = layout.row() row.prop(self.properties, 'option_mix_colors') ## } layout.separator() ## Animation { row = layout.row() row.label(text="- Animation:") row = layout.row() row.prop(self.properties, 'option_animation_morph') row = layout.row() row.label(text="Skeletal animations:") row = layout.row() row.prop(self.properties, 'option_animation_skeletal') layout.row() row = layout.row() row.prop(self.properties, 'option_influences') row = layout.row() row.prop(self.properties, 'option_frame_step') row = layout.row() row.prop(self.properties, 'option_frame_index_as_time') row = layout.row() row.prop(self.properties, 'option_embed_animation') ## } layout.separator() ## Scene { row = layout.row() row.label(text="SCENE:") row = layout.row() row.prop(self.properties, 'option_export_scene') row.prop(self.properties, 'option_materials') #row = layout.row() #row.prop(self.properties, 'option_embed_geometry') row = layout.row() row.prop(self.properties, 'option_lights') row.prop(self.properties, 'option_cameras') ## } row = layout.row() row.prop(self.properties, 'option_hierarchy') layout.separator() ## Settings { row = layout.row() row.label(text="SETTINGS:") row = layout.row() row.prop(self.properties, 'option_maps') row = layout.row() row.prop(self.properties, 'option_copy_textures') row = layout.row() row.prop(self.properties, 'option_texture_folder') row = layout.row() row.prop(self.properties, 'option_scale') layout.row() row = layout.row() row.prop(self.properties, 'option_round_off') row = layout.row() row.prop(self.properties, 'option_round_value') layout.row() row = layout.row() row.label(text="Logging verbosity:") row = layout.row() row.prop(self.properties, 'option_logging') row = layout.row() row.label(text="File compression format:") row = layout.row() row.prop(self.properties, 'option_compression') row = layout.row() row.prop(self.properties, 'option_indent') ## } ## Operators { has_settings = context.scene.get(constants.EXPORT_SETTINGS_KEY, False) row = layout.row() row.operator( ThreeExportSettings.bl_idname, ThreeExportSettings.bl_label, icon="%s" % "PINNED" if has_settings else "UNPINNED") ## } def menu_func_export(self, context): """ :param self: :param context: """ default_path = bpy.data.filepath.replace('.blend', constants.EXTENSION) text = "Three.js (%s)" % constants.EXTENSION operator = self.layout.operator(ExportThree.bl_idname, text=text) operator.filepath = default_path def register(): """Registers the addon (Blender boilerplate)""" bpy.utils.register_module(__name__) bpy.types.INFO_MT_file_export.append(menu_func_export) def unregister(): """Unregisters the addon (Blender boilerplate)""" bpy.utils.unregister_module(__name__) bpy.types.INFO_MT_file_export.remove(menu_func_export) if __name__ == '__main__': register()