+ 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 == '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_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_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_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)],
+ 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','')
+ ])
+
+ 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()
+
+ tx = Vector((1,0,0))
+ ty = Vector((1,0,0))
+ cv_tangent_basis( n, tx, ty )
+
+ cv_view_verts += [p0,p1, midpt+(tx-n)*size,midpt, midpt+(-tx-n)*size,midpt ]
+ cv_view_colours += [c0,c0,c0,c0,c0,c0]
+ cv_draw_lines()
+#}
+
+def cv_draw_line_dotted( p0, p1, c0, dots=10 ):
+#{
+ global cv_view_verts, cv_view_colours
+
+ for i in range(dots):#{
+ t0 = i/dots
+ t1 = (i+0.25)/dots
+
+ p2 = p0*(1.0-t0)+p1*t0
+ p3 = p0*(1.0-t1)+p1*t1
+
+ cv_view_verts += [p2,p3]
+ cv_view_colours += [c0,c0]
+ #}
+ cv_draw_lines()
+#}
+
+# Drawhandles of a bezier control point
+#
+def cv_draw_bhandle( obj, direction, colour ):
+#{
+ global cv_view_verts, cv_view_colours
+
+ p0 = obj.location
+ h0 = obj.matrix_world @ Vector((0,direction,0))
+
+ cv_view_verts += [p0]
+ cv_view_verts += [h0]
+ cv_view_colours += [colour,colour]
+ cv_draw_lines()
+#}
+
+# 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
+
+ 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)]
+
+ last = p
+ #}
+ cv_draw_lines()
+#}
+
+# 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