import bpy, math, gpu
+import cProfile
from ctypes import *
from mathutils import *
from gpu_extras.batch import batch_for_shader
_pack_ = 1
_fields_ = [("co",c_float*3),
("norm",c_float*3),
- ("colour",c_float*4),
- ("uv",c_float*2)]
+ ("uv",c_float*2),
+ ("colour",c_uint8*4),
+ ("weights",c_uint16*4),
+ ("groups",c_uint8*4)]
class mdl_submesh(Structure):
_pack_ = 1
("submesh_count",c_uint32),
("classtype",c_uint32),
("offset",c_uint32),
+ ("parent",c_uint32),
("pstr_name",c_uint32)]
class mdl_header(Structure):
("node_count",c_uint32),
("node_offset",c_uint32),
+ ("anim_count",c_uint32),
+ ("anim_offset",c_uint32),
+
("strings_offset",c_uint32),
- ("entdata_offset",c_uint32)
+ ("entdata_offset",c_uint32),
+ ("animdata_offset",c_uint32)
]
+class mdl_animation(Structure):
+ _pack_ = 1
+ _fields_ = [("pstr_name",c_uint32),
+ ("length",c_uint32),
+ ("rate",c_float),
+ ("offset",c_uint32)]
+
+class mdl_keyframe(Structure):
+ _pack_ = 1
+ _fields_ = [("co",c_float*3),
+ ("q",c_float*4),
+ ("s",c_float*3)]
+
# Entity types
# ==========================================
class classtype_gate(Structure):
_pack_ = 1
- _fields_ = [("target",c_uint32)]
+ _fields_ = [("target",c_uint32),
+ ("dims",c_float*3)]
class classtype_block(Structure):
_pack_ = 1
_pack_ = 1
_fields_ = [("temp",c_uint32)]
+class classtype_car_path(Structure):
+ _pack_ = 1
+ _fields_ = [("target",c_uint32),
+ ("target1",c_uint32)]
+
+class classtype_instance(Structure):
+ _pack_ = 1
+ _fields_ = [("pstr_file",c_uint32)]
+
+class classtype_capsule(Structure):
+ _pack_ = 1
+ _fields_ = [("height",c_float),
+ ("radius",c_float)]
+
+class classtype_route_node(Structure):
+ _pack_ = 1
+ _fields_ = [("target",c_uint32),
+ ("target1",c_uint32)]
+
+class classtype_route(Structure):
+ _pack_ = 1
+ _fields_ = [("pstr_name",c_uint32),
+ ("id_start",c_uint32),
+ ("colour",c_float*3)]
+
+class classtype_skin(Structure):
+ _pack_ = 1
+ _fields_ = [("skeleton",c_uint32)]
+
+class classtype_skeleton(Structure):
+ _pack_ = 1
+ _fields_ = [("channels",c_uint32),
+ ("ik_count",c_uint32),
+ ("collider_count",c_uint32),
+ ("anim_start",c_uint32),
+ ("anim_count",c_uint32)]
+
+class classtype_bone(Structure):
+ _pack_ = 1
+ _fields_ = [("deform",c_uint32),
+ ("ik_target",c_uint32),
+ ("ik_pole",c_uint32),
+ ("collider",c_uint32),
+ ("use_limits",c_uint32),
+ ("angle_limits",(c_float*3)*2),
+ ("hitbox",(c_float*3)*2)]
+
# Exporter
# ==============================================================================
-def write_model(name):
- print( F"Create mode {name}" )
+def write_model(collection_name):
+ print( F"Model graph | Create mode '{collection_name}'" )
- collection = bpy.data.collections[name]
-
header = mdl_header()
header.identifier = 0xABCD0000
header.version = 0
entdata_buffer = []
entdata_length = 0
+ anim_buffer = []
+ animdata_length = 0
+ animdata_buffer = []
+
def emplace_string( s ):
nonlocal string_cache, strings_buffer
def emplace_material( mat ):
nonlocal material_cache, material_buffer
+ if mat == None:
+ return 0
+
if mat.name in material_cache:
return material_cache[mat.name]
return material_cache[mat.name]
# Create root or empty node and materials
+ # this is to designate id 0 as 'NULL'
#
none_material = c_uint32(69)
none_material.name = ""
# Do exporting
#
print( " assigning ids" )
- header.node_count = 1
- for obj in collection.all_objects:
- obj.cv_data.uid = header.node_count
+ collection = bpy.data.collections[collection_name]
+
+ # Scene graph
+ # ==========================================
+
+ header.node_count = 0
+ def _uid():
+ nonlocal header
+ uid = header.node_count
header.node_count += 1
+ return uid
+
+ print( " creating scene graph" )
+ graph = {}
+ graph["obj"] = None
+ graph["depth"] = 0
+ graph["children"] = []
+ graph["uid"] = _uid()
+ graph["parent"] = None
+
+ graph_lookup = {} # object can lookup its graph def here
- print( " compiling data" )
for obj in collection.all_objects:
- print( F" [{obj.cv_data.uid}/{header.node_count-1}] {obj.name}" )
+ if not obj.parent:
- node = mdl_node()
- node.co[0] = obj.location[0]
- node.co[1] = obj.location[2]
- node.co[2] = -obj.location[1]
-
- # Convert rotation quat to our space type
- quat = obj.matrix_world.to_quaternion()
- node.q[0] = quat[1]
- node.q[1] = quat[3]
- node.q[2] = -quat[2]
- node.q[3] = quat[0]
-
- node.s[0] = obj.scale[0]
- node.s[1] = obj.scale[2]
- node.s[2] = obj.scale[1]
- node.pstr_name = emplace_string( obj.name )
+ def _extend( p, n, d ):
+ uid = _uid()
+ tree = {}
+ tree["uid"] = uid
+ tree["children"] = []
+ tree["depth"] = d
+ tree["obj"] = n
+ tree["parent"] = p
+ n.cv_data.uid = uid
- # Process entity data
- #
- node.offset = entdata_length
- classtype = obj.cv_data.classtype
+ if n.type == 'ARMATURE':
+ tree["bones"] = [None] # None is the root transform
+ tree["ik_count"] = 0
+ tree["collider_count"] = 0
- if classtype == 'k_classtype_none':
- node.classtype = 0
- node.offset = 0
+ def _extendb( p, n, d ):
+ nonlocal tree
- elif classtype == 'k_classtype_gate':
- node.classtype = 1
- entdata_length += sizeof( classtype_gate )
+ btree = {}
+ btree["bone"] = n
+ btree["uid"] = _uid()
+ btree["children"] = []
+ btree["depth"] = d
+ btree["parent"] = p
+ tree["bones"] += [n.name]
- gate = classtype_gate()
- gate.target = 0
- if obj.cv_data.target != None:
- gate.target = obj.cv_data.target.cv_data.uid
+ for c in n.children:
+ _extendb( btree, c, d+1 )
- entdata_buffer += [gate]
+ for c in tree['obj'].pose.bones[n.name].constraints:
+ if c.type == 'IK':
+ btree["target"] = c.subtarget
+ btree["pole"] = c.pole_subtarget
+ tree["ik_count"] += 1
- elif classtype == 'k_classtype_block':
- node.classtype = 2
- entdata_length += sizeof( classtype_block )
+ if n.cv_data.collider:
+ tree['collider_count'] += 1
- source = obj.data.cv_data
+ btree['deform'] = n.use_deform
+ p['children'] += [btree]
- block = classtype_block()
- block.bbx[0][0] = source.v0[0]
- block.bbx[0][1] = source.v0[2]
- block.bbx[0][2] = -source.v0[1]
- block.bbx[1][0] = source.v1[0]
- block.bbx[1][1] = source.v1[2]
- block.bbx[1][2] = -source.v1[1]
- entdata_buffer += [block]
+ for b in n.data.bones:
+ if not b.parent:
+ _extendb( tree, b, d+1 )
- elif classtype == 'k_classtype_spawn':
- node.classtype = 3
+ for obj1 in n.children:
+ _extend( tree, obj1, d+1 )
- elif classtype == 'k_classtype_water':
- node.classtype = 4
+ p["children"] += [tree]
+ graph_lookup[n] = tree
- # Process meshes
- #
- node.submesh_start = header.submesh_count
- node.submesh_count = 0
+ _extend( graph, obj, 1 )
- if obj.type == 'MESH':
- default_mat = c_uint32(69)
- default_mat.name = ""
- if obj.data.name in mesh_cache:
+ def _graph_iter(p):
+ for c in p['children']:
+ yield c
+ yield from _graph_iter(c)
+
+ it = _graph_iter(graph)
+
+ root.parent = 0xffffffff
+
+ # Compile
+ # ==============================================
+ it = _graph_iter(graph)
+ print( " compiling data" )
+ for node_def in it:
+ if 'obj' in node_def:
+ obj = node_def['obj']
+ objt = obj.type
+ objco = obj.location
+ elif 'bone' in node_def:
+ obj = node_def['bone']
+ objt = 'BONE'
+ objco = obj.head_local
+
+ depth = node_def['depth']
+ uid = node_def['uid']
+
+ node = mdl_node()
+ node.co[0] = objco[0]
+ node.co[1] = objco[2]
+ node.co[2] = -objco[1]
+
+ # Convert rotation quat to our space type
+ quat = obj.matrix_local.to_quaternion()
+ node.q[0] = quat[1]
+ node.q[1] = quat[3]
+ node.q[2] = -quat[2]
+ node.q[3] = quat[0]
+
+ if objt == 'BONE':
+ node.s[0] = obj.tail_local[0] - node.co[0]
+ node.s[1] = obj.tail_local[2] - node.co[1]
+ node.s[2] = -obj.tail_local[1] - node.co[2]
+ else:
+ node.s[0] = obj.scale[0]
+ node.s[1] = obj.scale[2]
+ node.s[2] = obj.scale[1]
+
+ node.pstr_name = emplace_string( obj.name )
+
+ if node_def["parent"]:
+ node.parent = node_def["parent"]["uid"]
+
+ if objt == 'BONE':
+ classtype = 'k_classtype_bone'
+ elif objt == 'ARMATURE':
+ classtype = 'k_classtype_skeleton'
+ else:
+ classtype = obj.cv_data.classtype
+
+ # Process type: MESH
+ # =================================================================
+ #
+
+ # Dont use the cache if we have modifiers that affect the normals
+ #
+ compile_mesh = False
+ if objt == 'MESH':
+ armature_def = None
+ compile_mesh = True
+ can_use_cache = True
+
+ for mod in obj.modifiers:
+ if mod.type == 'DATA_TRANSFER' or mod.type == 'SHRINKWRAP' or \
+ mod.type == 'BOOLEAN' or mod.type == 'CURVE' or \
+ mod.type == 'ARRAY':
+ can_use_cache = False
+
+ if mod.type == 'ARMATURE':
+ classtype = 'k_classtype_skin'
+ armature_def = graph_lookup[mod.object]
+ POSE_OR_REST_CACHE = armature_def['obj'].data.pose_position
+
+ armature_def['obj'].data.pose_position = 'REST'
+
+ if can_use_cache and obj.data.name in mesh_cache:
ref = mesh_cache[obj.data.name]
node.submesh_start = ref.submesh_start
node.submesh_count = ref.submesh_count
- node_buffer += [node]
- continue
+ compile_mesh = False
+
+ if compile_mesh:
+ node.submesh_start = header.submesh_count
+ node.submesh_count = 0
+
+ default_mat = c_uint32(69)
+ default_mat.name = ""
dgraph = bpy.context.evaluated_depsgraph_get()
data = obj.evaluated_get(dgraph).data
for j in range(3):
vert = data.vertices[tri.vertices[j]]
li = tri.loops[j]
+ vi = data.loops[li].vertex_index
co = vert.co
norm = data.loops[li].normal
uv = (0,0)
- colour = (1,1,1,1)
+ colour = (255,255,255,255)
+ groups = [0,0,0,0]
+ weights = [0,0,0,0]
+
if data.uv_layers:
uv = data.uv_layers.active.data[li].uv
+
if data.vertex_colors:
colour = data.vertex_colors.active.data[li].color
-
- key = (round(co[0],4),round(co[1],4),round(co[2],4),\
- round(norm[0],4),round(norm[1],4),round(norm[2],4),\
- round(uv[0],4),round(uv[1],4),\
- round(colour[0],4),round(colour[1],4),\
- round(colour[2],4),round(colour[3],4))
+ colour = (int(colour[0]*255.0),\
+ int(colour[1]*255.0),\
+ int(colour[2]*255.0),\
+ int(colour[3]*255.0))
+
+ # WEight groups
+ #
+ if armature_def:
+ src_groups = [_ for _ in data.vertices[vi].groups \
+ if obj.vertex_groups[_.group].name in \
+ armature_def['bones']]
+
+ weight_groups = sorted( src_groups, key = \
+ lambda a: a.weight, reverse=True )
+ tot = 0.0
+ for ml in range(3):
+ if len(weight_groups) > ml:
+ g = weight_groups[ml]
+ name = obj.vertex_groups[g.group].name
+ weight = g.weight
+
+ weights[ml] = weight
+ groups[ml] = armature_def['bones'].index(name)
+ tot += weight
+
+ if len(weight_groups) > 0:
+ inv_norm = (1.0/tot) * 65535.0
+ for ml in range(3):
+ weights[ml] = int( weights[ml] * inv_norm )
+ weights[ml] = min( weights[ml], 65535 )
+ weights[ml] = max( weights[ml], 0 )
+
+ TOLERENCE = 4
+ m = float(10**TOLERENCE)
+
+ key = (int(co[0]*m+0.5),\
+ int(co[1]*m+0.5),\
+ int(co[2]*m+0.5),\
+ int(norm[0]*m+0.5),\
+ int(norm[1]*m+0.5),\
+ int(norm[2]*m+0.5),\
+ int(uv[0]*m+0.5),\
+ int(uv[1]*m+0.5),\
+ colour[0],\
+ colour[1],\
+ colour[2],\
+ colour[3],\
+ weights[0],\
+ weights[1],\
+ weights[2],\
+ weights[3],\
+ groups[0],\
+ groups[1],\
+ groups[2],\
+ groups[3])
if key in boffa:
indice_buffer += [boffa[key]]
v.colour[1] = colour[1]
v.colour[2] = colour[2]
v.colour[3] = colour[3]
+ v.weights[0] = weights[0]
+ v.weights[1] = weights[1]
+ v.weights[2] = weights[2]
+ v.weights[3] = weights[3]
+ v.groups[0] = groups[0]
+ v.groups[1] = groups[1]
+ v.groups[2] = groups[2]
+ v.groups[3] = groups[3]
+
vertex_buffer += [v]
for i in range(3):
header.indice_count += sm.indice_count
mesh_cache[obj.data.name] = node
+
+ # Process entity data
+ # ==================================================================
+ node.offset = entdata_length
+
+ if classtype != 'k_classtype_none':
+ disptype = classtype
+ else:
+ disptype = objt
+
+ s000 = F" [{uid: 3}/{header.node_count-1}]" + " |"*(depth-1)
+ s001 = F" L {obj.name}"
+ s002 = s000+s001
+ s003 = F"{disptype}"
+ s004 = F"{node.parent: 3}"
+ s005 = ""
+
+ if classtype == 'k_classtype_skin':
+ armature_def['obj'].data.pose_position = POSE_OR_REST_CACHE
+ s005 = F" [armature -> {armature_def['obj'].cv_data.uid}]"
+
+ scmp = F"{s002:<32} {s003:<22} {s004} {s005}"
+ print( scmp )
+
+ if classtype == 'k_classtype_INSTANCE' or \
+ classtype == 'k_classtype_BONE' or \
+ classtype == 'k_classtype_SKELETON' or \
+ classtype == 'k_classtype_SKIN':
+ print( "ERROR: user classtype cannot be _INSTANCE or _BONE" )
+ node.classtype = 0
+ node.offset = 0
+
+ elif classtype == 'k_classtype_skin':
+ node.classtype = 12
+
+ armature = armature_def['obj']
+ entdata_length += sizeof( classtype_skin )
+
+ skin = classtype_skin()
+ skin.skeleton = armature.cv_data.uid
+ entdata_buffer += [skin]
+
+ elif classtype == 'k_classtype_skeleton':
+ node.classtype = 11
+ entdata_length += sizeof( classtype_skeleton )
+ skeleton = classtype_skeleton()
+
+ armature_def = graph_lookup[obj]
+ armature = obj
+ bones = armature_def['bones']
+ skeleton.channels = len(bones)
+ skeleton.ik_count = armature_def["ik_count"]
+ skeleton.collider_count = armature_def["collider_count"]
+
+ if armature.animation_data:
+ previous_frame = bpy.context.scene.frame_current
+ previous_action = armature.animation_data.action
+
+ skeleton.anim_start = len(anim_buffer)
+ skeleton.anim_count = 0
+
+ for NLALayer in obj.animation_data.nla_tracks:
+ for NLAStrip in NLALayer.strips:
+ # Use action
+ for a in bpy.data.actions:
+ if a.name == NLAStrip.name:
+ armature.animation_data.action = a
+ break
+
+ anim_start = int(NLAStrip.action_frame_start)
+ anim_end = int(NLAStrip.action_frame_end)
+
+ # export strips
+ anim = mdl_animation()
+ anim.pstr_name = emplace_string( NLAStrip.action.name )
+ anim.rate = 30.0
+ anim.offset = animdata_length
+ anim.length = anim_end-anim_start
+
+ # Export the fucking keyframes
+ for frame in range(anim_start,anim_end):
+ bpy.context.scene.frame_set(frame)
+
+ for bone_name in bones:
+ for pb in armature.pose.bones:
+ if pb.name == bone_name:
+ rb = armature.data.bones[ bone_name ]
+
+ # relative bone matrix
+ if rb.parent is not None:
+ offset_mtx = rb.parent.matrix_local
+ offset_mtx = offset_mtx.inverted_safe() @ \
+ rb.matrix_local
+
+ inv_parent = pb.parent.matrix @ offset_mtx
+ inv_parent.invert_safe()
+ fpm = inv_parent @ pb.matrix
+ else:
+ bone_mtx = rb.matrix.to_4x4()
+ local_inv = rb.matrix_local.inverted_safe()
+ fpm = bone_mtx @ local_inv @ pb.matrix
+
+ loc, rot, sca = fpm.decompose()
+
+ # local position
+ final_pos = Vector(( loc[0], loc[2], -loc[1] ))
+
+ # rotation
+ lc_m = pb.matrix_channel.to_3x3()
+ if pb.parent is not None:
+ smtx = pb.parent.matrix_channel.to_3x3()
+ lc_m = smtx.inverted() @ lc_m
+ rq = lc_m.to_quaternion()
+
+ kf = mdl_keyframe()
+ kf.co[0] = final_pos[0]
+ kf.co[1] = final_pos[1]
+ kf.co[2] = final_pos[2]
+
+ kf.q[0] = rq[1]
+ kf.q[1] = rq[3]
+ kf.q[2] = -rq[2]
+ kf.q[3] = rq[0]
+
+ # scale
+ kf.s[0] = sca[0]
+ kf.s[1] = sca[2]
+ kf.s[2] = sca[1]
+
+ animdata_buffer += [kf]
+ animdata_length += sizeof(mdl_keyframe)
+ break
+
+ anim_buffer += [anim]
+ skeleton.anim_count += 1
+
+ s000 = F" [{uid: 3}/{header.node_count-1}]" + " |"*(depth-1)
+ print( F"{s000} | *anim: {NLAStrip.action.name}" )
+
+ bpy.context.scene.frame_set( previous_frame )
+ armature.animation_data.action = previous_action
+
+ entdata_buffer += [skeleton]
+
+ elif classtype == 'k_classtype_bone':
+ node.classtype = 10
+ entdata_length += sizeof( classtype_bone )
+
+ bone = classtype_bone()
+ bone.deform = node_def['deform']
+
+ if 'target' in node_def:
+ bone.ik_target = armature_def['bones'].index( node_def['target'] )
+ bone.ik_pole = armature_def['bones'].index( node_def['pole'] )
+ else:
+ bone.ik_target = 0
+ bone.ik_pole = 0
+
+ bone.collider = 1 if obj.cv_data.collider else 0
+ if obj.cv_data.collider:
+ bone.hitbox[0][0] = obj.cv_data.v0[0]
+ bone.hitbox[0][1] = obj.cv_data.v0[2]
+ bone.hitbox[0][2] = -obj.cv_data.v1[1]
+ bone.hitbox[1][0] = obj.cv_data.v1[0]
+ bone.hitbox[1][1] = obj.cv_data.v1[2]
+ bone.hitbox[1][2] = -obj.cv_data.v0[1]
+ else:
+ bone.hitbox[0][0] = 0.0
+ bone.hitbox[0][1] = 0.0
+ bone.hitbox[0][2] = 0.0
+ bone.hitbox[1][0] = 0.0
+ bone.hitbox[1][1] = 0.0
+ bone.hitbox[1][2] = 0.0
+
+ if obj.cv_data.con0:
+ bone.use_limits = 1
+ bone.angle_limits[0][0] = obj.cv_data.mins[0]
+ bone.angle_limits[0][1] = obj.cv_data.mins[2]
+ bone.angle_limits[0][2] = -obj.cv_data.maxs[1]
+ bone.angle_limits[1][0] = obj.cv_data.maxs[0]
+ bone.angle_limits[1][1] = obj.cv_data.maxs[2]
+ bone.angle_limits[1][2] = -obj.cv_data.mins[1]
+ else:
+ bone.use_limits = 0
+ bone.angle_limits[0][0] = 0.0
+ bone.angle_limits[0][1] = 0.0
+ bone.angle_limits[0][2] = 0.0
+ bone.angle_limits[1][0] = 0.0
+ bone.angle_limits[1][1] = 0.0
+ bone.angle_limits[1][2] = 0.0
+
+ bone.deform = node_def['deform']
+ entdata_buffer += [bone]
+
+ elif classtype == 'k_classtype_gate':
+ node.classtype = 1
+ entdata_length += sizeof( classtype_gate )
+
+ gate = classtype_gate()
+ gate.target = 0
+ if obj.cv_data.target != None:
+ gate.target = obj.cv_data.target.cv_data.uid
+
+ if obj.type == 'MESH':
+ gate.dims[0] = obj.data.cv_data.v0[0]
+ gate.dims[1] = obj.data.cv_data.v0[1]
+ gate.dims[2] = obj.data.cv_data.v0[2]
+ else:
+ gate.dims[0] = obj.cv_data.v0[0]
+ gate.dims[1] = obj.cv_data.v0[1]
+ gate.dims[2] = obj.cv_data.v0[2]
+
+ entdata_buffer += [gate]
+
+ elif classtype == 'k_classtype_block':
+ node.classtype = 2
+ entdata_length += sizeof( classtype_block )
+
+ source = obj.data.cv_data
+
+ block = classtype_block()
+ block.bbx[0][0] = source.v0[0]
+ block.bbx[0][1] = source.v0[2]
+ block.bbx[0][2] = -source.v1[1]
+
+ block.bbx[1][0] = source.v1[0]
+ block.bbx[1][1] = source.v1[2]
+ block.bbx[1][2] = -source.v0[1]
+ entdata_buffer += [block]
+
+ elif classtype == 'k_classtype_spawn':
+ node.classtype = 3
+
+ elif classtype == 'k_classtype_water':
+ node.classtype = 4
+
+ elif classtype == 'k_classtype_car_path':
+ node.classtype = 5
+ entdata_length += sizeof( classtype_car_path )
+
+ pn = classtype_car_path()
+ pn.target = 0
+ pn.target1 = 0
+
+ if obj.cv_data.target != None:
+ pn.target = obj.cv_data.target.cv_data.uid
+ if obj.cv_data.target1 != None:
+ pn.target1 = obj.cv_data.target1.cv_data.uid
+
+ entdata_buffer += [pn]
+
+ elif obj.is_instancer:
+ target = obj.instance_collection
+
+ node.classtype = 6
+ entdata_length += sizeof( classtype_instance )
+
+ inst = classtype_instance()
+ inst.pstr_file = emplace_string( F"models/{target.name}.mdl" )
+ entdata_buffer += [inst]
+
+ elif classtype == 'k_classtype_capsule':
+ node.classtype = 7
+
+ elif classtype == 'k_classtype_route_node':
+ node.classtype = 8
+ entdata_length += sizeof( classtype_route_node )
+
+ rn = classtype_route_node()
+ if obj.cv_data.target != None:
+ rn.target = obj.cv_data.target.cv_data.uid
+ if obj.cv_data.target1 != None:
+ rn.target1 = obj.cv_data.target1.cv_data.uid
+
+ entdata_buffer += [rn]
+
+ elif classtype == 'k_classtype_route':
+ node.classtype = 9
+ entdata_length += sizeof( classtype_route )
+ r = classtype_route()
+ r.pstr_name = emplace_string("not-implemented")
+ r.colour[0] = obj.cv_data.colour[0]
+ r.colour[1] = obj.cv_data.colour[1]
+ r.colour[2] = obj.cv_data.colour[2]
+
+ if obj.cv_data.target != None:
+ r.id_start = obj.cv_data.target.cv_data.uid
+
+ entdata_buffer += [r]
+
+ # classtype == 'k_classtype_none':
+ else:
+ node.classtype = 0
+ node.offset = 0
+
node_buffer += [node]
# Write data arrays
#
+ header.anim_count = len(anim_buffer)
+
print( "Writing data" )
fpos = sizeof(header)
+ print( F"Nodes: {header.node_count}" )
header.node_offset = fpos
fpos += sizeof(mdl_node)*header.node_count
+ print( F"Submeshes: {header.submesh_count}" )
header.submesh_offset = fpos
fpos += sizeof(mdl_submesh)*header.submesh_count
+ print( F"Materials: {header.material_count}" )
header.material_offset = fpos
fpos += sizeof(mdl_material)*header.material_count
+ print( F"Animation count: {header.anim_count}" )
+ header.anim_offset = fpos
+ fpos += sizeof(mdl_animation)*header.anim_count
+
+ print( F"Entdata length: {entdata_length}" )
header.entdata_offset = fpos
fpos += entdata_length
-
+
+ print( F"Vertex count: {header.vertex_count}" )
header.vertex_offset = fpos
fpos += sizeof(mdl_vert)*header.vertex_count
+ print( F"Indice count: {header.indice_count}" )
header.indice_offset = fpos
fpos += sizeof(c_uint32)*header.indice_count
+ print( F"Keyframe count: {animdata_length}" )
+ header.animdata_offset = fpos
+ fpos += animdata_length
+
+ print( F"Strings length: {len(strings_buffer)}" )
header.strings_offset = fpos
fpos += len(strings_buffer)
header.file_length = fpos
- fp = open(F"/home/harry/Documents/carve/models/{name}.mdl", "wb")
+ path = F"/home/harry/Documents/carve/models_src/{collection_name}.mdl"
+ fp = open( path, "wb" )
+
fp.write( bytearray( header ) )
for node in node_buffer:
fp.write( bytearray(sm) )
for mat in material_buffer:
fp.write( bytearray(mat) )
+ for a in anim_buffer:
+ fp.write( bytearray(a) )
for ed in entdata_buffer:
fp.write( bytearray(ed) )
for v in vertex_buffer:
fp.write( bytearray(v) )
for i in indice_buffer:
fp.write( bytearray(i) )
+ for kf in animdata_buffer:
+ fp.write( bytearray(kf) )
+
fp.write( strings_buffer )
fp.close()
- print( F"Completed {name}.mdl" )
+ print( F"Completed {collection_name}.mdl" )
# Clicky clicky GUI
# ------------------------------------------------------------------------------
gpu.state.depth_mask_set(False)
gpu.state.line_width_set(2.0)
gpu.state.face_culling_set('BACK')
- gpu.state.depth_test_set('NONE')
- gpu.state.blend_set('ADDITIVE')
+ gpu.state.depth_test_set('LESS')
+ gpu.state.blend_set('NONE')
verts = []
colours = []
+ #def drawbezier(p0,h0,p1,h1,c0,c1):
+ # nonlocal verts, colours
+
+ # verts += [p0]
+ # verts += [h0]
+ # colours += [(0.5,0.5,0.5,1.0),(0.5,0.5,0.5,1)]
+ # verts += [p1]
+ # verts += [h1]
+ # colours += [(1.0,1.0,1,1),(1,1,1,1)]
+ #
+ # last = p0
+ # for i in range(10):
+ # t = (i+1)/10
+ # a0 = 1-t
+
+ # tt = t*t
+ # ttt = tt*t
+ # p=ttt*p1+(3*tt-3*ttt)*h1+(3*ttt-6*tt+3*t)*h0+(3*tt-ttt-3*t+1)*p0
+ # verts += [(last[0],last[1],last[2])]
+ # verts += [(p[0],p[1],p[2])]
+ # colours += [c0*a0+c1*(1-a0),c0*a0+c1*(1-a0)]
+ # last = p
+
+ course_count = 0
+
+ def drawbhandle(obj, direction, colour):
+ nonlocal verts, colours
+ p0 = obj.location
+ h0 = obj.matrix_world @ Vector((0,direction,0))
+ verts += [p0]
+ verts += [h0]
+ colours += [colour,colour]
+
+ def drawbezier(p0,h0,p1,h1,c0,c1):
+ nonlocal verts, colours
+
+ last = p0
+ for i in range(10):
+ t = (i+1)/10
+ a0 = 1-t
+
+ tt = t*t
+ ttt = tt*t
+ p=ttt*p1+(3*tt-3*ttt)*h1+(3*ttt-6*tt+3*t)*h0+(3*tt-ttt-3*t+1)*p0
+ verts += [(last[0],last[1],last[2])]
+ verts += [(p[0],p[1],p[2])]
+ colours += [c0*a0+c1*(1-a0),c0*a0+c1*(1-a0)]
+ last = p
+
+ def drawsbpath(o0,o1,c0,c1,s0,s1):
+ nonlocal course_count
+
+ offs = ((course_count % 2)*2-1) * course_count * 0.02
+
+ p0 = o0.matrix_world @ Vector((offs, 0,0))
+ h0 = o0.matrix_world @ Vector((offs, s0,0))
+ p1 = o1.matrix_world @ Vector((offs, 0,0))
+ h1 = o1.matrix_world @ Vector((offs,-s1,0))
+ drawbezier(p0,h0,p1,h1,c0,c1)
+
+ def drawbpath(o0,o1,c0,c1):
+ drawsbpath(o0,o1,c0,c1,1.0,1.0)
+
+ def drawbline(p0,p1,c0,c1):
+ nonlocal verts, colours
+ verts += [p0,p1]
+ colours += [c0,c1]
+
for obj in bpy.context.collection.objects:
+ if obj.type == 'ARMATURE':
+ for bone in obj.data.bones:
+ if bone.cv_data.collider and obj.data.pose_position == 'REST':
+ c = bone.head_local
+ a = bone.cv_data.v0
+ b = bone.cv_data.v1
+
+ vs = [None]*8
+ vs[0]=obj.matrix_world@Vector((c[0]+a[0],c[1]+a[1],c[2]+a[2]))
+ vs[1]=obj.matrix_world@Vector((c[0]+a[0],c[1]+b[1],c[2]+a[2]))
+ vs[2]=obj.matrix_world@Vector((c[0]+b[0],c[1]+b[1],c[2]+a[2]))
+ vs[3]=obj.matrix_world@Vector((c[0]+b[0],c[1]+a[1],c[2]+a[2]))
+ vs[4]=obj.matrix_world@Vector((c[0]+a[0],c[1]+a[1],c[2]+b[2]))
+ vs[5]=obj.matrix_world@Vector((c[0]+a[0],c[1]+b[1],c[2]+b[2]))
+ vs[6]=obj.matrix_world@Vector((c[0]+b[0],c[1]+b[1],c[2]+b[2]))
+ vs[7]=obj.matrix_world@Vector((c[0]+b[0],c[1]+a[1],c[2]+b[2]))
+
+ indices = [(0,1),(1,2),(2,3),(3,0),(4,5),(5,6),(6,7),(7,4),\
+ (0,4),(1,5),(2,6),(3,7)]
+
+ for l in indices:
+ v0 = vs[l[0]]
+ v1 = vs[l[1]]
+ verts += [(v0[0],v0[1],v0[2])]
+ verts += [(v1[0],v1[1],v1[2])]
+ colours += [(0.5,0.5,0.5,0.5),(0.5,0.5,0.5,0.5)]
+
+ center=obj.matrix_world@c
+
+ def _angle_lim( major, minor, amin, amax, colour ):
+ nonlocal verts, colours
+ f = 0.05
+ ay = major*f
+ ax = minor*f
+
+ for x in range(16):
+ t0 = x/16
+ t1 = (x+1)/16
+ a0 = amin*(1.0-t0)+amax*t0
+ a1 = amin*(1.0-t1)+amax*t1
+
+ p0 = c + major*f*math.cos(a0) + minor*f*math.sin(a0)
+ p1 = c + major*f*math.cos(a1) + minor*f*math.sin(a1)
+
+ p0=obj.matrix_world @ p0
+ p1=obj.matrix_world @ p1
+ verts += [p0,p1]
+ colours += [colour,colour]
+
+ if x == 0:
+ verts += [p0,c]
+ colours += [colour,colour]
+ if x == 15:
+ verts += [p1,c]
+ colours += [colour,colour]
+
+ verts += [c+major*1.2*f,c+major*f*0.8]
+ colours += [colour,colour]
+
+ if bone.cv_data.con0:
+ _angle_lim( Vector((0,1,0)),Vector((0,0,1)), \
+ bone.cv_data.mins[0], bone.cv_data.maxs[0], \
+ (1,0,0,1))
+ _angle_lim( Vector((0,0,1)),Vector((1,0,0)), \
+ bone.cv_data.mins[1], bone.cv_data.maxs[1], \
+ (0,1,0,1))
+ _angle_lim( Vector((1,0,0)),Vector((0,1,0)), \
+ bone.cv_data.mins[2], bone.cv_data.maxs[2], \
+ (0,0,1,1))
+
+
if obj.cv_data.classtype == 'k_classtype_gate':
+ if obj.type == 'MESH':
+ dims = obj.data.cv_data.v0
+ else:
+ dims = obj.cv_data.v0
+
+ vs = [None]*9
+ c = Vector((0,0,dims[2]))
+
+ vs[0] = obj.matrix_world @ Vector((-dims[0],0.0,-dims[1]+dims[2]))
+ vs[1] = obj.matrix_world @ Vector((-dims[0],0.0, dims[1]+dims[2]))
+ vs[2] = obj.matrix_world @ Vector(( dims[0],0.0, dims[1]+dims[2]))
+ vs[3] = obj.matrix_world @ Vector(( dims[0],0.0,-dims[1]+dims[2]))
+ vs[4] = obj.matrix_world @ (c+Vector((-1,0,-2)))
+ vs[5] = obj.matrix_world @ (c+Vector((-1,0, 2)))
+ vs[6] = obj.matrix_world @ (c+Vector(( 1,0, 2)))
+ vs[7] = obj.matrix_world @ (c+Vector((-1,0, 0)))
+ vs[8] = obj.matrix_world @ (c+Vector(( 1,0, 0)))
+
+ indices = [(0,1),(1,2),(2,3),(3,0),(4,5),(5,6),(7,8)]
+
+ for l in indices:
+ v0 = vs[l[0]]
+ v1 = vs[l[1]]
+ verts += [(v0[0],v0[1],v0[2])]
+ verts += [(v1[0],v1[1],v1[2])]
+ colours += [(1,1,0,1),(1,1,0,1)]
+
+ sw = (0.4,0.4,0.4,0.2)
+ if obj.cv_data.target != None:
+ drawbline( obj.location, obj.cv_data.target.location, sw,sw )
+
+ elif obj.cv_data.classtype == 'k_classtype_route_node':
+ sw = Vector((0.4,0.4,0.4,0.2))
+ sw2 = Vector((1.5,0.2,0.2,0.0))
if obj.cv_data.target != None:
- p0 = obj.location
- p1 = obj.cv_data.target.location
- verts += [(p0[0],p0[1],p0[2])]
- verts += [(p1[0],p1[1],p1[2])]
- colours += [(0,1,0,1.0),(1,0,0,1.0)]
+ drawbpath( obj, obj.cv_data.target, sw, sw )
+ if obj.cv_data.target1 != None:
+ drawbpath( obj, obj.cv_data.target1, sw, sw )
+
+ drawbhandle( obj, 1.0, (0.8,0.8,0.8,1.0) )
+ drawbhandle( obj, -1.0, (0.4,0.4,0.4,1.0) )
+
+ p1 = obj.location+ \
+ obj.matrix_world.to_quaternion() @ Vector((0,0,-6+1.5))
+ drawbline( obj.location, p1, sw,sw2 )
+
+
elif obj.cv_data.classtype == 'k_classtype_block':
a = obj.data.cv_data.v0
b = obj.data.cv_data.v1
verts += [(v1[0],v1[1],v1[2])]
colours += [(1,1,0,1),(1,1,0,1)]
+ elif obj.cv_data.classtype == 'k_classtype_capsule':
+ h = obj.data.cv_data.v0[0]
+ r = obj.data.cv_data.v0[1]
+
+ vs = [None]*10
+ vs[0] = obj.matrix_world @ Vector((0.0,0.0, h*0.5 ))
+ vs[1] = obj.matrix_world @ Vector((0.0,0.0,-h*0.5 ))
+ vs[2] = obj.matrix_world @ Vector(( r,0.0, h*0.5-r))
+ vs[3] = obj.matrix_world @ Vector(( -r,0.0, h*0.5-r))
+ vs[4] = obj.matrix_world @ Vector(( r,0.0,-h*0.5+r))
+ vs[5] = obj.matrix_world @ Vector(( -r,0.0,-h*0.5+r))
+ vs[6] = obj.matrix_world @ Vector((0.0, r , h*0.5-r))
+ vs[7] = obj.matrix_world @ Vector((0.0,-r , h*0.5-r))
+ vs[8] = obj.matrix_world @ Vector((0.0, r ,-h*0.5+r))
+ vs[9] = obj.matrix_world @ Vector((0.0,-r ,-h*0.5+r))
+
+ indices = [(0,1),(2,3),(4,5),(6,7),(8,9)]
+
+ for l in indices:
+ v0 = vs[l[0]]
+ v1 = vs[l[1]]
+ verts += [(v0[0],v0[1],v0[2])]
+ verts += [(v1[0],v1[1],v1[2])]
+ colours += [(0.5,1,0,1),(0.5,1,0,1)]
+
+ elif obj.cv_data.classtype == 'k_classtype_spawn':
+ vs = [None]*4
+ vs[0] = obj.matrix_world @ Vector((0,0,0))
+ vs[1] = obj.matrix_world @ Vector((0,2,0))
+ vs[2] = obj.matrix_world @ Vector((0.5,1,0))
+ vs[3] = obj.matrix_world @ Vector((-0.5,1,0))
+ indices = [(0,1),(1,2),(1,3)]
+ for l in indices:
+ v0 = vs[l[0]]
+ v1 = vs[l[1]]
+ verts += [(v0[0],v0[1],v0[2])]
+ verts += [(v1[0],v1[1],v1[2])]
+ colours += [(0,1,1,1),(0,1,1,1)]
+
+ elif obj.cv_data.classtype == 'k_classtype_route':
+ vs = [None]*2
+ vs[0] = obj.location
+ vs[1] = obj.cv_data.target.location
+ indices = [(0,1)]
+ for l in indices:
+ v0 = vs[l[0]]
+ v1 = vs[l[1]]
+ verts += [(v0[0],v0[1],v0[2])]
+ verts += [(v1[0],v1[1],v1[2])]
+ colours += [(0,1,1,1),(0,1,1,1)]
+
+ stack = [None]*64
+ stack_i = [0]*64
+ stack[0] = obj.cv_data.target
+ si = 1
+ loop_complete = False
+
+ while si > 0:
+ if stack_i[si-1] == 2:
+ si -= 1
+ continue
+
+ if si == 0: # Loop failed to complete
+ break
+
+ node = stack[si-1]
+
+ targets = [None,None]
+ targets[0] = node.cv_data.target
+
+ if node.cv_data.classtype == 'k_classtype_route_node':
+ targets[1] = node.cv_data.target1
+
+ nextnode = targets[stack_i[si-1]]
+ stack_i[si-1] += 1
+
+ if nextnode != None: # branch
+ if nextnode == stack[0]: # Loop completed
+ loop_complete = True
+ break
+
+ valid=True
+ for sj in range(si):
+ if stack[sj] == nextnode: # invalidated path
+ valid=False
+ break
+
+ if valid:
+ stack_i[si] = 0
+ stack[si] = nextnode
+ si += 1
+ continue
+
+ if loop_complete:
+ cc = Vector((obj.cv_data.colour[0],\
+ obj.cv_data.colour[1],\
+ obj.cv_data.colour[2],\
+ 1.0))
+
+ for sj in range(si):
+ sk = (sj+1)%si
+
+ if stack[sj].cv_data.classtype == 'k_classtype_gate' and \
+ stack[sk].cv_data.classtype == 'k_classtype_gate':
+ dist = (stack[sj].location-stack[sk].location).magnitude
+ drawsbpath( stack[sj], stack[sk], cc*0.4, cc, dist, dist )
+
+ else:
+ drawbpath( stack[sj], stack[sk], cc, cc )
+
+ course_count += 1
+
+ elif obj.cv_data.classtype == 'k_classtype_car_path':
+ v0 = obj.matrix_world.to_quaternion() @ Vector((0,1,0))
+ c0 = Vector((v0.x*0.5+0.5, v0.y*0.5+0.5, 0.0, 1.0))
+ drawbhandle( obj, 1.0, (0.9,0.9,0.9,1.0) )
+
+ if obj.cv_data.target != None:
+ v1 = obj.cv_data.target.matrix_world.to_quaternion()@Vector((0,1,0))
+ c1 = Vector((v1.x*0.5+0.5, v1.y*0.5+0.5, 0.0, 1.0))
+
+ drawbhandle( obj.cv_data.target, -1.0, (0.5,0.5,0.5,1.0) )
+ drawbpath( obj, obj.cv_data.target, c0, c1 )
+
+ if obj.cv_data.target1 != None:
+ v1 = obj.cv_data.target1.matrix_world.to_quaternion()@Vector((0,1,0))
+ c1 = Vector((v1.x*0.5+0.5, v1.y*0.5+0.5, 0.0, 1.0))
+
+ drawbhandle( obj.cv_data.target1, -1.0, (0.5,0.5,0.5,1.0) )
+ drawbpath( obj, obj.cv_data.target1, c0, c1 )
+
lines = batch_for_shader(\
cv_view_shader, 'LINES', \
{ "pos":verts, "color":colours })
target: bpy.props.PointerProperty( type=bpy.types.Object, name="target", \
poll=cv_poll_target )
+ target1: bpy.props.PointerProperty( type=bpy.types.Object, name="target1", \
+ poll=cv_poll_target )
+
+ colour: bpy.props.FloatVectorProperty(name="colour",subtype='COLOR',\
+ min=0.0,max=1.0)
classtype: bpy.props.EnumProperty(
name="Format",
('k_classtype_gate', "k_classtype_gate", "", 1),
('k_classtype_block', "k_classtype_block", "", 2),
('k_classtype_spawn', "k_classtype_spawn", "", 3),
- ('k_classtype_water', "k_classtype_water", "", 4)
+ ('k_classtype_water', "k_classtype_water", "", 4),
+ ('k_classtype_car_path', "k_classtype_car_path", "", 5),
+ ('k_classtype_INSTANCE', "","", 6 ),
+ ('k_classtype_capsule', "k_classtype_capsule", "", 7 ),
+ ('k_classtype_route_node', "k_classtype_route_node", "", 8 ),
+ ('k_classtype_route', "k_classtype_route", "", 9 ),
+ ('k_classtype_bone',"k_classtype_bone","",10),
+ ('k_classtype_SKELETON', "","", 11 ),
+ ('k_classtype_SKIN',"","",12)
])
+class CV_BONE_SETTINGS(bpy.types.PropertyGroup):
+ collider: bpy.props.BoolProperty(name="Collider",default=False)
+ v0: bpy.props.FloatVectorProperty(name="v0",size=3)
+ v1: bpy.props.FloatVectorProperty(name="v1",size=3)
+
+ con0: bpy.props.BoolProperty(name="Constriant 0",default=False)
+ mins: bpy.props.FloatVectorProperty(name="mins",size=3)
+ maxs: bpy.props.FloatVectorProperty(name="maxs",size=3)
+
+class CV_BONE_PANEL(bpy.types.Panel):
+ bl_label="Bone Config"
+ bl_idname="SCENE_PT_cv_bone"
+ bl_space_type='PROPERTIES'
+ bl_region_type='WINDOW'
+ bl_context='bone'
+
+ def draw(_,context):
+ active_object = context.active_object
+ if active_object == None: return
+
+ bone = active_object.data.bones.active
+ if bone == None: return
+
+ _.layout.prop( bone.cv_data, "collider" )
+ _.layout.prop( bone.cv_data, "v0" )
+ _.layout.prop( bone.cv_data, "v1" )
+
+ _.layout.label( text="Angle Limits" )
+ _.layout.prop( bone.cv_data, "con0" )
+ _.layout.prop( bone.cv_data, "mins" )
+ _.layout.prop( bone.cv_data, "maxs" )
+
+class CV_SCENE_SETTINGS(bpy.types.PropertyGroup):
+ use_hidden: bpy.props.BoolProperty( name="use hidden", default=False )
+
class CV_OBJ_PANEL(bpy.types.Panel):
bl_label="Entity Config"
bl_idname="SCENE_PT_cv_entity"
if active_object.cv_data.classtype == 'k_classtype_gate':
_.layout.prop( active_object.cv_data, "target" )
+
+ mesh = active_object.data
+ _.layout.label( text=F"(i) Data is stored in {mesh.name}" )
+ _.layout.prop( mesh.cv_data, "v0" )
+
+ elif active_object.cv_data.classtype == 'k_classtype_car_path' or \
+ active_object.cv_data.classtype == 'k_classtype_route_node':
+ _.layout.prop( active_object.cv_data, "target" )
+ _.layout.prop( active_object.cv_data, "target1" )
+
+ elif active_object.cv_data.classtype == 'k_classtype_route':
+ _.layout.prop( active_object.cv_data, "target" )
+ _.layout.prop( active_object.cv_data, "colour" )
+
elif active_object.cv_data.classtype == 'k_classtype_block':
mesh = active_object.data
_.layout.prop( mesh.cv_data, "v1" )
_.layout.prop( mesh.cv_data, "v2" )
_.layout.prop( mesh.cv_data, "v3" )
+ elif active_object.cv_data.classtype == 'k_classtype_capsule':
+ mesh = active_object.data
+ _.layout.label( text=F"(i) Data is stored in {mesh.name}" )
+ _.layout.prop( mesh.cv_data, "v0" )
class CV_INTERFACE(bpy.types.Panel):
bl_idname = "VIEW3D_PT_carve"
def draw(_, context):
layout = _.layout
+ layout.prop( context.scene.cv_data, "use_hidden")
layout.operator( "carve.compile_all" )
+def test_compile():
+ view_layer = bpy.context.view_layer
+ for col in view_layer.layer_collection.children["export"].children:
+ if not col.hide_viewport or bpy.context.scene.cv_data.use_hidden:
+ write_model( col.name )
+
class CV_COMPILE(bpy.types.Operator):
bl_idname="carve.compile_all"
bl_label="Compile All"
def execute(_,context):
- for col in bpy.data.collections["export"].children:
- write_model( col.name )
+ test_compile()
+ #cProfile.runctx("test_compile()",globals(),locals(),sort=1)
+ #for col in bpy.data.collections["export"].children:
+ # write_model( col.name )
return {'FINISHED'}
classes = [CV_OBJ_SETTINGS,CV_OBJ_PANEL,CV_COMPILE,CV_INTERFACE,\
- CV_MESH_SETTINGS]
+ CV_MESH_SETTINGS, CV_SCENE_SETTINGS, CV_BONE_SETTINGS,\
+ CV_BONE_PANEL]
def register():
global cv_view_draw_handler
bpy.types.Object.cv_data = bpy.props.PointerProperty(type=CV_OBJ_SETTINGS)
bpy.types.Mesh.cv_data = bpy.props.PointerProperty(type=CV_MESH_SETTINGS)
+ bpy.types.Scene.cv_data = bpy.props.PointerProperty(type=CV_SCENE_SETTINGS)
+ bpy.types.Bone.cv_data = bpy.props.PointerProperty(type=CV_BONE_SETTINGS)
cv_view_draw_handler = bpy.types.SpaceView3D.draw_handler_add(\
cv_draw,(),'WINDOW','POST_VIEW')
projects / carveJwlIkooP6JGAAIwe30JlM.git / blobdiff