diff options
Diffstat (limited to 'io_scene_x3d/export_x3d.py')
| -rw-r--r-- | io_scene_x3d/export_x3d.py | 876 |
1 files changed, 876 insertions, 0 deletions
diff --git a/io_scene_x3d/export_x3d.py b/io_scene_x3d/export_x3d.py new file mode 100644 index 00000000..2dc9f638 --- /dev/null +++ b/io_scene_x3d/export_x3d.py @@ -0,0 +1,876 @@ +# ##### 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 ##### + +# <pep8 compliant> + +# Contributors: bart:neeneenee*de, http://www.neeneenee.de/vrml, Campbell Barton + +""" +This script exports to X3D format. + +Usage: +Run this script from "File->Export" menu. A pop-up will ask whether you +want to export only selected or all relevant objects. + +Known issues: + Doesn't handle multiple materials (don't use material indices);<br> + Doesn't handle multiple UV textures on a single mesh (create a mesh for each texture);<br> + Can't get the texture array associated with material * not the UV ones; +""" + +import math +import os + +import bpy +import mathutils + +from io_utils import create_derived_objects, free_derived_objects + + +def round_color(col, cp): + return tuple([round(max(min(c, 1.0), 0.0), cp) for c in col]) + + +def matrix_direction(mtx): + return (mathutils.Vector((0.0, 0.0, -1.0)) * mtx.to_3x3()).normalized()[:] + + +########################################################## +# Functions for writing output file +########################################################## + + +class x3d_class: + + def __init__(self, filepath): + #--- public you can change these --- + self.proto = 1 + self.billnode = 0 + self.halonode = 0 + self.collnode = 0 + self.verbose = 2 # level of verbosity in console 0-none, 1-some, 2-most + self.cp = 3 # decimals for material color values 0.000 - 1.000 + self.vp = 3 # decimals for vertex coordinate values 0.000 - n.000 + self.tp = 3 # decimals for texture coordinate values 0.000 - 1.000 + self.it = 3 + + self.global_matrix = mathutils.Matrix.Rotation(-(math.pi / 2.0), 4, 'X') + + #--- class private don't touch --- + self.indentLevel = 0 # keeps track of current indenting + self.filepath = filepath + self.file = None + if filepath.lower().endswith('.x3dz'): + try: + import gzip + self.file = gzip.open(filepath, "w") + except: + print("failed to import compression modules, exporting uncompressed") + self.filepath = filepath[:-1] # remove trailing z + + if self.file is None: + self.file = open(self.filepath, "w", encoding="utf8", newline="\n") + + self.bNav = 0 + self.nodeID = 0 + self.namesReserved = {"Anchor", "Appearance", "Arc2D", "ArcClose2D", "AudioClip", "Background", "Billboard", + "BooleanFilter", "BooleanSequencer", "BooleanToggle", "BooleanTrigger", "Box", "Circle2D", + "Collision", "Color", "ColorInterpolator", "ColorRGBA", "component", "Cone", "connect", + "Contour2D", "ContourPolyline2D", "Coordinate", "CoordinateDouble", "CoordinateInterpolator", + "CoordinateInterpolator2D", "Cylinder", "CylinderSensor", "DirectionalLight", "Disk2D", + "ElevationGrid", "EspduTransform", "EXPORT", "ExternProtoDeclare", "Extrusion", "field", + "fieldValue", "FillProperties", "Fog", "FontStyle", "GeoCoordinate", "GeoElevationGrid", + "GeoLocationLocation", "GeoLOD", "GeoMetadata", "GeoOrigin", "GeoPositionInterpolator", + "GeoTouchSensor", "GeoViewpoint", "Group", "HAnimDisplacer", "HAnimHumanoid", "HAnimJoint", + "HAnimSegment", "HAnimSite", "head", "ImageTexture", "IMPORT", "IndexedFaceSet", + "IndexedLineSet", "IndexedTriangleFanSet", "IndexedTriangleSet", "IndexedTriangleStripSet", + "Inline", "IntegerSequencer", "IntegerTrigger", "IS", "KeySensor", "LineProperties", "LineSet", + "LoadSensor", "LOD", "Material", "meta", "MetadataDouble", "MetadataFloat", "MetadataInteger", + "MetadataSet", "MetadataString", "MovieTexture", "MultiTexture", "MultiTextureCoordinate", + "MultiTextureTransform", "NavigationInfo", "Normal", "NormalInterpolator", "NurbsCurve", + "NurbsCurve2D", "NurbsOrientationInterpolator", "NurbsPatchSurface", + "NurbsPositionInterpolator", "NurbsSet", "NurbsSurfaceInterpolator", "NurbsSweptSurface", + "NurbsSwungSurface", "NurbsTextureCoordinate", "NurbsTrimmedSurface", "OrientationInterpolator", + "PixelTexture", "PlaneSensor", "PointLight", "PointSet", "Polyline2D", "Polypoint2D", + "PositionInterpolator", "PositionInterpolator2D", "ProtoBody", "ProtoDeclare", "ProtoInstance", + "ProtoInterface", "ProximitySensor", "ReceiverPdu", "Rectangle2D", "ROUTE", "ScalarInterpolator", + "Scene", "Script", "Shape", "SignalPdu", "Sound", "Sphere", "SphereSensor", "SpotLight", "StaticGroup", + "StringSensor", "Switch", "Text", "TextureBackground", "TextureCoordinate", "TextureCoordinateGenerator", + "TextureTransform", "TimeSensor", "TimeTrigger", "TouchSensor", "Transform", "TransmitterPdu", + "TriangleFanSet", "TriangleSet", "TriangleSet2D", "TriangleStripSet", "Viewpoint", "VisibilitySensor", + "WorldInfo", "X3D", "XvlShell", "VertexShader", "FragmentShader", "MultiShaderAppearance", "ShaderAppearance"} + + self.namesFog = ("", "LINEAR", "EXPONENTIAL", "") + +########################################################## +# Writing nodes routines +########################################################## + + def writeHeader(self): + #bfile = sys.expandpath( Blender.Get('filepath') ).replace('<', '<').replace('>', '>') + bfile = repr(os.path.basename(self.filepath).replace('<', '<').replace('>', '>'))[1:-1] # use outfile name + self.file.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n") + self.file.write("<!DOCTYPE X3D PUBLIC \"ISO//Web3D//DTD X3D 3.0//EN\" \"http://www.web3d.org/specifications/x3d-3.0.dtd\">\n") + self.file.write("<X3D version=\"3.0\" profile=\"Immersive\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema-instance\" xsd:noNamespaceSchemaLocation=\"http://www.web3d.org/specifications/x3d-3.0.xsd\">\n") + self.file.write("<head>\n") + self.file.write("\t<meta name=\"filename\" content=\"%s\" />\n" % bfile) + # self.file.write("\t<meta name=\"filename\" content=\"%s\" />\n" % sys.basename(bfile)) + self.file.write("\t<meta name=\"generator\" content=\"Blender %s\" />\n" % bpy.app.version_string) + # self.file.write("\t<meta name=\"generator\" content=\"Blender %s\" />\n" % Blender.Get('version')) + self.file.write("\t<meta name=\"translator\" content=\"X3D exporter v1.55 (2006/01/17)\" />\n") + self.file.write("</head>\n") + self.file.write("<Scene>\n") + + # This functionality is poorly defined, disabling for now - campbell + ''' + def writeScript(self): + textEditor = Blender.Text.Get() + alltext = len(textEditor) + for i in xrange(alltext): + nametext = textEditor[i].name + nlines = textEditor[i].getNLines() + if (self.proto == 1): + if (nametext == "proto" or nametext == "proto.js" or nametext == "proto.txt") and (nlines != None): + nalllines = len(textEditor[i].asLines()) + alllines = textEditor[i].asLines() + for j in xrange(nalllines): + self.write_indented(alllines[j] + "\n") + elif (self.proto == 0): + if (nametext == "route" or nametext == "route.js" or nametext == "route.txt") and (nlines != None): + nalllines = len(textEditor[i].asLines()) + alllines = textEditor[i].asLines() + for j in xrange(nalllines): + self.write_indented(alllines[j] + "\n") + self.write_indented("\n") + ''' + + def writeViewpoint(self, ob, mat, scene): + loc, quat, scale = mat.decompose() + self.file.write("<Viewpoint DEF=\"%s\" " % (self.cleanStr(ob.name))) + self.file.write("description=\"%s\" " % (ob.name)) + self.file.write("centerOfRotation=\"0 0 0\" ") + self.file.write("position=\"%3.2f %3.2f %3.2f\" " % loc[:]) + self.file.write("orientation=\"%3.2f %3.2f %3.2f %3.2f\" " % (quat.axis[:] + (quat.angle, ))) + self.file.write("fieldOfView=\"%.3f\" " % ob.data.angle) + self.file.write(" />\n\n") + + def writeFog(self, world): + if world: + mtype = world.mist_settings.falloff + mparam = world.mist_settings + else: + return + if (mtype == 'LINEAR' or mtype == 'INVERSE_QUADRATIC'): + mtype = 1 if mtype == 'LINEAR' else 2 + # if (mtype == 1 or mtype == 2): + self.file.write("<Fog fogType=\"%s\" " % self.namesFog[mtype]) + self.file.write("color=\"%s %s %s\" " % round_color(world.horizon_color, self.cp)) + self.file.write("visibilityRange=\"%s\" />\n\n" % round(mparam[2], self.cp)) + else: + return + + def writeNavigationInfo(self, scene): + self.file.write('<NavigationInfo headlight="false" visibilityLimit="0.0" type=\'"EXAMINE","ANY"\' avatarSize="0.25, 1.75, 0.75" />\n') + + def writeSpotLight(self, ob, mtx, lamp, world): + safeName = self.cleanStr(ob.name) + if world: + ambi = world.ambient_color + amb_intensity = ((ambi[0] + ambi[1] + ambi[2]) / 3.0) / 2.5 + del ambi + else: + amb_intensity = 0.0 + + # compute cutoff and beamwidth + intensity = min(lamp.energy / 1.75, 1.0) + beamWidth = lamp.spot_size * 0.37 + # beamWidth=((lamp.spotSize*math.pi)/180.0)*.37 + cutOffAngle = beamWidth * 1.3 + + dx, dy, dz = matrix_direction(mtx) + + location = mtx.to_translation()[:] + + radius = lamp.distance * math.cos(beamWidth) + # radius = lamp.dist*math.cos(beamWidth) + self.file.write("<SpotLight DEF=\"%s\" " % safeName) + self.file.write("radius=\"%.4f\" " % radius) + self.file.write("ambientIntensity=\"%.4f\" " % amb_intensity) + self.file.write("intensity=\"%.4f\" " % intensity) + self.file.write("color=\"%.4f %.4f %.4f\" " % round_color(lamp.color, 4)) + self.file.write("beamWidth=\"%.4f\" " % beamWidth) + self.file.write("cutOffAngle=\"%.4f\" " % cutOffAngle) + self.file.write("direction=\"%.4f %.4f %.4f\" " % (dx, dy, dz)) + self.file.write("location=\"%.4f %.4f %.4f\" />\n\n" % location) + + def writeDirectionalLight(self, ob, mtx, lamp, world): + safeName = self.cleanStr(ob.name) + if world: + ambi = world.ambient_color + # ambi = world.amb + amb_intensity = ((float(ambi[0] + ambi[1] + ambi[2])) / 3.0) / 2.5 + else: + ambi = 0 + amb_intensity = 0.0 + + intensity = min(lamp.energy / 1.75, 1.0) + dx, dy, dz = matrix_direction(mtx) + self.file.write("<DirectionalLight DEF=\"%s\" " % safeName) + self.file.write("ambientIntensity=\"%.4f\" " % amb_intensity) + self.file.write("color=\"%.4f %.4f %.4f\" " % round_color(lamp.color, 4)) + self.file.write("intensity=\"%.4f\" " % intensity) + self.file.write("direction=\"%.4f %.4f %.4f\" />\n\n" % (dx, dy, dz)) + + def writePointLight(self, ob, mtx, lamp, world): + safeName = self.cleanStr(ob.name) + if world: + ambi = world.ambient_color + # ambi = world.amb + amb_intensity = ((float(ambi[0] + ambi[1] + ambi[2])) / 3) / 2.5 + else: + ambi = 0.0 + amb_intensity = 0.0 + + intensity = min(lamp.energy / 1.75, 1.0) + location = mtx.to_translation()[:] + + self.file.write("<PointLight DEF=\"%s\" " % safeName) + self.file.write("ambientIntensity=\"%.4f\" " % amb_intensity) + self.file.write("color=\"%.4f %.4f %.4f\" " % round_color(lamp.color, 4)) + + self.file.write("intensity=\"%.4f\" " % intensity) + self.file.write("radius=\"%.4f\" " % lamp.distance) + self.file.write("location=\"%.4f %.4f %.4f\" />\n\n" % location) + + def secureName(self, name): + name = name + str(self.nodeID) + self.nodeID = self.nodeID + 1 + if len(name) <= 3: + newname = "_" + str(self.nodeID) + return "%s" % (newname) + else: + for bad in ('"', '#', "'", ', ', '.', '[', '\\', ']', '{', '}'): + name = name.replace(bad, "_") + if name in self.namesReserved: + newname = name[0:3] + "_" + str(self.nodeID) + return "%s" % (newname) + elif name[0].isdigit(): + newname = "_" + name + str(self.nodeID) + return "%s" % (newname) + else: + newname = name + return "%s" % (newname) + + def writeIndexedFaceSet(self, ob, mesh, mtx, world, EXPORT_TRI=False): + fw = self.file.write + mesh_name_x3d = self.cleanStr(ob.name) + + if not mesh.faces: + return + + mode = [] + # mode = 0 + if mesh.uv_textures.active: + # if mesh.faceUV: + for face in mesh.uv_textures.active.data: + # for face in mesh.faces: + if face.use_halo and 'HALO' not in mode: + mode += ['HALO'] + if face.use_billboard and 'BILLBOARD' not in mode: + mode += ['BILLBOARD'] + if face.use_object_color and 'OBJECT_COLOR' not in mode: + mode += ['OBJECT_COLOR'] + if face.use_collision and 'COLLISION' not in mode: + mode += ['COLLISION'] + # mode |= face.mode + + if 'HALO' in mode and self.halonode == 0: + # if mode & Mesh.FaceModes.HALO and self.halonode == 0: + self.write_indented("<Billboard axisOfRotation=\"0 0 0\">\n", 1) + self.halonode = 1 + elif 'BILLBOARD' in mode and self.billnode == 0: + # elif mode & Mesh.FaceModes.BILLBOARD and self.billnode == 0: + self.write_indented("<Billboard axisOfRotation=\"0 1 0\">\n", 1) + self.billnode = 1 + elif 'COLLISION' not in mode and self.collnode == 0: + # elif not mode & Mesh.FaceModes.DYNAMIC and self.collnode == 0: + self.write_indented("<Collision enabled=\"false\">\n", 1) + self.collnode = 1 + + loc, quat, sca = mtx.decompose() + + self.write_indented("<Transform DEF=\"%s\" " % mesh_name_x3d, 1) + fw("translation=\"%.6f %.6f %.6f\" " % loc[:]) + fw("scale=\"%.6f %.6f %.6f\" " % sca[:]) + fw("rotation=\"%.6f %.6f %.6f %.6f\" " % (quat.axis[:] + (quat.angle, ))) + fw(">\n") + + if mesh.tag: + self.write_indented("<Group USE=\"G_%s\" />\n" % mesh_name_x3d, 1) + else: + mesh.tag = True + + self.write_indented("<Group DEF=\"G_%s\">\n" % mesh_name_x3d, 1) + + is_uv = bool(mesh.uv_textures.active) + # is_col, defined for each material + + is_coords_written = False + + mesh_materials = mesh.materials[:] + if not mesh_materials: + mesh_materials = [None] + + mesh_material_tex = [None] * len(mesh_materials) + mesh_material_mtex = [None] * len(mesh_materials) + mesh_material_images = [None] * len(mesh_materials) + + for i, material in enumerate(mesh_materials): + if material: + for mtex in material.texture_slots: + if mtex: + tex = mtex.texture + if tex and tex.type == 'IMAGE': + image = tex.image + if image: + mesh_material_tex[i] = tex + mesh_material_mtex[i] = mtex + mesh_material_images[i] = image + break + + mesh_materials_use_face_texture = [getattr(material, "use_face_texture", True) for material in mesh_materials] + + mesh_faces = mesh.faces[:] + mesh_faces_materials = [f.material_index for f in mesh_faces] + + if is_uv and True in mesh_materials_use_face_texture: + mesh_faces_image = [(fuv.image if (mesh_materials_use_face_texture[mesh_faces_materials[i]] and fuv.use_image) else mesh_material_images[mesh_faces_materials[i]]) for i, fuv in enumerate(mesh.uv_textures.active.data)] + mesh_faces_image_unique = set(mesh_faces_image) + elif len(set(mesh_material_images) | {None}) > 1: # make sure there is at least one image + mesh_faces_image = [mesh_material_images[material_index] for material_index in mesh_faces_materials] + mesh_faces_image_unique = set(mesh_faces_image) + else: + mesh_faces_image = [None] * len(mesh_faces) + mesh_faces_image_unique = {None} + + # group faces + face_groups = {} + for material_index in range(len(mesh_materials)): + for image in mesh_faces_image_unique: + face_groups[material_index, image] = [] + del mesh_faces_image_unique + + for i, (material_index, image) in enumerate(zip(mesh_faces_materials, mesh_faces_image)): + face_groups[material_index, image].append(i) + + # same as face_groups.items() but sorted so we can get predictable output. + face_groups_items = list(face_groups.items()) + face_groups_items.sort(key=lambda m: (m[0][0], getattr(m[0][1], "name", ""))) + + for (material_index, image), face_group in face_groups_items: # face_groups.items() + if face_group: + material = mesh_materials[material_index] + + self.write_indented("<Shape>\n", 1) + is_smooth = False + is_col = (mesh.vertex_colors.active and (material is None or material.use_vertex_color_paint)) + + # kludge but as good as it gets! + for i in face_group: + if mesh_faces[i].use_smooth: + is_smooth = True + break + + self.write_indented("<Appearance>\n", 1) + + if image: + self.writeImageTexture(image) + + if mesh_materials_use_face_texture[material_index]: + if image.use_tiles: + self.write_indented("<TextureTransform scale=\"%s %s\" />\n" % (image.tiles_x, image.tiles_y)) + else: + # transform by mtex + loc = mesh_material_mtex[material_index].offset[:2] + + # mtex_scale * tex_repeat + sca_x, sca_y = mesh_material_mtex[material_index].scale[:2] + + sca_x *= mesh_material_tex[material_index].repeat_x + sca_y *= mesh_material_tex[material_index].repeat_y + + # flip x/y is a sampling feature, convert to transform + if mesh_material_tex[material_index].use_flip_axis: + rot = math.pi / -2.0 + sca_x, sca_y = sca_y, -sca_x + else: + rot = 0.0 + + self.write_indented("<TextureTransform ", 0) + # fw("center=\"%.6f %.6f\" " % (0.0, 0.0)) + fw("translation=\"%.6f %.6f\" " % loc) + fw("scale=\"%.6f %.6f\" " % (sca_x, sca_y)) + fw("rotation=\"%.6f\" " % rot) + fw("/>\n") + + if material: + self.writeMaterial(material, self.cleanStr(material.name, ""), world) + + self.write_indented("</Appearance>\n", -1) + + #-- IndexedFaceSet or IndexedLineSet + + self.write_indented("<IndexedFaceSet ", 1) + + # --- Write IndexedFaceSet Attributes + if mesh.show_double_sided: + fw("solid=\"true\" ") + else: + fw("solid=\"false\" ") + + if is_smooth: + fw("creaseAngle=\"%.4f\" " % mesh.auto_smooth_angle) + + if is_uv: + # "texCoordIndex" + fw("\n\t\t\ttexCoordIndex=\"") + j = 0 + for i in face_group: + if len(mesh_faces[i].vertices) == 4: + fw("%d %d %d %d -1, " % (j, j + 1, j + 2, j + 3)) + j += 4 + else: + fw("%d %d %d -1, " % (j, j + 1, j + 2)) + j += 3 + fw("\" ") + # --- end texCoordIndex + + if is_col: + fw("colorPerVertex=\"false\" ") + + if True: + # "coordIndex" + fw('coordIndex="') + if EXPORT_TRI: + for i in face_group: + fv = mesh_faces[i].vertices[:] + if len(fv) == 3: + fw("%i %i %i -1, " % fv) + else: + fw("%i %i %i -1, " % (fv[0], fv[1], fv[2])) + fw("%i %i %i -1, " % (fv[0], fv[2], fv[3])) + else: + for i in face_group: + fv = mesh_faces[i].vertices[:] + if len(fv) == 3: + fw("%i %i %i -1, " % fv) + else: + fw("%i %i %i %i -1, " % fv) + + fw("\" ") + # --- end coordIndex + + # close IndexedFaceSet + fw(">\n") + + # --- Write IndexedFaceSet Elements + if True: + if is_coords_written: + self.write_indented("<Coordinate USE=\"%s%s\" />\n" % ("coord_", mesh_name_x3d)) + else: + self.write_indented("<Coordinate DEF=\"%s%s\" \n" % ("coord_", mesh_name_x3d), 1) + fw("\t\t\t\tpoint=\"") + for v in mesh.vertices: + fw("%.6f %.6f %.6f, " % v.co[:]) + fw("\" />") + self.write_indented("\n", -1) + is_coords_written = True + + if is_uv: + self.write_indented("<TextureCoordinate point=\"", 1) + fw = fw + mesh_faces_uv = mesh.uv_textures.active.data + for i in face_group: + for uv in mesh_faces_uv[i].uv: + fw("%.4f %.4f, " % uv[:]) + del mesh_faces_uv + fw("\" />") + self.write_indented("\n", -1) + + if is_col: + self.write_indented("<Color color=\"", 1) + # XXX, 1 color per face, only + mesh_faces_col = mesh.vertex_colors.active.data + for i in face_group: + fw("%.3f %.3f %.3f, " % mesh_faces_col[i].color1[:]) + del mesh_faces_col + fw("\" />") + self.write_indented("\n", -1) + + #--- output vertexColors + + #--- output closing braces + self.write_indented("</IndexedFaceSet>\n", -1) + self.write_indented("</Shape>\n", -1) + + self.write_indented("</Group>\n", -1) + + self.write_indented("</Transform>\n", -1) + + if self.halonode == 1: + self.write_indented("</Billboard>\n", -1) + self.halonode = 0 + + if self.billnode == 1: + self.write_indented("</Billboard>\n", -1) + self.billnode = 0 + + if self.collnode == 1: + self.write_indented("</Collision>\n", -1) + self.collnode = 0 + + fw("\n") + + def writeMaterial(self, mat, matName, world): + # look up material name, use it if available + if mat.tag: + self.write_indented("<Material USE=\"MA_%s\" />\n" % matName) + else: + mat.tag = True + + emit = mat.emit + ambient = mat.ambient / 3.0 + diffuseColor = tuple(mat.diffuse_color) + if world: + ambiColor = tuple(((c * mat.ambient) * 2.0) for c in world.ambient_color) + else: + ambiColor = 0.0, 0.0, 0.0 + + emitColor = tuple(((c * emit) + ambiColor[i]) / 2.0 for i, c in enumerate(diffuseColor)) + shininess = mat.specular_hardness / 512.0 + specColor = tuple((c + 0.001) / (1.25 / (mat.specular_intensity + 0.001)) for c in mat.specular_color) + transp = 1.0 - mat.alpha + + if mat.use_shadeless: + ambient = 1.0 + shininess = 0.0 + specColor = emitColor = diffuseColor + + self.write_indented("<Material DEF=\"MA_%s\" " % matName, 1) + self.file.write("diffuseColor=\"%s %s %s\" " % round_color(diffuseColor, self.cp)) + self.file.write("specularColor=\"%s %s %s\" " % round_color(specColor, self.cp)) + self.file.write("emissiveColor=\"%s %s %s\" \n" % round_color(emitColor, self.cp)) + self.write_indented("ambientIntensity=\"%s\" " % (round(ambient, self.cp))) + self.file.write("shininess=\"%s\" " % (round(shininess, self.cp))) + self.file.write("transparency=\"%s\" />" % (round(transp, self.cp))) + self.write_indented("\n", -1) + + def writeImageTexture(self, image): + name = image.name + + if image.tag: + self.write_indented("<ImageTexture USE=\"%s\" />\n" % self.cleanStr(name)) + else: + image.tag = True + + self.write_indented("<ImageTexture DEF=\"%s\" " % self.cleanStr(name), 1) + filepath = image.filepath + relpath = os.path.dirname(self.filepath) # could cache + filepath_full = bpy.path.abspath(filepath) + # collect image paths, can load multiple + # [relative, name-only, absolute] + images = [] + + if bpy.path.is_subdir(filepath_full, relpath): + images.append(os.path.relpath(filepath_full, relpath)) + + images.append(os.path.basename(filepath_full)) + images.append(filepath_full) + + self.file.write("url='%s' />" % " ".join(["\"%s\"" % f.replace("\\", "/") for f in images])) + self.write_indented("\n", -1) + + def writeBackground(self, world, alltextures): + if world: + worldname = world.name + else: + return + + blending = world.use_sky_blend, world.use_sky_paper, world.use_sky_real + + grd_triple = round_color(world.horizon_color, self.cp) + sky_triple = round_color(world.zenith_color, self.cp) + mix_triple = round_color(((grd_triple[i] + sky_triple[i]) / 2.0 for i in range(3)), self.cp) + + self.file.write("<Background DEF=\"%s\" " % self.secureName(worldname)) + # No Skytype - just Hor color + if blending == (False, False, False): + self.file.write("groundColor=\"%s %s %s\" " % grd_triple) + self.file.write("skyColor=\"%s %s %s\" " % grd_triple) + # Blend Gradient + elif blending == (True, False, False): + self.file.write("groundColor=\"%s %s %s, " % grd_triple) + self.file.write("%s %s %s\" groundAngle=\"1.57, 1.57\" " % mix_triple) + self.file.write("skyColor=\"%s %s %s, " % sky_triple) + self.file.write("%s %s %s\" skyAngle=\"1.57, 1.57\" " % mix_triple) + # Blend+Real Gradient Inverse + elif blending == (True, False, True): + self.file.write("groundColor=\"%s %s %s, %s %s %s\" " % (sky_triple + grd_triple)) + self.file.write("groundAngle=\"1.57\" ") + self.file.write("skyColor=\"%s %s %s, %s %s %s, %s %s %s\" " % (sky_triple + grd_triple + sky_triple)) + self.file.write("skyAngle=\"1.57, 3.14159\" ") + # Paper - just Zen Color + elif blending == (False, False, True): + self.file.write("groundColor=\"%s %s %s\" " % sky_triple) + self.file.write("skyColor=\"%s %s %s\" " % sky_triple) + # Blend+Real+Paper - komplex gradient + elif blending == (True, True, True): + self.write_indented("groundColor=\"%s %s %s, " % sky_triple) + self.write_indented("%s %s %s\" groundAngle=\"1.57, 1.57\" " % grd_triple) + self.write_indented("skyColor=\"%s %s %s, " % sky_triple) + self.write_indented("%s %s %s\" skyAngle=\"1.57, 1.57\" " % grd_triple) + # Any Other two colors + else: + self.file.write("groundColor=\"%s %s %s\" " % grd_triple) + self.file.write("skyColor=\"%s %s %s\" " % sky_triple) + + alltexture = len(alltextures) + + for i in range(alltexture): + tex = alltextures[i] + + if tex.type != 'IMAGE' or tex.image is None: + continue + + namemat = tex.name + # namemat = alltextures[i].name + + pic = tex.image + + # using .expandpath just in case, os.path may not expect // + basename = os.path.basename(bpy.path.abspath(pic.filepath)) + + pic = alltextures[i].image + if (namemat == "back") and (pic != None): + self.file.write("\n\tbackUrl=\"%s\" " % basename) + elif (namemat == "bottom") and (pic != None): + self.write_indented("bottomUrl=\"%s\" " % basename) + elif (namemat == "front") and (pic != None): + self.write_indented("frontUrl=\"%s\" " % basename) + elif (namemat == "left") and (pic != None): + self.write_indented("leftUrl=\"%s\" " % basename) + elif (namemat == "right") and (pic != None): + self.write_indented("rightUrl=\"%s\" " % basename) + elif (namemat == "top") and (pic != None): + self.write_indented("topUrl=\"%s\" " % basename) + self.write_indented("/>\n\n") + +########################################################## +# export routine +########################################################## + + def export(self, scene, world, alltextures, + use_apply_modifiers=False, + use_selection=True, + EXPORT_TRI=False, + ): + + # tag un-exported IDs + bpy.data.meshes.tag(False) + bpy.data.materials.tag(False) + bpy.data.images.tag(False) + + print("Info: starting X3D export to %r..." % self.filepath) + self.writeHeader() + # self.writeScript() + self.writeNavigationInfo(scene) + self.writeBackground(world, alltextures) + self.writeFog(world) + self.proto = 0 + + if use_selection: + objects = (o for o in scene.objects if o.is_visible(scene) and o.select) + else: + objects = (o for o in scene.objects if o.is_visible(scene)) + + for ob_main in objects: + + free, derived = create_derived_objects(scene, ob_main) + + if derived is None: + continue + + for ob, ob_mat in derived: + objType = ob.type + objName = ob.name + ob_mat = self.global_matrix * ob_mat + + if objType == 'CAMERA': + self.writeViewpoint(ob, ob_mat, scene) + elif objType in ('MESH', 'CURVE', 'SURF', 'FONT'): + if (objType != 'MESH') or (use_apply_modifiers and ob.is_modified(scene, 'PREVIEW')): + try: + me = ob.to_mesh(scene, use_apply_modifiers, 'PREVIEW') + except: + me = None + else: + me = ob.data + + if me is not None: + self.writeIndexedFaceSet(ob, me, ob_mat, world, EXPORT_TRI=EXPORT_TRI) + + # free mesh created with create_mesh() + if me != ob.data: + bpy.data.meshes.remove(me) + + elif objType == 'LAMP': + data = ob.data + datatype = data.type + if datatype == 'POINT': + self.writePointLight(ob, ob_mat, data, world) + elif datatype == 'SPOT': + self.writeSpotLight(ob, ob_mat, data, world) + elif datatype == 'SUN': + self.writeDirectionalLight(ob, ob_mat, data, world) + else: + self.writeDirectionalLight(ob, ob_mat, data, world) + else: + #print "Info: Ignoring [%s], object type [%s] not handle yet" % (object.name,object.getType) + pass + + if free: + free_derived_objects(ob_main) + + self.file.write("\n</Scene>\n</X3D>") + + # if use_apply_modifiers: + # if containerMesh: + # containerMesh.vertices = None + + self.cleanup() + +########################################################## +# Utility methods +########################################################## + + def cleanup(self): + self.file.close() + self.indentLevel = 0 + print("Info: finished X3D export to %r" % self.filepath) + + def cleanStr(self, name, prefix='rsvd_'): + """cleanStr(name,prefix) - try to create a valid VRML DEF name from object name""" + + newName = name + if len(newName) == 0: + self.nNodeID += 1 + return "%s%d" % (prefix, self.nNodeID) + + if newName in self.namesReserved: + newName = '%s%s' % (prefix, newName) + + if newName[0].isdigit(): + newName = "%s%s" % ('_', newName) + + for bad in [' ', '"', '#', "'", ', ', '.', '[', '\\', ']', '{', '}']: + newName = newName.replace(bad, '_') + return newName + + def faceToString(self, face): + + print("Debug: face.flag=0x%x (bitflags)" % face.flag) + if face.sel: + print("Debug: face.sel=true") + + print("Debug: face.mode=0x%x (bitflags)" % face.mode) + if face.mode & Mesh.FaceModes.TWOSIDE: + print("Debug: face.mode twosided") + + print("Debug: face.transp=0x%x (enum)" % face.blend_type) + if face.blend_type == Mesh.FaceTranspModes.SOLID: + print("Debug: face.transp.SOLID") + + if face.image: + print("Debug: face.image=%s" % face.image.name) + print("Debug: face.materialIndex=%d" % face.materialIndex) + + def meshToString(self, mesh): + # print("Debug: mesh.hasVertexUV=%d" % mesh.vertexColors) + print("Debug: mesh.faceUV=%d" % (len(mesh.uv_textures) > 0)) + # print("Debug: mesh.faceUV=%d" % mesh.faceUV) + print("Debug: mesh.hasVertexColours=%d" % (len(mesh.vertex_colors) > 0)) + # print("Debug: mesh.hasVertexColours=%d" % mesh.hasVertexColours()) + print("Debug: mesh.vertices=%d" % len(mesh.vertices)) + print("Debug: mesh.faces=%d" % len(mesh.faces)) + print("Debug: mesh.materials=%d" % len(mesh.materials)) + + # s="%s %s %s" % ( + # round(c.r/255.0,self.cp), + # round(c.g/255.0,self.cp), + # round(c.b/255.0,self.cp)) + return s + + # For writing well formed VRML code + #------------------------------------------------------------------------ + def write_indented(self, s, inc=0): + if inc < 1: + self.indentLevel = self.indentLevel + inc + + self.file.write((self.indentLevel * "\t") + s) + + if inc > 0: + self.indentLevel = self.indentLevel + inc + +########################################################## +# Callbacks, needed before Main +########################################################## + + +def save(operator, context, filepath="", + use_selection=True, + use_apply_modifiers=False, + use_triangulate=False, + use_compress=False): + + if use_compress: + if not filepath.lower().endswith('.x3dz'): + filepath = '.'.join(filepath.split('.')[:-1]) + '.x3dz' + else: + if not filepath.lower().endswith('.x3d'): + filepath = '.'.join(filepath.split('.')[:-1]) + '.x3d' + + scene = context.scene + world = scene.world + + if bpy.ops.object.mode_set.poll(): + bpy.ops.object.mode_set(mode='OBJECT') + + # XXX these are global textures while .Get() returned only scene's? + alltextures = bpy.data.textures + # alltextures = Blender.Texture.Get() + + wrlexport = x3d_class(filepath) + wrlexport.export(scene, + world, + alltextures, + use_apply_modifiers=use_apply_modifiers, + use_selection=use_selection, + EXPORT_TRI=use_triangulate, + ) + + return {'FINISHED'} |