Hoikas
/
korman
mirror of https://github.com/H-uru/korman.git
4
4
Fork 0
Code Releases Activity

Compare commits

base: Hoikas:b059bb07a95f53c8256634c300fc5ffc8880499b
Branches Tags
Hoikas:master
..
compare: Hoikas:7861cb8af57d74e5bf682af4f7c755937ae0b0d4
Branches Tags
Hoikas:master

No commits in common. 'b059bb07a95f53c8256634c300fc5ffc8880499b' and '7861cb8af57d74e5bf682af4f7c755937ae0b0d4' have entirely different histories.
b059bb07a9 ... 7861cb8af5

4 changed files with 45 additions and 90 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats
  1. 45
      korman/exporter/animation.py
  2. 59
      korman/exporter/material.py
  3. 21
      korman/nodes/node_messages.py
  4. 10
      korman/nodes/node_python.py

45
korman/exporter/animation.py
Unescape View File

@ -479,8 +479,7 @@ class AnimationConverter:
return 0.0, 0.0
def make_matrix44_controller(self, fcurves, pos_path: str, scale_path: str, pos_default, scale_default,
*, start: Optional[int] = None, end: Optional[int] = None,
name: str = "") -> Optional[plLeafController]:
*, start: Optional[int] = None, end: Optional[int] = None) -> Optional[plLeafController]:
def convert_matrix_keyframe(**kwargs) -> hsMatrix44:
pos = kwargs[pos_path]
scale = kwargs[scale_path]
@ -500,7 +499,7 @@ class AnimationConverter:
channels = { pos_path: 3, scale_path: 3 }
default_values = { pos_path: pos_default, scale_path: scale_default }
keyframes = self._process_fcurves(fcurves, channels, 1, convert_matrix_keyframe,
default_values, start=start, end=end, name=name)
default_values, start=start, end=end)
if not keyframes:
return None
@ -509,10 +508,10 @@ class AnimationConverter:
def make_pos_controller(self, fcurves, data_path: str, default_xform,
convert: Optional[Callable] = None, *, start: Optional[int] = None,
end: Optional[int] = None, name: str = "") -> Optional[plLeafController]:
end: Optional[int] = None) -> Optional[plLeafController]:
pos_curves = [i for i in fcurves if i.data_path == data_path and i.keyframe_points]
keyframes, bez_chans = self._process_keyframes(pos_curves, 3, default_xform, convert,
start=start, end=end, name=name)
start=start, end=end)
if not keyframes:
return None
@ -523,7 +522,7 @@ class AnimationConverter:
def make_rot_controller(self, fcurves, rotation_mode: str, default_xform,
convert: Optional[Callable] = None, *, start: Optional[int] = None,
end: Optional[int] = None, name: str = "") -> Union[None, plCompoundController, plLeafController]:
end: Optional[int] = None) -> Union[None, plCompoundController, plLeafController]:
if rotation_mode in {"AXIS_ANGLE", "QUATERNION"}:
rot_curves = [i for i in fcurves if i.data_path == "rotation_{}".format(rotation_mode.lower()) and i.keyframe_points]
if not rot_curves:
@ -544,7 +543,7 @@ class AnimationConverter:
# I think that opting into quaternion keyframes is a good enough indication that
# you're OK with that.
keyframes, bez_chans = self._process_keyframes(rot_curves, 4, default_xform, convert,
start=start, end=end, name=name)
start=start, end=end)
if keyframes:
return self._make_quat_controller(keyframes)
else:
@ -565,7 +564,7 @@ class AnimationConverter:
euler_convert = convert_euler_keyframe if rotation_mode != "XYZ" else convert
keyframes, bez_chans = self._process_keyframes(rot_curves, 3, default_xform.to_euler(rotation_mode),
euler_convert, start=start, end=end, name=name)
euler_convert, start=start, end=end)
if keyframes:
# Once again, quaternion keyframes do not support bezier interpolation. Ideally,
# we would just drop support for rotation beziers entirely to simplify all this
@ -577,11 +576,10 @@ class AnimationConverter:
def make_scale_controller(self, fcurves, data_path: str, default_xform,
convert: Optional[Callable] = None, *, start: Optional[int] = None,
end: Optional[int] = None,
name: str = "") -> Optional[plLeafController]:
end: Optional[int] = None) -> Optional[plLeafController]:
scale_curves = [i for i in fcurves if i.data_path == data_path and i.keyframe_points]
keyframes, bez_chans = self._process_keyframes(scale_curves, 3, default_xform, convert,
start=start, end=end, name=name)
start=start, end=end)
if not keyframes:
return None
@ -592,9 +590,8 @@ class AnimationConverter:
def make_scalar_leaf_controller(self, fcurve: bpy.types.FCurve,
convert: Optional[Callable] = None, *,
start: Optional[int] = None,
end: Optional[int] = None,
name: str = "") -> Optional[plLeafController]:
keyframes, bezier = self._process_fcurve(fcurve, convert, start=start, end=end, name=name)
end: Optional[int] = None) -> Optional[plLeafController]:
keyframes, bezier = self._process_fcurve(fcurve, convert, start=start, end=end)
if not keyframes:
return None
@ -744,8 +741,7 @@ class AnimationConverter:
return [keyframes_sorted[i] for i in filtered_indices]
def _process_fcurve(self, fcurve: bpy.types.FCurve, convert: Optional[Callable] = None, *,
start: Optional[int] = None, end: Optional[int] = None,
name: str = "") -> Tuple[Sequence, AbstractSet]:
start: Optional[int] = None, end: Optional[int] = None) -> Tuple[Sequence, AbstractSet]:
"""Like _process_keyframes, but for one fcurve"""
# Adapt from incoming single item sequence to a single argument.
@ -754,7 +750,7 @@ class AnimationConverter:
else:
single_convert = None
# Can't proxy to _process_fcurves because it only supports linear interoplation.
return self._process_keyframes([fcurve], 1, [0.0], single_convert, start=start, end=end, name=name)
return self._process_keyframes([fcurve], 1, [0.0], single_convert, start=start, end=end)
def _santize_converted_values(self, num_channels: int, raw_values: Union[Dict, Sequence], convert: Callable):
assert convert is not None
@ -776,8 +772,7 @@ class AnimationConverter:
def _process_fcurves(self, fcurves: Sequence, channels: Dict[str, int], result_channels: int,
convert: Callable, defaults: Dict[str, Union[float, Sequence]], *,
start: Optional[int] = None, end: Optional[int] = None,
name: str = "") -> Sequence:
start: Optional[int] = None, end: Optional[int] = None) -> Sequence:
"""This consumes a sequence of Blender FCurves that map to a single Plasma controller.
Like `_process_keyframes()`, except the converter function is mandatory, and each
Blender `data_path` must have a fixed number of channels.
@ -843,14 +838,11 @@ class AnimationConverter:
keyframe.out_tans = [0.0] * result_channels
keyframes[frame_num] = keyframe
sorted_keyframes = self._sort_and_dedupe_keyframes(keyframes)
if keyframes and not sorted_keyframes and name:
self._exporter().report.warn(f"All keyframes for '{name}' are identical and have been discarded!")
return sorted_keyframes
return self._sort_and_dedupe_keyframes(keyframes)
def _process_keyframes(self, fcurves, num_channels: int, default_values: Sequence,
convert: Optional[Callable] = None, *, start: Optional[int] = None,
end: Optional[int] = None, name: str = "") -> Tuple[Sequence, AbstractSet]:
end: Optional[int] = None) -> Tuple[Sequence, AbstractSet]:
"""Groups all FCurves for the same frame together"""
keyframe_data = type("KeyFrameData", (), {})
fps, pi = self._bl_fps, math.pi
@ -909,10 +901,7 @@ class AnimationConverter:
keyframes[frame_num] = keyframe
# Return the keyframes in a sequence sorted by frame number
sorted_keyframes = self._sort_and_dedupe_keyframes(keyframes)
if keyframes and not sorted_keyframes and name:
self._exporter().report.warn(f"All keyframes for '{name}' are identical and have been discarded!")
return (sorted_keyframes, bez_chans)
return (self._sort_and_dedupe_keyframes(keyframes), bez_chans)
@property
def _mgr(self):

59
korman/exporter/material.py
Unescape View File

@ -529,9 +529,7 @@ class MaterialConverter:
# Export any layer animations
# NOTE: animated stencils and bumpmaps are nonsense.
if not slot.use_stencil and not wantBumpmap:
self._report.msg("Exporting layer animations")
with self._report.indent():
layer = self._export_layer_animations(bo, bm, slot, idx, layer)
layer = self._export_layer_animations(bo, bm, slot, idx, layer)
# Stash the top of the stack for later in the export
if bm is not None:
@ -564,18 +562,12 @@ class MaterialConverter:
if texture is not None:
layer_props = texture.plasma_layer
for anim in layer_props.subanimations:
self._report.msg(f"Exporting '{anim.animation_name}'")
if not anim.is_entire_animation:
start, end = anim.start, anim.end
else:
start, end = None, None
with self._report.indent():
controllers = self._export_layer_controllers(
bo, bm, tex_slot, idx, base_layer,
start=start, end=end
)
controllers = self._export_layer_controllers(bo, bm, tex_slot, idx, base_layer,
start=start, end=end)
if not controllers:
continue
@ -592,9 +584,7 @@ class MaterialConverter:
top_layer.varName = anim.sdl_var
else:
# Crappy automatic entire layer animation. Loop it by default.
self._report.msg(f"Exporting crappy '(Entire Animation)'")
with self._report.indent():
controllers = self._export_layer_controllers(bo, bm, tex_slot, idx, base_layer)
controllers = self._export_layer_controllers(bo, bm, tex_slot, idx, base_layer)
if controllers:
attach_layer(plLayerAnimation, "(Entire Animation)", controllers)
atc = top_layer.timeConvert
@ -640,21 +630,14 @@ class MaterialConverter:
# Take the FCurves and ram them through our converters, hopefully returning some valid
# animation controllers.
controllers: Dict[str, plController] = {}
controllers = {}
for attr, converter in self._animation_exporters.items():
ctrl = converter(bo, bm, tex_slot, base_layer, fcurves, start=start, end=end, ctrlName=attr)
ctrl = converter(bo, bm, tex_slot, base_layer, fcurves, start=start, end=end)
if ctrl is not None:
if isinstance(ctrl, plLeafController):
self._report.msg(f"'{attr}': {len(ctrl.keys)} keyframes")
elif isinstance(ctrl, plCompoundController):
# Shouldn't happen, but for completeness' sake.
self._report.msg(f"{attr}: X={len(ctrl.X.keys)}, Y={len(ctrl.Y.keys)}, Z={len(ctrl.Z.keys)} keyframes")
else:
raise RuntimeError()
controllers[attr] = ctrl
return controllers
def _export_layer_diffuse_animation(self, bo, bm, tex_slot, base_layer, fcurves, *, start, end, converter, ctrlName: str = ""):
def _export_layer_diffuse_animation(self, bo, bm, tex_slot, base_layer, fcurves, *, start, end, converter):
assert converter is not None
# If there's no material, then this is simply impossible.
@ -666,15 +649,12 @@ class MaterialConverter:
result = converter(bo, bm, tex_slot, mathutils.Color(color_sequence))
return result.red, result.green, result.blue
ctrl = self._exporter().animation.make_pos_controller(
fcurves, "diffuse_color",
bm.diffuse_color, translate_color,
start=start, end=end,
name=ctrlName
)
ctrl = self._exporter().animation.make_pos_controller(fcurves, "diffuse_color",
bm.diffuse_color, translate_color,
start=start, end=end)
return ctrl
def _export_layer_opacity_animation(self, bo, bm, tex_slot, base_layer, fcurves, *, start, end, ctrlName: str):
def _export_layer_opacity_animation(self, bo, bm, tex_slot, base_layer, fcurves, *, start, end):
# Dumb function to intercept the opacity values and properly flag the base layer
def process_opacity(value):
self._handle_layer_opacity(base_layer, value)
@ -682,27 +662,20 @@ class MaterialConverter:
for i in fcurves:
if i.data_path == "plasma_layer.opacity":
ctrl = self._exporter().animation.make_scalar_leaf_controller(
i, process_opacity,
start=start, end=end,
name=ctrlName
)
ctrl = self._exporter().animation.make_scalar_leaf_controller(i, process_opacity, start=start, end=end)
return ctrl
return None
def _export_layer_transform_animation(self, bo, bm, tex_slot, base_layer, fcurves, *, start, end, ctrlName: str):
def _export_layer_transform_animation(self, bo, bm, tex_slot, base_layer, fcurves, *, start, end):
if tex_slot is not None:
path = tex_slot.path_from_id()
pos_path = "{}.offset".format(path)
scale_path = "{}.scale".format(path)
# Plasma uses the controller to generate a matrix44... so we have to produce a leaf controller
ctrl = self._exporter().animation.make_matrix44_controller(
fcurves, pos_path, scale_path,
tex_slot.offset, tex_slot.scale,
start=start, end=end,
name=ctrlName
)
ctrl = self._exporter().animation.make_matrix44_controller(fcurves, pos_path, scale_path,
tex_slot.offset, tex_slot.scale,
start=start, end=end)
return ctrl
return None

21
korman/nodes/node_messages.py
Unescape View File

@ -255,7 +255,7 @@ class PlasmaAnimCmdMsgNode(idprops.IDPropMixin, PlasmaMessageWithCallbacksNode,
msg.addCallback(cb)
msg.setCmd(plAnimCmdMsg.kAddCallbacks, True)
def convert_message(self, exporter: Exporter, so: plSceneObject):
def convert_message(self, exporter, so):
msg = plAnimCmdMsg()
# We're either sending this off to an AGMasterMod or a LayerAnim
@ -271,18 +271,13 @@ class PlasmaAnimCmdMsgNode(idprops.IDPropMixin, PlasmaMessageWithCallbacksNode,
texture = self.target_texture
if obj is None and material is None and texture is None:
self.raise_error("At least one of: target object, material, texture MUST be specified")
target = tuple(exporter.mesh.material.get_texture_animation_key(obj, material, texture, self.anim_name))
filtered_target = [i for i in target if not isinstance(i.object, (plAgeGlobalAnim, plLayerSDLAnimation))]
if not filtered_target and target:
self.raise_error("No controllable animations were found!")
elif not filtered_target and not target:
self.raise_error("No animations were found!")
elif filtered_target:
for i in filtered_target:
msg.addReceiver(i)
else:
raise RuntimeError()
target = exporter.mesh.material.get_texture_animation_key(obj, material, texture, self.anim_name)
target = [i for i in target if not isinstance(i.object, (plAgeGlobalAnim, plLayerSDLAnimation))]
if not target:
self.raise_error("No controllable animations were found.")
for i in target:
msg.addReceiver(i)
# Check the enum properties to see what commands we need to add
for prop in (self.go_to, self.action, self.play_direction, self.looping):

10
korman/nodes/node_python.py
Unescape View File

@ -83,7 +83,7 @@ _attrib_key_types = {
"ptAttribNamedResponder": plFactory.ClassIndex("plResponderModifier"),
"ptAttribDynamicMap": plFactory.ClassIndex("plDynamicTextMap"),
"ptAttribGUIDialog": plFactory.ClassIndex("pfGUIDialogMod"),
"ptAttribExcludeRegion": plFactory.ClassIndex("plExcludeRegionModifier"),
"ptAttribExcludeRegion": plFactory.ClassIndex("plExcludeRegionMod"),
"ptAttribAnimation": (plFactory.ClassIndex("plAGMasterMod"),
plFactory.ClassIndex("plMsgForwarder")),
"ptAttribBehavior": plFactory.ClassIndex("plMultistageBehMod"),
@ -347,11 +347,9 @@ class PlasmaPythonFileNode(PlasmaVersionedNode, bpy.types.Node):
else:
good_key = key.type == key_type
if not good_key:
exporter.report.warn(
f"'{self.id_data.name}' Node '{socket.links[0].from_node.name}' "
f"returned an unexpected key type '{plFactory.ClassName(key.type)}' "
f"for use in Python File Node '{self.name}' attribute ID:{socket.attribute_id}",
)
exporter.report.warn("'{}' Node '{}' returned an unexpected key type '{}'",
self.id_data.name, socket.links[0].from_node.name,
plFactory.ClassName(key.type))
key_object = key.object
if isinstance(key_object, plSceneObject):

Write Preview
Loading…
Cancel
Save