def on_save_level_as(self, event):
""" Save the current level under a new name. """
# Ask for a name for the new level
dlg = filedlg.FileDialog(self.get_frame(), filedlg.SAVE, 'level',
'Level', "wc:levels", ["n2"])
if dlg.ShowModal() == wx.ID_OK:
new_level_name = dlg.get_guiname()
# Check the name hasn't already been taken
if dlg.file_exists():
msg = "There is already a level called '%s'.\n\n" \
"Please enter a new level name." % new_level_name
cjr.show_error_message(msg)
else:
try:
try:
new_level_path = dlg.get_path_as_string()
dlg2 = waitdlg.WaitDialog(
self.get_frame(),
"Saving level as '%s'..." % new_level_name)
save_ok = servers.get_conjurer().savecurrentlevelas(
new_level_path)
if save_ok:
self.refresh()
else:
cjr.show_error_message(
"Unable to save level as '%s'." %
new_level_name)
finally:
dlg2.Destroy()
except:
raise # make sure any errors are not hidden
dlg.Destroy()
def __save_docs(self):
dlg = waitdlg.WaitDialog(app.get_top_window())
for i in range(len(self.savers)):
if self.checklist.IsChecked(i):
dlg.set_message("Saving %s ..." % self.savers[i].get_brief())
self.savers[i].save()
dlg.Destroy()
def on_build_streams(self, event):
"""Build all streams"""
# Build all dirty streams
if not pynebula.exists(str("/usr/streams")):
app.get_state("geometrystream").loadstreamlibrary()
dlg2 = waitdlg.WaitDialog(self.get_frame(), "Building streams ...")
app.get_state("geometrystream").buildallstreams()
dlg2.Destroy()
def on_build_outdoor(self, event):
"""Build a navigation mesh for the outdoor"""
dlg = waitdlg.WaitDialog(self.get_frame(),
"Building navigation mesh...")
navbuilder = app.get_navbuilder()
success = navbuilder.buildnavmesh()
dlg.Destroy()
if not success:
cjr.show_error_message("Unable to create the navigation mesh")
def on_preprocess_horizon(self, event):
"""Preprocess terrain horizon culling information"""
try:
try:
dlg = waitdlg.WaitDialog(self.get_frame(),
"Preprocessing horizon...")
trn.get_terrain_module().preprocesshorizon()
finally:
dlg.Destroy()
except:
# make sure any errors are not hidden
raise
def on_generate_weightmaps(self, event):
"""Generate terrain weightmaps"""
try:
try:
dlg = waitdlg.WaitDialog(self.get_frame(),
"Generating weightmaps...")
trn.get_terrain_module().createterrainweightmaps()
finally:
dlg.Destroy()
except:
# make sure any errors are not hidden
raise
def on_generate_global_texture(self, event):
"""Generate the terrain global texture"""
try:
try:
dlg = waitdlg.WaitDialog(self.get_frame(),
"Generating global texture...")
trn.get_terrain_module().createterrainglobaltexture()
finally:
dlg.Destroy()
except:
# make sure any errors are not hidden
raise
def on_update_height(self, event):
"""Update grass height"""
level_manager = servers.get_level_manager()
level_name = level_manager.getcurrentlevelobject().getname()
if level_name == "default":
cjr.show_error_message(
"Unable to update grass height for default level.")
else:
dlg = waitdlg.WaitDialog(self.get_frame(),
"Updating grass height...")
terrain = app.get_outdoor()
terrain.grassupdateheight()
dlg.Destroy()
def on_delete_level(self, event):
"""Show a file browser and delete the selected level"""
# Ask for the level's name
current_level_name = get_name_of_current_level()
dlg = filedlg.FileDialog(
self.get_frame(),
filedlg.DELETE,
'level',
'Level',
"wc:levels", ["n2"],
excluded_files=['default.n2',
'%s.n2' % current_level_name])
result_ok = dlg.ShowModal() == wx.ID_OK
level_name = dlg.get_guiname()
level_path = dlg.get_path_as_string()
dlg.Destroy()
if not result_ok:
return
# Ask for confirmation
msg = "All your hard work is going to be removed, deleted, " \
"cleared, lost forever (ok, you can still revert\n" \
"your working copy, but your local level is going to be " \
"erased for sure).\n\nSo, are you sure that you want to " \
"delete the '%s' level?" % level_name
result = cjr.warn_yes_no(self.get_frame(), msg)
if result != wx.ID_YES:
return
# Ask for final confirmation
msg = "If you have clicked OK because of a tick in your finger, this " \
"is your last chance to avoid throwing away the whole level.\n\n" \
"Again, and for last time, are you ABSOLUTELY sure that you " \
"want to delete the '%s' level?" % level_name
result = cjr.warn_yes_no(self.get_frame(), msg)
if result != wx.ID_YES:
return
# Finally delete the level (and the presets configuration)
try:
try:
dlg = waitdlg.WaitDialog(self.get_frame(),
"Deleting level %s..." % level_name)
unassign_preset(level_name)
servers.get_conjurer().deletelevel(level_path)
finally:
dlg.Destroy()
except:
# make sure any errors are not hidden
raise
def on_generate_grass_dirty(self, event):
"""Generate terrain grass, only dirty"""
level_manager = servers.get_level_manager()
level_name = level_manager.getcurrentlevelobject().getname()
if level_name == "default":
cjr.show_error_message(
"Unable to generate grass for default level.")
else:
dlg = waitdlg.WaitDialog(self.get_frame(), "Generating grass...")
terrain = app.get_outdoor()
editing = terrain.isingrowthedition()
if not editing:
terrain.begingrowthediton()
terrain.buildonlydirtygrowth()
if not editing:
terrain.endgrowtedition(False)
dlg.Destroy()
def on_save_level(self, event):
"""Save the current level, overwritting the old file"""
level_name = get_name_of_current_level()
if level_name == "default":
cjr.show_error_message("The default level cannot be saved.")
else:
try:
try:
dlg = waitdlg.WaitDialog(
self.get_frame(), "Saving '%s' level..." % level_name)
if prelevel_process(False):
servers.get_conjurer().savelevel()
postlevel_process(False)
finally:
dlg.Destroy()
except:
raise # make sure any errors are not hidden
def on_ok(self, event):
# Verify that has been given a valid class name
name = str(self.text_classname.GetValue().capitalize())
if not servers.get_entity_class_server().checkclassname(name):
cjr.show_error_message("Invalid class name.")
return
# get lightmap size
lightmap_size = self.get_lightmap_resolution()
# get lightmap size
shadowmap_size = self.get_shadowmap_resolution()
# get the global lightmap size
global_lightmap_size = self.get_global_lightmap_resolution()
# get light id
lightid = app.get_level().findentity("terrain_lightmap_light")
distance = self.text_ctrl_distance.get_value()
offset_u = self.text_ctrl_offset_u.get_value()
offset_v = self.text_ctrl_offset_v.get_value()
aaliasing = self.text_ctrl_aaliasing.get_value()
overwrite = self.checkbox_overwrite.IsChecked()
# if light not found
if lightid == 0:
cjr.show_information_message(
"Please use the 'Select lightmap light' " \
"option to select the light"
)
return
# Create the terrain class
dlg = waitdlg.WaitDialog(self.GetParent(),
"Creating terrain lightmap...")
terrain = trn.get_terrain_module()
terrain.createterrainlightmaps(name, lightmap_size, shadowmap_size,
global_lightmap_size, lightid,
overwrite, distance, offset_u, offset_v,
aaliasing)
# Closes dialog reporting OK
dlg.Destroy()
self.EndModal(wx.ID_OK)
def on_ok(self, event):
outdoor = app.get_outdoor()
if outdoor is None:
cjr.show_error_message("The level has no terrain instance.")
return
if self.has_terrain_class_selected():
# Import terrain materials
try:
dlg = waitdlg.WaitDialog(self.GetParent(),
self.importing_materials_text())
imported_ok = self.import_materials_to_outdoor(outdoor)
finally:
dlg.Destroy()
if imported_ok:
# Closes dialog reporting OK
self.EndModal(wx.ID_OK)
else:
cjr.show_error_message(
"Please select a terrain class from the list.")
def on_area_stats(self, event):
"""Get stats and budget for loading area"""
# select an area and retrieve stats information for it
dlg = nodelibdlg.NodeLibDialog(self.get_frame(), nodelibdlg.OPEN,
'area', 'Area', "/usr/areas")
if dlg.ShowModal() == wx.ID_OK:
# Check that's an existing area
if not dlg.node_exists():
msg = "There is no area called '%s'" % dlg.get_guiname()
cjr.show_error_message(msg)
else:
# show log of resources for the area
dlg2 = waitdlg.WaitDialog(self.get_frame(),
"Analyzing area ...")
if not dlg.get_node().logdebugstats():
msg = "No stats available for this area, "\
"you need to load it first"
cjr.show_error_message(msg)
dlg2.Destroy()
dlg.Destroy()
def on_remove_stream(self, event):
"""Remove geometry stream"""
if not pynebula.exists(str("/usr/streams")):
app.get_state("geometrystream").loadstreamlibrary()
dlg = nodelibdlg.NodeLibDialog(self.get_frame(), nodelibdlg.OPEN,
'stream', 'Stream', "/usr/streams")
if dlg.ShowModal() == wx.ID_OK:
# Check that's an existing stream
if not dlg.node_exists():
msg = "There is no stream called '%s'" % dlg.get_guiname()
cjr.show_error_message(msg)
else:
# remove the stream
dlg2 = waitdlg.WaitDialog(
self.get_frame(),
"Removing stream '%s' ..." % dlg.get_guiname())
dlg.get_node().removestream()
dlg2.Destroy()
dlg.Destroy()
def on_ok(self, event):
if app.get_outdoor() is not None:
cjr.show_error_message("The level already has a terrain instance.")
return
if self.list.GetSelection() == wx.NOT_FOUND:
cjr.show_error_message("Please select a terrain class.")
else:
# Create a new terrain
dlg = waitdlg.WaitDialog(self.GetParent(),
"Creating terrain instance...")
created_ok = trn.get_terrain_module().createterraininstance(
str(self.list.GetStringSelection()))
dlg.Destroy()
if not created_ok:
cjr.show_error_message(
"Unable to create the terrain instance.")
else:
# Closes dialog reporting OK
self.EndModal(wx.ID_OK)
def on_build_indoors(self, event):
"""Build navigation meshes for all selected indoors"""
state = app.get_object_state()
navbuilder = app.get_navbuilder()
dlg = waitdlg.WaitDialog(
self.get_frame(), "Building navigation mesh for indoor 00/00...")
num_entities = state.getselectioncount()
for i in range(num_entities):
dlg.set_message( "Building navigation mesh for indoor " \
+ str(i+1) + "/" + str(num_entities) + "..." )
entity = state.getselectedentity(i)
success = True
if entity.isa('neindoor'):
success = navbuilder.buildindoornavmesh(entity)
elif entity.isa('newalkablebrush'):
success = navbuilder.buildbrushnavmesh(entity)
if not success:
msg = "Unable to create navigation mesh for entity %s" % str(
entity.getid())
cjr.show_error_message(msg)
dlg.Destroy()
def on_open_level(self, event):
"""Show a file browser and open the selected level"""
# Ask for the level's name
dlg = filedlg.FileDialog(self.get_frame(),
filedlg.OPEN,
'level',
'Level',
"wc:levels", ["n2"],
import_button=False)
if dlg.ShowModal() == wx.ID_OK:
# Check that the filename exists
level_name = dlg.get_guiname()
if not dlg.file_exists():
msg = "So you want to open the '%s' level that doesn't exist?" \
"\n<sigh> How curious these humans are..." \
% level_name
cjr.show_error_message(msg)
else:
# Ask for final confirmation
msg = "Any previous unsaved level data will be lost.\n\n" \
"Are you sure that you want to load the "\
"'%s' level?" % level_name
result = cjr.warn_yes_no(self.get_frame(), msg)
if result == wx.ID_YES:
# Finally load the level
try:
try:
dlg3 = waitdlg.WaitDialog(
self.get_frame(),
"Loading level %s..." % level_name)
if prelevel_process(True):
servers.get_conjurer().loadlevel(
dlg.get_path_as_string())
postlevel_process(True)
finally:
dlg3.Destroy()
except:
# make sure any errors are not hidden
raise
dlg.Destroy()
def on_ok(self, event):
if not self.__has_valid_class_name():
cjr.show_error_message("Invalid class name.")
return False
new_name = self.__get_class_name().capitalize()
global_lightmap_size = self.get_global_lightmap_resolution()
dlg = waitdlg.WaitDialog(self.GetParent(),
"Creating global terrain lightmap...")
terrain = trn.get_terrain_module()
result = terrain.createterraingloballightmap(new_name,
global_lightmap_size)
# Closes dialog reporting OK
dlg.Destroy()
if result:
cjr.show_information_message(
"Successfully created global terrain lightmap %s" % new_name)
self.EndModal(wx.ID_OK)
else:
cjr.show_error_message(
"Unable to create the global terrain lightmap")
self.EndModal(wx.ID_OK)
def on_ok(self, event):
ec_server = servers.get_entity_class_server()
# Verify that has been given a valid class name
name = str( self.text_classname.GetValue().capitalize() )
if not ec_server.checkclassname( name ):
cjr.show_error_message(
"Please enter a valid class name."
)
return
# Verify that there isn't another class with the given name
outdoors = ec_server.getentityclass("neoutdoor")
outdoor = outdoors.gethead()
while outdoor is not None:
if outdoor.getname() == name:
msg = "There is an existing terrain class with " \
"the given name.\n\nPlease enter another."
cjr.show_error_message(msg)
return
outdoor = outdoor.getsucc()
# Check that a level size has been entered
if not self.has_level_size():
cjr.show_error_message(
"Please select a level size."
)
return
if self.are_min_and_max_height_values_equal():
cjr.show_error_message(
"Minimum and maximum height values cannot be the same."
)
return
# Create the terrain class
dlg = waitdlg.WaitDialog(
self.GetParent(),
"Creating terrain class..."
)
try:
terrain = trn.get_terrain_module()
created_ok = terrain.createterrainclass(
name,
self.props_ctrls.get_current_resolution(),
self.props_ctrls.get_current_block_size(),
# N.B. we pass the terrain module the selection
# index of the "Cells per terrain block" choice
# Since the cells are in the format "2n x 2n",
# we are in effect passing the value of n
int( self.props_ctrls.choice_veg_cells_per_block.GetSelection() ),
int( self.props_ctrls.choice_vegetation_res.GetStringSelection() ),
int( self.props_ctrls.choice_weightmap.GetStringSelection() ),
int( self.props_ctrls.choice_global_res.GetStringSelection() ),
self.props_ctrls.get_point_separation()
)
if not created_ok:
cjr.show_error_message(
"Unable to create the terrain class."
)
return
flatten_at_value = self.props_ctrls.get_flatten_at_value()
if flatten_at_value == '':
flatten_at_value = '0.0'
set_params_ok = terrain.setterrainclassparams(
name,
float( self.props_ctrls.text_ctrl_min.get_value() ),
float( self.props_ctrls.text_ctrl_max.get_value() ),
bool( self.props_ctrls.is_flatten_all_selected() ),
float(flatten_at_value)
)
if not set_params_ok:
cjr.show_error_message(
"Unable to create the terrain class " \
"due to invalid parameters."
)
return
#set the level size
centre_to_boundary_trn = (self.props_ctrls.get_terrain_size_in_metres() ) / 2
centre_to_boundary_level = ( self.props_ctrls.get_current_level_size() ) / 2
new_class = ec_server.getentityclass(name)
new_class.setoriginalbbox(
centre_to_boundary_trn,
0,
centre_to_boundary_trn,
centre_to_boundary_level,
centre_to_boundary_level,
centre_to_boundary_level
)
# Create a terrain instance, if enabled
if self.checkbox_make_terrain.IsChecked():
dlg.set_message( "Creating terrain instance..." )
created_trn_ok = terrain.createterraininstance( name )
if not created_trn_ok:
cjr.show_error_message(
"Unable to create the terrain instance."
)
finally:
# Closes dialog
dlg.Destroy()
#report OK
self.EndModal(wx.ID_OK)
