+ if context.scene.SR_data.panel == 'ENTITY': #{
+ if context.active_object.type == 'MESH': #{
+ for e in mesh_entities: items += [(e,e,'')]
+ #}
+ #}
+ else: #{
+ for e in mesh_entities: items += [(e,e,'')]
+ #}
+
+ return items
+#}
+
+def sr_on_type_change( _, context ):
+#{
+ obj = context.active_object
+ ent_type = obj.SR_data.ent_type
+ if ent_type == 'none': return
+ if obj.type == 'MESH':#{
+ col = getattr( obj.data.SR_data, ent_type, None )
+ if col != None and len(col)==0: col.add()
+ #}
+
+ col = getattr( obj.SR_data, ent_type, None )
+ if col != None and len(col)==0: col.add()
+#}
+
+class SR_OBJECT_ENT_SPAWN(bpy.types.PropertyGroup):
+#{
+ alias: bpy.props.StringProperty( name='alias' )
+#}
+
+class SR_OBJECT_ENT_GATE(bpy.types.PropertyGroup):
+#{
+ target: bpy.props.PointerProperty( \
+ type=bpy.types.Object, name="destination", \
+ poll=lambda self,obj: sr_filter_ent_type(obj,['ent_gate']))
+#}
+
+class SR_MESH_ENT_GATE(bpy.types.PropertyGroup):
+#{
+ dimensions: bpy.props.FloatVectorProperty(name="dimensions",size=3)
+#}
+
+class SR_OBJECT_ENT_ROUTE_ENTRY(bpy.types.PropertyGroup):
+#{
+ target: bpy.props.PointerProperty( \
+ type=bpy.types.Object, name='target', \
+ poll=lambda self,obj: sr_filter_ent_type(obj,['ent_gate']))
+#}
+
+class SR_UL_ROUTE_NODE_LIST(bpy.types.UIList):
+#{
+ bl_idname = 'SR_UL_ROUTE_NODE_LIST'
+
+ def draw_item(_,context,layout,data,item,icon,active_data,active_propname):
+ #{
+ layout.prop( item, 'target', text='', emboss=False )
+ #}
+#}
+
+class SR_OT_ROUTE_LIST_NEW_ITEM(bpy.types.Operator):
+#{
+ bl_idname = "skaterift.new_entry"
+ bl_label = "Add gate"
+
+ def execute(self, context):#{
+ active_object = context.active_object
+ active_object.SR_data.ent_route[0].gates.add()
+ return{'FINISHED'}
+ #}
+#}
+
+class SR_OT_ROUTE_LIST_DEL_ITEM(bpy.types.Operator):
+#{
+ bl_idname = "skaterift.del_entry"
+ bl_label = "Remove gate"
+
+ @classmethod
+ def poll(cls, context):#{
+ active_object = context.active_object
+ if obj_ent_type(active_object) == 'ent_gate':#{
+ return active_object.SR_data.ent_route[0].gates
+ #}
+ else: return False
+ #}
+
+ def execute(self, context):#{
+ active_object = context.active_object
+ lista = active_object.SR_data.ent_route[0].gates
+ index = active_object.SR_data.ent_route[0].gates_index
+ lista.remove(index)
+ active_object.SR_data.ent_route[0].gates_index = \
+ min(max(0, index-1), len(lista) - 1)
+ return{'FINISHED'}
+ #}
+#}
+
+class SR_OT_AUDIO_LIST_NEW_ITEM(bpy.types.Operator):
+#{
+ bl_idname = "skaterift.al_new_entry"
+ bl_label = "Add file"
+
+ def execute(self, context):#{
+ active_object = context.active_object
+ active_object.SR_data.ent_audio[0].files.add()
+ return{'FINISHED'}
+ #}
+#}
+
+class SR_OT_AUDIO_LIST_DEL_ITEM(bpy.types.Operator):
+#{
+ bl_idname = "skaterift.al_del_entry"
+ bl_label = "Remove file"
+
+ @classmethod
+ def poll(cls, context):#{
+ active_object = context.active_object
+ if obj_ent_type(active_object) == 'ent_audio':#{
+ return active_object.SR_data.ent_audio[0].files
+ #}
+ else: return False
+ #}
+
+ def execute(self, context):#{
+ active_object = context.active_object
+ lista = active_object.SR_data.ent_audio[0].files
+ index = active_object.SR_data.ent_audio[0].file_index
+ lista.remove(index)
+ active_object.SR_data.ent_audio[0].file_index = \
+ min(max(0, index-1), len(lista) - 1)
+ return{'FINISHED'}
+ #}
+#}
+
+class SR_OBJECT_ENT_AUDIO_FILE_ENTRY(bpy.types.PropertyGroup):
+#{
+ path: bpy.props.StringProperty( name="Path" )
+ probability: bpy.props.FloatProperty( name="Probability",default=100.0 )
+#}
+
+class SR_UL_AUDIO_LIST(bpy.types.UIList):
+#{
+ bl_idname = 'SR_UL_AUDIO_LIST'
+
+ def draw_item(_,context,layout,data,item,icon,active_data,active_propname):
+ #{
+ split = layout.split(factor=0.7)
+ c = split.column()
+ c.prop( item, 'path', text='', emboss=False )
+ c = split.column()
+ c.prop( item, 'probability', text='%', emboss=True )
+ #}
+#}
+
+
+class SR_OBJECT_ENT_ROUTE(bpy.types.PropertyGroup):
+#{
+ gates: bpy.props.CollectionProperty(type=SR_OBJECT_ENT_ROUTE_ENTRY)
+ gates_index: bpy.props.IntProperty()
+
+ colour: bpy.props.FloatVectorProperty( \
+ name="Colour",\
+ subtype='COLOR',\
+ min=0.0,max=1.0,\
+ default=Vector((0.79,0.63,0.48)),\
+ description="Route colour"\
+ )
+
+ alias: bpy.props.StringProperty(\
+ name="Alias",\
+ default="Untitled Course")
+
+ @staticmethod
+ def sr_inspector( layout, data ):
+ #{
+ layout.prop( data[0], 'alias' )
+ layout.prop( data[0], 'colour' )
+
+ layout.label( text='Checkpoints' )
+ layout.template_list('SR_UL_ROUTE_NODE_LIST', 'Checkpoints', \
+ data[0], 'gates', data[0], 'gates_index', rows=5)
+
+ row = layout.row()
+ row.operator( 'skaterift.new_entry', text='Add' )
+ row.operator( 'skaterift.del_entry', text='Remove' )
+ #}
+#}
+
+class SR_OBJECT_ENT_VOLUME(bpy.types.PropertyGroup):
+#{
+ subtype: bpy.props.EnumProperty(
+ name="Subtype",
+ items=[('0','Trigger',''),
+ ('1','Particles (0.1s)','')]
+ )
+
+ target: bpy.props.PointerProperty( \
+ type=bpy.types.Object, name="Target", \
+ poll=lambda self,obj: sr_filter_ent_type(obj,['ent_audio']))
+
+ @staticmethod
+ def sr_inspector( layout, data ):
+ #{
+ data = data[0]
+ layout.prop( data, 'subtype' )
+ layout.prop( data, 'target' )
+ #}
+#}
+
+class SR_OBJECT_ENT_AUDIO(bpy.types.PropertyGroup):
+#{
+ files: bpy.props.CollectionProperty(type=SR_OBJECT_ENT_AUDIO_FILE_ENTRY)
+ file_index: bpy.props.IntProperty()
+
+ flag_3d: bpy.props.BoolProperty( name="3D audio",default=True )
+ flag_loop: bpy.props.BoolProperty( name="Loop",default=False )
+ flag_auto: bpy.props.BoolProperty( name="Play at start",default=False )
+ flag_nodoppler: bpy.props.BoolProperty( name="No Doppler",default=False )
+
+ group: bpy.props.IntProperty( name="Group ID", default=0 )
+ formato: bpy.props.EnumProperty(
+ name="Format",
+ items=[('0','Uncompressed Mono',''),
+ ('1','Compressed Vorbis',''),
+ ('2','[vg] Bird Synthesis','')]
+ )
+ probability_curve: bpy.props.EnumProperty(
+ name="Probability Curve",
+ items=[('0','Constant',''),
+ ('1','Wildlife Daytime',''),
+ ('2','Wildlife Nighttime','')])
+ channel_behaviour: bpy.props.EnumProperty(
+ name="Channel Behaviour",
+ items=[('0','Unlimited',''),
+ ('1','Discard if group full', ''),
+ ('2','Crossfade if group full','')])
+
+ transition_duration: bpy.props.FloatProperty(name="Transition Time",\
+ default=0.2)
+
+ max_channels: bpy.props.IntProperty( name="Max Channels", default=1 )
+ volume: bpy.props.FloatProperty( name="Volume",default=1.0 )
+
+ @staticmethod
+ def sr_inspector( layout, data ):
+ #{
+ layout.prop( data[0], 'formato' )
+ layout.prop( data[0], 'volume' )
+
+ box = layout.box()
+ box.label( text='Channels' )
+ split = box.split(factor=0.3)
+ c = split.column()
+ c.prop( data[0], 'max_channels' )
+ c = split.column()
+ c.prop( data[0], 'channel_behaviour', text='Behaviour' )
+ if data[0].channel_behaviour >= '1':
+ box.prop( data[0], 'group' )
+ if data[0].channel_behaviour == '2':
+ box.prop( data[0], 'transition_duration' )
+
+ box = layout.box()
+ box.label( text='Flags' )
+ box.prop( data[0], 'flag_3d' )
+ if data[0].flag_3d: box.prop( data[0], 'flag_nodoppler' )
+
+ box.prop( data[0], 'flag_loop' )
+ box.prop( data[0], 'flag_auto' )
+
+ split = layout.split(factor=0.7)
+ c = split.column()
+ c.label( text='Filepath' )
+ c = split.column()
+ c.label( text='Chance (0.1s)' )
+
+ layout.prop( data[0], 'probability_curve' )
+
+ layout.template_list('SR_UL_AUDIO_LIST', 'Files', \
+ data[0], 'files', data[0], 'file_index', rows=5)
+
+ row = layout.row()
+ row.operator( 'skaterift.al_new_entry', text='Add' )
+ row.operator( 'skaterift.al_del_entry', text='Remove' )
+ #}
+#}
+
+class SR_OBJECT_PROPERTIES(bpy.types.PropertyGroup):
+#{
+ ent_gate: bpy.props.CollectionProperty(type=SR_OBJECT_ENT_GATE)
+ ent_spawn: bpy.props.CollectionProperty(type=SR_OBJECT_ENT_SPAWN)
+ ent_route: bpy.props.CollectionProperty(type=SR_OBJECT_ENT_ROUTE)
+ ent_volume: bpy.props.CollectionProperty(type=SR_OBJECT_ENT_VOLUME)
+ ent_audio: bpy.props.CollectionProperty(type=SR_OBJECT_ENT_AUDIO)
+
+ ent_type: bpy.props.EnumProperty(
+ name="Type",
+ items=[('none', 'None', '', 0),
+ ('ent_gate','Gate','', 1),
+ ('ent_spawn','Spawn','', 2),
+ ('ent_route_node', 'Route Node', '', 3 ),
+ ('ent_route', 'Route', '', 4),
+ ('ent_water', 'Water Surface', '', 5),
+ ('ent_volume', 'Volume', '', 6 ),
+ ('ent_audio', 'Audio Files', '', 7)],
+ update=sr_on_type_change
+ )
+#}
+
+class SR_MESH_PROPERTIES(bpy.types.PropertyGroup):
+#{
+ ent_gate: bpy.props.CollectionProperty(type=SR_MESH_ENT_GATE)
+#}
+
+class SR_LIGHT_PROPERTIES(bpy.types.PropertyGroup):
+#{
+ daytime: bpy.props.BoolProperty( name='Daytime' )
+#}
+
+class SR_BONE_PROPERTIES(bpy.types.PropertyGroup):
+#{
+ collider: bpy.props.EnumProperty( name='Collider Type',
+ items=[('0','none',''),
+ ('1','box',''),
+ ('2','capsule','')])
+
+ collider_min: bpy.props.FloatVectorProperty( name='Collider Min', size=3 )
+ collider_max: bpy.props.FloatVectorProperty( name='Collider Max', size=3 )
+
+ cone_constraint: bpy.props.BoolProperty( name='Cone constraint' )
+
+ conevx: bpy.props.FloatVectorProperty( name='vx' )
+ conevy: bpy.props.FloatVectorProperty( name='vy' )
+ coneva: bpy.props.FloatVectorProperty( name='va' )
+ conet: bpy.props.FloatProperty( name='t' )
+
+ @staticmethod
+ def sr_inspector( layout, data ):
+ #{
+ data = data[0]
+ box = layout.box()
+ box.prop( data, 'collider' )
+
+ if int(data.collider)>0:#{
+ row = box.row()
+ row.prop( data, 'collider_min' )
+ row = box.row()
+ row.prop( data, 'collider_max' )
+ #}
+
+ box = layout.box()
+ box.prop( data, 'cone_constraint' )
+ if data.cone_constraint:#{
+ row = box.row()
+ row.prop( data, 'conevx' )
+ row = box.row()
+ row.prop( data, 'conevy' )
+ row = box.row()
+ row.prop( data, 'coneva' )
+ box.prop( data, 'conet' )
+ #}
+ #}
+#}
+
+class SR_MATERIAL_PROPERTIES(bpy.types.PropertyGroup):
+#{
+ shader: bpy.props.EnumProperty(
+ name="Format",
+ items = [
+ ('standard',"standard",''),
+ ('standard_cutout', "standard_cutout", ''),
+ ('terrain_blend', "terrain_blend", ''),
+ ('vertex_blend', "vertex_blend", ''),
+ ('water',"water",'')
+ ])
+
+ surface_prop: bpy.props.EnumProperty(
+ name="Surface Property",
+ items = [
+ ('0','concrete',''),
+ ('1','wood',''),
+ ('2','grass',''),
+ ('3','tiles',''),
+ ('4','metal','')
+ ])
+
+ 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"\
+ )
+#}
+
+# ---------------------------------------------------------------------------- #
+# #
+# 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
+
+# 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
+
+ for i in range(16):
+ #{
+ t = ((i+1.0) * 1.0/16.0) * pi * 2.0
+ s = math.sin(t)
+ c = math.cos(t)
+
+ 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))
+
+ cv_view_verts += [ px, lx ]
+ cv_view_verts += [ py, ly ]
+ cv_view_verts += [ pz, lz ]
+
+ cv_view_colours += [ colour, colour, colour, colour, colour, colour ]
+
+ ly = py
+ lx = px
+ lz = pz
+ #}
+ cv_draw_lines()
+#}
+
+# 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
+
+ for i in range(16):
+ #{
+ t = ((i+1.0) * 1.0/16.0) * pi
+ s = math.sin(t)
+ c = math.cos(t)
+
+ s1 = math.sin(t*2.0)
+ c1 = math.cos(t*2.0)
+
+ py = pos + s*tx*radius + c *tz*radius
+ px = pos + s*tx*radius + c *ty*radius
+ pz = pos + s1*ty*radius + c1*tz*radius
+
+ cv_view_verts += [ px, lx ]
+ cv_view_verts += [ py, ly ]
+ cv_view_verts += [ pz, lz ]
+
+ cv_view_colours += [ colour, colour, colour, colour, colour, colour ]
+
+ ly = py
+ lx = px
+ lz = pz
+ #}
+ cv_draw_lines()
+#}
+
+# Draw transformed -1 -> 1 cube
+#
+def cv_draw_ucube( transform, colour, s=Vector((1,1,1)), o=Vector((0,0,0)) ):
+#{
+ global cv_view_verts, cv_view_colours
+
+ a = o + -1.0 * s
+ b = o + 1.0 * s
+
+ 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 += [colour, colour]
+ #}
+ cv_draw_lines()
+#}
+
+# Draw line with colour
+#
+def cv_draw_line( p0, p1, colour ):
+#{
+ global cv_view_verts, cv_view_colours
+
+ cv_view_verts += [p0,p1]
+ cv_view_colours += [colour, colour]
+ cv_draw_lines()
+#}
+
+# Draw line with colour(s)
+#
+def cv_draw_line2( p0, p1, c0, c1 ):
+#{
+ global cv_view_verts, cv_view_colours
+
+ cv_view_verts += [p0,p1]
+ cv_view_colours += [c0,c1]
+ cv_draw_lines()
+#}
+
+#
+#
+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]
+ #}
+
+ tx.normalize()
+ _ty = n.cross( tx )
+
+ ty[0] = _ty[0]
+ ty[1] = _ty[1]
+ ty[2] = _ty[2]
+#}
+
+# Draw coloured arrow
+#
+def cv_draw_arrow( p0, p1, c0, size=0.15 ):
+#{
+ global cv_view_verts, cv_view_colours
+
+ n = p1-p0
+ midpt = p0 + n*0.5
+ n.normalize()