From 8544110f6faedcd303d99c50824011dc91c12baf Mon Sep 17 00:00:00 2001 From: alteredq Date: Sat, 9 Jul 2011 00:35:39 +0200 Subject: [PATCH] Fixed Blender importer to work with Blender 2.58. --- .../addons/io_mesh_threejs/import_threejs.py | 218 +++++++++--------- 1 file changed, 109 insertions(+), 109 deletions(-) diff --git a/utils/exporters/blender/2.58/scripts/addons/io_mesh_threejs/import_threejs.py b/utils/exporters/blender/2.58/scripts/addons/io_mesh_threejs/import_threejs.py index 0cd893a1..104014bd 100644 --- a/utils/exporters/blender/2.58/scripts/addons/io_mesh_threejs/import_threejs.py +++ b/utils/exporters/blender/2.58/scripts/addons/io_mesh_threejs/import_threejs.py @@ -27,7 +27,7 @@ import json import bpy import mathutils from mathutils.geometry import tesselate_polygon -from io_utils import load_image, unpack_list, unpack_face_list +from bpy_extras.image_utils import load_image # ##################################################### # Generators @@ -40,43 +40,43 @@ def setColor(c, t): def create_texture(filename, modelpath): name = filename texture = bpy.data.textures.new(name, type='IMAGE') - + image = load_image(filename, modelpath) has_data = False if image: texture.image = image has_data = image.has_data - + return texture - + def create_materials(data, modelpath): materials = [] materials_data = data.get("materials", []) - + for i, m in enumerate(materials_data): name = m.get("DbgName", "material_%d" % i) - + colorAmbient = m.get("colorAmbient", None) colorDiffuse = m.get("colorDiffuse", None) colorSpecular = m.get("colorSpecular", None) alpha = m.get("transparency", 1.0) specular_hardness = m.get("specularCoef", 0) - + mapDiffuse = m.get("mapDiffuse", None) mapLightmap = m.get("mapLightmap", None) - + vertexColorsType = m.get("vertexColors", False) - + useVertexColors = False if vertexColorsType: useVertexColors = True - + material = bpy.data.materials.new(name) - + material.THREE_useVertexColors = useVertexColors - + if colorDiffuse: setColor(material.diffuse_color, colorDiffuse) material.diffuse_intensity = 1.0 @@ -84,14 +84,14 @@ def create_materials(data, modelpath): if colorSpecular: setColor(material.specular_color, colorSpecular) material.specular_intensity = 1.0 - + if alpha < 1.0: material.alpha = alpha material.use_transparency = True - + if specular_hardness: material.specular_hardness = specular_hardness - + if mapDiffuse: texture = create_texture(mapDiffuse, modelpath) mtex = material.texture_slots.add() @@ -99,13 +99,13 @@ def create_materials(data, modelpath): mtex.texture_coords = 'UV' mtex.use = True mtex.use_map_color_diffuse = True - + material.active_texture = texture materials.append(material) - + return materials - + def create_mesh_object(name, vertices, materials, face_data, flipYZ, recalculate_normals): faces = face_data["faces"] @@ -114,23 +114,23 @@ def create_mesh_object(name, vertices, materials, face_data, flipYZ, recalculate vertexUVs = face_data["vertexUVs"] faceMaterials = face_data["materials"] faceColors = face_data["faceColors"] - + edges = [] - + # Create a new mesh - + me = bpy.data.meshes.new(name) me.from_pydata(vertices, edges, faces) - + # Handle normals - + if not recalculate_normals: me.update(calc_edges = True) - + if face_data["hasVertexNormals"]: - + print("setting vertex normals") - + for fi in range(len(faces)): if vertexNormals[fi]: @@ -139,24 +139,24 @@ def create_mesh_object(name, vertices, materials, face_data, flipYZ, recalculate # if me.update() is called after setting vertex normals # setting face.use_smooth overrides these normals - # - this fixes weird shading artefacts (seems to come from sharing + # - this fixes weird shading artefacts (seems to come from sharing # of vertices between faces, didn't find a way how to set vertex normals - # per face use of vertex as opposed to per vertex), + # per face use of vertex as opposed to per vertex), # - probably this just overrides all custom vertex normals # - to preserve vertex normals from the original data # call me.update() before setting them - + me.faces[fi].use_smooth = True - + if not recalculate_normals: for j in range(len(vertexNormals[fi])): - + vertexNormal = vertexNormals[fi][j] - + x = vertexNormal[0] y = vertexNormal[1] z = vertexNormal[2] - + if flipYZ: tmp = y y = -z @@ -169,45 +169,45 @@ def create_mesh_object(name, vertices, materials, face_data, flipYZ, recalculate #z = -z vi = me.faces[fi].vertices[j] - + me.vertices[vi].normal.x = x me.vertices[vi].normal.y = y me.vertices[vi].normal.z = z - + if recalculate_normals: me.update(calc_edges = True) # Handle colors - + if face_data["hasVertexColors"]: print("setting vertex colors") me.vertex_colors.new("vertex_color_layer_0") - + for fi in range(len(faces)): if vertexColors[fi]: - + face_colors = me.vertex_colors[0].data[fi] face_colors = face_colors.color1, face_colors.color2, face_colors.color3, face_colors.color4 - + for vi in range(len(vertexColors[fi])): - + r = vertexColors[fi][vi][0] g = vertexColors[fi][vi][1] b = vertexColors[fi][vi][2] - + face_colors[vi].r = r face_colors[vi].g = g face_colors[vi].b = b - + elif face_data["hasFaceColors"]: print("setting vertex colors from face colors") me.vertex_colors.new("vertex_color_layer_0") - + for fi in range(len(faces)): if faceColors[fi]: @@ -218,19 +218,19 @@ def create_mesh_object(name, vertices, materials, face_data, flipYZ, recalculate face_colors = me.vertex_colors[0].data[fi] face_colors = face_colors.color1, face_colors.color2, face_colors.color3, face_colors.color4 - + for vi in range(len(faces[fi])): - + face_colors[vi].r = r face_colors[vi].g = g face_colors[vi].b = b # Handle uvs - + if face_data["hasVertexUVs"]: print("setting vertex uvs") - + for li, layer in enumerate(vertexUVs): me.uv_textures.new("uv_layer_%d" % li) @@ -238,47 +238,47 @@ def create_mesh_object(name, vertices, materials, face_data, flipYZ, recalculate for fi in range(len(faces)): if layer[fi]: - + uv_face = me.uv_textures[li].data[fi] face_uvs = uv_face.uv1, uv_face.uv2, uv_face.uv3, uv_face.uv4 - + for vi in range(len(layer[fi])): - + u = layer[fi][vi][0] v = layer[fi][vi][1] - + face_uvs[vi].x = u face_uvs[vi].y = 1.0 - v - + active_texture = materials[faceMaterials[fi]].active_texture - + if active_texture: uv_face.use_image = True uv_face.image = active_texture.image # Handle materials # 1 - + if face_data["hasMaterials"]: - + print("setting materials (mesh)") - + for m in materials: - + me.materials.append(m) - print("setting materials (faces)") + print("setting materials (faces)") for fi in range(len(faces)): - + if faceMaterials[fi] >= 0: - + me.faces[fi].material_index = faceMaterials[fi] # Create a new object - - ob = bpy.data.objects.new(name, me) + + ob = bpy.data.objects.new(name, me) ob.data = me # link the mesh data to the object @@ -286,14 +286,14 @@ def create_mesh_object(name, vertices, materials, face_data, flipYZ, recalculate scene.objects.link(ob) # link the object into the scene ob.location = scene.cursor_location # position object at 3d-cursor - - + + # ##################################################### # Faces # ##################################################### def extract_faces(data): - + result = { "faces" : [], "materials" : [], @@ -303,14 +303,14 @@ def extract_faces(data): "vertexNormals" : [], "faceColors" : [], "vertexColors" : [], - + "hasVertexNormals" : False, "hasVertexUVs" : False, "hasVertexColors" : False, "hasFaceColors" : False, "hasMaterials" : False } - + faces = data.get("faces", []) normals = data.get("normals", []) colors = data.get("colors", []) @@ -351,23 +351,23 @@ def extract_faces(data): result["hasVertexColors"] = result["hasVertexColors"] or hasFaceVertexColor result["hasFaceColors"] = result["hasFaceColors"] or hasFaceColor result["hasMaterials"] = result["hasMaterials"] or hasMaterial - + # vertices - + if isQuad: a = faces[ offset ] offset += 1 - + b = faces[ offset ] offset += 1 - + c = faces[ offset ] offset += 1 - + d = faces[ offset ] offset += 1 - + face = [a, b, c, d] nVertices = 4 @@ -376,26 +376,26 @@ def extract_faces(data): a = faces[ offset ] offset += 1 - + b = faces[ offset ] offset += 1 - + c = faces[ offset ] offset += 1 face = [a, b, c] - + nVertices = 3 result["faces"].append(face) # material - + if hasMaterial: materialIndex = faces[ offset ] offset += 1 - + else: materialIndex = -1 @@ -407,9 +407,9 @@ def extract_faces(data): for i in range(nUvLayers): faceUv = None - + if hasFaceUv: - + uvLayer = data["uvs"][ i ] uvIndex = faces[ offset ] @@ -419,7 +419,7 @@ def extract_faces(data): v = uvLayer[ uvIndex * 2 + 1 ] faceUv = [u, v] - + result["faceUVs"][i].append(faceUv) @@ -452,18 +452,18 @@ def extract_faces(data): z = normals[ normalIndex + 2 ] faceNormal = [x, y, z] - + else: faceNormal = None - + result["faceNormals"].append(faceNormal) if hasFaceVertexNormal: vertexNormals = [] - + for j in range(nVertices): normalIndex = faces[ offset ] * 3 @@ -472,14 +472,14 @@ def extract_faces(data): x = normals[ normalIndex ] y = normals[ normalIndex + 1 ] z = normals[ normalIndex + 2 ] - + vertexNormals.append( [x, y, z] ) else: vertexNormals = None - + result["vertexNormals"].append(vertexNormals) @@ -487,11 +487,11 @@ def extract_faces(data): colorIndex = faces[ offset ] offset += 1 - + faceColor = hexToTuple( colors[ colorIndex ] ) else: - + faceColor = None result["faceColors"].append(faceColor) @@ -510,14 +510,14 @@ def extract_faces(data): vertexColors.append( color ) else: - + vertexColors = None - + result["vertexColors"].append(vertexColors) return result - + # ##################################################### # Utils # ##################################################### @@ -527,10 +527,10 @@ def hexToTuple( hexColor ): g = (( hexColor >> 8 ) & 0xff) / 255.0 b = ( hexColor & 0xff) / 255.0 return (r, g, b) - + def isBitSet(value, position): return value & ( 1 << position ) - + def splitArray(data, chunkSize): result = [] chunk = [] @@ -546,7 +546,7 @@ def splitArray(data, chunkSize): def extract_json_string(text): marker_begin = "var model =" marker_end = "postMessage" - + start = text.find(marker_begin) + len(marker_begin) end = text.find(marker_end) end = text.rfind("}", start, end) @@ -563,13 +563,13 @@ def get_path(filepath): # ##################################################### def load(operator, context, filepath, option_flip_yz = True, recalculate_normals = True): - + print('\nimporting %r' % filepath) time_main = time.time() print("\tparsing JSON file...") - + time_sub = time.time() file = open(filepath, 'rU') @@ -578,24 +578,24 @@ def load(operator, context, filepath, option_flip_yz = True, recalculate_normals json_string = extract_json_string(rawcontent) data = json.loads( json_string ) - + time_new = time.time() print('parsing %.4f sec' % (time_new - time_sub)) - + time_sub = time_new # flip YZ - + vertices = splitArray(data["vertices"], 3) - + if option_flip_yz: - vertices[:] = [(v[0], -v[2], v[1]) for v in vertices] + vertices[:] = [(v[0], -v[2], v[1]) for v in vertices] # extract faces - + face_data = extract_faces(data) - + # deselect all bpy.ops.object.select_all(action='DESELECT') @@ -606,19 +606,19 @@ def load(operator, context, filepath, option_flip_yz = True, recalculate_normals ncolors = len(data.get("colors", [])) / 3 nuvs = len(data.get("uvs", [])) / 2 nmaterials = len(data.get("materials", [])) - - print('\tbuilding geometry...\n\tfaces:%i, vertices:%i, vertex normals: %i, vertex uvs: %i, vertex colors: %i, materials: %i ...' % ( + + print('\tbuilding geometry...\n\tfaces:%i, vertices:%i, vertex normals: %i, vertex uvs: %i, vertex colors: %i, materials: %i ...' % ( nfaces, nvertices, nnormals, nuvs, ncolors, nmaterials )) # Create materials - + materials = create_materials(data, get_path(filepath)) - + # Create new obj - + create_mesh_object(get_name(filepath), vertices, materials, face_data, option_flip_yz, recalculate_normals) - scene = bpy.context.scene + scene = bpy.context.scene scene.update() time_new = time.time()