blender/blender-addons
19
43
Fork 96
Code Issues 630 Pull Requests 27 Projects 1 Releases Wiki Activity

Mesh: Update addons for auto smooth removal #104609

Merged
Hans Goudey merged 10 commits from HooglyBoogly/blender-addons:refactor-mesh-corner-normals-lazy into main 2023-10-20 16:53:48 +02:00
Conversation 7 Commits 10 Files Changed 20 +602 -230
6 changed files with 602 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 24777cec06 - Show all commits

4
io_mesh_atomic/__init__.py
View File

@ -2,12 +2,12 @@
# #
# #
# Author : Clemens Barth (Blendphys@root-1.de) # Author : Clemens Barth (Blendphys@root-1.de)
# Homepage(Wiki) : http://development.root-1.de/Atomic_Blender.php # Homepage(Wiki) : https://docs.blender.org/manual/en/dev/addons/import_export/mesh_atomic.html
# #
# Start of project : 2011-08-31 by CB # Start of project : 2011-08-31 by CB
# First publication in Blender : 2011-11-11 by CB # First publication in Blender : 2011-11-11 by CB
# Fusion of the PDB, XYZ and Panel : 2019-03-22 by CB # Fusion of the PDB, XYZ and Panel : 2019-03-22 by CB
# Last modified : 2019-05-17 # Last modified : 2023-05-19
# #
# Contributing authors # Contributing authors
# ==================== # ====================

9
io_mesh_atomic/pdb_gui.py
View File

@ -96,8 +96,8 @@ class IMPORT_OT_pdb(Operator, ImportHelper):
name="Bonds", default=False, name="Bonds", default=False,
description="Show double and triple bonds") description="Show double and triple bonds")
sticks_dist: FloatProperty( sticks_dist: FloatProperty(
name="", default = 1.1, min=1.0, max=3.0, name="", default = 0.8, min=0.0, max=3.0,
description="Distance between sticks measured in stick diameter") description="Distance between sticks (double or tripple bonds) measured in stick diameter")
use_sticks_one_object: BoolProperty( use_sticks_one_object: BoolProperty(
name="One object", default=False, name="One object", default=False,
description="All sticks are one object") description="All sticks are one object")
@ -184,7 +184,10 @@ class IMPORT_OT_pdb(Operator, ImportHelper):
col = row.column() col = row.column()
col.active = self.use_sticks_one_object col.active = self.use_sticks_one_object
col.prop(self, "use_sticks_one_object_nr") col.prop(self, "use_sticks_one_object_nr")
row = box.row()
row.active = self.use_sticks and self.use_sticks_bonds
row.label(text="Distance")
row.prop(self, "sticks_dist")
def execute(self, context): def execute(self, context):
# Switch to 'OBJECT' mode when in 'EDIT' mode. # Switch to 'OBJECT' mode when in 'EDIT' mode.

86
io_mesh_atomic/pdb_import.py
View File

@ -556,7 +556,7 @@ def camera_light_source(use_camera,
camera_factor = 15.0 camera_factor = 15.0
# If chosen a camera is put into the scene. # If chosen, a camera is put into the scene.
if use_camera == True: if use_camera == True:
# Assume that the object is put into the global origin. Then, the # Assume that the object is put into the global origin. Then, the
@ -850,7 +850,7 @@ def draw_sticks_dupliverts(all_atoms,
i = 0 i = 0
# What follows is school mathematics! :-) We construct equidistant # What follows is school mathematics! :-) We construct equidistant
# planes, on which the stcik sections (cylinders) are perpendicular on. # planes, on which the stick sections (cylinders) are perpendicular on.
for stick in stick_list: for stick in stick_list:
dv = stick[2] dv = stick[2]
@ -1100,6 +1100,7 @@ def draw_sticks_normal(all_atoms,
center, center,
Stick_diameter, Stick_diameter,
Stick_sectors, Stick_sectors,
Stick_dist,
use_sticks_smooth, use_sticks_smooth,
use_sticks_one_object, use_sticks_one_object,
use_sticks_one_object_nr, use_sticks_one_object_nr,
@ -1117,52 +1118,96 @@ def draw_sticks_normal(all_atoms,
list_group = [] list_group = []
list_group_sub = [] list_group_sub = []
counter = 0 counter = 0
for stick in all_sticks: for i, stick in enumerate(all_sticks):
# We treat here single, double and tripple bonds: stick.number <= 3
for repeat in range(stick.number):
# The vectors of the two atoms # The vectors of the two atoms
atom1 = all_atoms[stick.atom1-1].location-center atom1 = copy(all_atoms[stick.atom1-1].location)-center
atom2 = all_atoms[stick.atom2-1].location-center atom2 = copy(all_atoms[stick.atom2-1].location)-center
# Location
dist = Stick_diameter * Stick_dist
# The two sticks are on the left and right of the middle connection.
if stick.number == 2:
if repeat == 0:
atom1 += (stick.dist * dist)
atom2 += (stick.dist * dist)
if repeat == 1:
atom1 -= (stick.dist * dist)
atom2 -= (stick.dist * dist)
if stick.number == 3:
if repeat == 0:
atom1 += (stick.dist * dist)
atom2 += (stick.dist * dist)
if repeat == 2:
atom1 -= (stick.dist * dist)
atom2 -= (stick.dist * dist)
# Vector pointing along the stick direction
dv = atom1 - atom2
# The normalized vector of this, with lenght 1
n = dv / dv.length
# Starting point of the stick
location = (atom1 + atom2) * 0.5 location = (atom1 + atom2) * 0.5
# The difference of both vectors
v = (atom2 - atom1)
# Angle with respect to the z-axis # Angle with respect to the z-axis
angle = v.angle(up_axis, 0) angle = dv.angle(up_axis, 0)
# Cross-product between v and the z-axis vector. It is the # Cross-product between v and the z-axis vector. It is the
# vector of rotation. # vector of rotation.
axis = up_axis.cross(v) axis = up_axis.cross(dv)
# Calculate Euler angles # Calculate Euler angles
euler = Matrix.Rotation(angle, 4, axis).to_euler() euler = Matrix.Rotation(angle, 4, axis).to_euler()
# Create stick # Create stick
stick = bpy.ops.mesh.primitive_cylinder_add(vertices=Stick_sectors, stick_obj = bpy.ops.mesh.primitive_cylinder_add(vertices=Stick_sectors,
radius=Stick_diameter, radius=Stick_diameter,
depth=v.length, depth=dv.length,
end_fill_type='NGON', end_fill_type='NGON',
align='WORLD', align='WORLD',
enter_editmode=False, enter_editmode=False,
location=location, location=location,
rotation=(0, 0, 0)) rotation=(0, 0, 0))
# Put the stick into the scene ... # Put the stick into the scene ...
stick = bpy.context.view_layer.objects.active stick_obj = bpy.context.view_layer.objects.active
# ... and rotate the stick. # ... and rotate the stick.
stick.rotation_euler = euler stick_obj.rotation_euler = euler
# ... and name # ... and name
stick.name = "Stick_Cylinder" if stick.number == 1:
stick_obj.name = "Stick_Cylinder_%04d" %(i)
elif stick.number == 2:
if repeat == 0:
stick_obj.name = "Stick_Cylinder_%04d" %(i) + "_left"
elif repeat == 1:
stick_obj.name = "Stick_Cylinder_%04d" %(i) + "_right"
elif stick.number == 3:
if repeat == 0:
stick_obj.name = "Stick_Cylinder_%04d" %(i) + "_left"
elif repeat == 1:
stick_obj.name = "Stick_Cylinder_%04d" %(i) + "_middle"
elif repeat == 2:
stick_obj.name = "Stick_Cylinder_%04d" %(i) + "_right"
# Never occurs:
else:
stick_obj.name = "Stick_Cylinder"
# Never occurs:
else:
stick_obj.name = "Stick_Cylinder"
counter += 1 counter += 1
# Smooth the cylinder. # Smooth the cylinder.
if use_sticks_smooth == True: if use_sticks_smooth == True:
bpy.ops.object.select_all(action='DESELECT') bpy.ops.object.select_all(action='DESELECT')
stick.select_set(True) stick_obj.select_set(True)
bpy.ops.object.shade_smooth() bpy.ops.object.shade_smooth()
list_group_sub.append(stick) list_group_sub.append(stick_obj)
if use_sticks_one_object == True: if use_sticks_one_object == True:
if counter == use_sticks_one_object_nr: if counter == use_sticks_one_object_nr:
bpy.ops.object.select_all(action='DESELECT') bpy.ops.object.select_all(action='DESELECT')
for stick in list_group_sub: for stick_select in list_group_sub:
stick.select_set(True) stick_select.select_set(True)
bpy.ops.object.join() bpy.ops.object.join()
list_group.append(bpy.context.view_layer.objects.active) list_group.append(bpy.context.view_layer.objects.active)
bpy.ops.object.select_all(action='DESELECT') bpy.ops.object.select_all(action='DESELECT')
@ -1170,7 +1215,7 @@ def draw_sticks_normal(all_atoms,
counter = 0 counter = 0
else: else:
# Material ... # Material ...
stick.active_material = stick_material stick_obj.active_material = stick_material
if use_sticks_one_object == True: if use_sticks_one_object == True:
bpy.ops.object.select_all(action='DESELECT') bpy.ops.object.select_all(action='DESELECT')
@ -1531,6 +1576,7 @@ def import_pdb(Ball_type,
object_center_vec, object_center_vec,
Stick_diameter, Stick_diameter,
Stick_sectors, Stick_sectors,
Stick_dist,
use_sticks_smooth, use_sticks_smooth,
use_sticks_one_object, use_sticks_one_object,
use_sticks_one_object_nr, use_sticks_one_object_nr,

11
io_scene_3ds/__init__.py
View File

@ -16,7 +16,7 @@ import bpy
bl_info = { bl_info = {
"name": "Autodesk 3DS format", "name": "Autodesk 3DS format",
"author": "Bob Holcomb, Campbell Barton, Andreas Atteneder, Sebastian Schrand", "author": "Bob Holcomb, Campbell Barton, Andreas Atteneder, Sebastian Schrand",
"version": (2, 4, 0), "version": (2, 4, 1),
"blender": (3, 6, 0), "blender": (3, 6, 0),
"location": "File > Import-Export", "location": "File > Import-Export",
"description": "3DS Import/Export meshes, UVs, materials, textures, " "description": "3DS Import/Export meshes, UVs, materials, textures, "
@ -65,12 +65,12 @@ class Import3DS(bpy.types.Operator, ImportHelper):
"importing incorrectly", "importing incorrectly",
default=True, default=True,
) )
read_keyframe: bpy.props.BoolProperty( read_keyframe: BoolProperty(
name="Read Keyframe", name="Read Keyframe",
description="Read the keyframe data", description="Read the keyframe data",
default=True, default=True,
) )
use_world_matrix: bpy.props.BoolProperty( use_world_matrix: BoolProperty(
name="World Space", name="World Space",
description="Transform to matrix world", description="Transform to matrix world",
default=False, default=False,
@ -109,6 +109,11 @@ class Export3DS(bpy.types.Operator, ExportHelper):
description="Export selected objects only", description="Export selected objects only",
default=False, default=False,
) )
write_keyframe: BoolProperty(
name="Write Keyframe",
description="Write the keyframe data",
default=False,
)
def execute(self, context): def execute(self, context):
from . import export_3ds from . import export_3ds

641
io_scene_3ds/export_3ds.py
View File

@ -121,6 +121,7 @@ KFDATA_KFCURTIME = 0xB009 # Frame current
KFDATA_KFHDR = 0xB00A # Keyframe header KFDATA_KFHDR = 0xB00A # Keyframe header
# >------ sub defines of OBJECT_NODE_TAG # >------ sub defines of OBJECT_NODE_TAG
PARENT_NAME = 0x80F0 # Object parent name tree
OBJECT_NODE_ID = 0xB030 # Object hierachy ID OBJECT_NODE_ID = 0xB030 # Object hierachy ID
OBJECT_NODE_HDR = 0xB010 # Hierachy tree header OBJECT_NODE_HDR = 0xB010 # Hierachy tree header
OBJECT_INSTANCE_NAME = 0xB011 # Object instance name OBJECT_INSTANCE_NAME = 0xB011 # Object instance name
@ -157,7 +158,7 @@ def sane_name(name):
new_name = new_name_clean + '.%.3d' % i new_name = new_name_clean + '.%.3d' % i
i += 1 i += 1
# note, appending the 'str' version. # note, appending the 'str' version
name_unique.append(new_name) name_unique.append(new_name)
name_mapping[name] = new_name = new_name.encode("ASCII", "replace") name_mapping[name] = new_name = new_name.encode("ASCII", "replace")
return new_name return new_name
@ -166,7 +167,7 @@ def sane_name(name):
def uv_key(uv): def uv_key(uv):
return round(uv[0], 6), round(uv[1], 6) return round(uv[0], 6), round(uv[1], 6)
# size defines: # size defines
SZ_SHORT = 2 SZ_SHORT = 2
SZ_INT = 4 SZ_INT = 4
SZ_FLOAT = 4 SZ_FLOAT = 4
@ -239,7 +240,7 @@ class _3ds_string(object):
file.write(struct.pack(binary_format, self.value)) file.write(struct.pack(binary_format, self.value))
def __str__(self): def __str__(self):
return str(self.value) return str((self.value).decode("ASCII"))
class _3ds_point_3d(object): class _3ds_point_3d(object):
@ -260,15 +261,15 @@ class _3ds_point_3d(object):
# Used for writing a track # Used for writing a track
'''
class _3ds_point_4d(object): class _3ds_point_4d(object):
"""Class representing a four-dimensional point for a 3ds file, for instance a quaternion.""" """Class representing a four-dimensional point for a 3ds file, for instance a quaternion."""
__slots__ = "w","x","y","z" __slots__ = "w", "x", "y", "z"
def __init__(self, point=(0.0,0.0,0.0,0.0)):
def __init__(self, point):
self.w, self.x, self.y, self.z = point self.w, self.x, self.y, self.z = point
def get_size(self): def get_size(self):
return 4*SZ_FLOAT return 4 * SZ_FLOAT
def write(self,file): def write(self,file):
data=struct.pack('<4f', self.w, self.x, self.y, self.z) data=struct.pack('<4f', self.w, self.x, self.y, self.z)
@ -276,7 +277,6 @@ class _3ds_point_4d(object):
def __str__(self): def __str__(self):
return '(%f, %f, %f, %f)' % (self.w, self.x, self.y, self.z) return '(%f, %f, %f, %f)' % (self.w, self.x, self.y, self.z)
'''
class _3ds_point_uv(object): class _3ds_point_uv(object):
@ -342,9 +342,7 @@ class _3ds_face(object):
def get_size(self): def get_size(self):
return 4 * SZ_SHORT return 4 * SZ_SHORT
# no need to validate every face vert. the oversized array will # no need to validate every face vert. the oversized array will catch this problem
# catch this problem
def write(self, file): def write(self, file):
# The last short is used for face flags # The last short is used for face flags
file.write(struct.pack('<4H', self.vindex[0], self.vindex[1], self.vindex[2], self.flag)) file.write(struct.pack('<4H', self.vindex[0], self.vindex[1], self.vindex[2], self.flag))
@ -363,7 +361,7 @@ class _3ds_array(object):
self.values = [] self.values = []
self.size = SZ_SHORT self.size = SZ_SHORT
# add an item: # add an item
def add(self, item): def add(self, item):
self.values.append(item) self.values.append(item)
self.size += item.get_size() self.size += item.get_size()
@ -380,14 +378,13 @@ class _3ds_array(object):
value.write(file) value.write(file)
# To not overwhelm the output in a dump, a _3ds_array only # To not overwhelm the output in a dump, a _3ds_array only
# outputs the number of items, not all of the actual items. # outputs the number of items, not all of the actual items
def __str__(self): def __str__(self):
return '(%d items)' % len(self.values) return '(%d items)' % len(self.values)
class _3ds_named_variable(object): class _3ds_named_variable(object):
"""Convenience class for named variables.""" """Convenience class for named variables."""
__slots__ = "value", "name" __slots__ = "value", "name"
def __init__(self, name, val=None): def __init__(self, name, val=None):
@ -485,9 +482,9 @@ class _3ds_chunk(object):
subchunk.dump(indent + 1) subchunk.dump(indent + 1)
########## #############
# EXPORT # # MATERIALS #
########## #############
def get_material_image(material): def get_material_image(material):
""" Get images from paint slots.""" """ Get images from paint slots."""
@ -583,7 +580,7 @@ def make_material_texture_chunk(chunk_id, texslots, pct):
0x40 activates alpha source, 0x80 activates tinting, 0x100 ignores alpha, 0x200 activates RGB tint. 0x40 activates alpha source, 0x80 activates tinting, 0x100 ignores alpha, 0x200 activates RGB tint.
Bits 0x80, 0x100, and 0x200 are only used with TEXMAP, TEX2MAP, and SPECMAP chunks. Bits 0x80, 0x100, and 0x200 are only used with TEXMAP, TEX2MAP, and SPECMAP chunks.
0x40, when used with a TEXMAP, TEX2MAP, or SPECMAP chunk must be accompanied with a tint bit, 0x40, when used with a TEXMAP, TEX2MAP, or SPECMAP chunk must be accompanied with a tint bit,
either 0x100 or 0x200, tintcolor will be processed if colorchunks are present""" either 0x100 or 0x200, tintcolor will be processed if a tintflag is present"""
mapflags = 0 mapflags = 0
if texslot.extension == 'EXTEND': if texslot.extension == 'EXTEND':
@ -632,9 +629,8 @@ def make_material_texture_chunk(chunk_id, texslots, pct):
rgb.add_variable("mapcolor", _3ds_rgb_color(spec if texslot.socket_dst.identifier == 'Specular' else base)) rgb.add_variable("mapcolor", _3ds_rgb_color(spec if texslot.socket_dst.identifier == 'Specular' else base))
mat_sub.add_subchunk(rgb) mat_sub.add_subchunk(rgb)
# store all textures for this mapto in order. This at least is what # store all textures for this mapto in order. This at least is what the
# the 3DS exporter did so far, afaik most readers will just skip # 3DS exporter did so far, afaik most readers will just skip over 2nd textures
# over 2nd textures.
for slot in texslots: for slot in texslots:
if slot.image is not None: if slot.image is not None:
add_texslot(slot) add_texslot(slot)
@ -685,9 +681,9 @@ def make_material_chunk(material, image):
primary_tex = False primary_tex = False
if wrap.base_color_texture: if wrap.base_color_texture:
d_pct = 0.7 + sum(wrap.base_color[:]) * 0.1
color = [wrap.base_color_texture] color = [wrap.base_color_texture]
matmap = make_material_texture_chunk(MAT_DIFFUSEMAP, color, d_pct) c_pct = 0.7 + sum(wrap.base_color[:]) * 0.1
matmap = make_material_texture_chunk(MAT_DIFFUSEMAP, color, c_pct)
if matmap: if matmap:
material_chunk.add_subchunk(matmap) material_chunk.add_subchunk(matmap)
primary_tex = True primary_tex = True
@ -729,8 +725,8 @@ def make_material_chunk(material, image):
material_chunk.add_subchunk(matmap) material_chunk.add_subchunk(matmap)
if wrap.emission_color_texture: if wrap.emission_color_texture:
e_pct = wrap.emission_strength
emission = [wrap.emission_color_texture] emission = [wrap.emission_color_texture]
e_pct = wrap.emission_strength
matmap = make_material_texture_chunk(MAT_SELFIMAP, emission, e_pct) matmap = make_material_texture_chunk(MAT_SELFIMAP, emission, e_pct)
if matmap: if matmap:
material_chunk.add_subchunk(matmap) material_chunk.add_subchunk(matmap)
@ -770,6 +766,10 @@ def make_material_chunk(material, image):
return material_chunk return material_chunk
#############
# MESH DATA #
#############
class tri_wrapper(object): class tri_wrapper(object):
"""Class representing a triangle. """Class representing a triangle.
Used when converting faces to triangles""" Used when converting faces to triangles"""
@ -849,31 +849,27 @@ def remove_face_uv(verts, tri_list):
need to be converted to vertex uv coordinates. That means that vertices need to be duplicated when need to be converted to vertex uv coordinates. That means that vertices need to be duplicated when
there are multiple uv coordinates per vertex.""" there are multiple uv coordinates per vertex."""
# initialize a list of UniqueLists, one per vertex: # initialize a list of UniqueLists, one per vertex
# uv_list = [UniqueList() for i in xrange(len(verts))]
unique_uvs = [{} for i in range(len(verts))] unique_uvs = [{} for i in range(len(verts))]
# for each face uv coordinate, add it to the UniqueList of the vertex # for each face uv coordinate, add it to the UniqueList of the vertex
for tri in tri_list: for tri in tri_list:
for i in range(3): for i in range(3):
# store the index into the UniqueList for future reference: # store the index into the UniqueList for future reference
# offset.append(uv_list[tri.vertex_index[i]].add(_3ds_point_uv(tri.faceuvs[i]))) # offset.append(uv_list[tri.vertex_index[i]].add(_3ds_point_uv(tri.faceuvs[i])))
context_uv_vert = unique_uvs[tri.vertex_index[i]] context_uv_vert = unique_uvs[tri.vertex_index[i]]
uvkey = tri.faceuvs[i] uvkey = tri.faceuvs[i]
offset_index__uv_3ds = context_uv_vert.get(uvkey) offset_index__uv_3ds = context_uv_vert.get(uvkey)
if not offset_index__uv_3ds: if not offset_index__uv_3ds:
offset_index__uv_3ds = context_uv_vert[uvkey] = len(context_uv_vert), _3ds_point_uv(uvkey) offset_index__uv_3ds = context_uv_vert[uvkey] = len(context_uv_vert), _3ds_point_uv(uvkey)
tri.offset[i] = offset_index__uv_3ds[0] tri.offset[i] = offset_index__uv_3ds[0]
# At this point, each vertex has a UniqueList containing every uv coordinate that is associated with it # At this point each vertex has a UniqueList containing every uv coord associated with it only once
# only once.
# Now we need to duplicate every vertex as many times as it has uv coordinates and make sure the # Now we need to duplicate every vertex as many times as it has uv coordinates and make sure the
# faces refer to the new face indices: # faces refer to the new face indices
vert_index = 0 vert_index = 0
vert_array = _3ds_array() vert_array = _3ds_array()
uv_array = _3ds_array() uv_array = _3ds_array()
@ -894,12 +890,12 @@ def remove_face_uv(verts, tri_list):
# Add the uv's in the correct order # Add the uv's in the correct order
for uv_3ds in uvmap: for uv_3ds in uvmap:
# add the uv coordinate to the uv array: # add the uv coordinate to the uv array
uv_array.add(uv_3ds) uv_array.add(uv_3ds)
vert_index += len(unique_uvs[i]) vert_index += len(unique_uvs[i])
# Make sure the triangle vertex indices now refer to the new vertex list: # Make sure the triangle vertex indices now refer to the new vertex list
for tri in tri_list: for tri in tri_list:
for i in range(3): for i in range(3):
tri.offset[i] += index_list[tri.vertex_index[i]] tri.offset[i] += index_list[tri.vertex_index[i]]
@ -1003,30 +999,30 @@ def make_uv_chunk(uv_array):
def make_mesh_chunk(ob, mesh, matrix, materialDict, translation): def make_mesh_chunk(ob, mesh, matrix, materialDict, translation):
"""Make a chunk out of a Blender mesh.""" """Make a chunk out of a Blender mesh."""
# Extract the triangles from the mesh: # Extract the triangles from the mesh
tri_list = extract_triangles(mesh) tri_list = extract_triangles(mesh)
if mesh.uv_layers: if mesh.uv_layers:
# Remove the face UVs and convert it to vertex UV: # Remove the face UVs and convert it to vertex UV
vert_array, uv_array, tri_list = remove_face_uv(mesh.vertices, tri_list) vert_array, uv_array, tri_list = remove_face_uv(mesh.vertices, tri_list)
else: else:
# Add the vertices to the vertex array: # Add the vertices to the vertex array
vert_array = _3ds_array() vert_array = _3ds_array()
for vert in mesh.vertices: for vert in mesh.vertices:
vert_array.add(_3ds_point_3d(vert.co)) vert_array.add(_3ds_point_3d(vert.co))
# no UV at all: # no UV at all
uv_array = None uv_array = None
# create the chunk: # create the chunk
mesh_chunk = _3ds_chunk(OBJECT_MESH) mesh_chunk = _3ds_chunk(OBJECT_MESH)
# add vertex chunk: # add vertex chunk
mesh_chunk.add_subchunk(make_vert_chunk(vert_array)) mesh_chunk.add_subchunk(make_vert_chunk(vert_array))
# add faces chunk: # add faces chunk
mesh_chunk.add_subchunk(make_faces_chunk(tri_list, mesh, materialDict)) mesh_chunk.add_subchunk(make_faces_chunk(tri_list, mesh, materialDict))
# if available, add uv chunk: # if available, add uv chunk
if uv_array: if uv_array:
mesh_chunk.add_subchunk(make_uv_chunk(uv_array)) mesh_chunk.add_subchunk(make_uv_chunk(uv_array))
@ -1058,17 +1054,18 @@ def make_mesh_chunk(ob, mesh, matrix, materialDict, translation):
return mesh_chunk return mesh_chunk
''' # COMMENTED OUT FOR 2.42 RELEASE!! CRASHES 3DS MAX #################
def make_kfdata(start=0, stop=0, curtime=0): # KEYFRAME DATA #
#################
def make_kfdata(revision, start=0, stop=100, curtime=0):
"""Make the basic keyframe data chunk""" """Make the basic keyframe data chunk"""
kfdata = _3ds_chunk(KFDATA) kfdata = _3ds_chunk(KFDATA)
kfhdr = _3ds_chunk(KFDATA_KFHDR) kfhdr = _3ds_chunk(KFDATA_KFHDR)
kfhdr.add_variable("revision", _3ds_ushort(0)) kfhdr.add_variable("revision", _3ds_ushort(revision))
# Not really sure what filename is used for, but it seems it is usually used kfhdr.add_variable("filename", _3ds_string(b'Blender'))
# to identify the program that generated the .3ds: kfhdr.add_variable("animlen", _3ds_uint(stop - start))
kfhdr.add_variable("filename", _3ds_string("Blender"))
kfhdr.add_variable("animlen", _3ds_uint(stop-start))
kfseg = _3ds_chunk(KFDATA_KFSEG) kfseg = _3ds_chunk(KFDATA_KFSEG)
kfseg.add_variable("start", _3ds_uint(start)) kfseg.add_variable("start", _3ds_uint(start))
@ -1082,107 +1079,396 @@ def make_kfdata(start=0, stop=0, curtime=0):
kfdata.add_subchunk(kfcurtime) kfdata.add_subchunk(kfcurtime)
return kfdata return kfdata
def make_track_chunk(ID, obj): def make_track_chunk(ID, ob, ob_pos, ob_rot, ob_size):
"""Make a chunk for track data. """Make a chunk for track data. Depending on the ID, this will
Depending on the ID, this will construct a position, rotation or scale track.""" construct a position, rotation, scale, roll, color or fov track."""
track_chunk = _3ds_chunk(ID) track_chunk = _3ds_chunk(ID)
track_chunk.add_variable("track_flags", _3ds_ushort())
track_chunk.add_variable("unknown", _3ds_uint()) if ID in {POS_TRACK_TAG, ROT_TRACK_TAG, SCL_TRACK_TAG} and ob.animation_data and ob.animation_data.action:
track_chunk.add_variable("unknown", _3ds_uint()) action = ob.animation_data.action
if action.fcurves:
fcurves = action.fcurves
kframes = [kf.co[0] for kf in [fc for fc in fcurves if fc is not None][0].keyframe_points]
nkeys = len(kframes)
if not 0 in kframes:
kframes.append(0)
nkeys = nkeys + 1
kframes = sorted(set(kframes))
track_chunk.add_variable("track_flags", _3ds_ushort(0x40))
track_chunk.add_variable("frame_start", _3ds_uint(int(action.frame_start)))
track_chunk.add_variable("frame_total", _3ds_uint(int(action.frame_end)))
track_chunk.add_variable("nkeys", _3ds_uint(nkeys))
if ID==POS_TRACK_TAG: # Position
for i, frame in enumerate(kframes):
position = [fc.evaluate(frame) for fc in fcurves if fc is not None and fc.data_path == 'location']
if not position:
position.append(ob_pos)
track_chunk.add_variable("tcb_frame", _3ds_uint(int(frame)))
track_chunk.add_variable("tcb_flags", _3ds_ushort())
track_chunk.add_variable("position", _3ds_point_3d(position))
elif ID==ROT_TRACK_TAG: # Rotation
for i, frame in enumerate(kframes):
rotation = [fc.evaluate(frame) for fc in fcurves if fc is not None and fc.data_path == 'rotation_euler']
if not rotation:
rotation.append(ob_rot)
quat = mathutils.Euler(rotation).to_quaternion()
axis_angle = quat.angle, quat.axis[0], quat.axis[1], quat.axis[2]
track_chunk.add_variable("tcb_frame", _3ds_uint(int(frame)))
track_chunk.add_variable("tcb_flags", _3ds_ushort())
track_chunk.add_variable("rotation", _3ds_point_4d(axis_angle))
elif ID==SCL_TRACK_TAG: # Scale
for i, frame in enumerate(kframes):
size = [fc.evaluate(frame) for fc in fcurves if fc is not None and fc.data_path == 'scale']
if not size:
size.append(ob_size)
track_chunk.add_variable("tcb_frame", _3ds_uint(int(frame)))
track_chunk.add_variable("tcb_flags", _3ds_ushort())
track_chunk.add_variable("scale", _3ds_point_3d(size))
elif ID==ROLL_TRACK_TAG: # Roll
for i, frame in enumerate(kframes):
roll = [fc.evaluate(frame) for fc in fcurves if fc is not None and fc.data_path == 'rotation_euler']
if not roll:
roll.append(ob_rot)
track_chunk.add_variable("tcb_frame", _3ds_uint(int(frame)))
track_chunk.add_variable("tcb_flags", _3ds_ushort())
track_chunk.add_variable("roll", _3ds_float(round(math.degrees(roll[1]), 4)))
elif ID in {COL_TRACK_TAG, FOV_TRACK_TAG, HOTSPOT_TRACK_TAG, FALLOFF_TRACK_TAG} and ob.data.animation_data and ob.data.animation_data.action:
action = ob.data.animation_data.action
if action.fcurves:
fcurves = action.fcurves
kframes = [kf.co[0] for kf in [fc for fc in fcurves if fc is not None][0].keyframe_points]
nkeys = len(kframes)
if not 0 in kframes:
kframes.append(0)
nkeys = nkeys + 1
kframes = sorted(set(kframes))
track_chunk.add_variable("track_flags", _3ds_ushort(0x40))
track_chunk.add_variable("frame_start", _3ds_uint(int(action.frame_start)))
track_chunk.add_variable("frame_total", _3ds_uint(int(action.frame_end)))
track_chunk.add_variable("nkeys", _3ds_uint(nkeys))
if ID==COL_TRACK_TAG: # Color
for i, frame in enumerate(kframes):
color = [fc.evaluate(frame) for fc in fcurves if fc is not None and fc.data_path == 'color']
if not color:
color.append(ob.data.color[:3])
track_chunk.add_variable("tcb_frame", _3ds_uint(int(frame)))
track_chunk.add_variable("tcb_flags", _3ds_ushort())
track_chunk.add_variable("color", _3ds_float_color(color))
elif ID==FOV_TRACK_TAG: # Field of view
for i, frame in enumerate(kframes):
lens = [fc.evaluate(frame) for fc in fcurves if fc is not None and fc.data_path == 'lens']
if not lens:
lens.append(ob.data.lens)
fov = 2 * math.atan(ob.data.sensor_width/(2*lens[0]))
track_chunk.add_variable("tcb_frame", _3ds_uint(int(frame)))
track_chunk.add_variable("tcb_flags", _3ds_ushort())
track_chunk.add_variable("fov", _3ds_float(round(math.degrees(fov), 4)))
elif ID==HOTSPOT_TRACK_TAG: # Hotspot
beam_angle = math.degrees(ob.data.spot_size)
for i, frame in enumerate(kframes):
blend = [fc.evaluate(frame) for fc in fcurves if fc is not None and fc.data_path == 'spot_blend']
if not blend:
blend.append(ob.data.spot_blend)
hot_spot = beam_angle-(blend[0]*math.floor(beam_angle))
track_chunk.add_variable("tcb_frame", _3ds_uint(int(frame)))
track_chunk.add_variable("tcb_flags", _3ds_ushort())
track_chunk.add_variable("hotspot", _3ds_float(round(hot_spot, 4)))
elif ID==FALLOFF_TRACK_TAG: # Falloff
for i, frame in enumerate(kframes):
fall_off = [fc.evaluate(frame) for fc in fcurves if fc is not None and fc.data_path == 'spot_size']
if not fall_off:
fall_off.append(ob.data.spot_size)
track_chunk.add_variable("tcb_frame", _3ds_uint(int(frame)))
track_chunk.add_variable("tcb_flags", _3ds_ushort())
track_chunk.add_variable("falloff", _3ds_float(round(math.degrees(fall_off[0]), 4)))
else:
track_chunk.add_variable("track_flags", _3ds_ushort(0x40)) # Based on observation default flag is 0x40
track_chunk.add_variable("frame_start", _3ds_uint(0))
track_chunk.add_variable("frame_total", _3ds_uint(0))
track_chunk.add_variable("nkeys", _3ds_uint(1)) track_chunk.add_variable("nkeys", _3ds_uint(1))
# Next section should be repeated for every keyframe, but for now, animation is not actually supported. # Next section should be repeated for every keyframe, with no animation only one tag is needed
track_chunk.add_variable("tcb_frame", _3ds_uint(0)) track_chunk.add_variable("tcb_frame", _3ds_uint(0))
track_chunk.add_variable("tcb_flags", _3ds_ushort()) track_chunk.add_variable("tcb_flags", _3ds_ushort())
if obj.type=='Empty':
if ID==POS_TRACK_TAG: # New method simply inserts the parameters
# position vector: if ID==POS_TRACK_TAG: # Position vector
track_chunk.add_variable("position", _3ds_point_3d(obj.getLocation())) track_chunk.add_variable("position", _3ds_point_3d(ob_pos))
elif ID==ROT_TRACK_TAG:
# rotation (quaternion, angle first, followed by axis): elif ID==ROT_TRACK_TAG: # Rotation (angle first [radians], followed by axis)
q = obj.getEuler().to_quaternion() # XXX, todo! track_chunk.add_variable("rotation", _3ds_point_4d((ob_rot.angle, ob_rot.axis[0], ob_rot.axis[1], ob_rot.axis[2])))
track_chunk.add_variable("rotation", _3ds_point_4d((q.angle, q.axis[0], q.axis[1], q.axis[2])))
elif ID==SCL_TRACK_TAG: elif ID==SCL_TRACK_TAG: # Scale vector
# scale vector: track_chunk.add_variable("scale", _3ds_point_3d(ob_size))
track_chunk.add_variable("scale", _3ds_point_3d(obj.getSize()))
else: elif ID==ROLL_TRACK_TAG: # Roll angle
# meshes have their transformations applied before track_chunk.add_variable("roll", _3ds_float(round(math.degrees(ob.rotation_euler[1]), 4)))
# exporting, so write identity transforms here:
if ID==POS_TRACK_TAG: elif ID==COL_TRACK_TAG: # Color values
# position vector: track_chunk.add_variable("color", _3ds_float_color(ob.data.color))
track_chunk.add_variable("position", _3ds_point_3d((0.0,0.0,0.0)))
elif ID==ROT_TRACK_TAG: elif ID==FOV_TRACK_TAG: # Field of view
# rotation (quaternion, angle first, followed by axis): track_chunk.add_variable("fov", _3ds_float(round(math.degrees(ob.data.angle), 4)))
track_chunk.add_variable("rotation", _3ds_point_4d((0.0, 1.0, 0.0, 0.0)))
elif ID==SCL_TRACK_TAG: elif ID==HOTSPOT_TRACK_TAG: # Hotspot
# scale vector: beam_angle = math.degrees(ob.data.spot_size)
track_chunk.add_variable("scale", _3ds_point_3d((1.0, 1.0, 1.0))) track_chunk.add_variable("hotspot", _3ds_float(round(beam_angle-(ob.data.spot_blend*math.floor(beam_angle)), 4)))
elif ID==FALLOFF_TRACK_TAG: # Falloff
track_chunk.add_variable("falloff", _3ds_float(round(math.degrees(ob.data.spot_size), 4)))
return track_chunk return track_chunk
def make_kf_obj_node(obj, name_to_id):
"""Make a node chunk for a Blender object. def make_object_node(ob, translation, rotation, scale):
Takes the Blender object as a parameter. Object id's are taken from the dictionary name_to_id. """Make a node chunk for a Blender object. Takes Blender object as parameter.
Blender Empty objects are converted to dummy nodes.""" Blender Empty objects are converted to dummy nodes."""
name = obj.name name = ob.name
# main object node chunk: if ob.type == 'CAMERA':
kf_obj_node = _3ds_chunk(OBJECT_NODE_TAG) obj_node = _3ds_chunk(CAMERA_NODE_TAG)
# chunk for the object id: elif ob.type == 'LIGHT':
obj_id_chunk = _3ds_chunk(OBJECT_NODE_ID) obj_node = _3ds_chunk(LIGHT_NODE_TAG)
# object id is from the name_to_id dictionary: if ob.data.type == 'SPOT':
obj_id_chunk.add_variable("node_id", _3ds_ushort(name_to_id[name])) obj_node = _3ds_chunk(SPOT_NODE_TAG)
else: # Main object node chunk
obj_node = _3ds_chunk(OBJECT_NODE_TAG)
# object node header: # Object node header with object name
obj_node_header_chunk = _3ds_chunk(OBJECT_NODE_HDR) obj_node_header_chunk = _3ds_chunk(OBJECT_NODE_HDR)
# object name: parent = ob.parent
if obj.type == 'Empty':
# Empties are called "$$$DUMMY" and use the OBJECT_INSTANCE_NAME chunk if ob.type == 'EMPTY': # Forcing to use the real name for empties
# for their name (see below): # Empties called $$$DUMMY and use OBJECT_INSTANCE_NAME chunk as name
obj_node_header_chunk.add_variable("name", _3ds_string("$$$DUMMY")) obj_node_header_chunk.add_variable("name", _3ds_string(b"$$$DUMMY"))
else: obj_node_header_chunk.add_variable("flags1", _3ds_ushort(0x4000))
# Add the name:
obj_node_header_chunk.add_variable("name", _3ds_string(sane_name(name)))
# Add Flag variables (not sure what they do):
obj_node_header_chunk.add_variable("flags1", _3ds_ushort(0))
obj_node_header_chunk.add_variable("flags2", _3ds_ushort(0)) obj_node_header_chunk.add_variable("flags2", _3ds_ushort(0))
# Check parent-child relationships: else: # Add flag variables - Based on observation flags1 is usually 0x0040 and 0x4000 for empty objects
parent = obj.parent obj_node_header_chunk.add_variable("name", _3ds_string(sane_name(name)))
if (parent is None) or (parent.name not in name_to_id): obj_node_header_chunk.add_variable("flags1", _3ds_ushort(0x0040))
# If no parent, or the parents name is not in the name_to_id dictionary,
# parent id becomes -1: # Flag 0x01 display path 0x02 use autosmooth 0x04 object frozen 0x10 motion blur 0x20 material morph 0x40 mesh morph
obj_node_header_chunk.add_variable("parent", _3ds_ushort(-1)) if ob.type == 'MESH' and ob.data.use_auto_smooth:
obj_node_header_chunk.add_variable("flags2", _3ds_ushort(0x02))
else: else:
# Get the parent's id from the name_to_id dictionary: obj_node_header_chunk.add_variable("flags2", _3ds_ushort(0))
obj_node_header_chunk.add_variable("parent", _3ds_ushort(ROOT_OBJECT))
'''
# COMMENTED OUT FOR 2.42 RELEASE!! CRASHES 3DS MAX
# Check parent-child relationships:
if parent is None or parent.name not in name_to_id:
# If no parent, or parents name is not in dictionary, ID becomes -1:
obj_node_header_chunk.add_variable("parent", _3ds_ushort(-1))
else: # Get the parent's ID from the name_to_id dictionary:
obj_node_header_chunk.add_variable("parent", _3ds_ushort(name_to_id[parent.name])) obj_node_header_chunk.add_variable("parent", _3ds_ushort(name_to_id[parent.name]))
'''
# Add pivot chunk: # Add subchunk for node header
obj_pivot_chunk = _3ds_chunk(OBJECT_PIVOT) obj_node.add_subchunk(obj_node_header_chunk)
obj_pivot_chunk.add_variable("pivot", _3ds_point_3d(obj.getLocation()))
kf_obj_node.add_subchunk(obj_pivot_chunk)
# add subchunks for object id and node header: # Empty objects need to have an extra chunk for the instance name
kf_obj_node.add_subchunk(obj_id_chunk) if ob.type == 'EMPTY': # Will use a real object name for empties for now
kf_obj_node.add_subchunk(obj_node_header_chunk)
# Empty objects need to have an extra chunk for the instance name:
if obj.type == 'Empty':
obj_instance_name_chunk = _3ds_chunk(OBJECT_INSTANCE_NAME) obj_instance_name_chunk = _3ds_chunk(OBJECT_INSTANCE_NAME)
obj_instance_name_chunk.add_variable("name", _3ds_string(sane_name(name))) obj_instance_name_chunk.add_variable("name", _3ds_string(sane_name(name)))
kf_obj_node.add_subchunk(obj_instance_name_chunk) obj_node.add_subchunk(obj_instance_name_chunk)
# Add track chunks for position, rotation and scale: if ob.type in {'MESH', 'EMPTY'}: # Add a pivot point at the object center
kf_obj_node.add_subchunk(make_track_chunk(POS_TRACK_TAG, obj)) pivot_pos = (translation[name])
kf_obj_node.add_subchunk(make_track_chunk(ROT_TRACK_TAG, obj)) obj_pivot_chunk = _3ds_chunk(OBJECT_PIVOT)
kf_obj_node.add_subchunk(make_track_chunk(SCL_TRACK_TAG, obj)) obj_pivot_chunk.add_variable("pivot", _3ds_point_3d(pivot_pos))
obj_node.add_subchunk(obj_pivot_chunk)
return kf_obj_node # Create a bounding box from quadrant diagonal
''' obj_boundbox = _3ds_chunk(OBJECT_BOUNDBOX)
obj_boundbox.add_variable("min", _3ds_point_3d(ob.bound_box[0]))
obj_boundbox.add_variable("max", _3ds_point_3d(ob.bound_box[6]))
obj_node.add_subchunk(obj_boundbox)
# Add smooth angle if autosmooth is used
if ob.type == 'MESH' and ob.data.use_auto_smooth:
obj_morph_smooth = _3ds_chunk(OBJECT_MORPH_SMOOTH)
obj_morph_smooth.add_variable("angle", _3ds_float(round(ob.data.auto_smooth_angle, 6)))
obj_node.add_subchunk(obj_morph_smooth)
# Add track chunks for color, position, rotation and scale
if parent is None:
ob_pos = translation[name]
ob_rot = rotation[name]
ob_size = scale[name]
else: # Calculate child position and rotation of the object center, no scale applied
ob_pos = translation[name] - translation[parent.name]
ob_rot = rotation[name].cross(rotation[parent.name].copy().inverted())
ob_size = (1.0, 1.0, 1.0)
obj_node.add_subchunk(make_track_chunk(POS_TRACK_TAG, ob, ob_pos, ob_rot, ob_size))
if ob.type in {'MESH', 'EMPTY'}:
obj_node.add_subchunk(make_track_chunk(ROT_TRACK_TAG, ob, ob_pos, ob_rot, ob_size))
obj_node.add_subchunk(make_track_chunk(SCL_TRACK_TAG, ob, ob_pos, ob_rot, ob_size))
if ob.type =='CAMERA':
obj_node.add_subchunk(make_track_chunk(FOV_TRACK_TAG, ob, ob_pos, ob_rot, ob_size))
obj_node.add_subchunk(make_track_chunk(ROLL_TRACK_TAG, ob, ob_pos, ob_rot, ob_size))
if ob.type =='LIGHT':
obj_node.add_subchunk(make_track_chunk(COL_TRACK_TAG, ob, ob_pos, ob_rot, ob_size))
if ob.type == 'LIGHT' and ob.data.type == 'SPOT':
obj_node.add_subchunk(make_track_chunk(HOTSPOT_TRACK_TAG, ob, ob_pos, ob_rot, ob_size))
obj_node.add_subchunk(make_track_chunk(FALLOFF_TRACK_TAG, ob, ob_pos, ob_rot, ob_size))
obj_node.add_subchunk(make_track_chunk(ROLL_TRACK_TAG, ob, ob_pos, ob_rot, ob_size))
return obj_node
def make_target_node(ob, translation, rotation, scale):
"""Make a target chunk for light and camera objects"""
name = ob.name
if ob.type == 'CAMERA': #Add camera target
tar_node = _3ds_chunk(TARGET_NODE_TAG)
elif ob.type == 'LIGHT': # Add spot target
tar_node = _3ds_chunk(LTARGET_NODE_TAG)
# Object node header with object name
tar_node_header_chunk = _3ds_chunk(OBJECT_NODE_HDR)
# Targets get the same name as the object, flags1 is usually 0x0010 and parent ROOT_OBJECT
tar_node_header_chunk.add_variable("name", _3ds_string(sane_name(name)))
tar_node_header_chunk.add_variable("flags1", _3ds_ushort(0x0010))
tar_node_header_chunk.add_variable("flags2", _3ds_ushort(0))
tar_node_header_chunk.add_variable("parent", _3ds_ushort(ROOT_OBJECT))
# Add subchunk for node header
tar_node.add_subchunk(tar_node_header_chunk)
# Calculate target position
ob_pos = translation[name]
ob_rot = rotation[name].to_euler()
ob_size = scale[name]
diagonal = math.copysign(math.sqrt(pow(ob_pos[0],2)+pow(ob_pos[1],2)), ob_pos[1])
target_x = ob_pos[0]+(ob_pos[1]*math.tan(ob_rot[2]))
target_y = ob_pos[1]+(ob_pos[0]*math.tan(math.radians(90)-ob_rot[2]))
target_z = -1*diagonal*math.tan(math.radians(90)-ob_rot[0])
# Add track chunks for target position
track_chunk = _3ds_chunk(POS_TRACK_TAG)
if ob.animation_data and ob.animation_data.action:
action = ob.animation_data.action
if action.fcurves:
fcurves = action.fcurves
kframes = [kf.co[0] for kf in [fc for fc in fcurves if fc is not None][0].keyframe_points]
nkeys = len(kframes)
if not 0 in kframes:
kframes.append(0)
nkeys = nkeys + 1
kframes = sorted(set(kframes))
track_chunk.add_variable("track_flags", _3ds_ushort(0x40))
track_chunk.add_variable("frame_start", _3ds_uint(int(action.frame_start)))
track_chunk.add_variable("frame_total", _3ds_uint(int(action.frame_end)))
track_chunk.add_variable("nkeys", _3ds_uint(nkeys))
for i, frame in enumerate(kframes):
target_pos = [fc.evaluate(frame) for fc in fcurves if fc is not None and fc.data_path == 'location']
target_rot = [fc.evaluate(frame) for fc in fcurves if fc is not None and fc.data_path == 'rotation_euler']
if not target_pos:
target_pos.append(ob_pos)
if not target_rot:
target_rot.insert(0, ob_rot.x)
target_rot.insert(1, ob_rot.y)
target_rot.insert(2, ob_rot.z)
diagonal = math.copysign(math.sqrt(pow(target_pos[0],2)+pow(target_pos[1],2)), target_pos[1])
target_x = target_pos[0]+(target_pos[1]*math.tan(target_rot[2]))
target_y = target_pos[1]+(target_pos[0]*math.tan(math.radians(90)-target_rot[2]))
target_z = -1*diagonal*math.tan(math.radians(90)-target_rot[0])
track_chunk.add_variable("tcb_frame", _3ds_uint(int(frame)))
track_chunk.add_variable("tcb_flags", _3ds_ushort())
track_chunk.add_variable("position", _3ds_point_3d((target_x, target_y, target_z)))
else: # Track header
track_chunk.add_variable("track_flags", _3ds_ushort(0x40)) # Based on observation default flag is 0x40
track_chunk.add_variable("frame_start", _3ds_uint(0))
track_chunk.add_variable("frame_total", _3ds_uint(0))
track_chunk.add_variable("nkeys", _3ds_uint(1))
# Keyframe header
track_chunk.add_variable("tcb_frame", _3ds_uint(0))
track_chunk.add_variable("tcb_flags", _3ds_ushort())
track_chunk.add_variable("position", _3ds_point_3d((target_x, target_y, target_z)))
tar_node.add_subchunk(track_chunk)
return tar_node
def make_ambient_node(world):
amb_color = world.color
amb_node = _3ds_chunk(AMBIENT_NODE_TAG)
track_chunk = _3ds_chunk(COL_TRACK_TAG)
# Object node header, name is "$AMBIENT$" for ambient nodes
amb_node_header_chunk = _3ds_chunk(OBJECT_NODE_HDR)
amb_node_header_chunk.add_variable("name", _3ds_string(b"$AMBIENT$"))
amb_node_header_chunk.add_variable("flags1", _3ds_ushort(0x4000)) # Flags1 0x4000 for empty objects
amb_node_header_chunk.add_variable("flags2", _3ds_ushort(0))
amb_node_header_chunk.add_variable("parent", _3ds_ushort(ROOT_OBJECT))
amb_node.add_subchunk(amb_node_header_chunk)
if world.animation_data.action:
action = world.animation_data.action
if action.fcurves:
fcurves = action.fcurves
kframes = [kf.co[0] for kf in [fc for fc in fcurves if fc is not None][0].keyframe_points]
nkeys = len(kframes)
if not 0 in kframes:
kframes.append(0)
nkeys = nkeys + 1
kframes = sorted(set(kframes))
track_chunk.add_variable("track_flags", _3ds_ushort(0x40))
track_chunk.add_variable("frame_start", _3ds_uint(int(action.frame_start)))
track_chunk.add_variable("frame_total", _3ds_uint(int(action.frame_end)))
track_chunk.add_variable("nkeys", _3ds_uint(nkeys))
for i, frame in enumerate(kframes):
ambient = [fc.evaluate(frame) for fc in fcurves if fc is not None and fc.data_path == 'color']
if not ambient:
ambient.append(world.color)
track_chunk.add_variable("tcb_frame", _3ds_uint(int(frame)))
track_chunk.add_variable("tcb_flags", _3ds_ushort())
track_chunk.add_variable("color", _3ds_float_color(ambient))
else: # Track header
track_chunk.add_variable("track_flags", _3ds_ushort(0x40))
track_chunk.add_variable("frame_start", _3ds_uint(0))
track_chunk.add_variable("frame_total", _3ds_uint(0))
track_chunk.add_variable("nkeys", _3ds_uint(1))
# Keyframe header
track_chunk.add_variable("tcb_frame", _3ds_uint(0))
track_chunk.add_variable("tcb_flags", _3ds_ushort())
track_chunk.add_variable("color", _3ds_float_color(amb_color))
amb_node.add_subchunk(track_chunk)
return amb_node
##########
# EXPORT #
##########
def save(operator, def save(operator,
context, filepath="", context, filepath="",
use_selection=True, use_selection=False,
write_keyframe=False,
global_matrix=None, global_matrix=None,
): ):
@ -1193,6 +1479,7 @@ def save(operator,
scene = context.scene scene = context.scene
layer = context.view_layer layer = context.view_layer
depsgraph = context.evaluated_depsgraph_get() depsgraph = context.evaluated_depsgraph_get()
world = scene.world
if global_matrix is None: if global_matrix is None:
global_matrix = mathutils.Matrix() global_matrix = mathutils.Matrix()
@ -1200,15 +1487,15 @@ def save(operator,
if bpy.ops.object.mode_set.poll(): if bpy.ops.object.mode_set.poll():
bpy.ops.object.mode_set(mode='OBJECT') bpy.ops.object.mode_set(mode='OBJECT')
# Initialize the main chunk (primary): # Initialize the main chunk (primary)
primary = _3ds_chunk(PRIMARY) primary = _3ds_chunk(PRIMARY)
# Add version chunk: # Add version chunk
version_chunk = _3ds_chunk(VERSION) version_chunk = _3ds_chunk(VERSION)
version_chunk.add_variable("version", _3ds_uint(3)) version_chunk.add_variable("version", _3ds_uint(3))
primary.add_subchunk(version_chunk) primary.add_subchunk(version_chunk)
# Init main object info chunk: # Init main object info chunk
object_info = _3ds_chunk(OBJECTINFO) object_info = _3ds_chunk(OBJECTINFO)
mesh_version = _3ds_chunk(MESHVERSION) mesh_version = _3ds_chunk(MESHVERSION)
mesh_version.add_variable("mesh", _3ds_uint(3)) mesh_version.add_variable("mesh", _3ds_uint(3))
@ -1219,21 +1506,26 @@ def save(operator,
mscale.add_variable("scale", _3ds_float(1)) mscale.add_variable("scale", _3ds_float(1))
object_info.add_subchunk(mscale) object_info.add_subchunk(mscale)
# Init main keyframe data chunk
if write_keyframe:
revision = 0x0005
stop = scene.frame_end
start = scene.frame_start
curtime = scene.frame_current
kfdata = make_kfdata(revision, start, stop, curtime)
# Add AMBIENT color # Add AMBIENT color
if scene.world is not None: if world is not None:
ambient_chunk = _3ds_chunk(AMBIENTLIGHT) ambient_chunk = _3ds_chunk(AMBIENTLIGHT)
ambient_light = _3ds_chunk(RGB) ambient_light = _3ds_chunk(RGB)
ambient_light.add_variable("ambient", _3ds_float_color(scene.world.color)) ambient_light.add_variable("ambient", _3ds_float_color(scene.world.color))
ambient_chunk.add_subchunk(ambient_light) ambient_chunk.add_subchunk(ambient_light)
object_info.add_subchunk(ambient_chunk) object_info.add_subchunk(ambient_chunk)
if write_keyframe and world.animation_data:
''' # COMMENTED OUT FOR 2.42 RELEASE!! CRASHES 3DS MAX kfdata.add_subchunk(make_ambient_node(world))
# init main key frame data chunk:
kfdata = make_kfdata()
'''
# Make a list of all materials used in the selected meshes (use a dictionary, # Make a list of all materials used in the selected meshes (use a dictionary,
# each material is added once): # each material is added once)
materialDict = {} materialDict = {}
mesh_objects = [] mesh_objects = []
@ -1270,7 +1562,7 @@ def save(operator,
ma_ls = data.materials ma_ls = data.materials
ma_ls_len = len(ma_ls) ma_ls_len = len(ma_ls)
# get material/image tuples. # get material/image tuples
if data.uv_layers: if data.uv_layers:
if not ma_ls: if not ma_ls:
ma = ma_name = None ma = ma_name = None
@ -1291,7 +1583,7 @@ def save(operator,
else: else:
for ma in ma_ls: for ma in ma_ls:
if ma: # material may be None so check its not. if ma: # material may be None so check its not
materialDict.setdefault((ma.name, None), (ma, None)) materialDict.setdefault((ma.name, None), (ma, None))
# Why 0 Why! # Why 0 Why!
@ -1300,25 +1592,31 @@ def save(operator,
f.material_index = 0 f.material_index = 0
# Make material chunks for all materials used in the meshes: # Make material chunks for all materials used in the meshes
for ma_image in materialDict.values(): for ma_image in materialDict.values():
object_info.add_subchunk(make_material_chunk(ma_image[0], ma_image[1])) object_info.add_subchunk(make_material_chunk(ma_image[0], ma_image[1]))
# Collect translation for transformation matrix # Collect translation for transformation matrix
translation = {} translation = {}
rotation = {}
scale = {}
# Give all objects a unique ID and build a dictionary from object name to object id: # Give all objects a unique ID and build a dictionary from object name to object id
# name_to_id = {} # name_to_id = {}
for ob, data, matrix in mesh_objects: for ob, data, matrix in mesh_objects:
translation[ob.name] = ob.location translation[ob.name] = ob.location
rotation[ob.name] = ob.rotation_euler.to_quaternion().inverted()
scale[ob.name] = ob.scale
# name_to_id[ob.name]= len(name_to_id) # name_to_id[ob.name]= len(name_to_id)
for ob in empty_objects: for ob in empty_objects:
translation[ob.name] = ob.location translation[ob.name] = ob.location
rotation[ob.name] = ob.rotation_euler.to_quaternion().inverted()
scale[ob.name] = ob.scale
# name_to_id[ob.name]= len(name_to_id) # name_to_id[ob.name]= len(name_to_id)
# Create object chunks for all meshes: # Create object chunks for all meshes
i = 0 i = 0
for ob, mesh, matrix in mesh_objects: for ob, mesh, matrix in mesh_objects:
# create a new object chunk # create a new object chunk
@ -1327,34 +1625,34 @@ def save(operator,
# set the object name # set the object name
object_chunk.add_variable("name", _3ds_string(sane_name(ob.name))) object_chunk.add_variable("name", _3ds_string(sane_name(ob.name)))
# make a mesh chunk out of the mesh: # make a mesh chunk out of the mesh
object_chunk.add_subchunk(make_mesh_chunk(ob, mesh, matrix, materialDict, translation)) object_chunk.add_subchunk(make_mesh_chunk(ob, mesh, matrix, materialDict, translation))
# ensure the mesh has no over sized arrays # ensure the mesh has no over sized arrays, skip ones that do!
# skip ones that do!, otherwise we cant write since the array size wont # Otherwise we cant write since the array size wont fit into USHORT
# fit into USHORT.
if object_chunk.validate(): if object_chunk.validate():
object_info.add_subchunk(object_chunk) object_info.add_subchunk(object_chunk)
else: else:
operator.report({'WARNING'}, "Object %r can't be written into a 3DS file") operator.report({'WARNING'}, "Object %r can't be written into a 3DS file")
''' # COMMENTED OUT FOR 2.42 RELEASE!! CRASHES 3DS MAX # Export kf object node
# make a kf object node for the object: if write_keyframe:
kfdata.add_subchunk(make_kf_obj_node(ob, name_to_id)) kfdata.add_subchunk(make_object_node(ob, translation, rotation, scale))
'''
i += i i += i
# Create chunks for all empties: # Create chunks for all empties, only requires a kf object node
''' # COMMENTED OUT FOR 2.42 RELEASE!! CRASHES 3DS MAX if write_keyframe:
for ob in empty_objects: for ob in empty_objects:
# Empties only require a kf object node: kfdata.add_subchunk(make_object_node(ob, translation, rotation, scale))
kfdata.add_subchunk(make_kf_obj_node(ob, name_to_id))
pass
'''
# Create light object chunks # Create light object chunks
for ob in light_objects: for ob in light_objects:
translation[ob.name] = ob.location
rotation[ob.name] = ob.rotation_euler.to_quaternion()
scale[ob.name] = ob.scale
# Add light data subchunks
object_chunk = _3ds_chunk(OBJECT) object_chunk = _3ds_chunk(OBJECT)
light_chunk = _3ds_chunk(OBJECT_LIGHT) light_chunk = _3ds_chunk(OBJECT_LIGHT)
color_float_chunk = _3ds_chunk(RGB) color_float_chunk = _3ds_chunk(RGB)
@ -1392,8 +1690,19 @@ def save(operator,
object_chunk.add_subchunk(light_chunk) object_chunk.add_subchunk(light_chunk)
object_info.add_subchunk(object_chunk) object_info.add_subchunk(object_chunk)
# Export light and spotlight target node
if write_keyframe:
kfdata.add_subchunk(make_object_node(ob, translation, rotation, scale))
if ob.data.type == 'SPOT':
kfdata.add_subchunk(make_target_node(ob, translation, rotation, scale))
# Create camera object chunks # Create camera object chunks
for ob in camera_objects: for ob in camera_objects:
translation[ob.name] = ob.location
rotation[ob.name] = ob.rotation_euler.to_quaternion()
scale[ob.name] = ob.scale
# Add camera data subchunks
object_chunk = _3ds_chunk(OBJECT) object_chunk = _3ds_chunk(OBJECT)
camera_chunk = _3ds_chunk(OBJECT_CAMERA) camera_chunk = _3ds_chunk(OBJECT_CAMERA)
diagonal = math.copysign(math.sqrt(pow(ob.location[0], 2) + pow(ob.location[1], 2)), ob.location[1]) diagonal = math.copysign(math.sqrt(pow(ob.location[0], 2) + pow(ob.location[1], 2)), ob.location[1])
@ -1408,35 +1717,39 @@ def save(operator,
object_chunk.add_subchunk(camera_chunk) object_chunk.add_subchunk(camera_chunk)
object_info.add_subchunk(object_chunk) object_info.add_subchunk(object_chunk)
# Add main object info chunk to primary chunk: # Export camera and target node
if write_keyframe:
kfdata.add_subchunk(make_object_node(ob, translation, rotation, scale))
kfdata.add_subchunk(make_target_node(ob, translation, rotation, scale))
# Add main object info chunk to primary chunk
primary.add_subchunk(object_info) primary.add_subchunk(object_info)
''' # COMMENTED OUT FOR 2.42 RELEASE!! CRASHES 3DS MAX # Add main keyframe data chunk to primary chunk
# Add main keyframe data chunk to primary chunk: if write_keyframe:
primary.add_subchunk(kfdata) primary.add_subchunk(kfdata)
'''
# At this point, the chunk hierarchy is completely built. # At this point, the chunk hierarchy is completely built.
# Check the size: # Check the size
primary.get_size() primary.get_size()
# Open the file for writing: # Open the file for writing
file = open(filepath, 'wb') file = open(filepath, 'wb')
# Recursively write the chunks to file: # Recursively write the chunks to file
primary.write(file) primary.write(file)
# Close the file: # Close the file
file.close() file.close()
# Clear name mapping vars, could make locals too # Clear name mapping vars, could make locals too
del name_unique[:] del name_unique[:]
name_mapping.clear() name_mapping.clear()
# Debugging only: report the exporting time: # Debugging only: report the exporting time
print("3ds export time: %.2f" % (time.time() - duration)) print("3ds export time: %.2f" % (time.time() - duration))
# Debugging only: dump the chunk hierarchy: # Debugging only: dump the chunk hierarchy
# primary.dump() # primary.dump()
return {'FINISHED'} return {'FINISHED'}

9
object_carver/carver_utils.py
View File

@ -308,11 +308,16 @@ def CreateBevel(context, CurrentObject):
bpy.ops.object.mode_set(mode='OBJECT') bpy.ops.object.mode_set(mode='OBJECT')
CurrentObject.data.use_customdata_edge_bevel = True bevel_weights = CurrentObject.data.attributes["bevel_weight_edge"]
if not bevel_weights:
bevel_weights = CurrentObject.data.attributes.new("bevel_weight_edge", 'FLOAT', 'EDGE')
if bevel_weights.data_type != 'FLOAT' or bevel_weights.domain != 'EDGE':
bevel_weights = None
for i in range(len(CurrentObject.data.edges)): for i in range(len(CurrentObject.data.edges)):
if CurrentObject.data.edges[i].select is True: if CurrentObject.data.edges[i].select is True:
CurrentObject.data.edges[i].bevel_weight = 1.0 if bevel_weights:
bevel_weights.data[i] = 1.0
CurrentObject.data.edges[i].use_edge_sharp = True CurrentObject.data.edges[i].use_edge_sharp = True
bevel_modifier = False bevel_modifier = False