X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=blender_export.py;h=c069d7f925fa5412562eadee4e9bc5e27dd1e38e;hb=bceb3a28f8127fa27a17f480bd21fa20a340e848;hp=a13e84eb4a95b926018528902d7b26c9aee250b2;hpb=cb16ccb05a796178c879ea8d5091663d215a5217;p=carveJwlIkooP6JGAAIwe30JlM.git diff --git a/blender_export.py b/blender_export.py index a13e84e..c069d7f 100644 --- a/blender_export.py +++ b/blender_export.py @@ -1,5 +1,11 @@ +# +# Copyright (C) 2021-2022 Mt.ZERO Software, Harry Godden - All Rights Reserved +# + import bpy, math, gpu +import cProfile from ctypes import * +from mathutils import * from gpu_extras.batch import batch_for_shader bl_info = { @@ -14,168 +20,427 @@ bl_info = { "category":"Import/Export", } -class model(Structure): +class mdl_vert(Structure): _pack_ = 1 - _fields_ = [("identifier",c_uint32), - ("vertex_count",c_uint32), - ("indice_count",c_uint32), - ("layer_count",c_uint32), - ("marker_count",c_uint32)] + _fields_ = [("co",c_float*3), + ("norm",c_float*3), + ("uv",c_float*2), + ("colour",c_uint8*4), + ("weights",c_uint16*4), + ("groups",c_uint8*4)] -class submodel(Structure): +class mdl_submesh(Structure): _pack_ = 1 _fields_ = [("indice_start",c_uint32), ("indice_count",c_uint32), ("vertex_start",c_uint32), ("vertex_count",c_uint32), ("bbx",(c_float*3)*2), - ("pivot",c_float*3), - ("q",c_float*4), - ("name",c_char*32), - ("material",c_char*32)] + ("material_id",c_uint32)] # index into the material array -class classtype_gate(Structure): +class mdl_material(Structure): _pack_ = 1 - _fields_ = [("target",c_uint32)] + _fields_ = [("pstr_name",c_uint32)] -class marker(Structure): +class mdl_node(Structure): _pack_ = 1 _fields_ = [("co",c_float*3), ( "q",c_float*4), ( "s",c_float*3), + ("submesh_start",c_uint32), + ("submesh_count",c_uint32), ("classtype",c_uint32), ("offset",c_uint32), - ("name",c_char*32)] + ("parent",c_uint32), + ("pstr_name",c_uint32)] + +class mdl_header(Structure): + _pack_ = 1 + _fields_ = [("identifier",c_uint32), + ("version",c_uint32), + ("file_length",c_uint32), + ("vertex_count",c_uint32), + ("vertex_offset",c_uint32), + + ("indice_count",c_uint32), + ("indice_offset",c_uint32), + + ("submesh_count",c_uint32), + ("submesh_offset",c_uint32), + + ("material_count",c_uint32), + ("material_offset",c_uint32), + + ("node_count",c_uint32), + ("node_offset",c_uint32), -class model_vert(Structure): + ("anim_count",c_uint32), + ("anim_offset",c_uint32), + + ("strings_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), - ("norm",c_float*3), - ("colour",c_float*4), - ("uv",c_float*2)] - -def submesh_set_transform( sm, obj ): - sm.pivot[0] = obj.matrix_world.translation[0] - sm.pivot[1] = obj.matrix_world.translation[2] - sm.pivot[2] = -obj.matrix_world.translation[1] - - quat = obj.matrix_world.to_quaternion() - sm.q[0] = quat[1] - sm.q[1] = quat[3] - sm.q[2] = -quat[2] - sm.q[3] = quat[0] - -def write_model(name): - fp = open(F"/home/harry/Documents/carve/models/{name}.mdl", "wb") - collection = bpy.data.collections[name] - - header = model() + ("q",c_float*4), + ("s",c_float*3)] + +# Entity types +# ========================================== + +class classtype_gate(Structure): + _pack_ = 1 + _fields_ = [("target",c_uint32), + ("dims",c_float*3)] + +class classtype_block(Structure): + _pack_ = 1 + _fields_ = [("bbx",(c_float*3)*2)] + +class classtype_spawn(Structure): + _pack_ = 1 + _fields_ = [("temp",c_uint32)] + +class classtype_water(Structure): + _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_ = [("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)] + +class classtype_achievement_box(Structure): + _pack_ = 1 + _fields_ = [("pstr_name",c_uint32), + ("trigger",c_uint32)] + +class classtype_audio(Structure): + _pack_ = 1 + _fields_ = [("pstr_file",c_uint32), + ("flags",c_uint32), + ("volume",c_float)] + +# Exporter +# ============================================================================== + +def write_model(collection_name): + print( F"Model graph | Create mode '{collection_name}'" ) + + header = mdl_header() header.identifier = 0xABCD0000 + header.version = 0 header.vertex_count = 0 header.indice_count = 0 - header.layer_count = 0 - header.marker_count = 1 + header.submesh_count = 0 + header.node_count = 0 + header.material_count = 0 + header.file_length = 0 mesh_cache = {} - layers = [] + string_cache = {} + material_cache = {} + + strings_buffer = b'' + + material_buffer = [] + submesh_buffer = [] vertex_buffer = [] indice_buffer = [] - - print( F"Create mode {name}" ) - - rootmarker = marker() - rootmarker.co[0] = 0 - rootmarker.co[1] = 0 - rootmarker.co[2] = 0 - rootmarker.q[0] = 0 - rootmarker.q[1] = 0 - rootmarker.q[2] = 0 - rootmarker.q[3] = 1 - rootmarker.s[0] = 1 - rootmarker.s[1] = 1 - rootmarker.s[2] = 1 - rootmarker.name = "".encode('utf-8') - rootmarker.offset = 0 - rootmarker.classtype = 0 - - markers = [ rootmarker ] # aka entities - entdata_structs = [] - entdata_offset = 0 - - entity_count = 1 - - for obj in collection.objects: - if obj.type == 'EMPTY': - obj.cv_data.uid = entity_count - entity_count += 1 - - for obj in collection.objects: - if obj.type == 'EMPTY': - mk = marker() - mk.co[0] = obj.location[0] - mk.co[1] = obj.location[2] - mk.co[2] = -obj.location[1] - - # Convert rotation quat to our space type - quat = obj.matrix_world.to_quaternion() - mk.q[0] = quat[1] - mk.q[1] = quat[3] - mk.q[2] = -quat[2] - mk.q[3] = quat[0] - - mk.s[0] = obj.scale[0] - mk.s[1] = obj.scale[2] - mk.s[2] = obj.scale[1] - mk.name = obj.name.encode('utf-8') - mk.offset = entdata_offset - + node_buffer = [] + entdata_buffer = [] + entdata_length = 0 + + anim_buffer = [] + animdata_length = 0 + animdata_buffer = [] + + def emplace_string( s ): + nonlocal string_cache, strings_buffer + + if s in string_cache: + return string_cache[s] + + string_cache[s] = len( strings_buffer ) + strings_buffer += (s+'\0').encode('utf-8') + return string_cache[s] + + 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] + + material_cache[mat.name] = header.material_count + dest = mdl_material() + dest.pstr_name = emplace_string( mat.name ) + material_buffer += [dest] + + header.material_count += 1 + 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 = "" + emplace_material( none_material ) + + root = mdl_node() + root.co[0] = 0 + root.co[1] = 0 + root.co[2] = 0 + root.q[0] = 0 + root.q[1] = 0 + root.q[2] = 0 + root.q[3] = 1 + root.s[0] = 1 + root.s[1] = 1 + root.s[2] = 1 + root.pstr_name = emplace_string('') + root.submesh_start = 0 + root.submesh_count = 0 + root.offset = 0 + root.classtype = 0 + node_buffer += [root] + + # Do exporting + # + print( " assigning ids" ) + 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 + + for obj in collection.all_objects: + if not obj.parent: + + 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 + + if n.type == 'ARMATURE': + tree["bones"] = [None] # None is the root transform + tree["ik_count"] = 0 + tree["collider_count"] = 0 + + def _extendb( p, n, d ): + nonlocal tree + + btree = {} + btree["bone"] = n + btree["uid"] = _uid() + btree["children"] = [] + btree["depth"] = d + btree["parent"] = p + tree["bones"] += [n.name] + + for c in n.children: + _extendb( btree, c, d+1 ) + + 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 + + if n.cv_data.collider: + tree['collider_count'] += 1 + + btree['deform'] = n.use_deform + p['children'] += [btree] + + for b in n.data.bones: + if not b.parent: + _extendb( tree, b, d+1 ) + + for obj1 in n.children: + nonlocal collection + for c1 in obj1.users_collection: + if c1 == collection: + _extend( tree, obj1, d+1 ) + break + + p["children"] += [tree] + graph_lookup[n] = tree + + _extend( graph, obj, 1 ) + + + 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 + compile_mesh = False - if classtype == 'k_classtype_gate': - mk.classtype = 1 - entdata_offset += sizeof( classtype_gate ) - - gate = classtype_gate() - gate.target = 0 - if obj.cv_data.target != None: - gate.target = obj.cv_data.target.cv_data.uid - - entdata_structs += [gate] - - elif classtype == 'k_thingummybob': - pass - - markers += [mk] - header.marker_count += 1 + if compile_mesh: + node.submesh_start = header.submesh_count + node.submesh_count = 0 - elif obj.type == 'MESH': default_mat = c_uint32(69) default_mat.name = "" - if obj.data.name in mesh_cache: - ref = mesh_cache[obj.data.name] - for material_id, mref in enumerate(ref['sm']): - print(F" Link submesh({ref['users']}) '{obj.name}:{mat.name}'") - - sm = submodel() - sm.indice_start = mref['indice_start'] - sm.indice_count = mref['indice_count'] - sm.vertex_start = mref['vertex_start'] - sm.vertex_count = mref['vertex_count'] - sm.name = obj.name.encode('utf-8') - sm.material = mref['material'] - sm.bbx = mref['bbx'] - submesh_set_transform( sm, obj ) - layers += [sm] - header.layer_count += 1 - - ref['users'] += 1 - continue - - ref = mesh_cache[obj.data.name] = {} - ref['users'] = 0 - ref['sm'] = [] - dgraph = bpy.context.evaluated_depsgraph_get() data = obj.evaluated_get(dgraph).data data.calc_loop_triangles() @@ -185,24 +450,18 @@ def write_model(name): for material_id, mat in enumerate(mat_list): mref = {} - sm = submodel() + sm = mdl_submesh() sm.indice_start = header.indice_count sm.vertex_start = header.vertex_count sm.vertex_count = 0 sm.indice_count = 0 - submesh_set_transform( sm, obj ) + sm.material_id = emplace_material( mat ) for i in range(3): sm.bbx[0][i] = 999999 sm.bbx[1][i] = -999999 - - sm.name = obj.name.encode('utf-8') - sm.material = mat.name.encode('utf-8') - print( F" Creating submesh '{obj.name}:{mat.name}'" ) + boffa = {} - - hit_count = 0 - miss_count = 0 # Write the vertex / indice data # @@ -212,30 +471,87 @@ def write_model(name): 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[tri.loops[j]].normal + norm = data.loops[li].normal uv = (0,0) - if data.uv_layers: - uv = data.uv_layers.active.data[tri.loops[j]].uv + colour = (255,255,255,255) + groups = [0,0,0,0] + weights = [0,0,0,0] - 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)) + if data.uv_layers: + uv = data.uv_layers.active.data[li].uv + + if data.vertex_colors: + colour = data.vertex_colors.active.data[li].color + 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]] - hit_count += 1 else: - miss_count += 1 index = c_uint32(sm.vertex_count) sm.vertex_count += 1 boffa[key] = index - indice_buffer += [index] - v = model_vert() + v = mdl_vert() v.co[0] = co[0] v.co[1] = co[2] v.co[2] = -co[1] @@ -244,10 +560,19 @@ def write_model(name): v.norm[2] = -norm[1] v.uv[0] = uv[0] v.uv[1] = uv[1] - v.colour[0] = 1.0 - v.colour[1] = 1.0 - v.colour[2] = 1.0 - v.colour[3] = 1.0 + v.colour[0] = colour[0] + 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): @@ -261,35 +586,405 @@ def write_model(name): for i in range(3): sm.bbx[j][i] = 0 - layers += [sm] - header.layer_count += 1 + submesh_buffer += [sm] + node.submesh_count += 1 + header.submesh_count += 1 header.vertex_count += sm.vertex_count header.indice_count += sm.indice_count - mref['indice_start'] = sm.indice_start - mref['indice_count'] = sm.indice_count - mref['vertex_start'] = sm.vertex_start - mref['vertex_count'] = sm.vertex_count - mref['bbx'] = sm.bbx - print( F"{sm.bbx[0][0]},{sm.bbx[0][1]},{sm.bbx[0][2]}" ) + 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 ) - mref['material'] = sm.material - ref['sm'] += [mref] + 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_achievement_box': + node.classtype = 13 + + entdata_length += sizeof( classtype_achievement_box ) + ach = classtype_achievement_box() + ach.pstr_name = emplace_string( obj.cv_data.strp ) + ach.trigger = 0 + + if obj.cv_data.target != None: + ach.trigger = obj.cv_data.target.cv_data.uid + + entdata_buffer += [ach] + + elif classtype == 'k_classtype_audio': + node.classtype = 14 + + entdata_length += sizeof( classtype_audio ) + aud = classtype_audio() + aud.pstr_file = emplace_string( obj.cv_data.strp ) + aud.flags = obj.cv_data.intp + aud.volume = obj.cv_data.fltp + + entdata_buffer += [aud] + + 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.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 + + path = F"/home/harry/Documents/carve/models_src/{collection_name}.mdl" + fp = open( path, "wb" ) + fp.write( bytearray( header ) ) - for l in layers: - fp.write( bytearray(l) ) - for m in markers: - fp.write( bytearray(m) ) + + for node in node_buffer: + fp.write( bytearray(node) ) + for sm in submesh_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 ed in entdata_structs: - fp.write( bytearray(ed) ) + for kf in animdata_buffer: + fp.write( bytearray(kf) ) + fp.write( strings_buffer ) fp.close() + print( F"Completed {collection_name}.mdl" ) + # Clicky clicky GUI # ------------------------------------------------------------------------------ @@ -302,20 +997,390 @@ def cv_draw(): 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 = [] - for obj in bpy.context.collection.all_objects: + #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: + 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_achievement_box': + a = Vector((-1,-1,-1)) + b = Vector((1,1,1)) + + vs = [None]*8 + vs[0] = obj.matrix_world @ Vector((a[0], a[1], a[2])) + vs[1] = obj.matrix_world @ Vector((a[0], b[1], a[2])) + vs[2] = obj.matrix_world @ Vector((b[0], b[1], a[2])) + vs[3] = obj.matrix_world @ Vector((b[0], a[1], a[2])) + vs[4] = obj.matrix_world @ Vector((a[0], a[1], b[2])) + vs[5] = obj.matrix_world @ Vector((a[0], b[1], b[2])) + vs[6] = obj.matrix_world @ Vector((b[0], b[1], b[2])) + vs[7] = obj.matrix_world @ Vector((b[0], a[1], 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,1,0,1),(0,1,0,1)] + + if obj.cv_data.target != None: + 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)] + + + elif obj.cv_data.classtype == 'k_classtype_block': + a = obj.data.cv_data.v0 + b = obj.data.cv_data.v1 + + vs = [None]*8 + vs[0] = obj.matrix_world @ Vector((a[0], a[1], a[2])) + vs[1] = obj.matrix_world @ Vector((a[0], b[1], a[2])) + vs[2] = obj.matrix_world @ Vector((b[0], b[1], a[2])) + vs[3] = obj.matrix_world @ Vector((b[0], a[1], a[2])) + vs[4] = obj.matrix_world @ Vector((a[0], a[1], b[2])) + vs[5] = obj.matrix_world @ Vector((a[0], b[1], b[2])) + vs[6] = obj.matrix_world @ Vector((b[0], b[1], b[2])) + vs[7] = obj.matrix_world @ Vector((b[0], a[1], 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 += [(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: - 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)] + 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', \ @@ -330,19 +1395,82 @@ def cv_poll_target(scene, obj): return False return True +class CV_MESH_SETTINGS(bpy.types.PropertyGroup): + v0: bpy.props.FloatVectorProperty(name="v0",size=3) + v1: bpy.props.FloatVectorProperty(name="v1",size=3) + v2: bpy.props.FloatVectorProperty(name="v2",size=3) + v3: bpy.props.FloatVectorProperty(name="v3",size=3) + class CV_OBJ_SETTINGS(bpy.types.PropertyGroup): uid: bpy.props.IntProperty( name="" ) + strp: bpy.props.StringProperty( name="strp" ) + intp: bpy.props.IntProperty( name="intp" ) + fltp: bpy.props.FloatProperty( name="fltp" ) + 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", items = [ ('k_classtype_none', "k_classtype_none", "", 0), ('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_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), + ('k_classtype_achievement_box',"k_classtype_achievement_box","",13), + ('k_classtype_audio',"k_classtype_audio","",14), ]) +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" @@ -354,7 +1482,42 @@ class CV_OBJ_PANEL(bpy.types.Panel): active_object = bpy.context.active_object if active_object == None: return _.layout.prop( active_object.cv_data, "classtype" ) - _.layout.prop( active_object.cv_data, "target" ) + + 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.label( text=F"(i) Data is stored in {mesh.name}" ) + _.layout.prop( mesh.cv_data, "v0" ) + _.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" ) + elif active_object.cv_data.classtype == 'k_classtype_achievement_box': + _.layout.prop( active_object.cv_data, "strp" ) + _.layout.prop( active_object.cv_data, "target" ) + elif active_object.cv_data.classtype == 'k_classtype_audio': + _.layout.prop( active_object.cv_data, "strp" ) + _.layout.prop( active_object.cv_data, "intp" ) + _.layout.prop( active_object.cv_data, "fltp" ) class CV_INTERFACE(bpy.types.Panel): bl_idname = "VIEW3D_PT_carve" @@ -365,19 +1528,30 @@ class CV_INTERFACE(bpy.types.Panel): 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] +classes = [CV_OBJ_SETTINGS,CV_OBJ_PANEL,CV_COMPILE,CV_INTERFACE,\ + CV_MESH_SETTINGS, CV_SCENE_SETTINGS, CV_BONE_SETTINGS,\ + CV_BONE_PANEL] def register(): global cv_view_draw_handler @@ -386,6 +1560,10 @@ def register(): bpy.utils.register_class(c) 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')