X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=blender_export.py;h=a12850b2b347f02b0391166b8cb90ed191716083;hb=98b9bcf0e10bc02cf679d03fa269613e140ba878;hp=a7e714c2fae4a76661b19f7a9fcfa0e1f9412be1;hpb=bdac014448b6ec968fe645f1581f321144f07dba;p=carveJwlIkooP6JGAAIwe30JlM.git diff --git a/blender_export.py b/blender_export.py index a7e714c..a12850b 100644 --- a/blender_export.py +++ b/blender_export.py @@ -1,8 +1,23 @@ +# +# ============================================================================= +# +# Copyright . . . -----, ,----- ,---. .---. +# 2021-2023 |\ /| | / | | | | /| +# | \ / | +-- / +----- +---' | / | +# | \ / | | / | | \ | / | +# | \/ | | / | | \ | / | +# ' ' '--' [] '----- '----- ' ' '---' SOFTWARE +# +# ============================================================================= +# +# Python exporter for Blender, compiles .mdl format for Skate Rift. # -# Copyright (C) 2021-2022 Mt.ZERO Software, Harry Godden - All Rights Reserved +# Its really slow, sorry, I don't know how to speed it up. +# Also not sure why you need to put # before {} in code blocks, there is errors +# otherwise # -import bpy, math, gpu +import bpy, math, gpu, os import cProfile from ctypes import * from mathutils import * @@ -42,10 +57,26 @@ class mdl_submesh(Structure): ("material_id",c_uint32)] # index into the material array #} +class mdl_texture(Structure): +#{ + _pack_ = 1 + _fields_ = [("pstr_name",c_uint32), + ("pack_offset",c_uint32), + ("pack_length",c_uint32)] +#} + class mdl_material(Structure): #{ _pack_ = 1 - _fields_ = [("pstr_name",c_uint32)] + _fields_ = [("pstr_name",c_uint32), + ("shader",c_uint32), + ("flags",c_uint32), + ("surface_prop",c_uint32), + ("colour",c_float*4), + ("colour1",c_float*4), + ("tex_diffuse",c_uint32), + ("tex_decal",c_uint32), + ("tex_normal",c_uint32)] #} class mdl_node(Structure): @@ -80,6 +111,9 @@ class mdl_header(Structure): ("material_count",c_uint32), ("material_offset",c_uint32), + ("texture_count",c_uint32), + ("texture_offset",c_uint32), + ("anim_count",c_uint32), ("anim_offset",c_uint32), @@ -96,7 +130,10 @@ class mdl_header(Structure): ("vertex_offset",c_uint32), ("indice_count",c_uint32), - ("indice_offset",c_uint32),] + ("indice_offset",c_uint32), + + ("pack_size",c_uint32), + ("pack_offset",c_uint32)] #} class mdl_animation(Structure): @@ -116,17 +153,29 @@ class mdl_keyframe(Structure): ("s",c_float*3)] #} -# Entity types -# ========================================== +# ---------------------------------------------------------------------------- # +# # +# Entity definitions # +# # +# ---------------------------------------------------------------------------- # # # ctypes _fields_ defines the data which is filled in by: # def encode_obj( _, node, node_def ): # # gizmos get drawn into the viewport via: # @staticmethod -# def editor_interface( object ): +# def draw_scene_helpers( obj ): +# +# editor enterface, simiraliy: +# @staticmethod +# def editor_interface( layout, obj ): # +# Classtype 1 +# +# Purpose: A rift. must target another gate, the target gate can not have more +# than one target nodes of its own. +# class classtype_gate(Structure): #{ _pack_ = 1 @@ -155,8 +204,98 @@ class classtype_gate(Structure): _.dims[2] = obj.cv_data.v0[2] #} #} + + @staticmethod + def draw_scene_helpers( obj ): + #{ + global cv_view_verts, cv_view_colours + + 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]] + cv_view_verts += [(v0[0],v0[1],v0[2])] + cv_view_verts += [(v1[0],v1[1],v1[2])] + cv_view_colours += [(1,1,0,1),(1,1,0,1)] + #} + + sw = (0.4,0.4,0.4,0.2) + if obj.cv_data.target != None: + cv_draw_arrow( obj.location, obj.cv_data.target.location, sw ) + #} + + @staticmethod + def editor_interface( layout, obj ): + #{ + layout.prop( obj.cv_data, "target" ) + + mesh = obj.data + layout.label( text=F"(i) Data is stored in {mesh.name}" ) + layout.prop( mesh.cv_data, "v0", text="Gate dimensions" ) + #} +#} + +class classtype_nonlocal_gate(classtype_gate): +#{ + def encode_obj(_,node,node_def): + #{ + node.classtype = 300 + + obj = node_def['obj'] + _.target = encoder_process_pstr( node_def['obj'].cv_data.strp ) + + if obj.type == 'MESH': + #{ + _.dims[0] = obj.data.cv_data.v0[0] + _.dims[1] = obj.data.cv_data.v0[1] + _.dims[2] = obj.data.cv_data.v0[2] + #} + else: + #{ + _.dims[0] = obj.cv_data.v0[0] + _.dims[1] = obj.cv_data.v0[1] + _.dims[2] = obj.cv_data.v0[2] + #} + #} + + @staticmethod + def editor_interface( layout, obj ): + #{ + layout.prop( obj.cv_data, "strp", text="Nonlocal ID" ) + + mesh = obj.data + layout.label( text=F"(i) Data is stored in {mesh.name}" ) + layout.prop( mesh.cv_data, "v0", text="Gate dimensions" ) + #} #} +# Classtype 3 +# +# Purpose: player can reset here, its a safe place +# spawns can share the same name, the closest one will be picked +# +# when the world loads it will pick the one named 'start' first. +# class classtype_spawn(Structure): #{ _pack_ = 1 @@ -167,8 +306,43 @@ class classtype_spawn(Structure): node.classtype = 3 _.pstr_alias = encoder_process_pstr( node_def['obj'].cv_data.strp ) #} + + @staticmethod + def draw_scene_helpers( obj ): + #{ + global cv_view_verts, cv_view_colours + + 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]] + + cv_view_verts += [(v0[0],v0[1],v0[2])] + cv_view_verts += [(v1[0],v1[1],v1[2])] + cv_view_colours += [(0,1,1,1),(0,1,1,1)] + #} + + cv_draw_sphere( obj.location, 20.0, [0.1,0,0.9,0.4] ) + #} + + @staticmethod + def editor_interface( layout, obj ): + #{ + layout.prop( obj.cv_data, "strp", text="Alias" ) + #} #} +# Classtype 4 +# +# Purpose: Tells the game to draw water HERE, at this entity. +# class classtype_water(Structure): #{ _pack_ = 1 @@ -181,6 +355,10 @@ class classtype_water(Structure): #} #} +# Classtype 8 +# +# Purpose: Defines a route node and links to up to two more nodes +# class classtype_route_node(Structure): #{ _pack_ = 1 @@ -197,12 +375,44 @@ class classtype_route_node(Structure): if obj.cv_data.target1 != None: _.target1 = obj.cv_data.target1.cv_data.uid #} + + @staticmethod + def draw_scene_helpers( obj ): + #{ + global cv_view_verts, cv_view_colours + + 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: + cv_draw_bpath( obj, obj.cv_data.target, sw, sw ) + if obj.cv_data.target1 != None: + cv_draw_bpath( obj, obj.cv_data.target1, sw, sw ) + + cv_draw_bhandle( obj, 1.0, (0.8,0.8,0.8,1.0) ) + cv_draw_bhandle( 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)) + cv_draw_arrow( obj.location, p1, sw ) + #} + + @staticmethod + def editor_interface( layout, obj ): + #{ + layout.prop( obj.cv_data, "target", text="Left" ) + layout.prop( obj.cv_data, "target1", text="Right" ) + #} #} +# Classtype 9 +# +# Purpose: Defines a route, its 'starting' point, and the colour to use for it +# class classtype_route(Structure): #{ _pack_ = 1 _fields_ = [("id_start",c_uint32), + ("pstr_name",c_uint32), ("colour",c_float*3)] def encode_obj(_, node,node_def): @@ -213,12 +423,118 @@ class classtype_route(Structure): _.colour[0] = obj.cv_data.colour[0] _.colour[1] = obj.cv_data.colour[1] _.colour[2] = obj.cv_data.colour[2] + _.pstr_name = encoder_process_pstr( obj.cv_data.strp ) if obj.cv_data.target != None: _.id_start = obj.cv_data.target.cv_data.uid #} + + @staticmethod + def draw_scene_helpers( obj ): + #{ + global cv_view_verts, cv_view_colours, cv_view_course_i + + if obj.cv_data.target: + cv_draw_arrow( obj.location, obj.cv_data.target.location, [1,1,1,1] ) + + # Tries to simulate how we do it in the game + # + 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 == '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 == 'classtype_gate' and \ + stack[sk].cv_data.classtype == 'classtype_gate': + #{ + dist = (stack[sj].location-stack[sk].location).magnitude + cv_draw_sbpath( stack[sj], stack[sk], cc*0.4, cc, dist, dist ) + #} + else: + cv_draw_bpath( stack[sj], stack[sk], cc, cc ) + #} + + cv_view_course_i += 1 + #} + #} + + @staticmethod + def editor_interface( layout, obj ): + #{ + layout.prop( obj.cv_data, "target", text="'Start' from" ) + layout.prop( obj.cv_data, "colour" ) + layout.prop( obj.cv_data, "strp", text="Name" ) + #} #} +# Classtype 12 +# +# Purpose: links an mesh node to a type 11 +# class classtype_skin(Structure): #{ _pack_ = 1 @@ -233,6 +549,10 @@ class classtype_skin(Structure): #} #} +# Classtype 11 +# +# Purpose: defines the allocation requirements for a skeleton +# class classtype_skeleton(Structure): #{ _pack_ = 1 @@ -254,16 +574,22 @@ class classtype_skeleton(Structure): #} #} + +# Classtype 10 +# +# Purpose: intrinsic bone type, stores collision information and limits too +# class classtype_bone(Structure): #{ _pack_ = 1 - _fields_ = [("deform",c_uint32), + _fields_ = [("flags",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)] + ("hitbox",(c_float*3)*2), + ("conevx",c_float*3), + ("conevy",c_float*3), + ("coneva",c_float*3), + ("conet",c_float)] def encode_obj(_, node,node_def): #{ @@ -272,19 +598,24 @@ class classtype_bone(Structure): armature_def = node_def['linked_armature'] obj = node_def['bone'] - _.deform = node_def['deform'] + _.flags = node_def['deform'] if 'ik_target' in node_def: #{ + _.flags |= 0x2 _.ik_target = armature_def['bones'].index( node_def['ik_target'] ) _.ik_pole = armature_def['bones'].index( node_def['ik_pole'] ) #} # For ragdolls # - if obj.cv_data.collider: + if obj.cv_data.collider != 'collider_none': #{ - _.collider = 1 + if obj.cv_data.collider == 'collider_box': + _.flags |= 0x4 + else: + _.flags |= 0x8 + _.hitbox[0][0] = obj.cv_data.v0[0] _.hitbox[0][1] = obj.cv_data.v0[2] _.hitbox[0][2] = -obj.cv_data.v1[1] @@ -295,32 +626,142 @@ class classtype_bone(Structure): if obj.cv_data.con0: #{ - _.use_limits = 1 - _.angle_limits[0][0] = obj.cv_data.mins[0] - _.angle_limits[0][1] = obj.cv_data.mins[2] - _.angle_limits[0][2] = -obj.cv_data.maxs[1] - _.angle_limits[1][0] = obj.cv_data.maxs[0] - _.angle_limits[1][1] = obj.cv_data.maxs[2] - _.angle_limits[1][2] = -obj.cv_data.mins[1] + _.flags |= 0x100 + _.conevx[0] = obj.cv_data.conevx[0] + _.conevx[1] = obj.cv_data.conevx[2] + _.conevx[2] = -obj.cv_data.conevx[1] + _.conevy[0] = obj.cv_data.conevy[0] + _.conevy[1] = obj.cv_data.conevy[2] + _.conevy[2] = -obj.cv_data.conevy[1] + _.coneva[0] = obj.cv_data.coneva[0] + _.coneva[1] = obj.cv_data.coneva[2] + _.coneva[2] = -obj.cv_data.coneva[1] + _.conet = obj.cv_data.conet #} #} #} +# Classtype 100 +# +# Purpose: sends a signal to another entity +# +class classtype_trigger(Structure): +#{ + _pack_ = 1 + _fields_ = [("target",c_uint32)] + + def encode_obj(_, node,node_def ): + #{ + node.classtype = 100 + if node_def['obj'].cv_data.target: + _.target = node_def['obj'].cv_data.target.cv_data.uid + #} + + @staticmethod + def draw_scene_helpers( obj ): + #{ + global cv_view_verts, cv_view_colours + cv_draw_ucube( obj.matrix_world, [0,1,0,1] ) + + if obj.cv_data.target: + cv_draw_arrow( obj.location, obj.cv_data.target.location, [1,1,1,1] ) + #} + + @staticmethod + def editor_interface( layout, obj ): + #{ + layout.prop( obj.cv_data, "target", text="Triggers" ) + #} +#} -# TO BE REPLACED +# Classtype 101 +# +# Purpose: Gives the player an achievement. +# No cheating! You shouldn't use this entity anyway, since only ME can +# add achievements to the steam ;) # -class classtype_achievement_box(Structure): +class classtype_logic_achievement(Structure): #{ _pack_ = 1 - _fields_ = [("pstr_name",c_uint32), - ("trigger",c_uint32)] + _fields_ = [("pstr_name",c_uint32)] def encode_obj(_, node,node_def ): #{ - node.classtype = 0 + node.classtype = 101 + _.pstr_name = encoder_process_pstr( node_def['obj'].cv_data.strp ) + #} + + @staticmethod + def editor_interface( layout, obj ): + #{ + layout.prop( obj.cv_data, "strp", text="Achievement ID" ) + #} +#} + +# Classtype 102 +# +# Purpose: sends a signal to another entity +# +class classtype_logic_relay(Structure): +#{ + _pack_ = 1 + _fields_ = [("targets",c_uint32*4)] + + def encode_obj(_, node,node_def ): + #{ + node.classtype = 102 + obj = node_def['obj'] + if obj.cv_data.target: + _.targets[0] = obj.cv_data.target.cv_data.uid + if obj.cv_data.target1: + _.targets[1] = obj.cv_data.target1.cv_data.uid + if obj.cv_data.target2: + _.targets[2] = obj.cv_data.target2.cv_data.uid + if obj.cv_data.target3: + _.targets[3] = obj.cv_data.target3.cv_data.uid + #} + + @staticmethod + def draw_scene_helpers( obj ): + #{ + global cv_view_verts, cv_view_colours + + if obj.cv_data.target: + cv_draw_arrow( obj.location, obj.cv_data.target.location, [1,1,1,1] ) + if obj.cv_data.target1: + cv_draw_arrow( obj.location, obj.cv_data.target1.location, [1,1,1,1] ) + if obj.cv_data.target2: + cv_draw_arrow( obj.location, obj.cv_data.target2.location, [1,1,1,1] ) + if obj.cv_data.target3: + cv_draw_arrow( obj.location, obj.cv_data.target3.location, [1,1,1,1] ) + #} + + @staticmethod + def editor_interface( layout, obj ): + #{ + layout.prop( obj.cv_data, "target", text="Triggers" ) + layout.prop( obj.cv_data, "target1", text="Triggers" ) + layout.prop( obj.cv_data, "target2", text="Triggers" ) + layout.prop( obj.cv_data, "target3", text="Triggers" ) #} #} +# Classtype 14 +# +# Purpose: Plays some audio (44100hz .ogg vorbis only) +# NOTE: There is a 32mb limit on the audio buffer, world audio is +# decompressed and stored in signed 16 bit integers (2 bytes) +# per sample. +# +# volume: not used if has 3D flag +# flags: +# AUDIO_FLAG_LOOP 0x1 +# AUDIO_FLAG_ONESHOT 0x2 (DONT USE THIS, it breaks semaphores) +# AUDIO_FLAG_SPACIAL_3D 0x4 (Probably what you want) +# AUDIO_FLAG_AUTO_START 0x8 (Play when the world starts) +# ...... +# the rest are just internal flags, only use the above 3. +# class classtype_audio(Structure): #{ _pack_ = 1 @@ -335,57 +776,199 @@ class classtype_audio(Structure): obj = node_def['obj'] _.pstr_file = encoder_process_pstr( obj.cv_data.strp ) - _.flags = obj.cv_data.intp + + flags = 0x00 + if obj.cv_data.bp0: flags |= 0x1 + if obj.cv_data.bp1: flags |= 0x4 + if obj.cv_data.bp2: flags |= 0x8 + + _.flags = flags _.volume = obj.cv_data.fltp #} @staticmethod - def editor_interface(yada): + def editor_interface( layout, obj ): #{ - pass + layout.prop( obj.cv_data, "strp" ) + + layout.prop( obj.cv_data, "bp0", text = "Looping" ) + layout.prop( obj.cv_data, "bp1", text = "3D Audio" ) + layout.prop( obj.cv_data, "bp2", text = "Auto Start" ) #} @staticmethod - def draw_scene_helpers(yada): + def draw_scene_helpers( obj ): #{ - pass + global cv_view_verts, cv_view_colours + + cv_draw_sphere( obj.location, obj.scale[0], [1,1,0,1] ) #} #} - -# Current encoder state +# Classtype 200 +# +# Purpose: world light # -g_encoder = None +class classtype_world_light( Structure ): +#{ + _pack_ = 1 + _fields_ = [("type",c_uint32), + ("colour",c_float*4), + ("angle",c_float), + ("range",c_float)] + def encode_obj(_, node, node_def): + #{ + node.classtype = 200 + + obj = node_def['obj'] + data = obj.data + _.colour[0] = data.color[0] + _.colour[1] = data.color[1] + _.colour[2] = data.color[2] + _.colour[3] = data.energy + _.range = data.cutoff_distance # this has to be manually set + # TODO: At some point, automate a min + # threshold value + + if obj.data.type == 'POINT': + #{ + _.type = 0 + _.angle = 0.0 + #} + elif obj.data.type == 'SPOT': + #{ + _.type = 1 + _.angle = data.spot_size*0.5 + #} -# Reset encoder + if data.cv_data.bp0: + _.type += 2 + #} + + @staticmethod + def editor_interface( layout, obj ): + #{ + pass + #} +#} + +# Classtype 201 +# +# Purpose: lighting settings for world # -def encoder_init(): +class classtype_lighting_info(Structure): #{ - global g_encoder + _pack_ = 1 + _fields_ = [("colours",(c_float*3)*3), + ("directions",(c_float*2)*3), + ("states",c_uint32*3), + ("shadow_spread",c_float), + ("shadow_length",c_float), + ("ambient",c_float*3)] + + def encode_obj(_, node, node_def): + #{ + node.classtype = 201 - g_encoder = \ - { - # The actual file header - # - 'header': mdl_header(), + # TODO + #} - # Compiled data chunks (each can be read optionally by the client) - # - 'data': - { - #1--------------------------------- - 'node': [], # Metadata 'chunk' - 'submesh': [], - 'material': [], - 'anim': [], - 'entdata': bytearray(), # variable width - 'strings': bytearray(), # . - #2--------------------------------- - 'keyframe': [], # Animations - #3--------------------------------- + @staticmethod + def editor_interface( layout, obj ): + #{ + pass + #} +#} + +class classtype_spawn_link(Structure): +#{ + _pack_ = 1 + _fields_ = [("connections",c_uint32*4)] + + def encode_obj(_, node,node_def ): + #{ + node.classtype = 0 + #} + + @staticmethod + def editor_interface( layout, obj ): + #{ + pass + #} + + @staticmethod + def draw_scene_helpers( obj ): + #{ + global cv_view_verts, cv_view_colours + + count = 0 + + for obj1 in bpy.context.collection.objects: + #{ + if (obj1.cv_data.classtype != 'classtype_spawn_link') and \ + (obj1.cv_data.classtype != 'classtype_spawn') : + continue + + if (obj1.location - obj.location).length < 40.0: + #{ + cv_draw_line( obj.location, obj1.location, [1,1,1,1] ) + count +=1 + #} + + if count == 4: + break + #} + + cv_draw_sphere( obj.location, 20.0, [0.5,0,0.2,0.4] ) + #} +#} + +# ---------------------------------------------------------------------------- # +# # +# Compiler section # +# # +# ---------------------------------------------------------------------------- # + +# Current encoder state +# +g_encoder = None + +# Reset encoder +# +def encoder_init( collection ): +#{ + global g_encoder + + g_encoder = \ + { + # The actual file header + # + 'header': mdl_header(), + + # Options + # + 'pack_textures': collection.cv_data.pack_textures, + + # Compiled data chunks (each can be read optionally by the client) + # + 'data': + { + #1--------------------------------- + 'node': [], # Metadata 'chunk' + 'submesh': [], + 'material': [], + 'texture': [], + 'anim': [], + 'entdata': bytearray(), # variable width + 'strings': bytearray(), # . + #2--------------------------------- + 'keyframe': [], # Animations + #3--------------------------------- 'vertex': [], # Mesh data 'indice': [], + #4--------------------------------- + 'pack': bytearray() # Other generic packed data }, # All objects of the model in their final heirachy @@ -399,16 +982,27 @@ def encoder_init(): 'string_cache':{}, 'mesh_cache': {}, 'material_cache': {}, + 'texture_cache': {} } g_encoder['header'].identifier = 0xABCD0000 g_encoder['header'].version = 1 - # Add fake NoneID material + # Add fake NoneID material and texture # - none_material = c_uint32(1234) - none_material.name = "" - encoder_process_material( none_material ) + none_material = mdl_material() + none_material.pstr_name = encoder_process_pstr( "" ) + none_material.texture_id = 0 + + none_texture = mdl_texture() + none_texture.pstr_name = encoder_process_pstr( "" ) + none_texture.pack_offset = 0 + none_texture.pack_length = 0 + + g_encoder['data']['material'] += [none_material] + g_encoder['data']['texture'] += [none_texture] + + g_encoder['data']['pack'].extend( b'datapack\0\0\0\0\0\0\0\0' ) # Add root node # @@ -471,6 +1065,175 @@ def encoder_process_pstr( s ): return cache[s] #} +def get_texture_resource_name( img ): +#{ + return os.path.splitext( img.name )[0] +#} + +# Pack a texture +# +def encoder_process_texture( img ): +#{ + global g_encoder + + if img == None: + return 0 + + cache = g_encoder['texture_cache'] + buffer = g_encoder['data']['texture'] + pack = g_encoder['data']['pack'] + + name = get_texture_resource_name( img ) + + if name in cache: + return cache[name] + + cache[name] = len( buffer ) + + tex = mdl_texture() + tex.pstr_name = encoder_process_pstr( name ) + + if g_encoder['pack_textures']: + #{ + tex.pack_offset = len( pack ) + pack.extend( qoi_encode( img ) ) + tex.pack_length = len( pack ) - tex.pack_offset + #} + else: + tex.pack_offset = 0 + + buffer += [ tex ] + return cache[name] +#} + +def material_tex_image(v): +#{ + return { + "Image Texture": + { + "image": F"{v}" + } + } +#} + +cxr_graph_mapping = \ +{ + # Default shader setup + "Principled BSDF": + { + "Base Color": + { + "Image Texture": + { + "image": "tex_diffuse" + }, + "Mix": + { + "A": material_tex_image("tex_diffuse"), + "B": material_tex_image("tex_decal") + }, + }, + "Normal": + { + "Normal Map": + { + "Color": material_tex_image("tex_normal") + } + } + } +} + +# https://harrygodden.com/git/?p=convexer.git;a=blob;f=__init__.py;#l1164 +# +def material_info(mat): +#{ + info = {} + + # Using the cv_graph_mapping as a reference, go through the shader + # graph and gather all $props from it. + # + def _graph_read( node_def, node=None, depth=0 ): + #{ + nonlocal mat + nonlocal info + + # Find rootnodes + # + if node == None: + #{ + _graph_read.extracted = [] + + for node_idname in node_def: + #{ + for n in mat.node_tree.nodes: + #{ + if n.name == node_idname: + #{ + node_def = node_def[node_idname] + node = n + break + #} + #} + #} + #} + + for link in node_def: + #{ + link_def = node_def[link] + + if isinstance( link_def, dict ): + #{ + node_link = None + for x in node.inputs: + #{ + if isinstance( x, bpy.types.NodeSocketColor ): + #{ + if link == x.name: + #{ + node_link = x + break + #} + #} + #} + + if node_link and node_link.is_linked: + #{ + # look for definitions for the connected node type + # + from_node = node_link.links[0].from_node + + node_name = from_node.name.split('.')[0] + if node_name in link_def: + #{ + from_node_def = link_def[ node_name ] + + _graph_read( from_node_def, from_node, depth+1 ) + #} + + # No definition! :( + # TODO: Make a warning for this? + #} + else: + #{ + if "default" in link_def: + #{ + prop = link_def['default'] + info[prop] = node_link.default_value + #} + #} + #} + else: + #{ + prop = link_def + info[prop] = getattr( node, link ) + #} + #} + #} + + _graph_read( cxr_graph_mapping ) + return info +#} + # Add a material to the material buffer. Returns 0 (None ID) if invalid # def encoder_process_material( mat ): @@ -490,8 +1253,69 @@ def encoder_process_material( mat ): dest = mdl_material() dest.pstr_name = encoder_process_pstr( mat.name ) - buffer += [dest] + + flags = 0x00 + if mat.cv_data.collision: + flags |= 0x2 + if mat.cv_data.skate_surface: flags |= 0x1 + if mat.cv_data.grind_surface: flags |= (0x8|0x1) + + if mat.cv_data.grow_grass: flags |= 0x4 + dest.flags = flags + + if mat.cv_data.surface_prop == 'concrete': dest.surface_prop = 0 + if mat.cv_data.surface_prop == 'wood': dest.surface_prop = 1 + if mat.cv_data.surface_prop == 'grass': dest.surface_prop = 2 + + if mat.cv_data.shader == 'standard': dest.shader = 0 + if mat.cv_data.shader == 'standard_cutout': dest.shader = 1 + if mat.cv_data.shader == 'terrain_blend': + #{ + dest.shader = 2 + + dest.colour[0] = pow( mat.cv_data.sand_colour[0], 1.0/2.2 ) + dest.colour[1] = pow( mat.cv_data.sand_colour[1], 1.0/2.2 ) + dest.colour[2] = pow( mat.cv_data.sand_colour[2], 1.0/2.2 ) + dest.colour[3] = 1.0 + + dest.colour1[0] = mat.cv_data.blend_offset[0] + dest.colour1[1] = mat.cv_data.blend_offset[1] + #} + + if mat.cv_data.shader == 'vertex_blend': + #{ + dest.shader = 3 + + dest.colour1[0] = mat.cv_data.blend_offset[0] + dest.colour1[1] = mat.cv_data.blend_offset[1] + #} + + if mat.cv_data.shader == 'water': + #{ + dest.shader = 4 + + dest.colour[0] = pow( mat.cv_data.shore_colour[0], 1.0/2.2 ) + dest.colour[1] = pow( mat.cv_data.shore_colour[1], 1.0/2.2 ) + dest.colour[2] = pow( mat.cv_data.shore_colour[2], 1.0/2.2 ) + dest.colour[3] = 1.0 + dest.colour1[0] = pow( mat.cv_data.ocean_colour[0], 1.0/2.2 ) + dest.colour1[1] = pow( mat.cv_data.ocean_colour[1], 1.0/2.2 ) + dest.colour1[2] = pow( mat.cv_data.ocean_colour[2], 1.0/2.2 ) + dest.colour1[3] = 1.0 + #} + + inf = material_info( mat ) + + if mat.cv_data.shader == 'standard' or \ + mat.cv_data.shader == 'standard_cutout' or \ + mat.cv_data.shader == 'terrain_blend' or \ + mat.cv_data.shader == 'vertex_blend': + #{ + if 'tex_diffuse' in inf: + dest.tex_diffuse = encoder_process_texture(inf['tex_diffuse']) + #} + buffer += [dest] return cache[mat.name] #} @@ -523,10 +1347,12 @@ def encoder_build_scene_graph( collection ): for obj in collection.all_objects: #{ - if obj.parent: continue + #if obj.parent: continue def _extend( p, n, d ): #{ + nonlocal collection + uid = _new_uid() tree = {} tree["uid"] = uid @@ -535,7 +1361,7 @@ def encoder_build_scene_graph( collection ): tree["obj"] = n tree["parent"] = p n.cv_data.uid = uid - + # Descend into amature # if n.type == 'ARMATURE': @@ -543,6 +1369,7 @@ def encoder_build_scene_graph( collection ): tree["bones"] = [None] # None is the root transform tree["ik_count"] = 0 tree["collider_count"] = 0 + tree["compile_animation"] = collection.cv_data.animations # Here also collects some information about constraints, ik and # counts colliders for the armature. @@ -575,7 +1402,7 @@ def encoder_build_scene_graph( collection ): #} #} - if n.cv_data.collider: + if n.cv_data.collider != 'collider_none': tree['collider_count'] += 1 btree['deform'] = n.use_deform @@ -585,14 +1412,12 @@ def encoder_build_scene_graph( collection ): for b in n.data.bones: if not b.parent: _extendb( tree, b, d+1 ) - #} #} # Recurse into children of this object # for obj1 in n.children: #{ - nonlocal collection for c1 in obj1.users_collection: #{ if c1 == collection: @@ -647,18 +1472,18 @@ def encoder_vertex_push( vertex_reference, co,norm,uv,colour,groups,weights ): int(norm[2]*m+0.5), int(uv[0]*m+0.5), int(uv[1]*m+0.5), - colour[0]*m+0.5, # these guys are already quantized - colour[1]*m+0.5, # . - colour[2]*m+0.5, # . - colour[3]*m+0.5, # . - weights[0]*m+0.5, # v - weights[1]*m+0.5, - weights[2]*m+0.5, - weights[3]*m+0.5, - groups[0]*m+0.5, - groups[1]*m+0.5, - groups[2]*m+0.5, - groups[3]*m+0.5) + colour[0], # these guys are already quantized + colour[1], # . + colour[2], # . + colour[3], # . + weights[0], # v + weights[1], + weights[2], + weights[3], + groups[0], + groups[1], + groups[2], + groups[3]) if key in vertex_reference: return vertex_reference[key] @@ -742,9 +1567,6 @@ def encoder_compile_mesh( node, node_def ): node.submesh_start = len( g_encoder['data']['submesh'] ) node.submesh_count = 0 - default_mat = c_uint32(12345) - default_mat.name = "" - dgraph = bpy.context.evaluated_depsgraph_get() data = obj.evaluated_get(dgraph).data data.calc_loop_triangles() @@ -752,7 +1574,7 @@ def encoder_compile_mesh( node, node_def ): # Mesh is split into submeshes based on their material # - mat_list = data.materials if len(data.materials) > 0 else [default_mat] + mat_list = data.materials if len(data.materials) > 0 else [None] for material_id, mat in enumerate(mat_list): #{ mref = {} @@ -849,6 +1671,20 @@ def encoder_compile_mesh( node, node_def ): weights[ml] = max( weights[ml], 0 ) #} #} + #} + else: + #{ + li1 = tri.loops[(j+1)%3] + vi1 = data.loops[li1].vertex_index + e0 = data.edges[ data.loops[li].edge_index ] + + if e0.use_freestyle_mark and \ + ((e0.vertices[0] == vi and e0.vertices[1] == vi1) or \ + (e0.vertices[0] == vi1 and e0.vertices[1] == vi)): + #{ + weights[0] = 1 + #} + #} # Add vertex and expand bound box # @@ -943,7 +1779,12 @@ def encoder_compile_armature( node, node_def ): # extra info node_def['anim_start'] = len(animdata) node_def['anim_count'] = 0 - + + if not node_def['compile_animation']: + #{ + return + #} + # Compile anims # if obj.animation_data: @@ -1081,10 +1922,14 @@ def encoder_process_definition( node_def ): #{ obj = node_def['obj'] obj_type = obj.type - obj_co = obj.location + obj_co = obj.matrix_world @ Vector((0,0,0)) if obj_type == 'ARMATURE': obj_classtype = 'classtype_skeleton' + elif obj_type == 'LIGHT': + #{ + obj_classtype = 'classtype_world_light' + #} else: #{ obj_classtype = obj.cv_data.classtype @@ -1257,10 +2102,13 @@ def write_model(collection_name): #{ global g_encoder print( F"Model graph | Create mode '{collection_name}'" ) + folder = bpy.path.abspath(bpy.context.scene.cv_data.export_dir) + path = F"{folder}{collection_name}.mdl" + print( path ) collection = bpy.data.collections[collection_name] - encoder_init() + encoder_init( collection ) encoder_build_scene_graph( collection ) # Compile @@ -1272,467 +2120,612 @@ def write_model(collection_name): # Write # - # TODO HOLY - path = F"/home/harry/Documents/carve/models_src/{collection_name}.mdl" encoder_write_to_file( path ) print( F"Completed {collection_name}.mdl" ) #} - -# Clicky clicky GUI -# ------------------------------------------------------------------------------ +# ---------------------------------------------------------------------------- # +# # +# GUI section # +# # +# ---------------------------------------------------------------------------- # cv_view_draw_handler = None cv_view_shader = gpu.shader.from_builtin('3D_SMOOTH_COLOR') +cv_view_verts = [] +cv_view_colours = [] +cv_view_course_i = 0 -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('LESS') - gpu.state.blend_set('NONE') - - verts = [] - colours = [] - - #def drawbezier(p0,h0,p1,h1,c0,c1): - # nonlocal verts, colours - - # verts += [p0] - # verts += [h0] - # colours += [(0.5,0.5,0.5,1.0),(0.5,0.5,0.5,1)] - # verts += [p1] - # verts += [h1] - # colours += [(1.0,1.0,1,1),(1,1,1,1)] - # - # last = p0 - # for i in range(10): - # t = (i+1)/10 - # a0 = 1-t - - # tt = t*t - # ttt = tt*t - # p=ttt*p1+(3*tt-3*ttt)*h1+(3*ttt-6*tt+3*t)*h0+(3*tt-ttt-3*t+1)*p0 - # verts += [(last[0],last[1],last[2])] - # verts += [(p[0],p[1],p[2])] - # colours += [c0*a0+c1*(1-a0),c0*a0+c1*(1-a0)] - # last = p - - course_count = 0 - - def drawbhandle(obj, direction, colour): - nonlocal verts, colours - p0 = obj.location - h0 = obj.matrix_world @ Vector((0,direction,0)) - verts += [p0] - verts += [h0] - colours += [colour,colour] - - def drawbezier(p0,h0,p1,h1,c0,c1): - nonlocal verts, colours - - last = p0 - for i in range(10): - t = (i+1)/10 - a0 = 1-t - - tt = t*t - ttt = tt*t - p=ttt*p1+(3*tt-3*ttt)*h1+(3*ttt-6*tt+3*t)*h0+(3*tt-ttt-3*t+1)*p0 - verts += [(last[0],last[1],last[2])] - verts += [(p[0],p[1],p[2])] - colours += [c0*a0+c1*(1-a0),c0*a0+c1*(1-a0)] - last = p - - def drawsbpath(o0,o1,c0,c1,s0,s1): - nonlocal course_count - - offs = ((course_count % 2)*2-1) * course_count * 0.02 +# Draw axis alligned sphere at position with radius +# +def cv_draw_sphere( pos, radius, colour ): +#{ + global cv_view_verts, cv_view_colours + + ly = pos + Vector((0,0,radius)) + lx = pos + Vector((0,radius,0)) + lz = pos + Vector((0,0,radius)) + + pi = 3.14159265358979323846264 - 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) + for i in range(16): + #{ + t = ((i+1.0) * 1.0/16.0) * pi * 2.0 + s = math.sin(t) + c = math.cos(t) - def drawbpath(o0,o1,c0,c1): - drawsbpath(o0,o1,c0,c1,1.0,1.0) + py = pos + Vector((s*radius,0.0,c*radius)) + px = pos + Vector((s*radius,c*radius,0.0)) + pz = pos + Vector((0.0,s*radius,c*radius)) - def drawbline(p0,p1,c0,c1): - nonlocal verts, colours - verts += [p0,p1] - colours += [c0,c1] + cv_view_verts += [ px, lx ] + cv_view_verts += [ py, ly ] + cv_view_verts += [ pz, lz ] - 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)) - + cv_view_colours += [ colour, colour, colour, colour, colour, colour ] - if obj.cv_data.classtype == 'classtype_gate': - if obj.type == 'MESH': - dims = obj.data.cv_data.v0 - else: - dims = obj.cv_data.v0 + ly = py + lx = px + lz = pz + #} + cv_draw_lines() +#} - vs = [None]*9 - c = Vector((0,0,dims[2])) +# Draw axis alligned sphere at position with radius +# +def cv_draw_halfsphere( pos, tx, ty, tz, radius, colour ): +#{ + global cv_view_verts, cv_view_colours + + ly = pos + tz*radius + lx = pos + ty*radius + lz = pos + tz*radius + + pi = 3.14159265358979323846264 - 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))) + for i in range(16): + #{ + t = ((i+1.0) * 1.0/16.0) * pi + s = math.sin(t) + c = math.cos(t) - indices = [(0,1),(1,2),(2,3),(3,0),(4,5),(5,6),(7,8)] + s1 = math.sin(t*2.0) + c1 = math.cos(t*2.0) - 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 == '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 == '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])) + py = pos + s*tx*radius + c *tz*radius + px = pos + s*tx*radius + c *ty*radius + pz = pos + s1*ty*radius + c1*tz*radius - 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)] + cv_view_verts += [ px, lx ] + cv_view_verts += [ py, ly ] + cv_view_verts += [ pz, lz ] - 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 == '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])) + cv_view_colours += [ colour, colour, colour, colour, colour, colour ] - 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)] + ly = py + lx = px + lz = pz + #} + cv_draw_lines() +#} - 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 == '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)] +# Draw transformed -1 -> 1 cube +# +def cv_draw_ucube( transform, colour ): +#{ + global cv_view_verts, cv_view_colours - 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 == '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 == '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 + a = Vector((-1,-1,-1)) + b = Vector((1,1,1)) + + vs = [None]*8 + vs[0] = transform @ Vector((a[0], a[1], a[2])) + vs[1] = transform @ Vector((a[0], b[1], a[2])) + vs[2] = transform @ Vector((b[0], b[1], a[2])) + vs[3] = transform @ Vector((b[0], a[1], a[2])) + vs[4] = transform @ Vector((a[0], a[1], b[2])) + vs[5] = transform @ Vector((a[0], b[1], b[2])) + vs[6] = transform @ Vector((b[0], b[1], b[2])) + vs[7] = transform @ 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]] + cv_view_verts += [(v0[0],v0[1],v0[2])] + cv_view_verts += [(v1[0],v1[1],v1[2])] + cv_view_colours += [(0,1,0,1),(0,1,0,1)] + #} + cv_draw_lines() +#} - if si == 0: # Loop failed to complete - break +# Draw line with colour +# +def cv_draw_line( p0, p1, colour ): +#{ + global cv_view_verts, cv_view_colours - node = stack[si-1] + cv_view_verts += [p0,p1] + cv_view_colours += [colour, colour] + cv_draw_lines() +#} - targets = [None,None] - targets[0] = node.cv_data.target +# Draw line with colour(s) +# +def cv_draw_line2( p0, p1, c0, c1 ): +#{ + global cv_view_verts, cv_view_colours - if node.cv_data.classtype == 'classtype_route_node': - targets[1] = node.cv_data.target1 - - nextnode = targets[stack_i[si-1]] - stack_i[si-1] += 1 + cv_view_verts += [p0,p1] + cv_view_colours += [c0,c1] + cv_draw_lines() +#} - if nextnode != None: # branch - if nextnode == stack[0]: # Loop completed - loop_complete = True - break +# +# +def cv_tangent_basis( n, tx, ty ): +#{ + if abs( n[0] ) >= 0.57735027: + #{ + tx[0] = n[1] + tx[1] = -n[0] + tx[2] = 0.0 + #} + else: + #{ + tx[0] = 0.0 + tx[1] = n[2] + tx[2] = -n[1] + #} - valid=True - for sj in range(si): - if stack[sj] == nextnode: # invalidated path - valid=False - break + tx.normalize() + _ty = n.cross( tx ) - if valid: - stack_i[si] = 0 - stack[si] = nextnode - si += 1 - continue + ty[0] = _ty[0] + ty[1] = _ty[1] + ty[2] = _ty[2] +#} - if loop_complete: - cc = Vector((obj.cv_data.colour[0],\ - obj.cv_data.colour[1],\ - obj.cv_data.colour[2],\ - 1.0)) +# Draw coloured arrow +# +def cv_draw_arrow( p0, p1, c0 ): +#{ + global cv_view_verts, cv_view_colours - for sj in range(si): - sk = (sj+1)%si + n = p1-p0 + midpt = p0 + n*0.5 + n.normalize() - if stack[sj].cv_data.classtype == 'classtype_gate' and \ - stack[sk].cv_data.classtype == 'classtype_gate': - dist = (stack[sj].location-stack[sk].location).magnitude - drawsbpath( stack[sj], stack[sk], cc*0.4, cc, dist, dist ) + tx = Vector((1,0,0)) + ty = Vector((1,0,0)) + cv_tangent_basis( n, tx, ty ) + + cv_view_verts += [p0,p1, midpt+(tx-n)*0.15,midpt, midpt+(-tx-n)*0.15,midpt ] + cv_view_colours += [c0,c0,c0,c0,c0,c0] + cv_draw_lines() +#} - else: - drawbpath( stack[sj], stack[sk], cc, cc ) +# Drawhandles of a bezier control point +# +def cv_draw_bhandle( obj, direction, colour ): +#{ + global cv_view_verts, cv_view_colours - course_count += 1 + p0 = obj.location + h0 = obj.matrix_world @ Vector((0,direction,0)) - elif obj.cv_data.classtype == '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) ) + cv_view_verts += [p0] + cv_view_verts += [h0] + cv_view_colours += [colour,colour] + cv_draw_lines() +#} - if obj.cv_data.target != None: - v1 = obj.cv_data.target.matrix_world.to_quaternion()@Vector((0,1,0)) - c1 = Vector((v1.x*0.5+0.5, v1.y*0.5+0.5, 0.0, 1.0)) +# Draw a bezier curve (at fixed resolution 10) +# +def cv_draw_bezier( p0,h0,p1,h1,c0,c1 ): +#{ + global cv_view_verts, cv_view_colours - drawbhandle( obj.cv_data.target, -1.0, (0.5,0.5,0.5,1.0) ) - drawbpath( obj, obj.cv_data.target, c0, c1 ) + 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 + + cv_view_verts += [(last[0],last[1],last[2])] + cv_view_verts += [(p[0],p[1],p[2])] + cv_view_colours += [c0*a0+c1*(1-a0),c0*a0+c1*(1-a0)] - 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)) + last = p + #} + cv_draw_lines() +#} - drawbhandle( obj.cv_data.target1, -1.0, (0.5,0.5,0.5,1.0) ) - drawbpath( obj, obj.cv_data.target1, c0, c1 ) +# I think this one extends the handles of the bezier otwards...... +# +def cv_draw_sbpath( o0,o1,c0,c1,s0,s1 ): +#{ + global cv_view_course_i + + offs = ((cv_view_course_i % 2)*2-1) * cv_view_course_i * 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)) + + cv_draw_bezier( p0,h0,p1,h1,c0,c1 ) + cv_draw_lines() +#} + +# Flush the lines buffers. This is called often because god help you if you want +# to do fixed, fast buffers in this catastrophic programming language. +# +def cv_draw_lines(): +#{ + global cv_view_shader, cv_view_verts, cv_view_colours + + if len(cv_view_verts) < 2: + return lines = batch_for_shader(\ cv_view_shader, 'LINES', \ - { "pos":verts, "color":colours }) + { "pos":cv_view_verts, "color":cv_view_colours }) lines.draw( cv_view_shader ) + cv_view_verts = [] + cv_view_colours = [] +#} + +# I dont remember what this does exactly +# +def cv_draw_bpath( o0,o1,c0,c1 ): +#{ + cv_draw_sbpath( o0,o1,c0,c1,1.0,1.0 ) +#} + +# Semi circle to show the limit. and some lines +# +def draw_limit( obj, center, major, minor, amin, amax, colour ): +#{ + global cv_view_verts, cv_view_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 = center + major*f*math.cos(a0) + minor*f*math.sin(a0) + p1 = center + major*f*math.cos(a1) + minor*f*math.sin(a1) + + p0=obj.matrix_world @ p0 + p1=obj.matrix_world @ p1 + cv_view_verts += [p0,p1] + cv_view_colours += [colour,colour] + + if x == 0: + #{ + cv_view_verts += [p0,center] + cv_view_colours += [colour,colour] + #} + if x == 15: + #{ + cv_view_verts += [p1,center] + cv_view_colours += [colour,colour] + #} + #} + + cv_view_verts += [center+major*1.2*f,center+major*f*0.8] + cv_view_colours += [colour,colour] + + cv_draw_lines() +#} + +# Cone and twist limit +# +def draw_cone_twist( center, vx, vy, va ): +#{ + global cv_view_verts, cv_view_colours + axis = vy.cross( vx ) + axis.normalize() + + size = 0.12 + + cv_view_verts += [center, center+va*size] + cv_view_colours += [ (1,1,1,1), (1,1,1,1) ] + + for x in range(32): + #{ + t0 = (x/32) * math.tau + t1 = ((x+1)/32) * math.tau + + c0 = math.cos(t0) + s0 = math.sin(t0) + c1 = math.cos(t1) + s1 = math.sin(t1) + + p0 = center + (axis + vx*c0 + vy*s0).normalized() * size + p1 = center + (axis + vx*c1 + vy*s1).normalized() * size + + col0 = ( abs(c0), abs(s0), 0.0, 1.0 ) + col1 = ( abs(c1), abs(s1), 0.0, 1.0 ) + + cv_view_verts += [center, p0, p0, p1] + cv_view_colours += [ (0,0,0,0), col0, col0, col1 ] + #} + + cv_draw_lines() +#} + +# Draws constraints and stuff for the skeleton. This isnt documented and wont be +# +def draw_skeleton_helpers( obj ): +#{ + global cv_view_verts, cv_view_colours + + if obj.data.pose_position != 'REST': + #{ + return + #} + + for bone in obj.data.bones: + #{ + c = bone.head_local + a = Vector((bone.cv_data.v0[0], bone.cv_data.v0[1], bone.cv_data.v0[2])) + b = Vector((bone.cv_data.v1[0], bone.cv_data.v1[1], bone.cv_data.v1[2])) + + if bone.cv_data.collider == 'collider_box': + #{ + + 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]] + + cv_view_verts += [(v0[0],v0[1],v0[2])] + cv_view_verts += [(v1[0],v1[1],v1[2])] + cv_view_colours += [(0.5,0.5,0.5,0.5),(0.5,0.5,0.5,0.5)] + #} + #} + elif bone.cv_data.collider == 'collider_capsule': + #{ + v0 = b-a + major_axis = 0 + largest = -1.0 + + for i in range(3): + #{ + if abs(v0[i]) > largest: + #{ + largest = abs(v0[i]) + major_axis = i + #} + #} + + v1 = Vector((0,0,0)) + v1[major_axis] = 1.0 + + tx = Vector((0,0,0)) + ty = Vector((0,0,0)) + + cv_tangent_basis( v1, tx, ty ) + r = (abs(tx.dot( v0 )) + abs(ty.dot( v0 ))) * 0.25 + l = v0[ major_axis ] - r*2 + + p0 = obj.matrix_world@Vector( c + (a+b)*0.5 + v1*l*-0.5 ) + p1 = obj.matrix_world@Vector( c + (a+b)*0.5 + v1*l* 0.5 ) + + colour = [0.2,0.2,0.2,1.0] + colour[major_axis] = 0.5 + + cv_draw_halfsphere( p0, -v1, ty, tx, r, colour ) + cv_draw_halfsphere( p1, v1, ty, tx, r, colour ) + cv_draw_line( p0+tx* r, p1+tx* r, colour ) + cv_draw_line( p0+tx*-r, p1+tx*-r, colour ) + cv_draw_line( p0+ty* r, p1+ty* r, colour ) + cv_draw_line( p0+ty*-r, p1+ty*-r, colour ) + #} + else: + #{ + continue + #} + + center = obj.matrix_world @ c + if bone.cv_data.con0: + #{ + vx = Vector([bone.cv_data.conevx[_] for _ in range(3)]) + vy = Vector([bone.cv_data.conevy[_] for _ in range(3)]) + va = Vector([bone.cv_data.coneva[_] for _ in range(3)]) + draw_cone_twist( center, vx, vy, va ) + + #draw_limit( obj, c, Vector((0,0,1)),Vector((0,-1,0)), \ + # bone.cv_data.mins[0], bone.cv_data.maxs[0], \ + # (1,0,0,1)) + #draw_limit( obj, c, Vector((0,-1,0)),Vector((1,0,0)), \ + # bone.cv_data.mins[1], bone.cv_data.maxs[1], \ + # (0,1,0,1)) + #draw_limit( obj, c, Vector((1,0,0)),Vector((0,0,1)), \ + # bone.cv_data.mins[2], bone.cv_data.maxs[2], \ + # (0,0,1,1)) + #} + #} +#} + +def cv_draw(): +#{ + global cv_view_shader + global cv_view_verts + global cv_view_colours + global cv_view_course_i + + cv_view_course_i = 0 + cv_view_verts = [] + cv_view_colours = [] + + 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('LESS') + gpu.state.blend_set('NONE') + + for obj in bpy.context.collection.objects: + #{ + if obj.type == 'ARMATURE': + #{ + if obj.data.pose_position == 'REST': + draw_skeleton_helpers( obj ) + #} + else: + #{ + classtype = obj.cv_data.classtype + if (classtype != 'classtype_none') and (classtype in globals()): + #{ + cl = globals()[ classtype ] + + if getattr( cl, "draw_scene_helpers", None ): + #{ + cl.draw_scene_helpers( obj ) + #} + #} + #} + #} + + cv_draw_lines() + return +#} + + +# ---------------------------------------------------------------------------- # +# # +# Blender # +# # +# ---------------------------------------------------------------------------- # + +# Checks whether this object has a classtype assigned. we can only target other +# classes def cv_poll_target(scene, obj): +#{ if obj == bpy.context.active_object: return False if obj.cv_data.classtype == '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_LIGHT_SETTINGS(bpy.types.PropertyGroup): +#{ + bp0: bpy.props.BoolProperty( name="bp0" ); +#} + +class CV_LIGHT_PANEL(bpy.types.Panel): +#{ + bl_label="[Skate Rift]" + bl_idname="SCENE_PT_cv_light" + bl_space_type='PROPERTIES' + bl_region_type='WINDOW' + bl_context='data' + + def draw(_,context): + #{ + active_object = context.active_object + if active_object == None: return + + if active_object.type != 'LIGHT': return + + data = active_object.data.cv_data + _.layout.prop( data, "bp0", text="Only on during night" ) + #} +#} 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" ) + bp0: bpy.props.BoolProperty( name="bp0" ) + bp1: bpy.props.BoolProperty( name="bp1" ) + bp2: bpy.props.BoolProperty( name="bp2" ) + bp3: bpy.props.BoolProperty( name="bp3" ) 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 ) + target2: bpy.props.PointerProperty( type=bpy.types.Object, name="target2", \ + poll=cv_poll_target ) + target3: bpy.props.PointerProperty( type=bpy.types.Object, name="target3", \ + poll=cv_poll_target ) - colour: bpy.props.FloatVectorProperty(name="colour",subtype='COLOR',\ - min=0.0,max=1.0) + colour: bpy.props.FloatVectorProperty( name="colour",subtype='COLOR',\ + min=0.0,max=1.0) classtype: bpy.props.EnumProperty( name="Format", items = [ ('classtype_none', "classtype_none", "", 0), ('classtype_gate', "classtype_gate", "", 1), - ('classtype_block', "classtype_block", "", 2), ('classtype_spawn', "classtype_spawn", "", 3), ('classtype_water', "classtype_water", "", 4), - ('classtype_car_path', "classtype_car_path", "", 5), - ('classtype_INSTANCE', "","", 6 ), - ('classtype_capsule', "classtype_capsule", "", 7 ), ('classtype_route_node', "classtype_route_node", "", 8 ), ('classtype_route', "classtype_route", "", 9 ), - ('classtype_bone',"classtype_bone","",10), - ('classtype_SKELETON', "","", 11 ), - ('classtype_SKIN',"","",12), - ('classtype_achievement_box',"classtype_achievement_box","",13), ('classtype_audio',"classtype_audio","",14), + ('classtype_trigger',"classtype_trigger","",100), + ('classtype_logic_achievement',"classtype_logic_achievement","",101), + ('classtype_logic_relay',"classtype_logic_relay","",102), + ('classtype_spawn_link',"classtype_spawn_link","",150), + ('classtype_nonlocal_gate', "classtype_nonlocal_gate", "", 300) ]) +#} class CV_BONE_SETTINGS(bpy.types.PropertyGroup): - collider: bpy.props.BoolProperty(name="Collider",default=False) +#{ + collider: bpy.props.EnumProperty( + name="Collider Type", + items = [ + ('collider_none', "collider_none", "", 0), + ('collider_box', "collider_box", "", 1), + ('collider_capsule', "collider_capsule", "", 2), + ]) + v0: bpy.props.FloatVectorProperty(name="v0",size=3) v1: bpy.props.FloatVectorProperty(name="v1",size=3) @@ -1740,14 +2733,22 @@ class CV_BONE_SETTINGS(bpy.types.PropertyGroup): mins: bpy.props.FloatVectorProperty(name="mins",size=3) maxs: bpy.props.FloatVectorProperty(name="maxs",size=3) + conevx: bpy.props.FloatVectorProperty(name="conevx",size=3) + conevy: bpy.props.FloatVectorProperty(name="conevy",size=3) + coneva: bpy.props.FloatVectorProperty(name="coneva",size=3) + conet: bpy.props.FloatProperty(name="conet") +#} + class CV_BONE_PANEL(bpy.types.Panel): - bl_label="Bone Config" +#{ + bl_label="[Skate Rift]" 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 @@ -1760,13 +2761,152 @@ class CV_BONE_PANEL(bpy.types.Panel): _.layout.label( text="Angle Limits" ) _.layout.prop( bone.cv_data, "con0" ) - _.layout.prop( bone.cv_data, "mins" ) - _.layout.prop( bone.cv_data, "maxs" ) + + _.layout.prop( bone.cv_data, "conevx" ) + _.layout.prop( bone.cv_data, "conevy" ) + _.layout.prop( bone.cv_data, "coneva" ) + _.layout.prop( bone.cv_data, "conet" ) + #} +#} class CV_SCENE_SETTINGS(bpy.types.PropertyGroup): +#{ use_hidden: bpy.props.BoolProperty( name="use hidden", default=False ) + export_dir: bpy.props.StringProperty( name="Export Dir", subtype='DIR_PATH' ) +#} + +class CV_COLLECTION_SETTINGS(bpy.types.PropertyGroup): +#{ + pack_textures: bpy.props.BoolProperty( name="Pack Textures", default=False ) + animations: bpy.props.BoolProperty( name="Export animation", default=True) +#} + +class CV_MATERIAL_SETTINGS(bpy.types.PropertyGroup): +#{ + shader: bpy.props.EnumProperty( + name="Format", + items = [ + ('standard',"standard","",0), + ('standard_cutout', "standard_cutout", "", 1), + ('terrain_blend', "terrain_blend", "", 2), + ('vertex_blend', "vertex_blend", "", 3), + ('water',"water","",4), + ]) + + surface_prop: bpy.props.EnumProperty( + name="Surface Property", + items = [ + ('concrete','concrete','',0), + ('wood','wood','',1), + ('grass','grass','',2) + ]) + + collision: bpy.props.BoolProperty( \ + name="Collisions Enabled",\ + default=True,\ + description = "Can the player collide with this material"\ + ) + skate_surface: bpy.props.BoolProperty( \ + name="Skate Surface", \ + default=True,\ + description = "Should the game try to target this surface?" \ + ) + grind_surface: bpy.props.BoolProperty( \ + name="Grind Surface", \ + default=False,\ + description = "Grind face?" \ + ) + grow_grass: bpy.props.BoolProperty( \ + name="Grow Grass", \ + default=False,\ + description = "Spawn grass sprites on this surface?" \ + ) + blend_offset: bpy.props.FloatVectorProperty( \ + name="Blend Offset", \ + size=2, \ + default=Vector((0.5,0.0)),\ + description="When surface is more than 45 degrees, add this vector " +\ + "to the UVs" \ + ) + sand_colour: bpy.props.FloatVectorProperty( \ + name="Sand Colour",\ + subtype='COLOR',\ + min=0.0,max=1.0,\ + default=Vector((0.79,0.63,0.48)),\ + description="Blend to this colour near the 0 coordinate on UP axis"\ + ) + shore_colour: bpy.props.FloatVectorProperty( \ + name="Shore Colour",\ + subtype='COLOR',\ + min=0.0,max=1.0,\ + default=Vector((0.03,0.32,0.61)),\ + description="Water colour at the shoreline"\ + ) + ocean_colour: bpy.props.FloatVectorProperty( \ + name="Ocean Colour",\ + subtype='COLOR',\ + min=0.0,max=1.0,\ + default=Vector((0.0,0.006,0.03)),\ + description="Water colour in the deep bits"\ + ) +#} + +class CV_MATERIAL_PANEL(bpy.types.Panel): +#{ + bl_label="Skate Rift material" + bl_idname="MATERIAL_PT_cv_material" + bl_space_type='PROPERTIES' + bl_region_type='WINDOW' + bl_context="material" + + def draw(_,context): + #{ + active_object = bpy.context.active_object + if active_object == None: return + active_mat = active_object.active_material + if active_mat == None: return + + info = material_info( active_mat ) + + if 'tex_diffuse' in info: + #{ + _.layout.label( icon='INFO', \ + text=F"{info['tex_diffuse'].name} will be compiled" ) + #} + + _.layout.prop( active_mat.cv_data, "shader" ) + _.layout.prop( active_mat.cv_data, "surface_prop" ) + _.layout.prop( active_mat.cv_data, "collision" ) + + if active_mat.cv_data.collision: + _.layout.prop( active_mat.cv_data, "skate_surface" ) + _.layout.prop( active_mat.cv_data, "grind_surface" ) + _.layout.prop( active_mat.cv_data, "grow_grass" ) + + if active_mat.cv_data.shader == "terrain_blend": + #{ + box = _.layout.box() + box.prop( active_mat.cv_data, "blend_offset" ) + box.prop( active_mat.cv_data, "sand_colour" ) + #} + elif active_mat.cv_data.shader == "vertex_blend": + #{ + box = _.layout.box() + box.label( icon='INFO', text="Uses vertex colours, the R channel" ) + box.prop( active_mat.cv_data, "blend_offset" ) + #} + elif active_mat.cv_data.shader == "water": + #{ + box = _.layout.box() + box.label( icon='INFO', text="Depth scale of 16 meters" ) + box.prop( active_mat.cv_data, "shore_colour" ) + box.prop( active_mat.cv_data, "ocean_colour" ) + #} + #} +#} class CV_OBJ_PANEL(bpy.types.Panel): +#{ bl_label="Entity Config" bl_idname="SCENE_PT_cv_entity" bl_space_type='PROPERTIES' @@ -1774,6 +2914,7 @@ class CV_OBJ_PANEL(bpy.types.Panel): bl_context="object" def draw(_,context): + #{ active_object = bpy.context.active_object if active_object == None: return if active_object.type == 'ARMATURE': @@ -1786,77 +2927,118 @@ class CV_OBJ_PANEL(bpy.types.Panel): _.layout.prop( active_object.cv_data, "classtype" ) - if active_object.cv_data.classtype == '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 == 'classtype_car_path' or \ - active_object.cv_data.classtype == 'classtype_route_node': - _.layout.prop( active_object.cv_data, "target" ) - _.layout.prop( active_object.cv_data, "target1" ) - - elif active_object.cv_data.classtype == 'classtype_route': - _.layout.prop( active_object.cv_data, "target" ) - _.layout.prop( active_object.cv_data, "colour" ) - - elif active_object.cv_data.classtype == '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 == '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 == 'classtype_achievement_box': - _.layout.prop( active_object.cv_data, "strp" ) - _.layout.prop( active_object.cv_data, "target" ) - elif active_object.cv_data.classtype == 'classtype_audio': - _.layout.prop( active_object.cv_data, "strp" ) - _.layout.prop( active_object.cv_data, "intp" ) - _.layout.prop( active_object.cv_data, "fltp" ) + classtype = active_object.cv_data.classtype + + if (classtype != 'classtype_none') and (classtype in globals()): + #{ + cl = globals()[ classtype ] + + if getattr( cl, "editor_interface", None ): + #{ + cl.editor_interface( _.layout, active_object ) + #} + #} + #} +#} + +class CV_COMPILE(bpy.types.Operator): +#{ + bl_idname="carve.compile_all" + bl_label="Compile All" + + def execute(_,context): + #{ + 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 ) + + return {'FINISHED'} + #} +#} + +class CV_COMPILE_THIS(bpy.types.Operator): +#{ + bl_idname="carve.compile_this" + bl_label="Compile This collection" + + def execute(_,context): + #{ + col = bpy.context.collection + write_model( col.name ) + + return {'FINISHED'} + #} +#} class CV_INTERFACE(bpy.types.Panel): +#{ bl_idname = "VIEW3D_PT_carve" - bl_label = "Carve" + bl_label = "Skate Rift" bl_space_type = 'VIEW_3D' bl_region_type = 'UI' - bl_category = "Carve" + bl_category = "Skate Rift" def draw(_, context): + #{ layout = _.layout - layout.prop( context.scene.cv_data, "use_hidden") - layout.operator( "carve.compile_all" ) + layout.prop( context.scene.cv_data, "export_dir" ) + + col = bpy.context.collection + + found_in_export = False + export_count = 0 + view_layer = bpy.context.view_layer + for c1 in view_layer.layer_collection.children["export"].children: + #{ + if not c1.hide_viewport or bpy.context.scene.cv_data.use_hidden: + export_count += 1 -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 ) + if c1.name == col.name: + #{ + found_in_export = True + #} + #} -class CV_COMPILE(bpy.types.Operator): - bl_idname="carve.compile_all" - bl_label="Compile All" + box = layout.box() + if found_in_export: + #{ + box.label( text=col.name + ".mdl" ) + box.prop( col.cv_data, "pack_textures" ) + box.prop( col.cv_data, "animations" ) + box.operator( "carve.compile_this" ) + #} + else: + #{ + row = box.row() + row.enabled=False + row.label( text=col.name ) + box.label( text="This collection is not in the export group" ) + #} - 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 ) + box = layout.box() + row = box.row() + + split = row.split( factor = 0.3, align=True ) + split.prop( context.scene.cv_data, "use_hidden", text="hidden" ) + + row1 = split.row() + if export_count == 0: + row1.enabled=False + row1.operator( "carve.compile_all", \ + text=F"Compile all ({export_count} collections)" ) + #} +#} - return {'FINISHED'} classes = [CV_OBJ_SETTINGS,CV_OBJ_PANEL,CV_COMPILE,CV_INTERFACE,\ CV_MESH_SETTINGS, CV_SCENE_SETTINGS, CV_BONE_SETTINGS,\ - CV_BONE_PANEL] + CV_BONE_PANEL, CV_COLLECTION_SETTINGS, CV_COMPILE_THIS,\ + CV_MATERIAL_SETTINGS, CV_MATERIAL_PANEL, CV_LIGHT_SETTINGS,\ + CV_LIGHT_PANEL] def register(): +#{ global cv_view_draw_handler for c in classes: @@ -1866,14 +3048,206 @@ def register(): 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) + bpy.types.Collection.cv_data = \ + bpy.props.PointerProperty(type=CV_COLLECTION_SETTINGS) + bpy.types.Material.cv_data = \ + bpy.props.PointerProperty(type=CV_MATERIAL_SETTINGS) + bpy.types.Light.cv_data = bpy.props.PointerProperty(type=CV_LIGHT_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') +#} + +# ---------------------------------------------------------------------------- # +# # +# QOI encoder # +# # +# ---------------------------------------------------------------------------- # +# # +# Transliteration of: # +# https://github.com/phoboslab/qoi/blob/master/qoi.h # +# # +# Copyright (c) 2021, Dominic Szablewski - https://phoboslab.org # +# SPDX-License-Identifier: MIT # +# QOI - The "Quite OK Image" format for fast, lossless image compression # +# # +# ---------------------------------------------------------------------------- # + +class qoi_rgba_t(Structure): +#{ + _pack_ = 1 + _fields_ = [("r",c_uint8), + ("g",c_uint8), + ("b",c_uint8), + ("a",c_uint8)] +#} + +QOI_OP_INDEX = 0x00 # 00xxxxxx +QOI_OP_DIFF = 0x40 # 01xxxxxx +QOI_OP_LUMA = 0x80 # 10xxxxxx +QOI_OP_RUN = 0xc0 # 11xxxxxx +QOI_OP_RGB = 0xfe # 11111110 +QOI_OP_RGBA = 0xff # 11111111 + +QOI_MASK_2 = 0xc0 # 11000000 + +def qoi_colour_hash( c ): +#{ + return c.r*3 + c.g*5 + c.b*7 + c.a*11 +#} + +def qoi_eq( a, b ): +#{ + return (a.r==b.r) and (a.g==b.g) and (a.b==b.b) and (a.a==b.a) +#} + +def qoi_32bit( v ): +#{ + return bytearray([ (0xff000000 & v) >> 24, \ + (0x00ff0000 & v) >> 16, \ + (0x0000ff00 & v) >> 8, \ + (0x000000ff & v) ]) +#} + +def qoi_encode( img ): +#{ + data = bytearray() + + print(F" . Encoding {img.name}.qoi[{img.size[0]},{img.size[1]}]") + + index = [ qoi_rgba_t() for _ in range(64) ] + + # Header + # + data.extend( bytearray(c_uint32(0x66696f71)) ) + data.extend( qoi_32bit( img.size[0] ) ) + data.extend( qoi_32bit( img.size[1] ) ) + data.extend( bytearray(c_uint8(4)) ) + data.extend( bytearray(c_uint8(0)) ) + + run = 0 + px_prev = qoi_rgba_t() + px_prev.r = c_uint8(0) + px_prev.g = c_uint8(0) + px_prev.b = c_uint8(0) + px_prev.a = c_uint8(255) + + px = qoi_rgba_t() + px.r = c_uint8(0) + px.g = c_uint8(0) + px.b = c_uint8(0) + px.a = c_uint8(255) + + px_len = img.size[0] * img.size[1] + + paxels = [ int(min(max(_,0),1)*255) for _ in img.pixels ] + + for px_pos in range( px_len ): + #{ + idx = px_pos * img.channels + nc = img.channels-1 + + px.r = paxels[idx+min(0,nc)] + px.g = paxels[idx+min(1,nc)] + px.b = paxels[idx+min(2,nc)] + px.a = paxels[idx+min(3,nc)] + + if qoi_eq( px, px_prev ): + #{ + run += 1 + + if (run == 62) or (px_pos == px_len-1): + #{ + data.extend( bytearray( c_uint8(QOI_OP_RUN | (run-1))) ) + run = 0 + #} + #} + else: + #{ + if run > 0: + #{ + data.extend( bytearray( c_uint8(QOI_OP_RUN | (run-1))) ) + run = 0 + #} + + index_pos = qoi_colour_hash(px) % 64 + + if qoi_eq( index[index_pos], px ): + #{ + data.extend( bytearray( c_uint8(QOI_OP_INDEX | index_pos)) ) + #} + else: + #{ + index[ index_pos ].r = px.r + index[ index_pos ].g = px.g + index[ index_pos ].b = px.b + index[ index_pos ].a = px.a + + if px.a == px_prev.a: + #{ + vr = int(px.r) - int(px_prev.r) + vg = int(px.g) - int(px_prev.g) + vb = int(px.b) - int(px_prev.b) + + vg_r = vr - vg + vg_b = vb - vg + + if (vr > -3) and (vr < 2) and\ + (vg > -3) and (vg < 2) and\ + (vb > -3) and (vb < 2): + #{ + op = QOI_OP_DIFF | (vr+2) << 4 | (vg+2) << 2 | (vb+2) + data.extend( bytearray( c_uint8(op) )) + #} + elif (vg_r > -9) and (vg_r < 8) and\ + (vg > -33) and (vg < 32 ) and\ + (vg_b > -9) and (vg_b < 8): + #{ + op = QOI_OP_LUMA | (vg+32) + delta = (vg_r+8) << 4 | (vg_b + 8) + data.extend( bytearray( c_uint8(op) ) ) + data.extend( bytearray( c_uint8(delta) )) + #} + else: + #{ + data.extend( bytearray( c_uint8(QOI_OP_RGB) ) ) + data.extend( bytearray( c_uint8(px.r) )) + data.extend( bytearray( c_uint8(px.g) )) + data.extend( bytearray( c_uint8(px.b) )) + #} + #} + else: + #{ + data.extend( bytearray( c_uint8(QOI_OP_RGBA) ) ) + data.extend( bytearray( c_uint8(px.r) )) + data.extend( bytearray( c_uint8(px.g) )) + data.extend( bytearray( c_uint8(px.b) )) + data.extend( bytearray( c_uint8(px.a) )) + #} + #} + #} + + px_prev.r = px.r + px_prev.g = px.g + px_prev.b = px.b + px_prev.a = px.a + #} + + # Padding + for i in range(7): + data.extend( bytearray( c_uint8(0) )) + data.extend( bytearray( c_uint8(1) )) + bytearray_align_to( data, 16, 0 ) + + return data +#}