Wrong uncompressed formats... oops
[convexer.git] / __init__.py
1 # Copyright (C) 2022 Harry Godden (hgn)
2
3 bl_info = {
4 "name":"Convexer",
5 "author": "Harry Godden (hgn)",
6 "version": (0,1),
7 "blender":(3,1,0),
8 "location":"Export",
9 "descriptin":"",
10 "warning":"",
11 "wiki_url":"",
12 "category":"Import/Export",
13 }
14
15 print( "Convexer reload" )
16
17 #from mathutils import *
18 import bpy, gpu, math, os, time, mathutils, blf, subprocess, shutil, hashlib
19 from ctypes import *
20 from gpu_extras.batch import batch_for_shader
21 from bpy.app.handlers import persistent
22
23 # GPU and viewport drawing
24 # ------------------------------------------------------------------------------
25
26 # Handlers
27 cxr_view_draw_handler = None
28 cxr_ui_draw_handler = None
29
30 # Batches
31 cxr_view_lines = None
32 cxr_view_mesh = None
33 cxr_jobs_batch = None
34 cxr_jobs_inf = []
35
36 # Shaders
37 cxr_view_shader = gpu.shader.from_builtin('3D_SMOOTH_COLOR')
38 cxr_ui_shader = gpu.types.GPUShader("""
39 uniform mat4 ModelViewProjectionMatrix;
40 uniform float scale;
41
42 in vec2 aPos;
43 in vec4 aColour;
44
45 out vec4 colour;
46
47 void main()
48 {
49 gl_Position = ModelViewProjectionMatrix * vec4(aPos.x*scale,aPos.y, 0.0, 1.0);
50 colour = aColour;
51 }
52 ""","""
53 in vec4 colour;
54 out vec4 FragColor;
55
56 void main()
57 {
58 FragColor = colour;
59 }
60 """)
61
62 # Render functions
63 #
64 def cxr_ui(_,context):
65 global cxr_jobs_batch, cxr_ui_shader, cxr_jobs_inf
66
67 w = gpu.state.viewport_get()[2]
68 cxr_ui_shader.bind()
69 cxr_ui_shader.uniform_float( "scale", w )
70
71 if cxr_jobs_batch != None:
72 gpu.state.blend_set('ALPHA')
73 cxr_jobs_batch.draw(cxr_ui_shader)
74
75 blf.position(0,2,50,0)
76 blf.size(0,50,48)
77 blf.color(0,1.0,1.0,1.0,1.0)
78 blf.draw(0,"Compiling")
79
80 for ji in cxr_jobs_inf:
81 blf.position(0,ji[0]*w,35,0)
82 blf.size(0,50,20)
83 blf.draw(0,ji[1])
84
85 py = 80
86 blf.size(0,50,16)
87 for ln in reversed(CXR_COMPILER_CHAIN.LOG[-25:]):
88 blf.position(0,2,py,0)
89 blf.draw(0,ln[:-1])
90 py += 16
91
92 #if CXR_PREVIEW_OPERATOR.LASTERR != None:
93 # blf.position(0,2,80,0)
94 # blf.size(0,50,48)
95 # blf.color(0,1.0,0.2,0.2,0.9)
96 # blf.draw(0,"Invalid geometry")
97
98 # Something is off with TIMER,
99 # this forces the viewport to redraw before we can continue with our
100 # compilation stuff.
101
102 CXR_COMPILER_CHAIN.WAIT_REDRAW = False
103
104 def cxr_draw():
105 global cxr_view_shader, cxr_view_mesh, cxr_view_lines
106
107 cxr_view_shader.bind()
108
109 gpu.state.depth_mask_set(False)
110 gpu.state.line_width_set(1.5)
111 gpu.state.face_culling_set('BACK')
112 gpu.state.depth_test_set('NONE')
113 gpu.state.blend_set('ALPHA')
114
115 if cxr_view_lines != None:
116 cxr_view_lines.draw( cxr_view_shader )
117
118 gpu.state.depth_test_set('LESS_EQUAL')
119 gpu.state.blend_set('ADDITIVE')
120 if cxr_view_mesh != None:
121 cxr_view_mesh.draw( cxr_view_shader )
122
123 def cxr_jobs_update_graph(jobs):
124 global cxr_jobs_batch, cxr_ui_shader, cxr_jobs_inf
125
126 cxr_jobs_inf = []
127
128 total_width = 0
129 verts = []
130 colours = []
131 indices = []
132
133 for sys in jobs:
134 total_width += sys['w']
135
136 sf = 1.0/total_width
137 cur = 0.0
138 ci = 0
139
140 for sys in jobs:
141 w = sys['w']
142 h = 30.0
143 colour = sys['colour']
144 colourwait = (colour[0],colour[1],colour[2],0.4)
145 colourrun = (colour[0]*1.5,colour[1]*1.5,colour[2]*1.5,0.5)
146 colourdone = (colour[0],colour[1],colour[2],1.0)
147
148 jobs = sys['jobs']
149 sfsub = (1.0/(len(jobs)))*w
150 i = 0
151
152 for j in jobs:
153 if j == None: colour = colourdone
154 else: colour = colourwait
155
156 px = (cur + (i)*sfsub) * sf
157 px1 = (cur + (i+1.0)*sfsub) * sf
158 i += 1
159
160 verts += [(px,0), (px, h), (px1, 0.0), (px1,h)]
161 colours += [colour,colour,colour,colour]
162 indices += [(ci+0,ci+2,ci+3),(ci+0,ci+3,ci+1)]
163 ci += 4
164
165 cxr_jobs_inf += [((sf*cur), sys['title'])]
166 cur += w
167
168 cxr_jobs_batch = batch_for_shader(
169 cxr_ui_shader, 'TRIS',
170 { "aPos": verts, "aColour": colours },
171 indices = indices
172 )
173
174 # view_layer.update() doesnt seem to work,
175 # tag_redraw() seems to have broken
176 # therefore, change a property
177 def scene_redraw():
178 ob = bpy.context.scene.objects[0]
179 ob.hide_render = ob.hide_render
180
181 # the 'real' way to refresh the scene
182 for area in bpy.context.window.screen.areas:
183 if area.type == 'view_3d':
184 area.tag_redraw()
185
186 # Shared libraries
187 # ------------------------------------------------------------------------------
188
189 # dlclose for reloading modules manually
190 libc_dlclose = None
191 libc_dlclose = cdll.LoadLibrary(None).dlclose
192 libc_dlclose.argtypes = [c_void_p]
193
194 # wrapper for ctypes binding
195 class extern():
196 def __init__(_,name,argtypes,restype):
197 _.name = name
198 _.argtypes = argtypes
199 _.restype = restype
200 _.call = None
201
202 def loadfrom(_,so):
203 _.call = getattr(so,_.name)
204 _.call.argtypes = _.argtypes
205
206 if _.restype != None:
207 _.call.restype = _.restype
208
209 # libcxr (convexer)
210 # ------------------------------------------------------------------------------
211
212 libcxr = None
213
214 # Structure definitions
215 #
216 class cxr_edge(Structure):
217 _fields_ = [("i0",c_int32),
218 ("i1",c_int32),
219 ("freestyle",c_int32)]
220
221 class cxr_static_loop(Structure):
222 _fields_ = [("index",c_int32),
223 ("edge_index",c_int32),
224 ("uv",c_double * 2)]
225
226 class cxr_polygon(Structure):
227 _fields_ = [("loop_start",c_int32),
228 ("loop_total",c_int32),
229 ("normal",c_double * 3),
230 ("center",c_double * 3),
231 ("material_id",c_int32)]
232
233 class cxr_material(Structure):
234 _fields_ = [("res",c_int32 * 2),
235 ("name",c_char_p)]
236
237 class cxr_static_mesh(Structure):
238 _fields_ = [("vertices",POINTER(c_double * 3)),
239 ("edges",POINTER(cxr_edge)),
240 ("loops",POINTER(cxr_static_loop)),
241 ("polys",POINTER(cxr_polygon)),
242 ("materials",POINTER(cxr_material)),
243
244 ("poly_count",c_int32),
245 ("vertex_count",c_int32),
246 ("edge_count",c_int32),
247 ("loop_count",c_int32),
248 ("material_count",c_int32)]
249
250 class cxr_tri_mesh(Structure):
251 _fields_ = [("vertices",POINTER(c_double *3)),
252 ("colours",POINTER(c_double *4)),
253 ("indices",POINTER(c_int32)),
254 ("indices_count",c_int32),
255 ("vertex_count",c_int32)]
256
257 class cxr_vmf_context(Structure):
258 _fields_ = [("mapversion",c_int32),
259 ("skyname",c_char_p),
260 ("detailvbsp",c_char_p),
261 ("detailmaterial",c_char_p),
262 ("scale",c_double),
263 ("offset",c_double *3),
264 ("lightmap_scale",c_int32),
265 ("brush_count",c_int32),
266 ("entity_count",c_int32),
267 ("face_count",c_int32)]
268
269 # Convert blenders mesh format into CXR's static format (they are very similar)
270 #
271 def mesh_cxr_format(obj):
272 orig_state = None
273
274 if bpy.context.active_object != None:
275 orig_state = obj.mode
276 if orig_state != 'OBJECT':
277 bpy.ops.object.mode_set(mode='OBJECT')
278
279 dgraph = bpy.context.evaluated_depsgraph_get()
280 data = obj.evaluated_get(dgraph).data
281
282 _,mtx_rot,_ = obj.matrix_world.decompose()
283
284 mesh = cxr_static_mesh()
285
286 vertex_data = ((c_double*3)*len(data.vertices))()
287 for i, vert in enumerate(data.vertices):
288 v = obj.matrix_world @ vert.co
289 vertex_data[i][0] = c_double(v[0])
290 vertex_data[i][1] = c_double(v[1])
291 vertex_data[i][2] = c_double(v[2])
292
293 loop_data = (cxr_static_loop*len(data.loops))()
294 polygon_data = (cxr_polygon*len(data.polygons))()
295
296 for i, poly in enumerate(data.polygons):
297 loop_start = poly.loop_start
298 loop_end = poly.loop_start + poly.loop_total
299 for loop_index in range(loop_start, loop_end):
300 loop = data.loops[loop_index]
301 loop_data[loop_index].index = loop.vertex_index
302 loop_data[loop_index].edge_index = loop.edge_index
303
304 if data.uv_layers:
305 uv = data.uv_layers.active.data[loop_index].uv
306 loop_data[loop_index].uv[0] = c_double(uv[0])
307 loop_data[loop_index].uv[1] = c_double(uv[1])
308 else:
309 loop_data[loop_index].uv[0] = c_double(0.0)
310 loop_data[loop_index].uv[1] = c_double(0.0)
311 center = obj.matrix_world @ poly.center
312 normal = mtx_rot @ poly.normal
313
314 polygon_data[i].loop_start = poly.loop_start
315 polygon_data[i].loop_total = poly.loop_total
316 polygon_data[i].normal[0] = normal[0]
317 polygon_data[i].normal[1] = normal[1]
318 polygon_data[i].normal[2] = normal[2]
319 polygon_data[i].center[0] = center[0]
320 polygon_data[i].center[1] = center[1]
321 polygon_data[i].center[2] = center[2]
322 polygon_data[i].material_id = poly.material_index
323
324 edge_data = (cxr_edge*len(data.edges))()
325
326 for i, edge in enumerate(data.edges):
327 edge_data[i].i0 = edge.vertices[0]
328 edge_data[i].i1 = edge.vertices[1]
329 edge_data[i].freestyle = edge.use_freestyle_mark
330
331 material_data = (cxr_material*len(obj.material_slots))()
332
333 for i, ms in enumerate(obj.material_slots):
334 inf = material_info(ms.material)
335 material_data[i].res[0] = inf['res'][0]
336 material_data[i].res[1] = inf['res'][1]
337 material_data[i].name = inf['name'].encode('utf-8')
338
339 mesh.edges = cast(edge_data, POINTER(cxr_edge))
340 mesh.vertices = cast(vertex_data, POINTER(c_double*3))
341 mesh.loops = cast(loop_data,POINTER(cxr_static_loop))
342 mesh.polys = cast(polygon_data, POINTER(cxr_polygon))
343 mesh.materials = cast(material_data, POINTER(cxr_material))
344
345 mesh.poly_count = len(data.polygons)
346 mesh.vertex_count = len(data.vertices)
347 mesh.edge_count = len(data.edges)
348 mesh.loop_count = len(data.loops)
349 mesh.material_count = len(obj.material_slots)
350
351 if orig_state != None:
352 bpy.ops.object.mode_set(mode=orig_state)
353
354 return mesh
355
356 # Callback ctypes indirection things.. not really sure.
357 c_libcxr_log_callback = None
358 c_libcxr_line_callback = None
359
360 # Public API
361 # -------------------------------------------------------------
362 libcxr_decompose = extern( "cxr_decompose",
363 [POINTER(cxr_static_mesh), POINTER(c_int32)],
364 c_void_p
365 )
366 libcxr_free_world = extern( "cxr_free_world",
367 [c_void_p],
368 None
369 )
370 libcxr_write_test_data = extern( "cxr_write_test_data",
371 [POINTER(cxr_static_mesh)],
372 None
373 )
374 libcxr_world_preview = extern( "cxr_world_preview",
375 [c_void_p],
376 POINTER(cxr_tri_mesh)
377 )
378 libcxr_free_tri_mesh = extern( "cxr_free_tri_mesh",
379 [c_void_p],
380 None
381 )
382 libcxr_begin_vmf = extern( "cxr_begin_vmf",
383 [POINTER(cxr_vmf_context), c_void_p],
384 None
385 )
386 libcxr_vmf_begin_entities = extern( "cxr_vmf_begin_entities",
387 [POINTER(cxr_vmf_context), c_void_p],
388 None
389 )
390 libcxr_push_world_vmf = extern("cxr_push_world_vmf",
391 [c_void_p,POINTER(cxr_vmf_context),c_void_p],
392 None
393 )
394 libcxr_end_vmf = extern( "cxr_end_vmf",
395 [POINTER(cxr_vmf_context),c_void_p],
396 None
397 )
398
399 # VDF + with open wrapper
400 libcxr_vdf_open = extern( "cxr_vdf_open", [c_char_p], c_void_p )
401 libcxr_vdf_close = extern( "cxr_vdf_close", [c_void_p], None )
402 libcxr_vdf_put = extern( "cxr_vdf_put", [c_void_p,c_char_p], None )
403 libcxr_vdf_node = extern( "cxr_vdf_node", [c_void_p,c_char_p], None )
404 libcxr_vdf_edon = extern( "cxr_vdf_edon", [c_void_p], None )
405 libcxr_vdf_kv = extern( "cxr_vdf_kv", [c_void_p,c_char_p,c_char_p], None )
406
407 class vdf_structure():
408 def __init__(_,path):
409 _.path = path
410 def __enter__(_):
411 _.fp = libcxr_vdf_open.call( _.path.encode('utf-8') )
412 if _.fp == None:
413 print( F"Could not open file {_.path}" )
414 return None
415 return _
416 def __exit__(_,type,value,traceback):
417 if _.fp != None:
418 libcxr_vdf_close.call(_.fp)
419 def put(_,s):
420 libcxr_vdf_put.call(_.fp, s.encode('utf-8') )
421 def node(_,name):
422 libcxr_vdf_node.call(_.fp, name.encode('utf-8') )
423 def edon(_):
424 libcxr_vdf_edon.call(_.fp)
425 def kv(_,k,v):
426 libcxr_vdf_kv.call(_.fp, k.encode('utf-8'), v.encode('utf-8'))
427
428 # Other
429 libcxr_lightpatch_bsp = extern( "cxr_lightpatch_bsp", [c_char_p], None )
430
431 libcxr_funcs = [ libcxr_decompose, libcxr_free_world, libcxr_begin_vmf, \
432 libcxr_vmf_begin_entities, libcxr_push_world_vmf, \
433 libcxr_end_vmf, libcxr_vdf_open, libcxr_vdf_close, \
434 libcxr_vdf_put, libcxr_vdf_node, libcxr_vdf_edon,
435 libcxr_vdf_kv, libcxr_lightpatch_bsp, libcxr_write_test_data,\
436 libcxr_world_preview, libcxr_free_tri_mesh ]
437
438 # Callbacks
439
440 def libcxr_log_callback(logStr):
441 print( F"{logStr.decode('utf-8')}",end='' )
442
443 cxr_line_positions = None
444 cxr_line_colours = None
445
446 def cxr_reset_lines():
447 global cxr_line_positions, cxr_line_colours
448
449 cxr_line_positions = []
450 cxr_line_colours = []
451
452 def cxr_batch_lines():
453 global cxr_line_positions, cxr_line_colours, cxr_view_shader, cxr_view_lines
454
455 cxr_view_lines = batch_for_shader(\
456 cxr_view_shader, 'LINES',\
457 { "pos": cxr_line_positions, "color": cxr_line_colours })
458
459 def libcxr_line_callback( p0,p1,colour ):
460 global cxr_line_colours, cxr_line_positions
461
462 cxr_line_positions += [(p0[0],p0[1],p0[2])]
463 cxr_line_positions += [(p1[0],p1[1],p1[2])]
464 cxr_line_colours += [(colour[0],colour[1],colour[2],colour[3])]
465 cxr_line_colours += [(colour[0],colour[1],colour[2],colour[3])]
466
467 # libnbvtf
468 # ------------------------------------------------------------------------------
469
470 libnbvtf = None
471
472 # Constants
473 NBVTF_IMAGE_FORMAT_ABGR8888 = 1
474 NBVTF_IMAGE_FORMAT_BGR888 = 3
475 NBVTF_IMAGE_FORMAT_DXT1 = 13
476 NBVTF_IMAGE_FORMAT_DXT5 = 15
477 NBVTF_TEXTUREFLAGS_CLAMPS = 0x00000004
478 NBVTF_TEXTUREFLAGS_CLAMPT = 0x00000008
479 NBVTF_TEXTUREFLAGS_NORMAL = 0x00000080
480 NBVTF_TEXTUREFLAGS_NOMIP = 0x00000100
481 NBVTF_TEXTUREFLAGS_NOLOD = 0x00000200
482
483 libnbvtf_convert = extern( "nbvtf_convert", \
484 [c_char_p,c_int32,c_int32,c_int32,c_int32,c_int32,c_uint32,c_char_p], \
485 c_int32 )
486
487 libnbvtf_init = extern( "nbvtf_init", [], None )
488 libnbvtf_funcs = [ libnbvtf_convert, libnbvtf_init ]
489
490 # Loading
491 # --------------------------
492
493 def shared_reload():
494 global libcxr, libnbvtf, libcxr_funcs, libnbvtf_funcs
495
496 # Unload libraries if existing
497 def _reload( lib, path ):
498 if lib != None:
499 _handle = lib._handle
500 for i in range(10): libc_dlclose( _handle )
501 lib = None
502 del lib
503 return cdll.LoadLibrary( F'{os.path.dirname(__file__)}/{path}.so' )
504
505 libnbvtf = _reload( libnbvtf, "libnbvtf" )
506 libcxr = _reload( libcxr, "libcxr" )
507
508 for fd in libnbvtf_funcs:
509 fd.loadfrom( libnbvtf )
510 libnbvtf_init.call()
511
512 for fd in libcxr_funcs:
513 fd.loadfrom( libcxr )
514
515 # Callbacks
516 global c_libcxr_log_callback, c_libcxr_line_callback
517
518 LOG_FUNCTION_TYPE = CFUNCTYPE(None,c_char_p)
519 c_libcxr_log_callback = LOG_FUNCTION_TYPE(libcxr_log_callback)
520
521 LINE_FUNCTION_TYPE = CFUNCTYPE(None,\
522 POINTER(c_double), POINTER(c_double), POINTER(c_double))
523 c_libcxr_line_callback = LINE_FUNCTION_TYPE(libcxr_line_callback)
524
525 libcxr.cxr_set_log_function(cast(c_libcxr_log_callback,c_void_p))
526 libcxr.cxr_set_line_function(cast(c_libcxr_line_callback,c_void_p))
527
528 build_time = c_char_p.in_dll(libcxr,'cxr_build_time')
529 print( F"libcxr build time: {build_time.value}" )
530
531 shared_reload()
532
533 # Configuration
534 # ------------------------------------------------------------------------------
535
536 # Standard entity functions, think of like base.fgd
537 #
538 def cxr_get_origin(context):
539 return context['object'].location * context['transform']['scale'] + \
540 mathutils.Vector(context['transform']['offset'])
541
542 def cxr_get_angles(context):
543 obj = context['object']
544 euler = [ a*57.295779513 for a in obj.rotation_euler ]
545 angle = [0,0,0]
546 angle[0] = euler[1]
547 angle[1] = euler[2]
548 angle[2] = euler[0]
549 return angle
550
551 def cxr_baseclass(classes, other):
552 base = other.copy()
553 for x in classes:
554 base.update(x.copy())
555 return base
556
557 # EEVEE Light component converter -> Source 1
558 #
559 def ent_lights(context):
560 obj = context['object']
561 kvs = cxr_baseclass([ent_origin],\
562 {
563 "_distance": (0.0 if obj.data.cxr_data.realtime else -1.0),
564 "_light": [int(pow(obj.data.color[i],1.0/2.2)*255.0) for i in range(3)] +\
565 [int(obj.data.energy * bpy.context.scene.cxr_data.light_scale)],
566 "_lightHDR": '-1 -1 -1 1',
567 "_lightscaleHDR": 1
568 })
569
570 if obj.data.type == 'SPOT':
571 kvs['_cone'] = obj.data.spot_size*(57.295779513/2.0)
572 kvs['_inner_cone'] = (1.0-obj.data.spot_blend)*kvs['_cone']
573
574 # Blenders spotlights are -z forward
575 # Source is +x, however, it seems to use a completely different system.
576 # Since we dont care about roll for spotlights, we just take the
577 # pitch and yaw via trig
578
579 _,mtx_rot,_ = obj.matrix_world.decompose()
580 fwd = mtx_rot @ mathutils.Vector((0,0,-1))
581
582 kvs['pitch'] = math.asin(fwd[2]) * 57.295779513
583 kvs['angles'] = [ 0.0, math.atan2(fwd[1],fwd[0]) * 57.295779513, 0.0 ]
584 kvs['_quadratic_attn'] = 0.0 # Source spotlights + quadratic falloff look
585 # Really bad...
586 #
587 # Blender's default has a much more 'nice'
588 # look.
589 kvs['_linear_attn'] = 1.0
590
591 elif obj.data.type == 'POINT':
592 kvs['_quadratic_attn'] = 1.0
593 kvs['_linear_attn'] = 0.0
594
595 elif obj.data.type == 'SUN':
596 pass # TODO
597
598 return kvs
599
600 def ent_prop(context):
601 kvs = {}
602 if isinstance( context['object'], bpy.types.Collection ):
603 kvs['angles'] = [0,180,0]
604 kvs['enablelightbounce'] = 1
605 kvs['disableshadows'] = 0
606 kvs['fademindist'] = -1
607 kvs['fadescale'] = 1
608 kvs['model'] = F"{asset_path('models',context['object'])}.mdl".lower()
609 kvs['renderamt'] = 255
610 kvs['rendercolor'] = [255, 255, 255]
611 kvs['skin'] = 0
612 kvs['solid'] = 6
613 kvs['uniformscale'] = 1.0
614
615 pos = mathutils.Vector(context['origin'])
616 pos += mathutils.Vector(context['transform']['offset'])
617
618 kvs['origin'] = [pos[1],-pos[0],pos[2]]
619
620 return kvs
621
622 def ent_cubemap(context):
623 obj = context['object']
624 return cxr_baseclass([ent_origin], {"cubemapsize": obj.data.cxr_data.size})
625
626 ent_origin = { "origin": cxr_get_origin }
627 ent_angles = { "angles": cxr_get_angles }
628 ent_transform = cxr_baseclass( [ent_origin], ent_angles )
629
630 #include the user config
631 exec(open(F'{os.path.dirname(__file__)}/config.py').read())
632
633 # Blender state callbacks
634 # ------------------------------------------------------------------------------
635
636 @persistent
637 def cxr_on_load(dummy):
638 global cxr_view_lines, cxr_view_mesh
639
640 cxr_view_lines = None
641 cxr_view_mesh = None
642
643 @persistent
644 def cxr_dgraph_update(scene,dgraph):
645 return
646 print( F"Hallo {time.time()}" )
647
648 # Convexer compilation functions
649 # ------------------------------------------------------------------------------
650
651 # Asset path management
652
653 def asset_uid(asset):
654 if isinstance(asset,str):
655 return asset
656
657 # Create a unique ID string
658 base = "bopshei"
659 v = asset.cxr_data.asset_id
660 name = ""
661
662 if v == 0:
663 name = "A"
664 else:
665 dig = []
666
667 while v:
668 dig.append( int( v % len(base) ) )
669 v //= len(base)
670
671 for d in dig[::-1]:
672 name += base[d]
673
674 if bpy.context.scene.cxr_data.include_names:
675 name += asset.name.replace('.','_')
676
677 return name
678
679 # -> <project_name>/<asset_name>
680 def asset_name(asset):
681 return F"{bpy.context.scene.cxr_data.project_name}/{asset_uid(asset)}"
682
683 # -> <subdir>/<project_name>/<asset_name>
684 def asset_path(subdir, asset):
685 return F"{subdir}/{asset_name(asset_uid(asset))}"
686
687 # -> <csgo>/<subdir>/<project_name>/<asset_name>
688 def asset_full_path(sdir,asset):
689 return F"{bpy.context.scene.cxr_data.subdir}/"+\
690 F"{asset_path(sdir,asset_uid(asset))}"
691
692 # Entity functions / infos
693 # ------------------------
694
695 def cxr_intrinsic_classname(obj):
696 if obj.type == 'LIGHT':
697 return {
698 'SPOT': "light_spot",
699 'POINT': "light",
700 'SUN': "light_directional" }[ obj.data.type ]
701
702 elif obj.type == 'LIGHT_PROBE':
703 return "env_cubemap"
704 elif obj.type == 'EMPTY':
705 if obj.is_instancer:
706 return "prop_static"
707
708 return None
709
710 def cxr_custom_class(obj):
711 if obj.type == 'MESH': custom_class = obj.cxr_data.brushclass
712 else: custom_class = obj.cxr_data.classname
713
714 return custom_class
715
716 def cxr_classname(obj):
717 intr = cxr_intrinsic_classname(obj)
718 if intr != None: return intr
719
720 custom_class = cxr_custom_class(obj)
721 if custom_class != 'NONE':
722 return custom_class
723
724 return None
725
726 # Returns array of:
727 # intinsic: (k, False, value)
728 # property: (k, True, value or default)
729 #
730 # Error: None
731 #
732 def cxr_entity_keyvalues(context):
733 classname = context['classname']
734 obj = context['object']
735 if classname not in cxr_entities: return None
736
737 result = []
738
739 entdef = cxr_entities[classname]
740 kvs = entdef['keyvalues']
741
742 if callable(kvs): kvs = kvs(context)
743
744 for k in kvs:
745 kv = kvs[k]
746 value = kv
747 isprop = False
748
749 if isinstance(kv,dict):
750 isprop = True
751 value = obj[ F"cxrkv_{k}" ]
752 else:
753 if callable(kv):
754 value = kv(context)
755
756 if isinstance(value,mathutils.Vector):
757 value = [_ for _ in value]
758
759 result += [(k, isprop, value)]
760
761 return result
762
763 # Extract material information from shader graph data
764 #
765 def material_info(mat):
766 info = {}
767 info['res'] = (512,512)
768 info['name'] = 'tools/toolsnodraw'
769
770 if mat == None or mat.use_nodes == False:
771 return info
772
773 # Builtin shader
774 if mat.cxr_data.shader == 'Builtin':
775 info['name'] = mat.name
776 return info
777
778 # Custom materials
779 info['name'] = asset_name(mat)
780
781 # Using the cxr_graph_mapping as a reference, go through the shader
782 # graph and gather all $props from it.
783 #
784 def _graph_read( node_def, node=None, depth=0 ):
785 nonlocal mat
786 nonlocal info
787
788 def _variant_apply( val ):
789 nonlocal mat
790
791 if isinstance( val, str ):
792 return val
793 else:
794 for shader_variant in val:
795 if shader_variant[0] == mat.cxr_data.shader:
796 return shader_variant[1]
797
798 # Find rootnodes
799 if node == None:
800 _graph_read.extracted = []
801
802 for node_idname in node_def:
803 for n in mat.node_tree.nodes:
804 if n.bl_idname == node_idname:
805 node_def = node_def[node_idname]
806 node = n
807 break
808
809 for link in node_def:
810 if isinstance( node_def[link], dict ):
811 inputt = node.inputs[link]
812 inputt_def = node_def[link]
813
814 if inputt.is_linked:
815
816 # look for definitions for the connected node type
817 con = inputt.links[0].from_node
818
819 for node_idname in inputt_def:
820 if con.bl_idname == node_idname:
821 con_def = inputt_def[ node_idname ]
822 _graph_read( con_def, con, depth+1 )
823
824 # No definition found! :(
825 # TODO: Make a warning for this?
826
827 else:
828 if "default" in inputt_def:
829 prop = _variant_apply( inputt_def['default'] )
830 info[prop] = inputt.default_value
831 else:
832 prop = _variant_apply( node_def[link] )
833 info[prop] = getattr(node,link)
834
835 _graph_read(cxr_graph_mapping)
836
837 if "$basetexture" in info:
838 export_res = info['$basetexture'].cxr_data.export_res
839 info['res'] = (export_res[0], export_res[1])
840
841 return info
842
843 def vec3_min( a, b ):
844 return mathutils.Vector((min(a[0],b[0]),min(a[1],b[1]),min(a[2],b[2])))
845 def vec3_max( a, b ):
846 return mathutils.Vector((max(a[0],b[0]),max(a[1],b[1]),max(a[2],b[2])))
847
848 def cxr_collection_center(collection, transform):
849 BIG=999999999
850 bounds_min = mathutils.Vector((BIG,BIG,BIG))
851 bounds_max = mathutils.Vector((-BIG,-BIG,-BIG))
852
853 for obj in collection.objects:
854 if obj.type == 'MESH':
855 corners = [ mathutils.Vector(c) for c in obj.bound_box ]
856
857 for corner in [ obj.matrix_world@c for c in corners ]:
858 bounds_min = vec3_min( bounds_min, corner )
859 bounds_max = vec3_max( bounds_max, corner )
860
861 center = (bounds_min + bounds_max) / 2.0
862
863 origin = mathutils.Vector((-center[1],center[0],center[2]))
864 origin *= transform['scale']
865
866 return origin
867
868 # Prepares Scene into dictionary format
869 #
870 def cxr_scene_collect():
871 context = bpy.context
872
873 # Make sure all of our asset types have a unique ID
874 def _uid_prepare(objtype):
875 used_ids = [0]
876 to_generate = []
877 id_max = 0
878 for o in objtype:
879 vs = o.cxr_data
880 if vs.asset_id in used_ids:
881 to_generate+=[vs]
882 else:
883 id_max = max(id_max,vs.asset_id)
884 used_ids+=[vs.asset_id]
885 for vs in to_generate:
886 id_max += 1
887 vs.asset_id = id_max
888 _uid_prepare(bpy.data.materials)
889 _uid_prepare(bpy.data.images)
890 _uid_prepare(bpy.data.collections)
891
892 sceneinfo = {
893 "entities": [], # Everything with a classname
894 "geo": [], # All meshes without a classname
895 "heros": [] # Collections prefixed with mdl_
896 }
897
898 def _collect(collection,transform):
899 nonlocal sceneinfo
900
901 if collection.name.startswith('.'): return
902 if collection.hide_render: return
903
904 if collection.name.startswith('mdl_'):
905 sceneinfo['entities'] += [{
906 "object": collection,
907 "classname": "prop_static",
908 "transform": transform,
909 "origin": cxr_collection_center( collection, transform )
910 }]
911
912 sceneinfo['heros'] += [{
913 "collection": collection,
914 "transform": transform,
915 "origin": cxr_collection_center( collection, transform )
916 }]
917 return
918
919 for obj in collection.objects:
920 if obj.hide_get(): continue
921
922 classname = cxr_classname( obj )
923
924 if classname != None:
925 sceneinfo['entities'] += [{
926 "object": obj,
927 "classname": classname,
928 "transform": transform
929 }]
930 elif obj.type == 'MESH':
931 sceneinfo['geo'] += [{
932 "object": obj,
933 "transform": transform
934 }]
935
936 for c in collection.children:
937 _collect( c, transform )
938
939 transform_main = {
940 "scale": context.scene.cxr_data.scale_factor,
941 "offset": (0,0,0)
942 }
943
944 transform_sky = {
945 "scale": context.scene.cxr_data.skybox_scale_factor,
946 "offset": (0,0,context.scene.cxr_data.skybox_offset )
947 }
948
949 if 'main' in bpy.data.collections:
950 _collect( bpy.data.collections['main'], transform_main )
951
952 if 'skybox' in bpy.data.collections:
953 _collect( bpy.data.collections['skybox'], transform_sky )
954
955 return sceneinfo
956
957 # Write VMF out to file (JOB HANDLER)
958 #
959 def cxr_export_vmf(sceneinfo, output_vmf):
960 cxr_reset_lines()
961
962 with vdf_structure(output_vmf) as m:
963 print( F"Write: {output_vmf}" )
964
965 vmfinfo = cxr_vmf_context()
966 vmfinfo.mapversion = 4
967
968 #TODO: These need to be in options...
969 vmfinfo.skyname = b"sky_csgo_night02b"
970 vmfinfo.detailvbsp = b"detail.vbsp"
971 vmfinfo.detailmaterial = b"detail/detailsprites"
972 vmfinfo.lightmap_scale = 12
973
974 vmfinfo.brush_count = 0
975 vmfinfo.entity_count = 0
976 vmfinfo.face_count = 0
977
978 libcxr_begin_vmf.call( pointer(vmfinfo), m.fp )
979
980 def _buildsolid( cmd ):
981 nonlocal m
982
983 print( F"{vmfinfo.brush_count} :: {cmd['object'].name}" )
984
985 baked = mesh_cxr_format( cmd['object'] )
986 world = libcxr_decompose.call( baked, None )
987
988 if world == None:
989 return False
990
991 vmfinfo.scale = cmd['transform']['scale']
992
993 offset = cmd['transform']['offset']
994 vmfinfo.offset[0] = offset[0]
995 vmfinfo.offset[1] = offset[1]
996 vmfinfo.offset[2] = offset[2]
997
998 libcxr_push_world_vmf.call( world, pointer(vmfinfo), m.fp )
999 libcxr_free_world.call( world )
1000
1001 return True
1002
1003 # World geometry
1004 for brush in sceneinfo['geo']:
1005 if not _buildsolid( brush ):
1006 cxr_batch_lines()
1007 scene_redraw()
1008 return False
1009
1010 libcxr_vmf_begin_entities.call(pointer(vmfinfo), m.fp)
1011
1012 # Entities
1013 for ent in sceneinfo['entities']:
1014 obj = ent['object']
1015 ctx = ent['transform']
1016 cls = ent['classname']
1017
1018 m.node( 'entity' )
1019 m.kv( 'classname', cls )
1020
1021 kvs = cxr_entity_keyvalues( ent )
1022
1023 for kv in kvs:
1024 if isinstance(kv[2], list):
1025 m.kv( kv[0], ' '.join([str(_) for _ in kv[2]]) )
1026 else: m.kv( kv[0], str(kv[2]) )
1027
1028 if not isinstance( obj, bpy.types.Collection ):
1029 if obj.type == 'MESH':
1030 if not _buildsolid( ent ):
1031 cxr_batch_lines()
1032 scene_redraw()
1033 return False
1034
1035 m.edon()
1036
1037 print( "Done" )
1038 return True
1039
1040 # COmpile image using NBVTF and hash it (JOB HANDLER)
1041 #
1042 def compile_image(img):
1043 if img==None:
1044 return None
1045
1046 name = asset_name(img)
1047 src_path = bpy.path.abspath(img.filepath)
1048
1049 dims = img.cxr_data.export_res
1050 fmt = {
1051 'RGBA': NBVTF_IMAGE_FORMAT_ABGR8888,
1052 'DXT1': NBVTF_IMAGE_FORMAT_DXT1,
1053 'DXT5': NBVTF_IMAGE_FORMAT_DXT5,
1054 'RGB': NBVTF_IMAGE_FORMAT_BGR888
1055 }[ img.cxr_data.fmt ]
1056
1057 mipmap = img.cxr_data.mipmap
1058 lod = img.cxr_data.lod
1059 clamp = img.cxr_data.clamp
1060 flags = img.cxr_data.flags
1061
1062 q=bpy.context.scene.cxr_data.image_quality
1063
1064 userflag_hash = F"{mipmap}.{lod}.{clamp}.{flags}"
1065 file_hash = F"{name}.{os.path.getmtime(src_path)}"
1066 comphash = F"{file_hash}.{dims[0]}.{dims[1]}.{fmt}.{userflag_hash}.{q}"
1067
1068 if img.cxr_data.last_hash != comphash:
1069 print( F"Texture update: {img.filepath}" )
1070
1071 src = src_path.encode('utf-8')
1072 dst = (asset_full_path('materials',img)+'.vtf').encode('utf-8')
1073
1074 flags_full = flags
1075
1076 # texture setting flags
1077 if not lod: flags_full |= NBVTF_TEXTUREFLAGS_NOLOD
1078 if clamp:
1079 flags_full |= NBVTF_TEXTUREFLAGS_CLAMPS
1080 flags_full |= NBVTF_TEXTUREFLAGS_CLAMPT
1081
1082 if libnbvtf_convert.call(src,dims[0],dims[1],mipmap,fmt,q,flags_full,dst):
1083 img.cxr_data.last_hash = comphash
1084
1085 return name
1086
1087 #
1088 # Compile a material to VMT format. This is quick to run, doesnt need to be a
1089 # job handler.
1090 #
1091 def compile_material(mat):
1092 info = material_info(mat)
1093 properties = mat.cxr_data
1094
1095 print( F"Compile {asset_full_path('materials',mat)}.vmt" )
1096 if properties.shader == 'Builtin':
1097 return []
1098
1099 props = []
1100
1101 # Walk the property tree
1102 def _mlayer( layer ):
1103 nonlocal properties, props
1104
1105 for decl in layer:
1106 if isinstance(layer[decl],dict): # $property definition
1107 pdef = layer[decl]
1108 ptype = pdef['type']
1109
1110 subdefines = False
1111 default = None
1112 prop = None
1113
1114 if 'shaders' in pdef and properties.shader not in pdef['shaders']:
1115 continue
1116
1117 # Group expansion (does it have subdefinitions?)
1118 for ch in pdef:
1119 if isinstance(pdef[ch],dict):
1120 subdefines = True
1121 break
1122
1123 expandview = False
1124
1125 if ptype == 'ui':
1126 expandview = True
1127 else:
1128 if ptype == 'intrinsic':
1129 if decl in info:
1130 prop = info[decl]
1131 else:
1132 prop = getattr(properties,decl)
1133 default = pdef['default']
1134
1135 if not isinstance(prop,str) and \
1136 not isinstance(prop,bpy.types.Image) and \
1137 hasattr(prop,'__getitem__'):
1138 prop = tuple([p for p in prop])
1139
1140 if prop != default:
1141 # write prop
1142 props += [(decl,pdef,prop)]
1143
1144 if subdefines:
1145 expandview = True
1146
1147 if expandview: _mlayer(pdef)
1148
1149 _mlayer( cxr_shader_params )
1150
1151 # Write the vmt
1152 with vdf_structure( F"{asset_full_path('materials',mat)}.vmt" ) as vmt:
1153 vmt.node( properties.shader )
1154 vmt.put( "// Convexer export\n" )
1155
1156 for pair in props:
1157 decl = pair[0]
1158 pdef = pair[1]
1159 prop = pair[2]
1160
1161 def _numeric(v):
1162 nonlocal pdef
1163 if 'exponent' in pdef: return str(pow( v, pdef['exponent'] ))
1164 else: return str(v)
1165
1166 if isinstance(prop,bpy.types.Image):
1167 vmt.kv( decl, asset_name(prop))
1168 elif isinstance(prop,bool):
1169 vmt.kv( decl, '1' if prop else '0' )
1170 elif isinstance(prop,str):
1171 vmt.kv( decl, prop )
1172 elif isinstance(prop,float) or isinstance(prop,int):
1173 vmt.kv( decl, _numeric(prop) )
1174 elif isinstance(prop,tuple):
1175 vmt.kv( decl, F"[{' '.join([_numeric(_) for _ in prop])}]" )
1176 else:
1177 vmt.put( F"// (cxr) unkown shader value type'{type(prop)}'" )
1178
1179 vmt.edon()
1180 return props
1181
1182 def cxr_export_modelsrc( mdl, origin, asset_dir, project_name, transform ):
1183 dgraph = bpy.context.evaluated_depsgraph_get()
1184
1185 # Compute hash value
1186 chash = asset_uid(mdl)+str(origin)+str(transform)
1187
1188 #for obj in mdl.objects:
1189 # if obj.type != 'MESH':
1190 # continue
1191
1192 # ev = obj.evaluated_get(dgraph).data
1193 # srcverts=[(v.co[0],v.co[1],v.co[2]) for v in ev.vertices]
1194 # srcloops=[(l.normal[0],l.normal[1],l.normal[2]) for l in ev.loops]
1195
1196 # chash=hashlib.sha224((str(srcverts)+chash).encode()).hexdigest()
1197 # chash=hashlib.sha224((str(srcloops)+chash).encode()).hexdigest()
1198
1199 # if ev.uv_layers.active != None:
1200 # uv_layer = ev.uv_layers.active.data
1201 # srcuv=[(uv.uv[0],uv.uv[1]) for uv in uv_layer]
1202 # else:
1203 # srcuv=['none']
1204
1205 # chash=hashlib.sha224((str(srcuv)+chash).encode()).hexdigest()
1206 # srcmats=[ ms.material.name for ms in obj.material_slots ]
1207 # chash=hashlib.sha224((str(srcmats)+chash).encode()).hexdigest()
1208 # transforms=[ obj.location, obj.rotation_euler, obj.scale ]
1209 # srctr=[(v[0],v[1],v[2]) for v in transforms]
1210 # chash=hashlib.sha224((str(srctr)+chash).encode()).hexdigest()
1211
1212 #if chash != mdl.cxr_data.last_hash:
1213 # mdl.cxr_data.last_hash = chash
1214 # print( F"Compile: {mdl.name}" )
1215 #else:
1216 # return True
1217
1218 bpy.ops.object.select_all(action='DESELECT')
1219
1220 # Get viewlayer
1221 def _get_layer(col,name):
1222 for c in col.children:
1223 if c.name == name:
1224 return c
1225 sub = _get_layer(c,name)
1226 if sub != None:
1227 return sub
1228 return None
1229 layer = _get_layer(bpy.context.view_layer.layer_collection,mdl.name)
1230
1231 prev_state = layer.hide_viewport
1232 layer.hide_viewport=False
1233
1234 # Collect materials to be compiled, and temp rename for export
1235 mat_dict = {}
1236
1237 vphys = None
1238 for obj in mdl.objects:
1239 if obj.name == F"{mdl.name}_phy":
1240 vphys = obj
1241 continue
1242
1243 obj.select_set(state=True)
1244 for ms in obj.material_slots:
1245 if ms.material != None:
1246 if ms.material not in mat_dict:
1247 mat_dict[ms.material] = ms.material.name
1248 ms.material.name = asset_uid(ms.material)
1249 ms.material.use_nodes = False
1250
1251 uid=asset_uid(mdl)
1252 bpy.ops.export_scene.fbx( filepath=F'{asset_dir}/{uid}_ref.fbx',\
1253 check_existing=False,
1254 use_selection=True,
1255 apply_unit_scale=False,
1256 bake_space_transform=False
1257 )
1258
1259 bpy.ops.object.select_all(action='DESELECT')
1260
1261 if vphys != None:
1262 vphys.select_set(state=True)
1263 bpy.ops.export_scene.fbx( filepath=F'{asset_dir}/{uid}_phy.fbx',\
1264 check_existing=False,
1265 use_selection=True,
1266 apply_unit_scale=False,
1267 bake_space_transform=False
1268 )
1269 bpy.ops.object.select_all(action='DESELECT')
1270
1271 # Fix material names back to original
1272 for mat in mat_dict:
1273 mat.name = mat_dict[mat]
1274 mat.use_nodes = True
1275
1276 layer.hide_viewport=prev_state
1277
1278 # Write out QC file
1279 with open(F'{asset_dir}/{uid}.qc','w') as o:
1280 o.write(F'$modelname "{project_name}/{uid}"\n')
1281 #o.write(F'$scale .32\n')
1282 o.write(F'$scale {transform["scale"]/100.0}\n')
1283 o.write(F'$body _ "{uid}_ref.fbx"\n')
1284 o.write(F'$staticprop\n')
1285 o.write(F'$origin {origin[0]} {origin[1]} {origin[2]}\n')
1286
1287 if vphys != None:
1288 o.write(F'$collisionmodel "{uid}_phy.fbx"\n')
1289 o.write("{\n")
1290 o.write(" $concave\n")
1291 o.write("}\n")
1292
1293 o.write(F'$cdmaterials {project_name}\n')
1294 o.write(F'$sequence idle {uid}_ref.fbx\n')
1295
1296 return True
1297 #
1298 # Copy bsp file (and also lightpatch it)
1299 #
1300 def cxr_patchmap( src, dst ):
1301 libcxr_lightpatch_bsp.call( src.encode('utf-8') )
1302 shutil.copyfile( src, dst )
1303 return True
1304
1305 # Convexer operators
1306 # ------------------------------------------------------------------------------
1307
1308 # Force reload of shared libraries
1309 #
1310 class CXR_RELOAD(bpy.types.Operator):
1311 bl_idname="convexer.reload"
1312 bl_label="Reload"
1313 def execute(_,context):
1314 shared_reload()
1315 return {'FINISHED'}
1316
1317 # Used for exporting data to use with ASAN builds
1318 #
1319 class CXR_DEV_OPERATOR(bpy.types.Operator):
1320 bl_idname="convexer.dev_test"
1321 bl_label="Export development data"
1322
1323 def execute(_,context):
1324 # Prepare input data
1325 mesh_src = mesh_cxr_format(context.active_object)
1326 libcxr_write_test_data.call( pointer(mesh_src) )
1327 return {'FINISHED'}
1328
1329 # UI: Preview how the brushes will looks in 3D view
1330 #
1331 class CXR_PREVIEW_OPERATOR(bpy.types.Operator):
1332 bl_idname="convexer.preview"
1333 bl_label="Preview Brushes"
1334
1335 LASTERR = None
1336 RUNNING = False
1337
1338 def execute(_,context):
1339 return {'FINISHED'}
1340
1341 def modal(_,context,event):
1342 global cxr_view_mesh
1343 static = _.__class__
1344
1345 if event.type == 'ESC':
1346 cxr_reset_lines()
1347 cxr_batch_lines()
1348 cxr_view_mesh = None
1349 static.RUNNING = False
1350
1351 scene_redraw()
1352 return {'FINISHED'}
1353
1354 return {'PASS_THROUGH'}
1355
1356 def invoke(_,context,event):
1357 global cxr_view_shader, cxr_view_mesh
1358 static = _.__class__
1359 static.LASTERR = None
1360
1361 cxr_reset_lines()
1362
1363 mesh_src = mesh_cxr_format(context.active_object)
1364
1365 err = c_int32(0)
1366 world = libcxr_decompose.call( mesh_src, pointer(err) )
1367
1368 if world == None:
1369 cxr_view_mesh = None
1370 cxr_batch_lines()
1371 scene_redraw()
1372
1373 static.LASTERR = ["There is no error", \
1374 "Non-Manifold",\
1375 "Bad-Manifold",\
1376 "No-Candidate",\
1377 "Internal-Fail",\
1378 "Non-Coplanar",\
1379 "Non-Convex Polygon",\
1380 "Bad Result"]\
1381 [err.value]
1382
1383 if static.RUNNING:
1384 return {'CANCELLED'}
1385 else:
1386 context.window_manager.modal_handler_add(_)
1387 return {'RUNNING_MODAL'}
1388
1389 # Generate preview using cxr
1390 #
1391 ptrpreview = libcxr_world_preview.call( world )
1392 preview = ptrpreview[0]
1393
1394 vertices = preview.vertices[:preview.vertex_count]
1395 vertices = [(_[0],_[1],_[2]) for _ in vertices]
1396
1397 colours = preview.colours[:preview.vertex_count]
1398 colours = [(_[0],_[1],_[2],_[3]) for _ in colours]
1399
1400 indices = preview.indices[:preview.indices_count]
1401 indices = [ (indices[i*3+0],indices[i*3+1],indices[i*3+2]) \
1402 for i in range(int(preview.indices_count/3)) ]
1403
1404 cxr_view_mesh = batch_for_shader(
1405 cxr_view_shader, 'TRIS',
1406 { "pos": vertices, "color": colours },
1407 indices = indices,
1408 )
1409
1410 libcxr_free_tri_mesh.call( ptrpreview )
1411 libcxr_free_world.call( world )
1412 cxr_batch_lines()
1413 scene_redraw()
1414
1415 # Allow user to spam the operator
1416 if static.RUNNING:
1417 return {'CANCELLED'}
1418
1419 if not static.RUNNING:
1420 static.RUNNING = True
1421 context.window_manager.modal_handler_add(_)
1422 return {'RUNNING_MODAL'}
1423
1424 # Search for VMF compiler executables in subdirectory
1425 #
1426 class CXR_DETECT_COMPILERS(bpy.types.Operator):
1427 bl_idname="convexer.detect_compilers"
1428 bl_label="Find compilers"
1429
1430 def execute(self,context):
1431 scene = context.scene
1432 settings = scene.cxr_data
1433 subdir = settings.subdir
1434
1435 for exename in ['studiomdl','vbsp','vvis','vrad']:
1436 searchpath = os.path.normpath(F'{subdir}/../bin/{exename}.exe')
1437 if os.path.exists(searchpath):
1438 settings[F'exe_{exename}'] = searchpath
1439
1440 return {'FINISHED'}
1441
1442 # Main compile function
1443 #
1444 class CXR_COMPILER_CHAIN(bpy.types.Operator):
1445 bl_idname="convexer.chain"
1446 bl_label="Compile Chain"
1447
1448 # 'static'
1449 USER_EXIT = False
1450 SUBPROC = None
1451 TIMER = None
1452 TIMER_LAST = 0.0
1453 WAIT_REDRAW = False
1454 FILE = None
1455 LOG = []
1456
1457 JOBINFO = None
1458 JOBID = 0
1459 JOBSYS = None
1460
1461 def cancel(_,context):
1462 global cxr_jobs_batch
1463 static = _.__class__
1464 wm = context.window_manager
1465
1466 if static.SUBPROC != None:
1467 static.SUBPROC.terminate()
1468 static.SUBPROC = None
1469
1470 if static.TIMER != None:
1471 wm.event_timer_remove( static.TIMER )
1472 static.TIMER = None
1473
1474 static.FILE.close()
1475
1476 cxr_jobs_batch = None
1477 scene_redraw()
1478 return {'FINISHED'}
1479
1480 def modal(_,context,ev):
1481 static = _.__class__
1482
1483 if ev.type == 'TIMER':
1484 global cxr_jobs_batch
1485
1486 if static.WAIT_REDRAW:
1487 scene_redraw()
1488 return {'PASS_THROUGH'}
1489 static.WAIT_REDRAW = True
1490
1491 if static.USER_EXIT:
1492 print( "Chain USER_EXIT" )
1493 return _.cancel(context)
1494
1495 if static.SUBPROC != None:
1496 # Deal with async modes
1497 status = static.SUBPROC.poll()
1498 if status == None:
1499
1500 # Cannot redirect STDOUT through here without causing
1501 # undefined behaviour due to the Blender Python specification.
1502 #
1503 # Have to write it out to a file and read it back in.
1504 #
1505 with open("/tmp/convexer_compile_log.txt","r") as log:
1506 static.LOG = log.readlines()
1507 return {'PASS_THROUGH'}
1508 else:
1509 #for l in static.SUBPROC.stdout:
1510 # print( F'-> {l.decode("utf-8")}',end='' )
1511 static.SUBPROC = None
1512
1513 if status != 0:
1514 print(F'Compiler () error: {status}')
1515 return _.cancel(context)
1516
1517 static.JOBSYS['jobs'][static.JOBID] = None
1518 cxr_jobs_update_graph( static.JOBINFO )
1519 scene_redraw()
1520 return {'PASS_THROUGH'}
1521
1522 # Compile syncronous thing
1523 for sys in static.JOBINFO:
1524 for i,target in enumerate(sys['jobs']):
1525 if target != None:
1526
1527 if callable(sys['exec']):
1528 print( F"Run (sync): {static.JOBID} @{time.time()}" )
1529
1530 if not sys['exec'](*target):
1531 print( "Job failed" )
1532 return _.cancel(context)
1533
1534 sys['jobs'][i] = None
1535 static.JOBID += 1
1536 else:
1537 # Run external executable (wine)
1538 static.SUBPROC = subprocess.Popen( target,
1539 stdout=static.FILE,\
1540 stderr=subprocess.PIPE,\
1541 cwd=sys['cwd'])
1542 static.JOBSYS = sys
1543 static.JOBID = i
1544
1545 cxr_jobs_update_graph( static.JOBINFO )
1546 scene_redraw()
1547 return {'PASS_THROUGH'}
1548
1549 # All completed
1550 print( "All jobs completed!" )
1551 cxr_jobs_batch = None
1552
1553 scene_redraw()
1554 return _.cancel(context)
1555
1556 return {'PASS_THROUGH'}
1557
1558 def invoke(_,context,event):
1559 static = _.__class__
1560 wm = context.window_manager
1561
1562 if static.TIMER == None:
1563 print("Launching compiler toolchain")
1564
1565 # Run static compilation units now (collect, vmt..)
1566 filepath = bpy.data.filepath
1567 directory = os.path.dirname(filepath)
1568 settings = bpy.context.scene.cxr_data
1569
1570 asset_dir = F"{directory}/modelsrc"
1571 material_dir = F"{settings.subdir}/materials/{settings.project_name}"
1572 model_dir = F"{settings.subdir}/models/{settings.project_name}"
1573 output_vmf = F"{directory}/{settings.project_name}.vmf"
1574
1575 os.makedirs( asset_dir, exist_ok=True )
1576 os.makedirs( material_dir, exist_ok=True )
1577 os.makedirs( model_dir, exist_ok=True )
1578
1579 static.FILE = open(F"/tmp/convexer_compile_log.txt","w")
1580 static.LOG = []
1581
1582 sceneinfo = cxr_scene_collect()
1583 image_jobs = []
1584 qc_jobs = []
1585
1586 # Collect materials
1587 a_materials = set()
1588 for brush in sceneinfo['geo']:
1589 for ms in brush['object'].material_slots:
1590 a_materials.add( ms.material )
1591 if ms.material.cxr_data.shader == 'VertexLitGeneric':
1592 errmat = ms.material.name
1593 errnam = brush['object'].name
1594 print( F"Vertex shader {errmat} used on {errnam}")
1595 return {'CANCELLED'}
1596
1597 for ent in sceneinfo['entities']:
1598 if isinstance(ent['object'],bpy.types.Collection): continue
1599
1600 if ent['object'].type == 'MESH':
1601 for ms in ent['object'].material_slots:
1602 a_materials.add( ms.material )
1603
1604 # TODO.. this should just be in the entity loop
1605 for hero in sceneinfo['heros']:
1606 uid = asset_uid(hero['collection'])
1607 qc_jobs += [F'{uid}.qc']
1608 for obj in hero['collection'].objects:
1609 for ms in obj.material_slots:
1610 a_materials.add( ms.material )
1611 if ms.material.cxr_data.shader == 'LightMappedGeneric' or \
1612 ms.material.cxr_data.shader == 'WorldVertexTransition':
1613
1614 errmat = ms.material.name
1615 errnam = obj.name
1616 print( F"Lightmapped shader {errmat} used on {errnam}")
1617 return {'CANCELLED'}
1618
1619 # Collect images
1620 for mat in a_materials:
1621 for pair in compile_material(mat):
1622 decl = pair[0]
1623 pdef = pair[1]
1624 prop = pair[2]
1625
1626 if isinstance(prop,bpy.types.Image):
1627 flags = 0
1628 if 'flags' in pdef: flags = pdef['flags']
1629 if prop not in image_jobs:
1630 image_jobs += [(prop,)]
1631 prop.cxr_data.flags = flags
1632
1633 # Convexer jobs
1634 static.JOBID = 0
1635 static.JOBINFO = []
1636
1637 if settings.comp_vmf:
1638 static.JOBINFO += [{
1639 "title": "Convexer",
1640 "w": 20,
1641 "colour": (1.0,0.3,0.1,1.0),
1642 "exec": cxr_export_vmf,
1643 "jobs": [(sceneinfo,output_vmf)]
1644 }]
1645
1646 if settings.comp_textures:
1647 if len(image_jobs) > 0:
1648 static.JOBINFO += [{
1649 "title": "Textures",
1650 "w": 40,
1651 "colour": (0.1,1.0,0.3,1.0),
1652 "exec": compile_image,
1653 "jobs": image_jobs
1654 }]
1655
1656 game = 'z:'+settings.subdir.replace('/','\\')
1657 args = [ \
1658 '-game', game, settings.project_name
1659 ]
1660
1661 # FBX stage
1662 if settings.comp_models:
1663 if len(sceneinfo['heros']) > 0:
1664 static.JOBINFO += [{
1665 "title": "Batches",
1666 "w": 25,
1667 "colour": (0.5,0.5,1.0,1.0),
1668 "exec": cxr_export_modelsrc,
1669 "jobs": [(h['collection'], h['origin'], asset_dir, \
1670 settings.project_name, h['transform']) for h in \
1671 sceneinfo['heros']]
1672 }]
1673
1674 if len(qc_jobs) > 0:
1675 static.JOBINFO += [{
1676 "title": "StudioMDL",
1677 "w": 20,
1678 "colour": (0.8,0.1,0.1,1.0),
1679 "exec": "studiomdl",
1680 "jobs": [[settings[F'exe_studiomdl']] + [\
1681 '-nop4', '-game', game, qc] for qc in qc_jobs],
1682 "cwd": asset_dir
1683 }]
1684
1685 # VBSP stage
1686 if settings.comp_compile:
1687 static.JOBINFO += [{
1688 "title": "VBSP",
1689 "w": 25,
1690 "colour": (0.1,0.2,1.0,1.0),
1691 "exec": "vbsp",
1692 "jobs": [[settings[F'exe_vbsp']] + args],
1693 "cwd": directory
1694 }]
1695
1696 static.JOBINFO += [{
1697 "title": "VVIS",
1698 "w": 25,
1699 "colour": (0.9,0.5,0.5,1.0),
1700 "exec": "vvis",
1701 "jobs": [[settings[F'exe_vvis']] + ['-fast'] + args ],
1702 "cwd": directory
1703 }]
1704
1705 vrad_opt = settings.opt_vrad.split()
1706 static.JOBINFO += [{
1707 "title": "VRAD",
1708 "w": 25,
1709 "colour": (0.9,0.2,0.3,1.0),
1710 "exec": "vrad",
1711 "jobs": [[settings[F'exe_vrad']] + vrad_opt + args ],
1712 "cwd": directory
1713 }]
1714
1715 static.JOBINFO += [{
1716 "title": "CXR",
1717 "w": 5,
1718 "colour": (0.0,1.0,0.4,1.0),
1719 "exec": cxr_patchmap,
1720 "jobs": [(F"{directory}/{settings.project_name}.bsp",\
1721 F"{settings.subdir}/maps/{settings.project_name}.bsp")]
1722 }]
1723
1724 static.USER_EXIT=False
1725 static.TIMER=wm.event_timer_add(0.1,window=context.window)
1726 wm.modal_handler_add(_)
1727
1728 cxr_jobs_update_graph( static.JOBINFO )
1729 scene_redraw()
1730 return {'RUNNING_MODAL'}
1731
1732 print("Chain exiting...")
1733 static.USER_EXIT=True
1734 return {'RUNNING_MODAL'}
1735
1736 class CXR_RESET_HASHES(bpy.types.Operator):
1737 bl_idname="convexer.hash_reset"
1738 bl_label="Reset asset hashes"
1739
1740 def execute(_,context):
1741 for c in bpy.data.collections:
1742 c.cxr_data.last_hash = F"<RESET>{time.time()}"
1743 c.cxr_data.asset_id=0
1744
1745 for t in bpy.data.images:
1746 t.cxr_data.last_hash = F"<RESET>{time.time()}"
1747 t.cxr_data.asset_id=0
1748
1749 return {'FINISHED'}
1750
1751 # Convexer panels
1752 # ------------------------------------------------------------------------------
1753
1754 # Helper buttons for 3d toolbox view
1755 #
1756 class CXR_VIEW3D( bpy.types.Panel ):
1757 bl_idname = "VIEW3D_PT_convexer"
1758 bl_label = "Convexer"
1759 bl_space_type = 'VIEW_3D'
1760 bl_region_type = 'UI'
1761 bl_category = "Convexer"
1762
1763 @classmethod
1764 def poll(cls, context):
1765 return (context.object is not None)
1766
1767 def draw(_, context):
1768 layout = _.layout
1769 row = layout.row()
1770 row.scale_y = 2
1771 row.operator("convexer.preview")
1772
1773 if CXR_PREVIEW_OPERATOR.LASTERR != None:
1774 box = layout.box()
1775 box.label(text=CXR_PREVIEW_OPERATOR.LASTERR, icon='ERROR')
1776
1777 # Main scene properties interface, where all the settings go
1778 #
1779 class CXR_INTERFACE(bpy.types.Panel):
1780 bl_label="Convexer"
1781 bl_idname="SCENE_PT_convexer"
1782 bl_space_type='PROPERTIES'
1783 bl_region_type='WINDOW'
1784 bl_context="scene"
1785
1786 def draw(_,context):
1787 _.layout.operator("convexer.reload")
1788 _.layout.operator("convexer.dev_test")
1789 _.layout.operator("convexer.preview")
1790 _.layout.operator("convexer.hash_reset")
1791
1792 settings = context.scene.cxr_data
1793
1794 _.layout.prop(settings, "debug")
1795 _.layout.prop(settings, "scale_factor")
1796 _.layout.prop(settings, "lightmap_scale")
1797 _.layout.prop(settings, "light_scale" )
1798 _.layout.prop(settings, "image_quality" )
1799
1800 box = _.layout.box()
1801
1802 box.prop(settings, "project_name")
1803 box.prop(settings, "subdir")
1804
1805 box = _.layout.box()
1806 box.operator("convexer.detect_compilers")
1807 box.prop(settings, "exe_studiomdl")
1808 box.prop(settings, "exe_vbsp")
1809 box.prop(settings, "exe_vvis")
1810 box.prop(settings, "exe_vrad")
1811 box.prop(settings, "opt_vrad")
1812
1813 box = box.box()
1814 row = box.row()
1815 row.prop(settings,"comp_vmf")
1816 row.prop(settings,"comp_textures")
1817 row.prop(settings,"comp_models")
1818 row.prop(settings,"comp_compile")
1819
1820 text = "Compile" if CXR_COMPILER_CHAIN.TIMER == None else "Cancel"
1821 row = box.row()
1822 row.scale_y = 3
1823 row.operator("convexer.chain", text=text)
1824
1825
1826 class CXR_MATERIAL_PANEL(bpy.types.Panel):
1827 bl_label="VMT Properties"
1828 bl_idname="SCENE_PT_convexer_vmt"
1829 bl_space_type='PROPERTIES'
1830 bl_region_type='WINDOW'
1831 bl_context="material"
1832
1833 def draw(_,context):
1834 active_object = bpy.context.active_object
1835 if active_object == None: return
1836
1837 active_material = active_object.active_material
1838 if active_material == None: return
1839
1840 properties = active_material.cxr_data
1841 info = material_info( active_material )
1842
1843 _.layout.label(text=F"{info['name']} @{info['res'][0]}x{info['res'][1]}")
1844 _.layout.prop( properties, "shader" )
1845
1846 for xk in info:
1847 _.layout.label(text=F"{xk}:={info[xk]}")
1848
1849 def _mtex( name, img, uiParent ):
1850 nonlocal properties
1851
1852 box = uiParent.box()
1853 box.label( text=F'{name} "{img.filepath}"' )
1854 def _p2( x ):
1855 if ((x & (x - 1)) == 0):
1856 return x
1857 closest = 0
1858 closest_diff = 10000000
1859 for i in range(16):
1860 dist = abs((1 << i)-x)
1861 if dist < closest_diff:
1862 closest_diff = dist
1863 closest = i
1864 real = 1 << closest
1865 if x > real:
1866 return 1 << (closest+1)
1867 if x < real:
1868 return 1 << (closest-1)
1869 return x
1870
1871 if img is not None:
1872 row = box.row()
1873 row.prop( img.cxr_data, "export_res" )
1874 row.prop( img.cxr_data, "fmt" )
1875
1876 row = box.row()
1877 row.prop( img.cxr_data, "mipmap" )
1878 row.prop( img.cxr_data, "lod" )
1879 row.prop( img.cxr_data, "clamp" )
1880
1881 img.cxr_data.export_res[0] = _p2( img.cxr_data.export_res[0] )
1882 img.cxr_data.export_res[1] = _p2( img.cxr_data.export_res[1] )
1883
1884 def _mview( layer, uiParent ):
1885 nonlocal properties
1886
1887 for decl in layer:
1888 if isinstance(layer[decl],dict): # $property definition
1889 pdef = layer[decl]
1890 ptype = pdef['type']
1891
1892 thisnode = uiParent
1893 expandview = True
1894 drawthis = True
1895
1896 if ('shaders' in pdef) and \
1897 (properties.shader not in pdef['shaders']):
1898 continue
1899
1900 if ptype == 'intrinsic':
1901 if decl not in info:
1902 drawthis = False
1903
1904 if drawthis:
1905 for ch in pdef:
1906 if isinstance(pdef[ch],dict):
1907 if ptype == 'ui' or ptype == 'intrinsic':
1908 pass
1909 elif getattr(properties,decl) == pdef['default']:
1910 expandview = False
1911
1912 thisnode = uiParent.box()
1913 break
1914
1915 if ptype == 'ui':
1916 thisnode.label( text=decl )
1917 elif ptype == 'intrinsic':
1918 if isinstance(info[decl], bpy.types.Image):
1919 _mtex( decl, info[decl], thisnode )
1920 else:
1921 # hidden intrinsic value.
1922 # Means its a float array or something not an image
1923 thisnode.label(text=F"-- hidden intrinsic '{decl}' --")
1924 else:
1925 thisnode.prop(properties,decl)
1926 if expandview: _mview(pdef,thisnode)
1927
1928 _mview( cxr_shader_params, _.layout )
1929
1930 def cxr_entity_changeclass(_,context):
1931 active_object = context.active_object
1932
1933 # Create ID properties
1934 entdef = None
1935 classname = cxr_custom_class(active_object)
1936
1937 if classname in cxr_entities:
1938 entdef = cxr_entities[classname]
1939
1940 kvs = entdef['keyvalues']
1941 if callable(kvs): kvs = kvs(active_object)
1942
1943 for k in kvs:
1944 kv = kvs[k]
1945 key = F'cxrkv_{k}'
1946
1947 if callable(kv) or not isinstance(kv,dict): continue
1948
1949 if key not in active_object:
1950 active_object[key] = kv['default']
1951 id_prop = active_object.id_properties_ui(key)
1952 id_prop.update(default=kv['default'])
1953
1954 class CXR_ENTITY_PANEL(bpy.types.Panel):
1955 bl_label="Entity Config"
1956 bl_idname="SCENE_PT_convexer_entity"
1957 bl_space_type='PROPERTIES'
1958 bl_region_type='WINDOW'
1959 bl_context="object"
1960
1961 def draw(_,context):
1962 active_object = bpy.context.active_object
1963
1964 if active_object == None: return
1965
1966 default_context = {
1967 "scale": bpy.context.scene.cxr_data.scale_factor,
1968 "offset": (0,0,0)
1969 }
1970
1971 ecn = cxr_intrinsic_classname( active_object )
1972 classname = cxr_custom_class( active_object )
1973
1974 if ecn == None:
1975 if active_object.type == 'MESH':
1976 _.layout.prop( active_object.cxr_data, 'brushclass' )
1977 else: _.layout.prop( active_object.cxr_data, 'classname' )
1978
1979 if classname == 'NONE':
1980 return
1981 else:
1982 _.layout.label(text=F"<implementation defined ({ecn})>")
1983 _.layout.enabled=False
1984 classname = ecn
1985
1986 kvs = cxr_entity_keyvalues( {
1987 "object": active_object,
1988 "transform": default_context,
1989 "classname": classname
1990 })
1991
1992 if kvs != None:
1993 for kv in kvs:
1994 if kv[1]:
1995 _.layout.prop( active_object, F'["cxrkv_{kv[0]}"]', text=kv[0])
1996 else:
1997 row = _.layout.row()
1998 row.enabled = False
1999 row.label( text=F'{kv[0]}: {repr(kv[2])}' )
2000 else:
2001 _.layout.label( text=F"ERROR: NO CLASS DEFINITION" )
2002
2003 class CXR_LIGHT_PANEL(bpy.types.Panel):
2004 bl_label = "Source Settings"
2005 bl_idname = "LIGHT_PT_cxr"
2006 bl_space_type = 'PROPERTIES'
2007 bl_region_type = 'WINDOW'
2008 bl_context = "data"
2009
2010 def draw(self, context):
2011 layout = self.layout
2012 scene = context.scene
2013
2014 active_object = bpy.context.active_object
2015 if active_object == None: return
2016
2017 if active_object.type == 'LIGHT' or \
2018 active_object.type == 'LIGHT_PROBE':
2019
2020 properties = active_object.data.cxr_data
2021
2022 if active_object.type == 'LIGHT':
2023 layout.prop( properties, "realtime" )
2024 elif active_object.type == 'LIGHT_PROBE':
2025 layout.prop( properties, "size" )
2026
2027 # Settings groups
2028 # ------------------------------------------------------------------------------
2029
2030 class CXR_IMAGE_SETTINGS(bpy.types.PropertyGroup):
2031 export_res: bpy.props.IntVectorProperty(
2032 name="",
2033 description="Texture Export Resolution",
2034 default=(512,512),
2035 min=1,
2036 max=4096,
2037 size=2)
2038
2039 fmt: bpy.props.EnumProperty(
2040 name="Format",
2041 items = [
2042 ('DXT1', "DXT1", "BC1 compressed", '', 0),
2043 ('DXT5', "DXT5", "BC3 compressed", '', 1),
2044 ('RGB', "RGB", "Uncompressed", '', 2),
2045 ('RGBA', "RGBA", "Uncompressed (with alpha)", '', 3)
2046 ],
2047 description="Image format",
2048 default=0)
2049
2050 last_hash: bpy.props.StringProperty( name="" )
2051 asset_id: bpy.props.IntProperty(name="intl_assetid",default=0)
2052
2053 mipmap: bpy.props.BoolProperty(name="MIP",default=True)
2054 lod: bpy.props.BoolProperty(name="LOD",default=True)
2055 clamp: bpy.props.BoolProperty(name="CLAMP",default=False)
2056 flags: bpy.props.IntProperty(name="flags",default=0)
2057
2058 class CXR_LIGHT_SETTINGS(bpy.types.PropertyGroup):
2059 realtime: bpy.props.BoolProperty(name="Realtime Light", default=True)
2060
2061 class CXR_CUBEMAP_SETTINGS(bpy.types.PropertyGroup):
2062 size: bpy.props.EnumProperty(
2063 name="Resolution",
2064 items = [
2065 ('1',"1x1",'','',0),
2066 ('2',"2x2",'','',1),
2067 ('3',"4x4",'','',2),
2068 ('4',"8x8",'','',3),
2069 ('5',"16x16",'','',4),
2070 ('6',"32x32",'','',5),
2071 ('7',"64x64",'','',6),
2072 ('8',"128x128",'','',7),
2073 ('9',"256x256",'','',8)
2074 ],
2075 description="Texture resolution",
2076 default=7)
2077
2078 class CXR_ENTITY_SETTINGS(bpy.types.PropertyGroup):
2079 entity: bpy.props.BoolProperty(name="")
2080
2081 enum_pointents = [('NONE',"None","")]
2082 enum_brushents = [('NONE',"None","")]
2083
2084 for classname in cxr_entities:
2085 entdef = cxr_entities[classname]
2086 if 'allow' in entdef:
2087 itm = [(classname, classname, "")]
2088 if 'EMPTY' in entdef['allow']: enum_pointents += itm
2089 else: enum_brushents += itm
2090
2091 classname: bpy.props.EnumProperty(items=enum_pointents, name="Class", \
2092 update=cxr_entity_changeclass, default='NONE' )
2093
2094 brushclass: bpy.props.EnumProperty(items=enum_brushents, name="Class", \
2095 update=cxr_entity_changeclass, default='NONE' )
2096
2097 class CXR_MODEL_SETTINGS(bpy.types.PropertyGroup):
2098 last_hash: bpy.props.StringProperty( name="" )
2099 asset_id: bpy.props.IntProperty(name="vmf_settings",default=0)
2100
2101 class CXR_SCENE_SETTINGS(bpy.types.PropertyGroup):
2102 project_name: bpy.props.StringProperty( name="Project Name" )
2103 subdir: bpy.props.StringProperty( name="Subdirectory" )
2104
2105 exe_studiomdl: bpy.props.StringProperty( name="studiomdl" )
2106 exe_vbsp: bpy.props.StringProperty( name="vbsp" )
2107 opt_vbsp: bpy.props.StringProperty( name="args" )
2108 exe_vvis: bpy.props.StringProperty( name="vvis" )
2109 opt_vvis: bpy.props.StringProperty( name="args" )
2110 exe_vrad: bpy.props.StringProperty( name="vrad" )
2111 opt_vrad: bpy.props.StringProperty( name="args" )
2112
2113 debug: bpy.props.BoolProperty(name="Debug",default=False)
2114 scale_factor: bpy.props.FloatProperty( name="VMF Scale factor", \
2115 default=32.0,min=1.0)
2116 skybox_scale_factor: bpy.props.FloatProperty( name="Sky Scale factor", \
2117 default=1.0,min=0.01)
2118
2119 skybox_offset: bpy.props.FloatProperty(name="Sky offset",default=-4096.0)
2120 light_scale: bpy.props.FloatProperty(name="Light Scale",default=1.0/5.0)
2121 include_names: bpy.props.BoolProperty(name="Append original file names",\
2122 default=True)
2123 lightmap_scale: bpy.props.IntProperty(name="Global Lightmap Scale",\
2124 default=12)
2125 image_quality: bpy.props.IntProperty(name="Texture Quality (0-18)",\
2126 default=8, min=0, max=18 )
2127
2128 comp_vmf: bpy.props.BoolProperty(name="VMF",default=True)
2129 comp_models: bpy.props.BoolProperty(name="Models",default=True)
2130 comp_textures: bpy.props.BoolProperty(name="Textures",default=True)
2131 comp_compile: bpy.props.BoolProperty(name="Compile",default=True)
2132
2133 classes = [ CXR_RELOAD, CXR_DEV_OPERATOR, CXR_INTERFACE, \
2134 CXR_MATERIAL_PANEL, CXR_IMAGE_SETTINGS,\
2135 CXR_MODEL_SETTINGS, CXR_ENTITY_SETTINGS, CXR_CUBEMAP_SETTINGS,\
2136 CXR_LIGHT_SETTINGS, CXR_SCENE_SETTINGS, CXR_DETECT_COMPILERS,\
2137 CXR_ENTITY_PANEL, CXR_LIGHT_PANEL, CXR_PREVIEW_OPERATOR,\
2138 CXR_VIEW3D, CXR_COMPILER_CHAIN, CXR_RESET_HASHES ]
2139
2140 vmt_param_dynamic_class = None
2141
2142 def register():
2143 global cxr_view_draw_handler, vmt_param_dynamic_class, cxr_ui_handler
2144
2145 for c in classes:
2146 bpy.utils.register_class(c)
2147
2148 # Build dynamic VMT properties class defined by cxr_shader_params
2149 annotations_dict = {}
2150
2151 def _dvmt_propogate(layer):
2152 nonlocal annotations_dict
2153
2154 for decl in layer:
2155 if isinstance(layer[decl],dict): # $property definition
2156 pdef = layer[decl]
2157
2158 prop = None
2159 if pdef['type'] == 'bool':
2160 prop = bpy.props.BoolProperty(\
2161 name = pdef['name'],\
2162 default = pdef['default'])
2163
2164 elif pdef['type'] == 'float':
2165 prop = bpy.props.FloatProperty(\
2166 name = pdef['name'],\
2167 default = pdef['default'])
2168
2169 elif pdef['type'] == 'vector':
2170 if 'subtype' in pdef:
2171 prop = bpy.props.FloatVectorProperty(\
2172 name = pdef['name'],\
2173 subtype = pdef['subtype'],\
2174 default = pdef['default'],\
2175 size = len(pdef['default']))
2176 else:
2177 prop = bpy.props.FloatVectorProperty(\
2178 name = pdef['name'],\
2179 default = pdef['default'],\
2180 size = len(pdef['default']))
2181
2182 elif pdef['type'] == 'string':
2183 prop = bpy.props.StringProperty(\
2184 name = pdef['name'],\
2185 default = pdef['default'])
2186
2187 elif pdef['type'] == 'enum':
2188 prop = bpy.props.EnumProperty(\
2189 name = pdef['name'],\
2190 items = pdef['items'],\
2191 default = pdef['default'])
2192
2193 if prop != None:
2194 annotations_dict[decl] = prop
2195
2196 # Recurse into sub-definitions
2197 _dvmt_propogate(pdef)
2198
2199 annotations_dict["shader"] = bpy.props.EnumProperty(\
2200 name = "Shader",\
2201 items = [( _,\
2202 cxr_shaders[_]["name"],\
2203 '') for _ in cxr_shaders],\
2204 default = next(iter(cxr_shaders)))
2205
2206 annotations_dict["asset_id"] = bpy.props.IntProperty(name="intl_assetid",\
2207 default=0)
2208
2209 _dvmt_propogate( cxr_shader_params )
2210 vmt_param_dynamic_class = type(
2211 "CXR_VMT_DYNAMIC",
2212 (bpy.types.PropertyGroup,),{
2213 "__annotations__": annotations_dict
2214 },
2215 )
2216
2217 bpy.utils.register_class( vmt_param_dynamic_class )
2218
2219 # Pointer types
2220 bpy.types.Material.cxr_data = \
2221 bpy.props.PointerProperty(type=vmt_param_dynamic_class)
2222 bpy.types.Image.cxr_data = \
2223 bpy.props.PointerProperty(type=CXR_IMAGE_SETTINGS)
2224 bpy.types.Object.cxr_data = \
2225 bpy.props.PointerProperty(type=CXR_ENTITY_SETTINGS)
2226 bpy.types.Collection.cxr_data = \
2227 bpy.props.PointerProperty(type=CXR_MODEL_SETTINGS)
2228 bpy.types.Light.cxr_data = \
2229 bpy.props.PointerProperty(type=CXR_LIGHT_SETTINGS)
2230 bpy.types.LightProbe.cxr_data = \
2231 bpy.props.PointerProperty(type=CXR_CUBEMAP_SETTINGS)
2232 bpy.types.Scene.cxr_data = \
2233 bpy.props.PointerProperty(type=CXR_SCENE_SETTINGS)
2234
2235 # CXR Scene settings
2236
2237 # GPU / callbacks
2238 cxr_view_draw_handler = bpy.types.SpaceView3D.draw_handler_add(\
2239 cxr_draw,(),'WINDOW','POST_VIEW')
2240
2241 cxr_ui_handler = bpy.types.SpaceView3D.draw_handler_add(\
2242 cxr_ui,(None,None),'WINDOW','POST_PIXEL')
2243
2244 bpy.app.handlers.load_post.append(cxr_on_load)
2245 bpy.app.handlers.depsgraph_update_post.append(cxr_dgraph_update)
2246
2247 def unregister():
2248 global cxr_view_draw_handler, vmt_param_dynamic_class, cxr_ui_handler
2249
2250 bpy.utils.unregister_class( vmt_param_dynamic_class )
2251 for c in classes:
2252 bpy.utils.unregister_class(c)
2253
2254 bpy.app.handlers.depsgraph_update_post.remove(cxr_dgraph_update)
2255 bpy.app.handlers.load_post.remove(cxr_on_load)
2256
2257 bpy.types.SpaceView3D.draw_handler_remove(cxr_view_draw_handler,'WINDOW')
2258 bpy.types.SpaceView3D.draw_handler_remove(cxr_ui_handler,'WINDOW')