X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=blender%2Fio_mspgl%2Fexport_scene.py;h=8666e98beee0ef9489557d28da89fdcf788ee036;hp=e272823ee164d257b1464a6f840ddb8a51e2e7cb;hb=f44366c8785eb7a88755cd71250a8b85289eeed2;hpb=5590886411b5779a7e6aa6a5ffeda8db6c515a55 diff --git a/blender/io_mspgl/export_scene.py b/blender/io_mspgl/export_scene.py index e272823e..8666e98b 100644 --- a/blender/io_mspgl/export_scene.py +++ b/blender/io_mspgl/export_scene.py @@ -2,79 +2,70 @@ import math import os class SceneExporter: - def __init__(self): - self.selected_only = False - self.visible_only = True - self.collection = True - self.skip_existing = True - self.show_progress = True - - def export_to_file(self, context, out_fn): - from .scene import create_scene_from_current - scene = create_scene_from_current(context, selected_only=self.selected_only, visible_only=self.visible_only) - - path, base = os.path.split(out_fn) - base, ext = os.path.splitext(base) - - export_names = {} - used_names = set() - for p in scene.prototypes: - clones = [i for i in scene.instances if i.prototype==p.name] - - prefix = p.name - for c in clones: - while not c.name.startswith(prefix): - pos = max(prefix.rfind(' '), prefix.rfind('.')) - if pos<0: - break; - prefix = prefix[:pos] - - if prefix: - export_names[p.name+".object"] = prefix.strip(" .") - else: - used_names.add(p.name) - - for n, e in export_names.items(): - if e in used_names: - number = 1 - while "{}_{}".format(e, number) in used_names: - number += 1 - e += "_{}".format(number) - export_names[n] = e+".object" - used_names.add(e) - + def export_to_file(self, context, out_fn, *, selected_only=False, visible_only=True, collection=True, skip_existing=True): from .util import Progress - progress = Progress(self.show_progress and context) + progress = Progress(context) - from .export import DataExporter - data_exporter = DataExporter() + from .scene import create_scene_from_current + scene = create_scene_from_current(context, selected_only=selected_only, visible_only=visible_only) resources = {} - data_exporter.export_resources(context, scene.prototypes, resources, None, progress) - for n, r in resources.items(): - if r.name in export_names: - r.name = export_names[r.name] + self.export_scene_resources(context, scene, resources, progress) + scene_res = self.export_scene(scene, resources) + progress.set_progress(1.0) - scene_res = self.export_scene(scene, resources, progress) - refs = scene_res.collect_references() + path, base = os.path.split(out_fn) + base, ext = os.path.splitext(base) - if self.collection: + if collection: existing = None - if self.skip_existing: + if skip_existing: existing = lambda r: not os.path.exists(os.path.join(path, r.name)) scene_res.write_collection(out_fn, filter=existing) else: scene_res.write_to_file(out_fn) - for r in refs: + for r in scene_res.collect_references(): r.write_to_file(os.path.join(path, r.name)) - def export_scene(self, scene, resources, progress): + def export_scene_resources(self, context, scene, resources, progress): + from .export import DataExporter + data_exporter = DataExporter() + + data_exporter.export_resources(context, scene.prototypes, resources, None, progress) + + def export_scene(self, scene, resources): from .datafile import Resource, Statement, Token scene_res = Resource(scene.name+".scene", "scene") - scene_res.statements.append(Statement("type", Token(scene.scene_type.lower()))) + if scene.background_set or (scene.instances and scene.blended_instances): + scene_res.statements.append(Statement("type", Token("ordered"))) + if scene.background_set: + scene_res.statements.append(scene_res.create_reference_statement("scene", resources[scene.background_set.name+".scene"])) + + if scene.instances: + st = Statement("scene") + st.sub.append(Statement("type", Token("simple"))) + self.add_instances(scene_res, st.sub, scene.instances, resources) + scene_res.statements.append(st) + + if scene.blended_instances: + st = Statement("scene") + st.sub.append(Statement("type", Token("zsorted"))) + self.add_instances(scene_res, st.sub, scene.blended_instances, resources) + scene_res.statements.append(st) + else: + scene_type = "zsorted" if scene.blended_instances else "simple" + scene_res.statements.append(Statement("type", Token(scene_type))) - for i in scene.instances: + self.add_instances(scene_res, scene_res.statements, scene.instances, resources) + self.add_instances(scene_res, scene_res.statements, scene.blended_instances, resources) + + return scene_res + + def add_instances(self, scene_res, statements, instances, resources): + from .datafile import Statement + + for i in instances: obj_res = resources[i.prototype+".object"] st = scene_res.create_reference_statement("object", obj_res, i.name) @@ -94,8 +85,98 @@ class SceneExporter: ss.sub.append(Statement("scale", *tuple(scale))) st.sub.append(ss) - scene_res.statements.append(st) + statements.append(st) - progress.set_progress(1.0) + def export_sequence_resources(self, scene, resources): + from .datafile import Resource, Statement, Token - return scene_res + lights = [] + s = scene + while s: + lights += s.lights + s = s.background_set + + from .util import make_unique + lights = make_unique(lights) + + from .export_light import LightExporter + light_exporter = LightExporter() + for l in lights: + light_name = l.name+".light" + if light_name not in resources: + resources[light_name] = light_exporter.export_light(l) + + lighting_name = scene.name+".lightn" + if lighting_name not in resources: + lighting_res = Resource(lighting_name, "lighting") + lighting_res.statements.append(Statement("ambient", *tuple(scene.ambient_light))) + for l in lights: + lighting_res.statements.append(lighting_res.create_reference_statement("light", resources[l.name+".light"])) + + resources[lighting_name] = lighting_res + + def export_sequence(self, scene, resources): + from .datafile import Resource, Statement, Token + seq_res = Resource(scene.name+".seq", "sequence") + + if scene.use_hdr: + seq_res.statements.append(Statement("hdr", True)) + + ss = Statement("clear") + ss.sub.append(Statement("color", 0.0, 0.0, 0.0, 0.0)) + ss.sub.append(Statement("depth", 1.0)) + seq_res.statements.append(ss) + + scene_res = resources[scene.name+".scene"] + seq_res.statements.append(seq_res.create_reference_statement("renderable", "content", scene_res)) + + lighting_res = resources[scene.name+".lightn"] + + any_opaque = False + any_blended = False + s = scene + while s: + if s.instances: + any_opaque = True + if s.blended_instances: + any_blended = True + s = s.background_set + + if any_opaque: + ss = Statement("step", "", "content") + ss.sub.append(Statement("depth_test", Token("LEQUAL"))) + ss.sub.append(seq_res.create_reference_statement("lighting", lighting_res)) + seq_res.statements.append(ss) + + if any_blended: + ss = Statement("step", "blended", "content") + ss.sub.append(Statement("depth_test", Token("LEQUAL"))) + ss.sub.append(seq_res.create_reference_statement("lighting", lighting_res)) + seq_res.statements.append(ss) + + if scene.use_ao: + ss = Statement("postprocessor") + ss.sub.append(Statement("type", Token("ambient_occlusion"))) + ss.sub.append(Statement("occlusion_radius", scene.ao_distance)) + ss.sub.append(Statement("samples", scene.ao_samples)) + seq_res.statements.append(ss) + + if scene.use_hdr: + ss = Statement("postprocessor") + ss.sub.append(Statement("type", Token("bloom"))) + seq_res.statements.append(ss) + + ss = Statement("postprocessor") + ss.sub.append(Statement("type", Token("colorcurve"))) + ss.sub.append(Statement("exposure_adjust", scene.exposure)) + ss.sub.append(Statement("srgb")) + seq_res.statements.append(ss) + else: + # Add a colorcurve with linear response to convert into sRGB color space + ss = Statement("postprocessor") + ss.sub.append(Statement("type", Token("colorcurve"))) + ss.sub.append(Statement("brightness_response", 1.0)) + ss.sub.append(Statement("srgb")) + seq_res.statements.append(ss) + + return seq_res