-import bpy, math
+import bpy, math, gpu
+import cProfile
from ctypes import *
-
-class model(Structure):
+from mathutils import *
+from gpu_extras.batch import batch_for_shader
+
+bl_info = {
+ "name":"Carve exporter",
+ "author": "Harry Godden (hgn)",
+ "version": (0,1),
+ "blender":(3,1,0),
+ "location":"Export",
+ "descriptin":"",
+ "warning":"",
+ "wiki_url":"",
+ "category":"Import/Export",
+}
+
+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),
+ ("colour",c_float*4),
+ ("uv",c_float*2)]
-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 marker(Structure):
+class mdl_material(Structure):
+ _pack_ = 1
+ _fields_ = [("pstr_name",c_uint32)]
+
+class mdl_node(Structure):
_pack_ = 1
_fields_ = [("co",c_float*3),
( "q",c_float*4),
( "s",c_float*3),
- ("name",c_char*32)]
+ ("submesh_start",c_uint32),
+ ("submesh_count",c_uint32),
+ ("classtype",c_uint32),
+ ("offset",c_uint32),
+ ("pstr_name",c_uint32)]
-class model_vert(Structure):
+class mdl_header(Structure):
_pack_ = 1
- _fields_ = [("co",c_float*3),
- ("norm",c_float*3),
- ("colour",c_float*4),
- ("uv",c_float*2)]
+ _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),
+
+ ("strings_offset",c_uint32),
+ ("entdata_offset",c_uint32)
+ ]
+
+# Entity types
+# ==========================================
+
+class classtype_gate(Structure):
+ _pack_ = 1
+ _fields_ = [("target",c_uint32),
+ ("target1",c_uint32)]
+
+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)]
-def v4_dot( a, b ):
- return a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*a[3]
-
-def v4_length( a ):
- return math.sqrt( v4_dot(a,a) )
-
-def v2_eq( a, b ):
- if abs(a[0]-b[0]) < 0.0001:
- if abs(a[1]-b[1]) < 0.0001:
- return True
- return False
-
-def v3_eq( a, b ):
- if abs(a[0]-b[0]) < 0.0001:
- if abs(a[1]-b[1]) < 0.0001:
- if abs(a[2]-b[2]) < 0.0001:
- return True
- return False
-
-def v4_eq( a, b ):
- if abs(a[0]-b[0]) < 0.0001:
- if abs(a[1]-b[1]) < 0.0001:
- if abs(a[2]-b[2]) < 0.0001:
- if abs(a[3]-b[3]) < 0.0001:
- return True
- return False
-
-def m3x3_mul( a, b, d ):
- a00 = a[0][0]
- a01 = a[0][1]
- a02 = a[0][2]
- a10 = a[1][0]
- a11 = a[1][1]
- a12 = a[1][2]
- a20 = a[2][0]
- a21 = a[2][1]
- a22 = a[2][2]
- b00 = b[0][0]
- b01 = b[0][1]
- b02 = b[0][2]
- b10 = b[1][0]
- b11 = b[1][1]
- b12 = b[1][2]
- b20 = b[2][0]
- b21 = b[2][1]
- b22 = b[2][2]
- d[0][0] = a00*b00 + a10*b01 + a20*b02
- d[0][1] = a01*b00 + a11*b01 + a21*b02
- d[0][2] = a02*b00 + a12*b01 + a22*b02
- d[1][0] = a00*b10 + a10*b11 + a20*b12
- d[1][1] = a01*b10 + a11*b11 + a21*b12
- d[1][2] = a02*b10 + a12*b11 + a22*b12
- d[2][0] = a00*b20 + a10*b21 + a20*b22
- d[2][1] = a01*b20 + a11*b21 + a21*b22
- d[2][2] = a02*b20 + a12*b21 + a22*b22
-
-def q_m3x3( q, d ):
- l = v4_length(q)
- s = 2.0 if l > 0.0 else 0.0
- xx = s*q[0]*q[0]
- xy = s*q[0]*q[1]
- wx = s*q[3]*q[0]
- yy = s*q[1]*q[1]
- yz = s*q[1]*q[2]
- wy = s*q[3]*q[1]
- zz = s*q[2]*q[2]
- xz = s*q[0]*q[2]
- wz = s*q[3]*q[2]
- d[0][0] = 1.0 - yy - zz
- d[1][1] = 1.0 - xx - zz
- d[2][2] = 1.0 - xx - yy
- d[0][1] = xy + wz
- d[1][2] = yz + wx
- d[2][0] = xz + wy
- d[1][0] = xy - wz
- d[2][1] = yz - wx
- d[0][2] = xz - wy
-
-def m3x3_q( m, q ):
- diag = m[0][0] + m[1][1] + m[2][2]
- if diag >= 0.0:
- r = math.sqrt( 1.0 + diag )
- rinv = 0.5 / r
- q[0] = rinv * (m[1][2] - m[2][1])
- q[1] = rinv * (m[2][0] - m[0][2])
- q[2] = rinv * (m[0][1] - m[1][0])
- q[3] = r * 0.5
- elif m[0][0] >= m[1][1] and m[0][0] >= m[2][2]:
- r = math.sqrt( 1.0 - m[1][1] - m[2][2] + m[0][0] )
- rinv = 0.5 / r
- q[0] = r * 0.5
- q[1] = rinv * (m[0][1] + m[1][0])
- q[2] = rinv * (m[0][2] + m[2][0])
- q[3] = rinv * (m[1][2] - m[2][1])
- elif m[1][1] >= m[2][2]:
- r = math.sqrt( 1.0 - m[0][0] - m[2][2] + m[1][1] )
- rinv = 0.5 / r
- q[0] = rinv * (m[0][1] + m[1][0])
- q[1] = r * 0.5
- q[2] = rinv * (m[1][2] + m[2][1])
- q[3] = rinv * (m[2][0] - m[0][2])
- else:
- r = math.sqrt( 1.0 - m[0][0] - m[1][1] + m[2][2] )
- rinv = 0.5 / r
- q[0] = rinv * (m[0][2] + m[2][0])
- q[1] = rinv * (m[1][2] + m[2][1])
- q[2] = r * 0.5
- q[3] = rinv * (m[0][1] - m[1][0])
+# Exporter
+# ==============================================================================
def write_model(name):
- fp = open(F"/home/harry/Documents/carve/models/{name}.mdl", "wb")
+ print( F"Create mode {name}" )
+
collection = bpy.data.collections[name]
- header = model()
+ header = mdl_header()
header.identifier = 0xABCD0000
+ header.version = 0
header.vertex_count = 0
header.indice_count = 0
- header.layer_count = 0
+ header.submesh_count = 0
+ header.node_count = 0
+ header.material_count = 0
+ header.file_length = 0
+
+ mesh_cache = {}
+ string_cache = {}
+ material_cache = {}
- layers = []
- markers = []
+ strings_buffer = b''
+
+ material_buffer = []
+ submesh_buffer = []
vertex_buffer = []
indice_buffer = []
+ node_buffer = []
+ entdata_buffer = []
+ entdata_length = 0
+
+ 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.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
+ #
+ 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" )
+ header.node_count = 1
+ for obj in collection.all_objects:
+ obj.cv_data.uid = header.node_count
+ header.node_count += 1
+
+ print( " compiling data" )
+ for obj in collection.all_objects:
+ print( F" [{obj.cv_data.uid}/{header.node_count-1}] {obj.name}" )
+
+ 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 )
+
+ # Process entity data
+ #
+ node.offset = entdata_length
+ classtype = obj.cv_data.classtype
+
+ if classtype == 'k_classtype_none':
+ node.classtype = 0
+ node.offset = 0
+
+ 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
+
+ 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]
+
+ # Process meshes
+ #
+ node.submesh_start = header.submesh_count
+ node.submesh_count = 0
+
+ if obj.type == 'MESH':
+ default_mat = c_uint32(69)
+ default_mat.name = ""
+
+ if 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
- print( F"Create mode {name}" )
-
- 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')
-
- markers += [mk]
- header.marker_count += 1
-
- elif obj.type == 'MESH':
dgraph = bpy.context.evaluated_depsgraph_get()
data = obj.evaluated_get(dgraph).data
data.calc_loop_triangles()
data.calc_normals_split()
- for material_id, mat in enumerate(data.materials):
- sm = submodel()
+ mat_list = data.materials if len(data.materials) > 0 else [default_mat]
+ for material_id, mat in enumerate(mat_list):
+ mref = {}
+
+ sm = mdl_submesh()
sm.indice_start = header.indice_count
sm.vertex_start = header.vertex_count
sm.vertex_count = 0
sm.indice_count = 0
- 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]
+ 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
#
for j in range(3):
vert = data.vertices[tri.vertices[j]]
+ li = tri.loops[j]
co = vert.co
- norm = data.loops[tri.loops[j]].normal
+ norm = data.loops[li].normal
uv = (0,0)
+ colour = (1,1,1,1)
if data.uv_layers:
- uv = data.uv_layers.active.data[tri.loops[j]].uv
-
- 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))
+ uv = data.uv_layers.active.data[li].uv
+ if data.vertex_colors:
+ colour = data.vertex_colors.active.data[li].color
+
+ 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),\
+ int(colour[0]*m+0.5),\
+ int(colour[1]*m+0.5),\
+ int(colour[2]*m+0.5),\
+ int(colour[3]*m+0.5))
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]
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]
vertex_buffer += [v]
for i in range(3):
sm.indice_count += 1
- layers += [sm]
- header.layer_count += 1
+ if sm.vertex_count == 0:
+ for j in range(2):
+ for i in range(3):
+ sm.bbx[j][i] = 0
+
+ submesh_buffer += [sm]
+ node.submesh_count += 1
+ header.submesh_count += 1
header.vertex_count += sm.vertex_count
header.indice_count += sm.indice_count
+ mesh_cache[obj.data.name] = node
+ node_buffer += [node]
+
+ # Write data arrays
+ #
+ print( "Writing data" )
+ fpos = sizeof(header)
+
+ header.node_offset = fpos
+ fpos += sizeof(mdl_node)*header.node_count
+
+ header.submesh_offset = fpos
+ fpos += sizeof(mdl_submesh)*header.submesh_count
+
+ header.material_offset = fpos
+ fpos += sizeof(mdl_material)*header.material_count
+
+ header.entdata_offset = fpos
+ fpos += entdata_length
+
+ header.vertex_offset = fpos
+ fpos += sizeof(mdl_vert)*header.vertex_count
+
+ header.indice_offset = fpos
+ fpos += sizeof(c_uint32)*header.indice_count
+
+ header.strings_offset = fpos
+ fpos += len(strings_buffer)
+
+ header.file_length = fpos
+
+ fp = open(F"/home/harry/Documents/carve/models/{name}.mdl", "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 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) )
-
+ fp.write( strings_buffer )
fp.close()
-for col in bpy.data.collections["export"].children:
- write_model( col.name )
+ print( F"Completed {name}.mdl" )
+
+# Clicky clicky GUI
+# ------------------------------------------------------------------------------
+
+cv_view_draw_handler = None
+cv_view_shader = gpu.shader.from_builtin('3D_SMOOTH_COLOR')
+
+def cv_draw():
+ global cv_view_shader
+ cv_view_shader.bind()
+ 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('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
+
+ for obj in bpy.context.collection.objects:
+ if obj.cv_data.classtype == 'k_classtype_gate':
+ 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)]
+ 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_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_car_path':
+ p0 = obj.location
+ h0 = obj.matrix_world @ Vector((1,0,0))
+
+ v0 = obj.matrix_world.to_quaternion() @ Vector((1,0,0))
+ c0 = Vector((v0.x*0.5+0.5, v0.y*0.5+0.5, 0.0, 1.0))
+
+ if obj.cv_data.target != None:
+ p1 = obj.cv_data.target.location
+ h1 = obj.cv_data.target.matrix_world @ Vector((-1,0,0))
+
+ v1 = obj.cv_data.target.matrix_world.to_quaternion()@Vector((1,0,0))
+ c1 = Vector((v1.x*0.5+0.5, v1.y*0.5+0.5, 0.0, 1.0))
+
+ drawbezier( p0, h0, p1, h1, c0, c1 )
+
+ if obj.cv_data.target1 != None:
+ p1 = obj.cv_data.target1.location
+ h1 = obj.cv_data.target1.matrix_world @ Vector((-1,0,0))
+
+ v1 = obj.cv_data.target1.matrix_world.to_quaternion()@Vector((1,0,0))
+ c1 = Vector((v1.x*0.5+0.5, v1.y*0.5+0.5, 0.0, 1.0))
+
+ drawbezier( p0, h0, p1, h1, c0, c1 )
+
+ lines = batch_for_shader(\
+ cv_view_shader, 'LINES', \
+ { "pos":verts, "color":colours })
+
+ lines.draw( cv_view_shader )
+
+def cv_poll_target(scene, obj):
+ if obj == bpy.context.active_object:
+ return False
+ if obj.cv_data.classtype == 'k_classtype_none':
+ 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="" )
+
+ 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 )
+
+ 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)
+ ])
+
+class CV_OBJ_PANEL(bpy.types.Panel):
+ bl_label="Entity Config"
+ bl_idname="SCENE_PT_cv_entity"
+ bl_space_type='PROPERTIES'
+ bl_region_type='WINDOW'
+ bl_context="object"
+
+ def draw(_,context):
+ active_object = bpy.context.active_object
+ if active_object == None: return
+ _.layout.prop( active_object.cv_data, "classtype" )
+
+ if active_object.cv_data.classtype == 'k_classtype_gate':
+ _.layout.prop( active_object.cv_data, "target" )
+ elif active_object.cv_data.classtype == 'k_classtype_car_path':
+ _.layout.prop( active_object.cv_data, "target" )
+ _.layout.prop( active_object.cv_data, "target1" )
+ 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" )
+
+class CV_INTERFACE(bpy.types.Panel):
+ bl_idname = "VIEW3D_PT_carve"
+ bl_label = "Carve"
+ bl_space_type = 'VIEW_3D'
+ bl_region_type = 'UI'
+ bl_category = "Carve"
+
+ def draw(_, context):
+ layout = _.layout
+ layout.operator( "carve.compile_all" )
+
+def test_compile():
+ for col in bpy.data.collections["export"].children:
+ write_model( col.name )
+
+class CV_COMPILE(bpy.types.Operator):
+ bl_idname="carve.compile_all"
+ bl_label="Compile All"
+
+ def execute(_,context):
+ 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]
+
+def register():
+ global cv_view_draw_handler
+
+ for c in classes:
+ 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)
+
+ cv_view_draw_handler = bpy.types.SpaceView3D.draw_handler_add(\
+ cv_draw,(),'WINDOW','POST_VIEW')
+
+def unregister():
+ global cv_view_draw_handler
+
+ for c in classes:
+ bpy.utils.unregister_class(c)
+
+ bpy.types.SpaceView3D.draw_handler_remove(cv_view_draw_handler,'WINDOW')
projects / carveJwlIkooP6JGAAIwe30JlM.git / blobdiff