('ent_menuitem', 'Menu Item', '', 15 ),
('ent_worldinfo', 'World Info', '', 16 ),
('ent_ccmd', 'CCmd', '', 17 ),
- ('ent_challenge', 'Challenge', '', 18 ),
- ('ent_unlock', 'Unlockable', '', 19 ),
+ ('ent_objective', 'Objective', '', 18 ),
+ ('ent_challenge', 'Challenge', '', 19 ),
('ent_relay', 'Relay', '', 20 )
]
MDL_VERSION_NR = 102
-SR_TRIGGERABLE = [ 'ent_audio', 'ent_ccmd', 'ent_gate', 'ent_unlock', \
- 'ent_relay', 'ent_skateshop', 'ent_challenge' ]
+SR_TRIGGERABLE = [ 'ent_audio', 'ent_ccmd', 'ent_gate', 'ent_challenge', \
+ 'ent_relay', 'ent_skateshop', 'ent_objective' ]
def get_entity_enum_id( alias ):
#{
#}
#}
+ if alias == 'ent_cubemap': return 21
+
return 0
#}
# Menu
# -----------------------------------------------------------------
+class ent_menuitem_visual(Structure):
+#{
+ _fields_ = [("pstr_name",c_uint32)]
+#}
class ent_menuitem_slider(Structure):
#{
_fields_ = [("id_min",c_uint32),
_fields_ = [("slider",ent_menuitem_slider),
("button",ent_menuitem_button),
("checkmark",ent_menuitem_checkmark),
- ("page",ent_menuitem_page)]
+ ("page",ent_menuitem_page),
+ ("visual",ent_menuitem_visual)]
#}
class ent_menuitem(Structure):
#{
_fields_ = [("pstr_command",c_uint32)]
#}
-class ent_challenge(Structure):#{
+class ent_objective(Structure):#{
_fields_ = [("transform",mdl_transform),
("submesh_start",c_uint32), ("submesh_count",c_uint32),
+ ("flags",c_uint32),
("id_next",c_uint32),
- ("filter",c_uint32),
+ ("filter",c_uint32),("filter2",c_uint32),
("id_win",c_uint32),
("win_event",c_uint32),
("time_limit",c_float)]
sr_functions = { 0: 'trigger',
- 1: 'start_challenge' }
+ 2: 'show',
+ 3: 'hide' }
#}
-class ent_unlock(Structure):#{
- _fields_ = [("pstr_alias",c_uint32),
+class ent_challenge(Structure):#{
+ _fields_ = [("transform",mdl_transform),
+ ("pstr_alias",c_uint32),
+ ("flags",c_uint32),
("target",c_uint32),
("target_event",c_uint32),
- ("status",c_uint32)]
- sr_functions = { 0: 'unlock' }
+ ("reset",c_uint32),
+ ("reset_event",c_uint32),
+ ("first",c_uint32),
+ ("camera",c_uint32),
+ ("status",c_uint32)] #runtime
+ sr_functions = { 0: 'unlock',
+ 1: 'view/reset' }
#}
class ent_relay(Structure):#{
sr_functions = { 0: 'trigger' }
#}
+class ent_cubemap(Structure):#{
+ _fields_ = [("co",c_float*3),
+ ("resolution",c_uint32), #placeholder
+ ("live",c_uint32), #placeholder
+ ("texture_id",c_uint32), #engine
+ ("framebuffer_id",c_uint32),#engine
+ ("renderbuffer_id",c_uint32),#engine
+ ("placeholder",c_uint32*2)]
+#}
+
def obj_ent_type( obj ):
#{
if obj.type == 'ARMATURE': return 'mdl_armature'
elif obj.type == 'LIGHT': return 'ent_light'
elif obj.type == 'CAMERA': return 'ent_camera'
+ elif obj.type == 'LIGHT_PROBE' and obj.data.type == 'CUBEMAP':
+ return 'ent_cubemap'
else: return obj.SR_data.ent_type
#}
return texture_index
#}
-def sr_compile_material( mat ):
-#{
+def sr_compile_material( mat ):#{
if mat == None:
return 0
if mat.name in sr_compile.material_cache:
#}
if mat.SR_data.shader == 'invisible': flags |= 0x10
if mat.SR_data.shader == 'boundary': flags |= (0x10|0x20)
+ if mat.SR_data.shader == 'walking': flags |= (0x10|0x80)
#}
m.flags = flags
m.surface_prop = int(mat.SR_data.surface_prop)
+ inf = material_info( mat )
if mat.SR_data.shader == 'standard': m.shader = 0
if mat.SR_data.shader == 'standard_cutout': m.shader = 1
if mat.SR_data.shader == 'fxglow':#{
m.shader = 7
#}
-
- inf = material_info( mat )
- if mat.SR_data.shader == 'standard' or \
- mat.SR_data.shader == 'standard_cutout' or \
- mat.SR_data.shader == 'terrain_blend' or \
- mat.SR_data.shader == 'vertex_blend' or \
- mat.SR_data.shader == 'fxglow': #{
+ if mat.SR_data.shader == 'cubemap':#{
+ m.shader = 8
+ m.tex_none0 = sr_entity_id( mat.SR_data.cubemap )
+
+ m.colour[0] = pow( mat.SR_data.tint[0], 1.0/2.2 )
+ m.colour[1] = pow( mat.SR_data.tint[1], 1.0/2.2 )
+ m.colour[2] = pow( mat.SR_data.tint[2], 1.0/2.2 )
+ m.colour[3] = pow( mat.SR_data.tint[3], 1.0/2.2 )
+ #}
+
+ if mat.SR_data.shader == 'walking':#{
+ m.shader = 9
+ #}
+
+ if mat.SR_data.shader in ['standard', 'standard_cutout', 'terrain_blend', \
+ 'vertex_blend', 'fxglow', 'cubemap' ]: #{
if 'tex_diffuse' in inf:
m.tex_diffuse = sr_compile_texture(inf['tex_diffuse'])
#}
item_button = item._anonymous_union.button
item_button.pstr = sr_compile_string( obj_data.string )
#}
+ elif item.type == 0:#{
+ item_visual = item._anonymous_union.visual
+ item_visual.pstr_name = sr_compile_string( obj_data.string )
+ #}
elif item.type == 3:#{
item_checkmark = item._anonymous_union.checkmark
item_checkmark.pstr_data = sr_compile_string( obj_data.string )
if ent_type == 'ent_font': continue
if ent_type == 'ent_font_variant': continue
if ent_type == 'ent_menuitem': continue
- if ent_type == 'ent_challenge': continue
+ if ent_type == 'ent_objective': continue
#TODO: This is messy.
if ent_type == 'ent_gate':#{
ccmd.pstr_command = sr_compile_string( obj_data.command )
sr_ent_push( ccmd )
#}
+ elif ent_type == 'ent_objective':#{
+ objective = ent_objective()
+ obj_data = obj.SR_data.ent_objective[0]
+ objective.id_next = sr_entity_id( obj_data.proxima )
+ objective.id_win = sr_entity_id( obj_data.target )
+ objective.win_event = obj_data.target_event
+ objective.filter = int(obj_data.filtrar)
+ objective.filter2 = 0
+ objective.time_limit = obj_data.time_limit
+
+ compile_obj_transform( obj, objective.transform )
+ objective.submesh_start, objective.submesh_count, _ = \
+ sr_compile_mesh_internal( obj )
+
+ sr_ent_push( objective )
+ #}
elif ent_type == 'ent_challenge':#{
challenge = ent_challenge()
obj_data = obj.SR_data.ent_challenge[0]
- challenge.id_next = sr_entity_id( obj_data.proxima )
- challenge.id_win = sr_entity_id( obj_data.target )
- challenge.win_event = obj_data.target_event
- challenge.filter = 0
- challenge.time_limit = obj_data.time_limit
-
compile_obj_transform( obj, challenge.transform )
- challenge.submesh_start, challenge.submesh_count, _ = \
- sr_compile_mesh_internal( obj )
-
+ challenge.pstr_alias = sr_compile_string( obj_data.alias )
+ challenge.target = sr_entity_id( obj_data.target )
+ challenge.target_event = obj_data.target_event
+ challenge.reset = sr_entity_id( obj_data.reset )
+ challenge.reset_event = obj_data.reset_event
+ challenge.first = sr_entity_id( obj_data.first )
+ challenge.flags = 0x00
+ challenge.camera = sr_entity_id( obj_data.camera )
+ if obj_data.time_limit: challenge.flags |= 0x01
+ challenge.status = 0
sr_ent_push( challenge )
#}
- elif ent_type == 'ent_unlock':#{
- unlock = ent_unlock()
- obj_data = obj.SR_data.ent_unlock[0]
- unlock.pstr_alias = sr_compile_string( obj_data.alias )
- unlock.target = sr_entity_id( obj_data.target )
- unlock.target_event = obj_data.target_event
- unlock.status = 0
- sr_ent_push( unlock )
- #}
elif ent_type == 'ent_relay':#{
relay = ent_relay()
obj_data = obj.SR_data.ent_relay[0]
relay.targets[3][1] = obj_data.target3_event
sr_ent_push( relay )
#}
+ elif ent_type == 'ent_cubemap':#{
+ cubemap = ent_cubemap()
+ co = obj.matrix_world @ Vector((0,0,0))
+ cubemap.co[0] = co[0]
+ cubemap.co[1] = co[2]
+ cubemap.co[2] = -co[1]
+ cubemap.resolution = 0
+ cubemap.live = 60
+ sr_ent_push( cubemap )
+ #}
#}
#}
#{
use_hidden: bpy.props.BoolProperty( name="use hidden", default=False )
export_dir: bpy.props.StringProperty( name="Export Dir", subtype='DIR_PATH' )
- gizmos: bpy.props.BoolProperty( name="Draw Gizmos", default=True )
+ gizmos: bpy.props.BoolProperty( name="Draw Gizmos", default=False )
panel: bpy.props.EnumProperty(
name='Panel',
row = box.row()
if (active_mat.SR_data.shader != 'invisible') and \
- (active_mat.SR_data.shader != 'boundary'):#{
+ (active_mat.SR_data.shader != 'boundary') and \
+ (active_mat.SR_data.shader != 'walking'):#{
row.prop( active_mat.SR_data, "skate_surface" )
row.prop( active_mat.SR_data, "grind_surface" )
row.prop( active_mat.SR_data, "grow_grass" )
box.prop( active_mat.SR_data, "shore_colour" )
box.prop( active_mat.SR_data, "ocean_colour" )
#}
+ elif active_mat.SR_data.shader == "cubemap":#{
+ box = _.layout.box()
+ box.prop( active_mat.SR_data, "cubemap" )
+ box.prop( active_mat.SR_data, "tint" )
+ #}
#}
#}
target: bpy.props.PointerProperty( \
type=bpy.types.Object, name="Target", \
- poll=lambda self,obj: sr_filter_ent_type(obj,\
- ['ent_audio','ent_skateshop','ent_ccmd',\
- 'ent_challenge']))
+ poll=lambda self,obj: sr_filter_ent_type(obj,SR_TRIGGERABLE))
target_event: bpy.props.IntProperty( name="Event/Method" )
@staticmethod
box.prop( data, 'tipo' )
if data.tipo == '0':#{
+ box.prop( data, 'string', text='Name' )
return
#}
elif data.tipo == '1':#{
command: bpy.props.StringProperty(name="Command Line")
#}
-class SR_OBJECT_ENT_CHALLENGE(bpy.types.PropertyGroup):#{
+class SR_OBJECT_ENT_OBJECTIVE(bpy.types.PropertyGroup):#{
proxima: bpy.props.PointerProperty( \
type=bpy.types.Object, name="Next", \
- poll=lambda self,obj: sr_filter_ent_type(obj,['ent_challenge']))
+ poll=lambda self,obj: sr_filter_ent_type(obj,['ent_objective']))
target: bpy.props.PointerProperty( \
type=bpy.types.Object, name="Win", \
poll=lambda self,obj: sr_filter_ent_type(obj,SR_TRIGGERABLE))
target_event: bpy.props.IntProperty( name="Event/Method" )
time_limit: bpy.props.FloatProperty( name="Time Limit", default=1.0 )
+ filtrar: bpy.props.EnumProperty( name='Filter',\
+ items=[('0','none',''),
+ (str(0x1),'trick_shuvit',''),
+ (str(0x2),'trick_kickflip',''),
+ (str(0x4),'trick_treflip',''),
+ (str(0x1|0x2|0x4),'trick_any',''),
+ (str(0x8),'flip_back',''),
+ (str(0x10),'flip_front',''),
+ (str(0x8|0x10),'flip_any',''),
+ (str(0x20),'grind_truck_any',''),
+ (str(0x40),'grind_board_any',''),
+ (str(0x20|0x40),'grind_any',''),
+ (str(0x80),'footplant',''),
+ (str(0x100),'passthrough',''),
+ ])
@staticmethod
def sr_inspector( layout, data ):#{
layout.prop( data[0], 'proxima' )
layout.prop( data[0], 'time_limit' )
+ layout.prop( data[0], 'filtrar' )
SR_OBJECT_ENT_VOLUME.inspect_target( layout, data, 'target' )
#}
#}
-class SR_OBJECT_ENT_UNLOCK(bpy.types.PropertyGroup):#{
+class SR_OBJECT_ENT_CHALLENGE(bpy.types.PropertyGroup):#{
alias: bpy.props.StringProperty( name="Alias" )
+
target: bpy.props.PointerProperty( \
- type=bpy.types.Object, name="Target", \
+ type=bpy.types.Object, name="On Complete", \
poll=lambda self,obj: sr_filter_ent_type(obj,SR_TRIGGERABLE))
target_event: bpy.props.IntProperty( name="Event/Method" )
+ reset: bpy.props.PointerProperty( \
+ type=bpy.types.Object, name="On Reset", \
+ poll=lambda self,obj: sr_filter_ent_type(obj,SR_TRIGGERABLE))
+ reset_event: bpy.props.IntProperty( name="Event/Method" )
+
+ time_limit: bpy.props.BoolProperty( name="Time Limit" )
+
+ first: bpy.props.PointerProperty( \
+ type=bpy.types.Object, name="First Objective", \
+ poll=lambda self,obj: sr_filter_ent_type(obj,['ent_objective']))
+
+ camera: bpy.props.PointerProperty( \
+ type=bpy.types.Object, name="Camera", \
+ poll=lambda self,obj: sr_filter_ent_type(obj,['ent_camera']))
+
@staticmethod
def sr_inspector( layout, data ):#{
layout.prop( data[0], 'alias' )
+ layout.prop( data[0], 'camera' )
+ layout.prop( data[0], 'first' )
+ layout.prop( data[0], 'time_limit' )
SR_OBJECT_ENT_VOLUME.inspect_target( layout, data, 'target' )
+ SR_OBJECT_ENT_VOLUME.inspect_target( layout, data, 'reset' )
#}
#}
ent_menuitem: bpy.props.CollectionProperty(type=SR_OBJECT_ENT_MENU_ITEM)
ent_worldinfo: bpy.props.CollectionProperty(type=SR_OBJECT_ENT_WORLD_INFO)
ent_ccmd: bpy.props.CollectionProperty(type=SR_OBJECT_ENT_CCMD)
+ ent_objective: bpy.props.CollectionProperty(type=SR_OBJECT_ENT_OBJECTIVE)
ent_challenge: bpy.props.CollectionProperty(type=SR_OBJECT_ENT_CHALLENGE)
- ent_unlock: bpy.props.CollectionProperty(type=SR_OBJECT_ENT_UNLOCK)
ent_relay: bpy.props.CollectionProperty(type=SR_OBJECT_ENT_RELAY)
ent_type: bpy.props.EnumProperty(
('invisible','Invisible',''),
('boundary','Boundary',''),
('fxglow','FX Glow',''),
+ ('cubemap','Cubemap',''),
+ ('walking','Walking','')
])
surface_prop: bpy.props.EnumProperty(
default=Vector((0.0,0.006,0.03)),\
description="Water colour in the deep bits"\
)
+ tint: bpy.props.FloatVectorProperty( \
+ name="Tint",\
+ subtype='COLOR',\
+ min=0.0,max=1.0,\
+ size=4,\
+ default=Vector((1.0,1.0,1.0,1.0)),\
+ description="Reflection tint"\
+ )
+
+ cubemap: bpy.props.PointerProperty( \
+ type=bpy.types.Object, name="cubemap", \
+ poll=lambda self,obj: sr_filter_ent_type(obj,['ent_cubemap']))
#}
# ---------------------------------------------------------------------------- #
# Draw coloured arrow
#
-def cv_draw_arrow( p0, p1, c0, size=0.25 ):
+def cv_draw_arrow( p0, p1, c0, size=0.25, outline=True ):
#{
global cv_view_verts, cv_view_colours
tx = Vector((1,0,0))
ty = Vector((1,0,0))
cv_tangent_basis( n, tx, ty )
-
+ tx *= 0.5
+ ty *= 0.5
+
+ if outline:#{
+ cv_draw_lines()
+ gpu.state.line_width_set(1.0)
+ #}
+
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()
+ cv_draw_lines()
+
+ if outline:#{
+ gpu.state.line_width_set(3.0)
+ cv_view_verts += [p0,p1,midpt+(tx-n)*size,midpt,midpt+(-tx-n)*size,midpt]
+ b0 = (0,0,0)
+ cv_view_colours += [b0,b0,b0,b0,b0,b0]
+ cv_draw_lines()
+ gpu.state.line_width_set(2.0)
+ #}
#}
def cv_draw_line_dotted( p0, p1, c0, dots=10 ):
data = obj.SR_data.ent_volume[0]
if data.subtype == '0':#{
- cv_draw_ucube( obj.matrix_world, (0,1,0) )
+ cv_draw_ucube( obj.matrix_world, (0,1,0), Vector((0.99,0.99,0.99)) )
if data.target:#{
- cv_draw_arrow( obj.location, data.target.location, (0,1,0) )
+ cv_draw_arrow( obj.location, data.target.location, (1,1,1) )
#}
#}
elif data.subtype == '1':#{
cv_draw_ucube( obj.matrix_world, (1,1,0) )
if data.target:#{
- cv_draw_arrow( obj.location, data.target.location, (1,1,0) )
+ cv_draw_arrow( obj.location, data.target.location, (1,1,1) )
#}
#}
#}
path = solve_graph( dij, gi.name, gj.name )
if path:#{
- cv_draw_arrow(gi.location,dij.points[path[0]],cc,1.5)
- cv_draw_arrow(dij.points[path[len(path)-1]],gj.location,cc,1.5)
+ cv_draw_arrow(gi.location,dij.points[path[0]],cc,1.5,False)
+ cv_draw_arrow(dij.points[path[len(path)-1]],gj.location,cc,1.5,False)
for j in range(len(path)-1):#{
i0 = path[j]
i1 = path[j+1]
o0 = dij.points[ i0 ]
o1 = dij.points[ i1 ]
- cv_draw_arrow(o0,o1,cc,1.5)
+ cv_draw_arrow(o0,o1,cc,1.5,False)
#}
#}
else:#{
cv_view_colours = []
cv_view_shader.bind()
- gpu.state.depth_mask_set(False)
+ gpu.state.depth_mask_set(True)
gpu.state.line_width_set(2.0)
gpu.state.face_culling_set('BACK')
gpu.state.depth_test_set('LESS')
elif ent_type == 'ent_volume':#{
cv_ent_volume( obj )
#}
- elif ent_type == 'ent_challenge':#{
- data = obj.SR_data.ent_challenge[0]
+ elif ent_type == 'ent_objective':#{
+ data = obj.SR_data.ent_objective[0]
if data.proxima:#{
- cv_draw_arrow( obj.location, data.proxima.location, (0,0.2,1.0) )
+ cv_draw_arrow( obj.location, data.proxima.location, (1,0.6,0.2) )
#}
if data.target:
- cv_draw_arrow( obj.location, data.target.location, (0,1.0,0.0) )
+ cv_draw_arrow( obj.location, data.target.location, (1,1,1) )
#}
elif ent_type == 'ent_relay':#{
data = obj.SR_data.ent_relay[0]
if data.target0:
- cv_draw_arrow( obj.location, data.target0.location, (0,1,0) )
+ cv_draw_arrow( obj.location, data.target0.location, (1,1,1) )
if data.target1:
- cv_draw_arrow( obj.location, data.target1.location, (0,1,0) )
+ cv_draw_arrow( obj.location, data.target1.location, (1,1,1) )
if data.target2:
- cv_draw_arrow( obj.location, data.target2.location, (0,1,0) )
+ cv_draw_arrow( obj.location, data.target2.location, (1,1,1) )
if data.target3:
- cv_draw_arrow( obj.location, data.target3.location, (0,1,0) )
+ cv_draw_arrow( obj.location, data.target3.location, (1,1,1) )
#}
- elif ent_type == 'ent_unlock':#{
- data = obj.SR_data.ent_unlock[0]
+ elif ent_type == 'ent_challenge':#{
+ data = obj.SR_data.ent_challenge[0]
if data.target:
- cv_draw_arrow( obj.location, data.target.location, (0,1.0,0.0) )
+ cv_draw_arrow( obj.location, data.target.location, (1,1,1) )
+ if data.reset:
+ cv_draw_arrow( obj.location, data.reset.location, (0.9,0,0) )
+ if data.first:
+ cv_draw_arrow( obj.location, data.first.location, (1,0.6,0.2) )
+
+ cc1 = (0.4,0.3,0.2)
+ info_cu = Vector((1.2,0.01,0.72))*0.5
+ info_co = Vector((0.0,0.0,0.72))*0.5
+ cv_draw_ucube( obj.matrix_world, cc1, info_cu, info_co)
+ if data.camera:
+ cv_draw_line_dotted( obj.location, data.camera.location, (1,1,1))
+
+ vs = [Vector((-0.2,0.0,0.10)),Vector((-0.2,0.0,0.62)),\
+ Vector(( 0.2,0.0,0.62)),Vector((-0.2,0.0,0.30)),\
+ Vector(( 0.1,0.0,0.30))]
+ for v in range(len(vs)):#{
+ vs[v] = obj.matrix_world @ vs[v]
+ #}
+
+ cv_view_verts += [vs[0],vs[1],vs[1],vs[2],vs[3],vs[4]]
+ cv_view_colours += [cc1,cc1,cc1,cc1,cc1,cc1]
#}
elif ent_type == 'ent_audio':#{
if obj.SR_data.ent_audio[0].flag_3d:
info_cu = Vector((1.2,0.01,0.3))*0.5
info_co = Vector((0.0,0.0,0.0))*0.5
#}
+ elif data.tipo == '3':#{
+ rack = None
+ display = None
+ info = None
+ #}
if rack:
cv_draw_ucube( rack.matrix_world, cc, rack_cu, rack_co )
SR_OBJECT_ENT_FONT,SR_OBJECT_ENT_TRAFFIC,SR_OBJECT_ENT_SKATESHOP,\
SR_OBJECT_ENT_WORKSHOP_PREVIEW,SR_OBJECT_ENT_MENU_ITEM,\
SR_OBJECT_ENT_WORLD_INFO,SR_OBJECT_ENT_CCMD,\
- SR_OBJECT_ENT_CHALLENGE,SR_OBJECT_ENT_UNLOCK,SR_OBJECT_ENT_RELAY,\
+ SR_OBJECT_ENT_OBJECTIVE,SR_OBJECT_ENT_CHALLENGE,\
+ SR_OBJECT_ENT_RELAY,\
\
SR_OBJECT_PROPERTIES, SR_LIGHT_PROPERTIES, SR_BONE_PROPERTIES,
SR_MESH_PROPERTIES, SR_MATERIAL_PROPERTIES \