Example #1
0
def DoExport():
    persist = n2.lookup("/sys/servers/persist")
    persist.setsaverclass(str(persist_servers[persist_server]))

    e = n2export.n2exporter()
    e.group = group
    e.mesh_format = str(mesh_formats[mesh_format])
    e.filename = filename

    if (e.ExportScene()):
        e.SaveScene()
    e.CleanUp()

    fullscreen_arg = ""
    if (fullscreen):
        fullscreen_arg = "-fullscreen true"

    os.spawnl(
        os.P_NOWAIT, "%s/nviewer.exe" % (file2.manglepath("bin:")),
        "program name",
        "-projdir %s" % n2.lookup("/sys/servers/file2").getassign("proj"),
        "-view gfxlib:%s/%s.n2" % (group, e.filename), "-eyeposx 0",
        "-eysposy 2", "-eyeposz -20", "-eyecoix 0", "-eyecoiy 0", "-eyecoiz 0",
        "-w %i" % window_width, "-h %i" % window_height,
        "-featureset %s" % str(renderpaths[renderpath]),
        "-aa %s" % aasamples[aa], fullscreen_arg)
Example #2
0
def button_event(evt):
	global n2mat, bl_mat_index, n2_shader_index, texture_param_index
	
	if(evt == BL_MAT_CHANGED):
		bl_mat_index = bl_mats_menu.val
		n2mat = n2exporter.n2Material(bl_mats[bl_mat_index])
		n2_shader_index = n2_shaders.index(n2mat.GetShader().m_name)
		
	if(evt == NEBULA_SHADER_CHANGED):
		n2_shader_index = n2_shader_menu.val
		n2mat.CreateShaderFromName(n2_shaders[n2_shader_index])
		n2mat.SetDefaults()
		
	if(evt == SHADER_PARAM_CHANGED):
		params = n2mat.GetShader().m_params
		for key in params:
			param = params[key]
			if(not n2exporter.texture_param_types.has_key(param.m_type) and (not n2exporter.misc_param_types.has_key(param.m_type))):
				val = shader_params_menu[param.m_name].val
				n2mat.SetParamValue(param.m_name, val)
			elif(param.m_type == "Vector"):
				x = shader_params_menu[param.m_name + "_x"].val
				y = shader_params_menu[param.m_name + "_y"].val
				z = shader_params_menu[param.m_name + "_z"].val
				w = shader_params_menu[param.m_name + "_w"].val
				v = n2exporter.nVector(x, y, z, w)
				n2mat.SetParamValue(param.m_name, n2exporter.VectorToString(v))
	
	if(evt == TEXTURE_PARAM_CHANGED):
		texture_param_index = shader_params_menu["TextureParams"].val
		
	if(evt == TEXTURE_SELECT_CLICKED):
		Blender.Window.FileSelector(chooseTexture, "Choose Texture", n2.lookup("/sys/servers/file2").manglepath("textures:"))
		
	Draw.Redraw(1)
Example #3
0
def button_event(evt):
	global persist_server, mesh_format, window_width, window_height, fullscreen, renderpath, filename, group, aa

	if(evt == CANCEL_CLICKED):
		SavePrefs()
		Draw.Exit()
		return
	
	if(evt == PERSIST_SERVER_CHANGED):
		persist_server = mnu_persist_servers.val
		
	if(evt == MESH_FORMAT_CHANGED):
		mesh_format = mnu_mesh_formats.val
		
	if(evt == WIDTH_CHANGED):
		window_width = mnu_width.val
	
	if(evt == HEIGHT_CHANGED):
		window_height = mnu_height.val
		
	if(evt == FULLSCREEN_CHANGED):
		fullscreen = 1 - fullscreen
		
	if(evt == AA_CHANGED):
		aa = mnu_aa.val
		
	if(evt == FILENAME_CHANGED):
		filename = mnu_filename.val
	
	if(evt == GROUP_CHANGED):
		file2 = n2.lookup("/sys/servers/file2")
		path = ""
		is_valid = True
		if(mnu_group.val):
			path = file2.manglepath("gfxlib:") + "/" + mnu_group.val
		else:
			path = file2.manglepath("gfxlib:")
		if(not Blender.sys.exists(path)):
			is_valid = False
		path = ""
		if(mnu_group.val):
			path = file2.manglepath("meshes:") + "/" + mnu_group.val
		else:
			path = file2.manglepath("meshes:")
		if(not Blender.sys.exists(path)):
			is_valid = False
		if(is_valid):
			group = mnu_group.val
		else:
			err = "The directory ' %s ' must exist in both gfxlib and meshes folders" % mnu_group.val
			Draw.PupMenu("Invalid Group%t|" + err)
			Draw.Redraw(1)
	
	if(evt == RENDERPATH_CHANGED):
		renderpath = mnu_renderpath.val
	
	if(evt == OK_CLICKED):
		SavePrefs()
		DoExport()
Example #4
0
def button_event(evt):
    global persist_server, mesh_format, window_width, window_height, fullscreen, renderpath, filename, group, aa

    if (evt == CANCEL_CLICKED):
        SavePrefs()
        Draw.Exit()
        return

    if (evt == PERSIST_SERVER_CHANGED):
        persist_server = mnu_persist_servers.val

    if (evt == MESH_FORMAT_CHANGED):
        mesh_format = mnu_mesh_formats.val

    if (evt == WIDTH_CHANGED):
        window_width = mnu_width.val

    if (evt == HEIGHT_CHANGED):
        window_height = mnu_height.val

    if (evt == FULLSCREEN_CHANGED):
        fullscreen = 1 - fullscreen

    if (evt == AA_CHANGED):
        aa = mnu_aa.val

    if (evt == FILENAME_CHANGED):
        filename = mnu_filename.val

    if (evt == GROUP_CHANGED):
        file2 = n2.lookup("/sys/servers/file2")
        path = ""
        is_valid = True
        if (mnu_group.val):
            path = file2.manglepath("gfxlib:") + "/" + mnu_group.val
        else:
            path = file2.manglepath("gfxlib:")
        if (not Blender.sys.exists(path)):
            is_valid = False
        path = ""
        if (mnu_group.val):
            path = file2.manglepath("meshes:") + "/" + mnu_group.val
        else:
            path = file2.manglepath("meshes:")
        if (not Blender.sys.exists(path)):
            is_valid = False
        if (is_valid):
            group = mnu_group.val
        else:
            err = "The directory ' %s ' must exist in both gfxlib and meshes folders" % mnu_group.val
            Draw.PupMenu("Invalid Group%t|" + err)
            Draw.Redraw(1)

    if (evt == RENDERPATH_CHANGED):
        renderpath = mnu_renderpath.val

    if (evt == OK_CLICKED):
        SavePrefs()
        DoExport()
Example #5
0
def Getn2Shaders():
	doc = minidom.parse(n2.lookup("/sys/servers/file2").manglepath("home:")+"/data/shaders/shaders.xml")
	shaders = doc.getElementsByTagName("shader")
	shd_list = []
	for shader in shaders:
		name = shader.getAttribute("name")
		shd_list.append(name)
	doc.unlink()	
	return shd_list
Example #6
0
def DoStartupChecks():
	file2 = n2.lookup("/sys/servers/file2")
	# Check for shaders.xml in home:data/shaders/shaders.xml
	valid = True
	if(not file2.fileexists("home:data/shaders/shaders.xml")):
		print "shaders.xml not found in %s" % file2.manglepath("home:data/shaders/shaders.xml")
		valid = False
	if(not file2.fileexists("bin:nviewer.exe")):
		print "nviewer not found in %s" % file2.manglepath("bin:nviewer.exe")
		valid = False
	return valid
Example #7
0
	def ExportAsMesh(self, obj, node=None):
		"""
		Export "obj" as Mesh by extracting and saving mesh data.
		"""
		node = n2.lookup(n2.psel())
		me = obj.getData(mesh=1)
		editmode = Window.EditMode()
		if(editmode):
			Window.EditMode(0)
		obj_name = obj.getName()
		# Check if more than one material
		if(len(me.materials)>1):
			n2class = self.GetTypeFromProperty(obj)
			if(not n2class):
				n2class = "nshapenode"
			# Create dictionary with materila index as key and kist of face indices as value
			mat_dict = {}
			faces = me.faces
			for f in faces:
				if(mat_dict.has_key(f.mat)):
					mat_dict[f.mat].append(f)
				else:
					mat_dict[f.mat] = []
					mat_dict[f.mat].append(f)
			# Create nshapenode for each material
			i = 0 # hack in case the same materila is assigned to diffrenet vertex groups
			for index in mat_dict:
				mat = me.materials[index]
				node = n2.new(n2class, "%s_%s_%i" % (obj_name, mat.getName(), i))
				self.CreateMesh(mat_dict[index], obj)
				group_idx = self.mesh.append(self.tmp_mesh)
				try:
					node.setgroupindex(group_idx)
					node.setmesh("meshes:%s/%s.%s" % (self.group, self.filename, self.mesh_format))
					self.SetShader(node, mat)
				except AttributeError:
					n2.nprint("%s 'class' property must be an nshapenode or derived\n" % obj_name)
				i = i+1
		else:
			if(node.isa("nshapenode")):
				mesh = obj.getData(mesh=1)
				self.CreateMesh(me.faces, obj)
				group_idx = self.mesh.append(self.tmp_mesh)
				node.setmesh("meshes:%s/%s.%s" % (self.group, self.filename, self.mesh_format))
				node.setgroupindex(group_idx)
				if(len(mesh.materials)>0):
					mat = mesh.materials[0]
					self.SetShader(node, mat)
				else:
					self.SetShader(node)
			else:
				n2.nprint("WARNING: Trying to export Mesh '%s' as ntransformnode, Mesh data not exported\n" % obj.getName())
		
		Window.EditMode(editmode)
Example #8
0
def GetTexturePath(path):
	# check if 'path' is a nebula path
	r = re.search('^[a-zA-Z0-9]+:{1}[a-zA-Z0-9]+', path)
	if(r):
		return path
	texture_dir = n2.lookup("/sys/servers/file2").manglepath("textures:")
		
	#path = os.path.abspath(path)
	path = Blender.sys.expandpath(path)
	filename = Blender.sys.basename(path)
	path = string.replace(path, "\\", "/")
	if(path[0:len(texture_dir)].lower() == texture_dir.lower()):
		path = "textures:" + path[(len(texture_dir)+1):]
	else:
		# Path outside texture assign
		file2 = n2.lookup("/sys/servers/file2")
		if(file2.fileexists(path)):
			file2.copyfile(path, "textures:%s" % filename)
			return "textures:%s" % filename
		return None
	return path
Example #9
0
	def SaveScene(self):
		"""
		Save the exported scene to an .n2 object.
		
		If the scene_name == None, the .n2 object's name will be the current scenes name.
		"""
		self.model.saveas("gfxlib:%s/%s.n2" % (self.group, self.filename))
		file2 = n2.lookup("/sys/servers/file2")
		self.mesh.buildtrianglenormals()
		self.mesh.buildvertextangents(False)
		self.mesh.buildvertexnormals()
		self.mesh.cleanup()
		self.mesh.save(file2, "meshes:%s/%s.%s" % (self.group, self.filename, self.mesh_format));
#end of n2exporter class def
		
Example #10
0
def SaveConfig():
	global config_data
	file2 = n2.lookup("/sys/servers/file2")
	#file2.setassign("home", str(config_data["home"]))
	#file2.setassign("proj", str(config_data["proj"]))
	for data in config_data:
			#if(data != "home"):
			data = str(data)
			assign = config_data[data]
			file2.setassign(data, assign)
	texture_dir = file2.manglepath("textures:")
	texture_dir = os.path.abspath(texture_dir)
	texture_dir = string.replace(texture_dir, "\\", "/")
	config_data["texture_dir"] = texture_dir
	Registry.SetKey(reg_name, config_data, True)
Example #11
0
def SaveConfig():
    global config_data
    file2 = n2.lookup("/sys/servers/file2")
    #file2.setassign("home", str(config_data["home"]))
    #file2.setassign("proj", str(config_data["proj"]))
    for data in config_data:
        #if(data != "home"):
        data = str(data)
        assign = config_data[data]
        file2.setassign(data, assign)
    texture_dir = file2.manglepath("textures:")
    texture_dir = os.path.abspath(texture_dir)
    texture_dir = string.replace(texture_dir, "\\", "/")
    config_data["texture_dir"] = texture_dir
    Registry.SetKey(reg_name, config_data, True)
Example #12
0
def DoExport():
	persist = n2.lookup("/sys/servers/persist")
	persist.setsaverclass(str(persist_servers[persist_server]))
		
	e = n2export.n2exporter()
	e.group = group
	e.mesh_format = str(mesh_formats[mesh_format])
	e.filename = filename
			
	if(e.ExportScene()):
		e.SaveScene()
	e.CleanUp()
	
	fullscreen_arg = ""
	if(fullscreen):
		fullscreen_arg = "-fullscreen true"
		
	os.spawnl(os.P_NOWAIT, "%s/nviewer.exe" % (file2.manglepath("bin:")), "program name", "-projdir %s" % n2.lookup("/sys/servers/file2").getassign("proj"), "-view gfxlib:%s/%s.n2" % (group, e.filename), "-eyeposx 0", "-eysposy 2", "-eyeposz -20", "-eyecoix 0", "-eyecoiy 0", "-eyecoiz 0", "-w %i" % window_width, "-h %i" % window_height, "-featureset %s" % str(renderpaths[renderpath]), "-aa %s" % aasamples[aa], fullscreen_arg)
Example #13
0
	def ExportAsLight(self, obj, node=None):
		"""
		Export object as a light node.
		
		If the light has different color values for Ambient, Diffuse and Specular, 
		create a mesh object and give its material colors the desired values then parent it to the light. 
		The objects name has to be in the format <light_name>_"color" e.g. if the light's name is Lamp01 
		the Meshes name should be "Lamp01_color"
		"""
	
		if(obj.getType()=="Lamp"):
			obj_name = obj.getName()
			lamp = obj.getData()
			scene_node = n2.lookup(n2.psel())
			scene_node.setfloat("LightRange", lamp.getDist())
			#scene_node.settype("Directional")
			
			mode = lamp.getMode()
			if(mode & lamp.Modes["RayShadow"]):
				scene_node.setcastshadows(True)
			else:
				scene_node.setcastshadows(False)
			
			color_info_obj = GetChildByName(obj, obj_name + "_color")
			if(color_info_obj and color_info_obj.getType() == "Mesh" and color_info_obj.getData(mesh=True).materials[0]):
				material = color_info_obj.getData(mesh=True).materials[0]
				# Col = Diffuse, Spe = Specular, Mir = Ambient
				diffuse = material.getRGBCol()
				specular = material.getSpecCol()
				ambient = material.getMirCol()
				scene_node.setvector("LightDiffuse", diffuse[0], diffuse[1], diffuse[2], 1.0)
				scene_node.setvector("LightSpecular", specular[0], specular[1], specular[2], 1.0)
				scene_node.setvector("LightAmbient", ambient[0], ambient[1], ambient[2], 1.0)
			else:
				n2.nprint("WARNING: Color information object for Lamp '%s' not found or not valid" % obj_name)
				col = lamp.col
				scene_node.setvector("LightDiffuse", col[0], col[1], col[2], 1.0)
				scene_node.setvector("LightSpecular", col[0], col[1], col[2], 1.0)
				scene_node.setvector("LightAmbient", col[0], col[1], col[2], 1.0)
		else:
			n2.nprint("WARNING: %s is Not a Lamp and was not exported\n" % obj.getName())
Example #14
0
	def CreateNew(self, name):
		if(self.m_name != name):
			self.Clear()
			doc = minidom.parse(n2.lookup("/sys/servers/file2").manglepath("home:")+"/data/shaders/shaders.xml")
			shaders = doc.getElementsByTagName("shader")
			for shader in shaders:
				tmp_name = shader.getAttribute("name")
				if(tmp_name == name):
					self.m_name = name
					self.m_file = shader.getAttribute("file")
					# Create shader Params
					tmp_params = shader.getElementsByTagName("param")
					for tmp_param in tmp_params:
						param_type = tmp_param.getAttribute("type")
						param_gui = tmp_param.getAttribute("gui")
						if(param_type != "Color"):
							param_name = tmp_param.getAttribute("name")
							param_label = tmp_param.getAttribute("label")
							param_export = tmp_param.getAttribute("export")
							param_default = tmp_param.getAttribute("def")
							param_min = ""
							param_max = ""
							param_enum = []
							param_default_enum = 0
							if(tmp_param.hasAttribute("min") and tmp_param.hasAttribute("max")):
								param_min = tmp_param.getAttribute("min")
								param_max = tmp_param.getAttribute("max")
							if(tmp_param.hasAttribute("enum")):
								enum = tmp_param.getAttribute("enum")
								items = string.split(enum, ":")
								first_items = string.split(items[0], "=")
								items[0] = first_items[0]
								param_default_enum = int(first_items[1])
								param_enum = items
							param = n2ShaderParam(param_name, param_label, param_type, param_gui, param_export, param_default, param_min, param_max, param_enum, param_default_enum)
							self.m_params[param_name] = param
					break
			doc.unlink()
Example #15
0
def button_event(evt):
    global n2mat, bl_mat_index, n2_shader_index, texture_param_index

    if (evt == BL_MAT_CHANGED):
        bl_mat_index = bl_mats_menu.val
        n2mat = n2exporter.n2Material(bl_mats[bl_mat_index])
        n2_shader_index = n2_shaders.index(n2mat.GetShader().m_name)

    if (evt == NEBULA_SHADER_CHANGED):
        n2_shader_index = n2_shader_menu.val
        n2mat.CreateShaderFromName(n2_shaders[n2_shader_index])
        n2mat.SetDefaults()

    if (evt == SHADER_PARAM_CHANGED):
        params = n2mat.GetShader().m_params
        for key in params:
            param = params[key]
            if (not n2exporter.texture_param_types.has_key(param.m_type) and
                (not n2exporter.misc_param_types.has_key(param.m_type))):
                val = shader_params_menu[param.m_name].val
                n2mat.SetParamValue(param.m_name, val)
            elif (param.m_type == "Vector"):
                x = shader_params_menu[param.m_name + "_x"].val
                y = shader_params_menu[param.m_name + "_y"].val
                z = shader_params_menu[param.m_name + "_z"].val
                w = shader_params_menu[param.m_name + "_w"].val
                v = n2exporter.nVector(x, y, z, w)
                n2mat.SetParamValue(param.m_name, n2exporter.VectorToString(v))

    if (evt == TEXTURE_PARAM_CHANGED):
        texture_param_index = shader_params_menu["TextureParams"].val

    if (evt == TEXTURE_SELECT_CLICKED):
        Blender.Window.FileSelector(
            chooseTexture, "Choose Texture",
            n2.lookup("/sys/servers/file2").manglepath("textures:"))

    Draw.Redraw(1)
Example #16
0
	button_width = 60
	
	mnu_renderpath = Draw.Menu(buildMenu(renderpaths), RENDERPATH_CHANGED, pen_x, pen_y, button_width, button_height, renderpath, "Renderpath to use for preview")
	
	# Move Pen Point
	pen_x = left + padding
	pen_y = pen_y - button_height - 5
	button_width = 80
	
	Draw.PushButton("Close", CANCEL_CLICKED, pen_x, pen_y, button_width, button_height, "Close Exporter")
	
	pen_x = pen_x + button_width + padding
	Draw.PushButton("Export", OK_CLICKED, pen_x, pen_y, button_width, button_height, "Export Scene")
	

file2 = n2.lookup("/sys/servers/file2")

reg_name = "n2exportconfig"			
export_config = Registry.GetKey(reg_name, True)

if(not export_config):
	export_config = GetPrefDefaults()

# Get Window width and height
win_size = Window.GetAreaSize()
left = 0
top = win_size[1]

# Space to leave between buttons
padding = 10
Example #17
0
                               renderpath, "Renderpath to use for preview")

    # Move Pen Point
    pen_x = left + padding
    pen_y = pen_y - button_height - 5
    button_width = 80

    Draw.PushButton("Close", CANCEL_CLICKED, pen_x, pen_y, button_width,
                    button_height, "Close Exporter")

    pen_x = pen_x + button_width + padding
    Draw.PushButton("Export", OK_CLICKED, pen_x, pen_y, button_width,
                    button_height, "Export Scene")


file2 = n2.lookup("/sys/servers/file2")

reg_name = "n2exportconfig"
export_config = Registry.GetKey(reg_name, True)

if (not export_config):
    export_config = GetPrefDefaults()

# Get Window width and height
win_size = Window.GetAreaSize()
left = 0
top = win_size[1]

# Space to leave between buttons
padding = 10