mirror of https://github.com/H-uru/korman.git
GitHub
24 changed files with 1320 additions and 43 deletions
@ -0,0 +1,225 @@
|
||||
# This file is part of Korman. |
||||
# |
||||
# Korman is free software: you can redistribute it and/or modify |
||||
# it under the terms of the GNU General Public License as published by |
||||
# the Free Software Foundation, either version 3 of the License, or |
||||
# (at your option) any later version. |
||||
# |
||||
# Korman is distributed in the hope that it will be useful, |
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
# GNU General Public License for more details. |
||||
# |
||||
# You should have received a copy of the GNU General Public License |
||||
# along with Korman. If not, see <http://www.gnu.org/licenses/>. |
||||
|
||||
from __future__ import annotations |
||||
|
||||
import bpy |
||||
import mathutils |
||||
|
||||
from contextlib import contextmanager, ExitStack |
||||
import itertools |
||||
import math |
||||
from PyHSPlasma import * |
||||
from typing import * |
||||
import weakref |
||||
|
||||
from .explosions import ExportError |
||||
from .. import helpers |
||||
from . import utils |
||||
|
||||
if TYPE_CHECKING: |
||||
from .convert import Exporter |
||||
from .logger import _ExportLogger as ExportLogger |
||||
|
||||
|
||||
class Clipping(NamedTuple): |
||||
hither: float |
||||
yonder: float |
||||
|
||||
|
||||
class PostEffectModMatrices(NamedTuple): |
||||
c2w: hsMatrix44 |
||||
w2c: hsMatrix44 |
||||
|
||||
|
||||
class GuiConverter: |
||||
|
||||
if TYPE_CHECKING: |
||||
_parent: weakref.ref[Exporter] = ... |
||||
|
||||
def __init__(self, parent: Optional[Exporter] = None): |
||||
self._parent = weakref.ref(parent) if parent is not None else None |
||||
|
||||
# Go ahead and prepare the GUI transparent material for future use. |
||||
if parent is not None: |
||||
self._transp_material = parent.exit_stack.enter_context( |
||||
helpers.TemporaryObject( |
||||
bpy.data.materials.new("GUITransparent"), |
||||
bpy.data.materials.remove |
||||
) |
||||
) |
||||
self._transp_material.diffuse_color = mathutils.Vector((1.0, 1.0, 0.0)) |
||||
self._transp_material.use_mist = False |
||||
|
||||
# Cyan's transparent GUI materials just set an opacity of 0% |
||||
tex_slot = self._transp_material.texture_slots.add() |
||||
tex_slot.texture = parent.exit_stack.enter_context( |
||||
helpers.TemporaryObject( |
||||
bpy.data.textures.new("AutoTransparentLayer", "NONE"), |
||||
bpy.data.textures.remove |
||||
) |
||||
) |
||||
tex_slot.texture.plasma_layer.opacity = 0.0 |
||||
else: |
||||
self._transp_material = None |
||||
|
||||
def calc_camera_matrix( |
||||
self, |
||||
scene: bpy.types.Scene, |
||||
objects: Sequence[bpy.types.Object], |
||||
fov: float, |
||||
scale: float = 0.75 |
||||
) -> mathutils.Matrix: |
||||
if not objects: |
||||
raise ExportError("No objects specified for GUI Camera generation.") |
||||
|
||||
# Generally, GUIs are flat planes. However, we are not Cyan, so artists cannot walk down |
||||
# the hallway to get smacked on the knuckles by programmers. This means that they might |
||||
# give us some three dimensional crap as a GUI. Therefore, to come up with a camera matrix, |
||||
# we'll use the average area-weighted inverse normal of all the polygons they give us. That |
||||
# way, the camera *always* should face the GUI as would be expected. |
||||
remove_mesh = bpy.data.meshes.remove |
||||
avg_normal = mathutils.Vector() |
||||
for i in objects: |
||||
mesh = i.to_mesh(bpy.context.scene, True, "RENDER", calc_tessface=False) |
||||
with helpers.TemporaryObject(mesh, remove_mesh): |
||||
utils.transform_mesh(mesh, i.matrix_world) |
||||
for polygon in mesh.polygons: |
||||
avg_normal += (polygon.normal * polygon.area) |
||||
avg_normal.normalize() |
||||
avg_normal *= -1.0 |
||||
|
||||
# From the inverse area weighted normal we found above, get the rotation from the up axis |
||||
# (that is to say, the +Z axis) and create our rotation matrix. |
||||
axis = mathutils.Vector((avg_normal.x, avg_normal.y, 0.0)) |
||||
axis.normalize() |
||||
angle = math.acos(avg_normal.z) |
||||
mat = mathutils.Matrix.Rotation(angle, 3, axis) |
||||
|
||||
# Now, we know the rotation of the camera. Great! What we need to do now is ensure that all |
||||
# of the objects in question fit within the view of a 4:3 camera rotated as above. Blender |
||||
# helpfully provides us with the localspace bounding boxes of all the objects and an API to |
||||
# fit points into the camera view. |
||||
with ExitStack() as stack: |
||||
stack.enter_context(self.generate_camera_render_settings(scene)) |
||||
|
||||
# Create a TEMPORARY camera object so we can use a certain Blender API. |
||||
camera = stack.enter_context(utils.temporary_camera_object(scene, "GUICameraTemplate")) |
||||
camera.matrix_world = mat.to_4x4() |
||||
camera.data.angle = fov |
||||
camera.data.lens_unit = "FOV" |
||||
|
||||
# Get all of the bounding points and make sure they all fit inside the camera's view frame. |
||||
bound_boxes = [ |
||||
obj.matrix_world * mathutils.Vector(bbox) |
||||
for obj in objects for bbox in obj.bound_box |
||||
] |
||||
co, _ = camera.camera_fit_coords( |
||||
scene, |
||||
# bound_box is a list of vectors of each corner of all the objects' bounding boxes; |
||||
# however, Blender's API wants a sequence of individual channel positions. Therefore, |
||||
# we need to flatten the vectors. |
||||
list(itertools.chain.from_iterable(bound_boxes)) |
||||
) |
||||
|
||||
# This generates a list of 6 faces per bounding box, which we then flatten out and pass |
||||
# into the BVHTree constructor. This is to calculate the distance from the camera to the |
||||
# "entire GUI" - which we can then use to apply the scale given to us. |
||||
if scale != 1.0: |
||||
bvh = mathutils.bvhtree.BVHTree.FromPolygons( |
||||
bound_boxes, |
||||
list(itertools.chain.from_iterable( |
||||
[(i + 0, i + 1, i + 5, i + 4), |
||||
(i + 1, i + 2, i + 5, i + 6), |
||||
(i + 3, i + 2, i + 6, i + 7), |
||||
(i + 0, i + 1, i + 2, i + 3), |
||||
(i + 0, i + 3, i + 7, i + 4), |
||||
(i + 4, i + 5, i + 6, i + 7), |
||||
] for i in range(0, len(bound_boxes), 8) |
||||
)) |
||||
) |
||||
loc, normal, index, distance = bvh.find_nearest(co) |
||||
co += normal * distance * (scale - 1.0) |
||||
|
||||
# ... |
||||
mat.resize_4x4() |
||||
mat.translation = co |
||||
return mat |
||||
|
||||
def calc_clipping( |
||||
self, |
||||
pose: mathutils.Matrix, |
||||
scene: bpy.types.Scene, |
||||
objects: Sequence[bpy.types.Object], |
||||
fov: float |
||||
) -> Clipping: |
||||
with ExitStack() as stack: |
||||
stack.enter_context(self.generate_camera_render_settings(scene)) |
||||
camera = stack.enter_context(utils.temporary_camera_object(scene, "GUICameraTemplate")) |
||||
camera.matrix_world = pose |
||||
camera.data.angle = fov |
||||
camera.data.lens_unit = "FOV" |
||||
|
||||
# Determine the camera plane's normal so we can do a distance check against the |
||||
# bounding boxes of the objects shown in the GUI. |
||||
view_frame = [i * pose for i in camera.data.view_frame(scene)] |
||||
cam_plane = mathutils.geometry.normal(view_frame) |
||||
bound_boxes = ( |
||||
obj.matrix_world * mathutils.Vector(bbox) |
||||
for obj in objects for bbox in obj.bound_box |
||||
) |
||||
pos = pose.to_translation() |
||||
bounds_dists = [ |
||||
abs(mathutils.geometry.distance_point_to_plane(i, pos, cam_plane)) |
||||
for i in bound_boxes |
||||
] |
||||
|
||||
# Offset them by some epsilon to ensure the objects are rendered. |
||||
hither, yonder = min(bounds_dists), max(bounds_dists) |
||||
if yonder - 0.5 < hither: |
||||
hither -= 0.25 |
||||
yonder += 0.25 |
||||
return Clipping(hither, yonder) |
||||
|
||||
def convert_post_effect_matrices(self, camera_matrix: mathutils.Matrix) -> PostEffectModMatrices: |
||||
# PostEffectMod matrices face *away* from the GUI... For some reason. |
||||
# See plPostEffectMod::SetWorldToCamera() |
||||
c2w = utils.matrix44(camera_matrix) |
||||
w2c = utils.matrix44(camera_matrix.inverted()) |
||||
for i in range(4): |
||||
c2w[i, 2] *= -1.0 |
||||
w2c[2, i] *= -1.0 |
||||
return PostEffectModMatrices(c2w, w2c) |
||||
|
||||
@contextmanager |
||||
def generate_camera_render_settings(self, scene: bpy.types.Scene) -> Iterator[None]: |
||||
# Set the render info to basically TV NTSC 4:3, which will set Blender's camera |
||||
# viewport up as a 4:3 thingy to match Plasma. |
||||
with helpers.GoodNeighbor() as toggle: |
||||
toggle.track(scene.render, "resolution_x", 720) |
||||
toggle.track(scene.render, "resolution_y", 486) |
||||
toggle.track(scene.render, "pixel_aspect_x", 10.0) |
||||
toggle.track(scene.render, "pixel_aspect_y", 11.0) |
||||
yield |
||||
|
||||
@property |
||||
def _report(self) -> ExportLogger: |
||||
return self._parent().report |
||||
|
||||
@property |
||||
def transparent_material(self) -> bpy.types.Material: |
||||
assert self._transp_material is not None |
||||
return self._transp_material |
||||
|
||||
@ -0,0 +1,119 @@
|
||||
# This file is part of Korman. |
||||
# |
||||
# Korman is free software: you can redistribute it and/or modify |
||||
# it under the terms of the GNU General Public License as published by |
||||
# the Free Software Foundation, either version 3 of the License, or |
||||
# (at your option) any later version. |
||||
# |
||||
# Korman is distributed in the hope that it will be useful, |
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
# GNU General Public License for more details. |
||||
# |
||||
# You should have received a copy of the GNU General Public License |
||||
# along with Korman. If not, see <http://www.gnu.org/licenses/>. |
||||
|
||||
from __future__ import annotations |
||||
|
||||
import bpy |
||||
from bpy.props import * |
||||
|
||||
import math |
||||
|
||||
from ..exporter.explosions import ExportError |
||||
from ..exporter.gui import GuiConverter |
||||
|
||||
class CameraOperator: |
||||
@classmethod |
||||
def poll(cls, context): |
||||
return context.scene.render.engine == "PLASMA_GAME" |
||||
|
||||
|
||||
class PlasmaGameGuiCameraOperator(CameraOperator, bpy.types.Operator): |
||||
bl_idname = "camera.plasma_create_game_gui_camera" |
||||
bl_label = "Create Game GUI Camera" |
||||
bl_description = "Create a camera looking at all of the objects in this GUI page with a custom scale factor" |
||||
|
||||
fov: float = FloatProperty( |
||||
name="Field of View", |
||||
description="Camera Field of View angle", |
||||
subtype="ANGLE", |
||||
default=math.radians(90.0), |
||||
min=0.0, |
||||
max=math.radians(360.0), |
||||
precision=1, |
||||
options=set() |
||||
) |
||||
gui_page: str = StringProperty( |
||||
name="GUI Page", |
||||
description="", |
||||
options={"HIDDEN"} |
||||
) |
||||
scale: float = FloatProperty( |
||||
name="GUI Scale", |
||||
description="GUI Camera distance scale factor.", |
||||
default=75.0, |
||||
min=0.1, |
||||
soft_max=100.0, |
||||
precision=1, |
||||
subtype="PERCENTAGE", |
||||
options=set() |
||||
) |
||||
|
||||
mod_id: str = StringProperty(options={"HIDDEN"}) |
||||
cam_prop_name: str = StringProperty(options={"HIDDEN"}) |
||||
|
||||
def invoke(self, context, event): |
||||
context.window_manager.invoke_props_dialog(self) |
||||
return {"RUNNING_MODAL"} |
||||
|
||||
def execute(self, context): |
||||
# If the modifier has been given to us, select all of the objects in the |
||||
# given GUI page. |
||||
if self.gui_page: |
||||
for i in context.scene.objects: |
||||
i.select = i.plasma_object.page == self.gui_page |
||||
context.scene.update() |
||||
|
||||
visible_objects = [ |
||||
i for i in context.selected_objects |
||||
if i.type in {"MESH", "FONT"} |
||||
] |
||||
|
||||
gui = GuiConverter() |
||||
try: |
||||
cam_matrix = gui.calc_camera_matrix( |
||||
context.scene, |
||||
visible_objects, |
||||
self.fov, |
||||
self.scale / 100.0 |
||||
) |
||||
except ExportError as e: |
||||
self.report({"ERROR"}, str(e)) |
||||
return {"CANCELLED"} |
||||
|
||||
if self.mod_id and self.cam_prop_name: |
||||
modifier = getattr(context.object.plasma_modifiers, self.mod_id) |
||||
cam_obj = getattr(modifier, self.cam_prop_name) |
||||
else: |
||||
cam_obj = None |
||||
if cam_obj is None: |
||||
if self.gui_page: |
||||
name = f"{self.gui_page}_GUICamera" |
||||
else: |
||||
name = f"{context.object.name}_GUICamera" |
||||
cam_data = bpy.data.cameras.new(name) |
||||
cam_obj = bpy.data.objects.new(name, cam_data) |
||||
context.scene.objects.link(cam_obj) |
||||
|
||||
cam_obj.matrix_world = cam_matrix |
||||
cam_obj.data.angle = self.fov |
||||
cam_obj.data.lens_unit = "FOV" |
||||
|
||||
for i in context.scene.objects: |
||||
i.select = i == cam_obj |
||||
|
||||
if self.mod_id and self.cam_prop_name: |
||||
modifier = getattr(context.object.plasma_modifiers, self.mod_id) |
||||
setattr(modifier, self.cam_prop_name, cam_obj) |
||||
return {"FINISHED"} |
||||
@ -0,0 +1,508 @@
|
||||
# This file is part of Korman. |
||||
# |
||||
# Korman is free software: you can redistribute it and/or modify |
||||
# it under the terms of the GNU General Public License as published by |
||||
# the Free Software Foundation, either version 3 of the License, or |
||||
# (at your option) any later version. |
||||
# |
||||
# Korman is distributed in the hope that it will be useful, |
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
# GNU General Public License for more details. |
||||
# |
||||
# You should have received a copy of the GNU General Public License |
||||
# along with Korman. If not, see <http://www.gnu.org/licenses/>. |
||||
|
||||
from __future__ import annotations |
||||
|
||||
import bpy |
||||
from bpy.props import * |
||||
|
||||
import itertools |
||||
import math |
||||
from typing import * |
||||
|
||||
from PyHSPlasma import * |
||||
|
||||
from ...exporter import ExportError |
||||
from .base import PlasmaModifierProperties |
||||
from ... import idprops |
||||
|
||||
if TYPE_CHECKING: |
||||
from ...exporter import Exporter |
||||
from ..prop_world import PlasmaAge, PlasmaPage |
||||
|
||||
class _GameGuiMixin: |
||||
@property |
||||
def gui_sounds(self) -> Iterable[Tuple[str, int]]: |
||||
"""Overload to automatically export GUI sounds on the control. This should return an iterable |
||||
of tuple attribute name and sound index. |
||||
""" |
||||
return [] |
||||
|
||||
def get_control(self, exporter: Exporter, bo: Optional[bpy.types.Object] = None, so: Optional[plSceneObject] = None) -> Optional[pfGUIControlMod]: |
||||
return None |
||||
|
||||
@property |
||||
def has_gui_proc(self) -> bool: |
||||
return True |
||||
|
||||
def iterate_control_modifiers(self) -> Iterator[_GameGuiMixin]: |
||||
pl_mods = self.id_data.plasma_modifiers |
||||
yield from ( |
||||
getattr(pl_mods, i.pl_id) |
||||
for i in self.iterate_control_subclasses() |
||||
if getattr(pl_mods, i.pl_id).enabled |
||||
) |
||||
|
||||
@classmethod |
||||
def iterate_control_subclasses(cls) -> Iterator[_GameGuiMixin]: |
||||
yield from filter( |
||||
lambda x: x.is_game_gui_control(), |
||||
_GameGuiMixin.__subclasses__() |
||||
) |
||||
|
||||
@classmethod |
||||
def is_game_gui_control(cls) -> bool: |
||||
return True |
||||
|
||||
@property |
||||
def requires_dyntext(self) -> bool: |
||||
return False |
||||
|
||||
def sanity_check(self): |
||||
age: PlasmaAge = bpy.context.scene.world.plasma_age |
||||
|
||||
# Game GUI modifiers must be attached to objects in a GUI page, ONLY |
||||
page_name: str = self.id_data.plasma_object.page |
||||
our_page: Optional[PlasmaPage] = next( |
||||
(i for i in age.pages if i.name == page_name) |
||||
) |
||||
if our_page is None or our_page.page_type != "gui": |
||||
raise ExportError(f"'{self.id_data.name}': {self.bl_label} Modifier must be in a GUI page!") |
||||
|
||||
# Only one Game GUI Control per object. Continuously check this because objects can be |
||||
# generated/mutated during the pre-export phase. |
||||
modifiers = self.id_data.plasma_modifiers |
||||
controls = [i for i in self.iterate_control_subclasses() if getattr(modifiers, i.pl_id).enabled] |
||||
num_controls = len(controls) |
||||
if num_controls > 1: |
||||
raise ExportError(f"'{self.id_data.name}': Only 1 GUI Control modifier is allowed per object. We found {num_controls}.") |
||||
|
||||
# Blow up on invalid sounds |
||||
soundemit = self.id_data.plasma_modifiers.soundemit |
||||
for attr_name, _ in self.gui_sounds: |
||||
sound_name = getattr(self, attr_name) |
||||
if not sound_name: |
||||
continue |
||||
sound = next((i for i in soundemit.sounds if i.name == sound_name), None) |
||||
if sound is None: |
||||
raise ExportError(f"'{self.id_data.name}': Invalid '{attr_name}' GUI Sound '{sound_name}'") |
||||
|
||||
|
||||
class PlasmaGameGuiControlModifier(PlasmaModifierProperties, _GameGuiMixin): |
||||
pl_id = "gui_control" |
||||
pl_page_types = {"gui"} |
||||
|
||||
bl_category = "GUI" |
||||
bl_label = "GUI Control (ex)" |
||||
bl_description = "XXX" |
||||
bl_object_types = {"FONT", "MESH"} |
||||
|
||||
tag_id = IntProperty( |
||||
name="Tag ID", |
||||
description="", |
||||
min=0, |
||||
options=set() |
||||
) |
||||
visible = BoolProperty( |
||||
name="Visible", |
||||
description="", |
||||
default=True, |
||||
options=set() |
||||
) |
||||
proc = EnumProperty( |
||||
name="Notification Procedure", |
||||
description="", |
||||
items=[ |
||||
("default", "[Default]", "Send notifications to the owner's notification procedure."), |
||||
("close_dialog", "Close Dialog", "Close the current Game GUI Dialog."), |
||||
("console_command", "Run Console Command", "Run a Plasma Console command.") |
||||
], |
||||
options=set() |
||||
) |
||||
console_command = StringProperty( |
||||
name="Command", |
||||
description="", |
||||
options=set() |
||||
) |
||||
|
||||
def convert_gui_control(self, exporter: Exporter, ctrl: pfGUIControlMod, bo: bpy.types.Object, so: plSceneObject): |
||||
ctrl.tagID = self.tag_id |
||||
ctrl.visible = self.visible |
||||
if self.proc == "default": |
||||
ctrl.setFlag(pfGUIControlMod.kInheritProcFromDlg, True) |
||||
elif self.proc == "close_dialog": |
||||
ctrl.handler = pfGUICloseDlgProc() |
||||
elif self.proc == "console_command": |
||||
handler = pfGUIConsoleCmdProc() |
||||
handler.command = self.console_command |
||||
ctrl.handler = handler |
||||
|
||||
def convert_gui_sounds(self, exporter: Exporter, ctrl: pfGUIControlMod, ctrl_mod: _GameGuiMixin): |
||||
soundemit = ctrl_mod.id_data.plasma_modifiers.soundemit |
||||
if not ctrl_mod.gui_sounds or not soundemit.enabled: |
||||
return |
||||
|
||||
# This is a lot like the plPhysicalSndGroup where we have a vector behaving as a lookup table. |
||||
# NOTE that zero is a special value here meaning no sound, so we need to offset the sounds |
||||
# that we get from the emitter modifier by +1. |
||||
sound_indices = {} |
||||
for attr_name, gui_sound_idx in ctrl_mod.gui_sounds: |
||||
sound_name = getattr(ctrl_mod, attr_name) |
||||
if not sound_name: |
||||
continue |
||||
sound_keys = soundemit.get_sound_keys(exporter, sound_name) |
||||
sound_key, soundemit_index = next(sound_keys, (None, -1)) |
||||
if sound_key is not None: |
||||
sound_indices[gui_sound_idx] = soundemit_index + 1 |
||||
|
||||
# Compress the list to include only the highest entry we need. |
||||
if sound_indices: |
||||
ctrl.soundIndices = [sound_indices.get(i, 0) for i in range(max(sound_indices) + 1)] |
||||
|
||||
def export(self, exporter: Exporter, bo: bpy.types.Object, so: plSceneObject): |
||||
ctrl_mods = list(self.iterate_control_modifiers()) |
||||
if not ctrl_mods: |
||||
exporter.report.msg(str(list(self.iterate_control_subclasses()))) |
||||
exporter.report.warn("This modifier has no effect because no GUI control modifiers are present!") |
||||
for ctrl_mod in ctrl_mods: |
||||
ctrl_obj = ctrl_mod.get_control(exporter, bo, so) |
||||
self.convert_gui_control(exporter, ctrl_obj, bo, so) |
||||
self.convert_gui_sounds(exporter, ctrl_obj, ctrl_mod) |
||||
|
||||
@property |
||||
def has_gui_proc(self) -> bool: |
||||
return any((i.has_gui_proc for i in self.iterate_control_modifiers())) |
||||
|
||||
@classmethod |
||||
def is_game_gui_control(cls) -> bool: |
||||
# How is a control not a control, you ask? Because, grasshopper, this modifier does not |
||||
# actually export a GUI control itself. Instead, it holds common properties that may |
||||
# or may not be used by other controls. This just helps fill out the other modifiers. |
||||
return False |
||||
|
||||
|
||||
class GameGuiAnimation(bpy.types.PropertyGroup): |
||||
def _poll_target_object(self, value): |
||||
# Only allow targetting things that are in our GUI page. |
||||
if value.plasma_object.page != self.id_data.plasma_object.page: |
||||
return False |
||||
if self.anim_type == "OBJECT": |
||||
return idprops.poll_animated_objects(self, value) |
||||
else: |
||||
return idprops.poll_drawable_objects(self, value) |
||||
|
||||
def _poll_texture(self, value): |
||||
# must be a legal option... but is it a member of this material... or, if no material, |
||||
# any of the materials attached to the object? |
||||
if self.target_material is not None: |
||||
return value.name in self.target_material.texture_slots |
||||
else: |
||||
target_object = self.target_object if self.target_object is not None else self.id_data |
||||
for i in (slot.material for slot in target_object.material_slots if slot and slot.material): |
||||
if value in (slot.texture for slot in i.texture_slots if slot and slot.texture): |
||||
return True |
||||
return False |
||||
|
||||
def _poll_material(self, value): |
||||
# Don't filter materials by texture - this would (potentially) result in surprising UX |
||||
# in that you would have to clear the texture selection before being able to select |
||||
# certain materials. |
||||
target_object = self.target_object if self.target_object is not None else self.id_data |
||||
object_materials = (slot.material for slot in target_object.material_slots if slot and slot.material) |
||||
return value in object_materials |
||||
|
||||
anim_type: str = EnumProperty( |
||||
name="Type", |
||||
description="Animation type to affect", |
||||
items=[ |
||||
("OBJECT", "Object", "Object Animation"), |
||||
("TEXTURE", "Texture", "Texture Animation"), |
||||
], |
||||
default="OBJECT", |
||||
options=set() |
||||
) |
||||
target_object: bpy.types.Object = PointerProperty( |
||||
name="Object", |
||||
description="Target object", |
||||
poll=_poll_target_object, |
||||
type=bpy.types.Object |
||||
) |
||||
target_material: bpy.types.Material = PointerProperty( |
||||
name="Material", |
||||
description="Target material", |
||||
type=bpy.types.Material, |
||||
poll=_poll_material |
||||
) |
||||
target_texture: bpy.types.Texture = PointerProperty( |
||||
name="Texture", |
||||
description="Target texture", |
||||
type=bpy.types.Texture, |
||||
poll=_poll_texture |
||||
) |
||||
|
||||
|
||||
class GameGuiAnimationGroup(bpy.types.PropertyGroup): |
||||
def _update_animation_name(self, context) -> None: |
||||
if not self.animation_name: |
||||
self.animation_name = "(Entire Animation)" |
||||
|
||||
animations = CollectionProperty( |
||||
name="Animations", |
||||
description="", |
||||
type=GameGuiAnimation, |
||||
options=set() |
||||
) |
||||
|
||||
animation_name: str = StringProperty( |
||||
name="Animation Name", |
||||
description="Name of the animation to play", |
||||
default="(Entire Animation)", |
||||
update=_update_animation_name, |
||||
options=set() |
||||
) |
||||
|
||||
active_anim_index: int = IntProperty(options={"HIDDEN"}) |
||||
show_expanded: bool = BoolProperty(options={"HIDDEN"}) |
||||
|
||||
def export( |
||||
self, exporter: Exporter, bo: bpy.types.Object, so: plSceneObject, |
||||
ctrl_obj: pfGUIControlMod, add_func: Callable[[plKey], None], |
||||
anim_name_attr: str |
||||
): |
||||
keys = set() |
||||
for anim in self.animations: |
||||
target_object = anim.target_object if anim.target_object is not None else bo |
||||
if anim.anim_type == "OBJECT": |
||||
keys.add(exporter.animation.get_animation_key(target_object)) |
||||
elif anim.anim_type == "TEXTURE": |
||||
# Layer animations don't respect the name field, so we need to grab exactly the |
||||
# layer animation key that is requested. Cyan's Max plugin does not allow specifying |
||||
# layer animations here as best I can tell, but I don't see why we shouldn't. |
||||
keys.update( |
||||
exporter.mesh.material.get_texture_animation_key( |
||||
target_object, |
||||
anim.target_material, |
||||
anim.target_texture, |
||||
self.animation_name |
||||
) |
||||
) |
||||
else: |
||||
raise RuntimeError() |
||||
|
||||
# This is to make sure that we only waste space in the PRP file with the animation |
||||
# name if we actually have some doggone animations. |
||||
if keys: |
||||
setattr(ctrl_obj, anim_name_attr, self.animation_name) |
||||
for i in keys: |
||||
add_func(i) |
||||
|
||||
|
||||
class PlasmaGameGuiButtonModifier(PlasmaModifierProperties, _GameGuiMixin): |
||||
pl_id = "gui_button" |
||||
pl_depends = {"gui_control"} |
||||
pl_page_types = {"gui"} |
||||
|
||||
bl_category = "GUI" |
||||
bl_label = "GUI Button (ex)" |
||||
bl_description = "XXX" |
||||
bl_object_types = {"FONT", "MESH"} |
||||
|
||||
def _update_notify_type(self, context): |
||||
# It doesn't make sense to have no notify type at all selected, so |
||||
# default to at least one option. |
||||
if not self.notify_type: |
||||
self.notify_type = {"DOWN"} |
||||
|
||||
notify_type = EnumProperty( |
||||
name="Notify On", |
||||
description="When the button should perform its action", |
||||
items=[ |
||||
("UP", "Up", "When the mouse button is down over the GUI button."), |
||||
("DOWN", "Down", "When the mouse button is released over the GUI button."), |
||||
], |
||||
default={"UP"}, |
||||
options={"ENUM_FLAG"}, |
||||
update=_update_notify_type |
||||
) |
||||
|
||||
mouse_over_anims: GameGuiAnimationGroup = PointerProperty(type=GameGuiAnimationGroup) |
||||
mouse_click_anims: GameGuiAnimationGroup = PointerProperty(type=GameGuiAnimationGroup) |
||||
show_expanded_sounds: bool = BoolProperty(options={"HIDDEN"}) |
||||
|
||||
mouse_down_sound: str = StringProperty( |
||||
name="Mouse Down SFX", |
||||
description="Sound played when the mouse button is down", |
||||
options=set() |
||||
) |
||||
|
||||
mouse_up_sound: str = StringProperty( |
||||
name="Mouse Up SFX", |
||||
description="Sound played when the mouse button is released", |
||||
options=set() |
||||
) |
||||
|
||||
mouse_over_sound: str = StringProperty( |
||||
name="Mouse Over SFX", |
||||
description="Sound played when the mouse moves over the GUI button", |
||||
options=set() |
||||
) |
||||
|
||||
mouse_off_sound: str = StringProperty( |
||||
name="Mouse Off SFX", |
||||
description="Sound played when the mouse moves off of the GUI button", |
||||
options=set() |
||||
) |
||||
|
||||
@property |
||||
def gui_sounds(self): |
||||
return ( |
||||
("mouse_down_sound", pfGUIButtonMod.kMouseDown), |
||||
("mouse_up_sound", pfGUIButtonMod.kMouseUp), |
||||
("mouse_over_sound", pfGUIButtonMod.kMouseOver), |
||||
("mouse_off_sound", pfGUIButtonMod.kMouseOff), |
||||
) |
||||
|
||||
def get_control(self, exporter: Exporter, bo: Optional[bpy.types.Object] = None, so: Optional[plSceneObject] = None) -> pfGUIButtonMod: |
||||
return exporter.mgr.find_create_object(pfGUIButtonMod, bl=bo, so=so) |
||||
|
||||
def export(self, exporter: Exporter, bo: bpy.types.Object, so: plSceneObject): |
||||
ctrl = self.get_control(exporter, bo, so) |
||||
ctrl.setFlag(pfGUIControlMod.kWantsInterest, True) |
||||
|
||||
if self.notify_type == {"UP"}: |
||||
ctrl.notifyType = pfGUIButtonMod.kNotifyOnUp |
||||
elif self.notify_type == {"DOWN"}: |
||||
ctrl.notifyType = pfGUIButtonMod.kNotifyOnDown |
||||
elif self.notify_type == {"UP", "DOWN"}: |
||||
ctrl.notifyType = pfGUIButtonMod.kNotifyOnUpAndDown |
||||
else: |
||||
raise ValueError(self.notify_type) |
||||
|
||||
self.mouse_over_anims.export(exporter, bo, so, ctrl, ctrl.addMouseOverKey, "mouseOverAnimName") |
||||
self.mouse_click_anims.export(exporter, bo, so, ctrl, ctrl.addAnimationKey, "animName") |
||||
|
||||
|
||||
class PlasmaGameGuiDialogModifier(PlasmaModifierProperties, _GameGuiMixin): |
||||
pl_id = "gui_dialog" |
||||
pl_page_types = {"gui"} |
||||
|
||||
bl_category = "GUI" |
||||
bl_label = "GUI Dialog (ex)" |
||||
bl_description = "XXX" |
||||
bl_object_types = {"FONT", "MESH"} |
||||
|
||||
camera_object: bpy.types.Object = PointerProperty( |
||||
name="GUI Camera", |
||||
description="Camera used to project the GUI to screenspace.", |
||||
type=bpy.types.Object, |
||||
poll=idprops.poll_camera_objects, |
||||
options=set() |
||||
) |
||||
is_modal = BoolProperty( |
||||
name="Modal", |
||||
description="", |
||||
default=True, |
||||
options=set() |
||||
) |
||||
|
||||
def export(self, exporter: Exporter, bo: bpy.types.Object, so: plSceneObject): |
||||
# Find all of the visible objects in the GUI page for use in hither/yon raycast and |
||||
# camera matrix calculations. |
||||
visible_objects = [ |
||||
i for i in exporter.get_objects(bo.plasma_object.page) |
||||
if i.type == "MESH" and i.data.materials |
||||
] |
||||
|
||||
camera_object = self.id_data if self.id_data.type == "CAMERA" else self.camera_object |
||||
if camera_object: |
||||
exporter.report.msg(f"Using camera matrix from camera '{camera_object.name}'") |
||||
if camera_object != self.id_data and camera_object.plasma_object.enabled: |
||||
with exporter.report.indent(): |
||||
exporter.report.warn("The camera object should NOT be a Plasma Object!") |
||||
camera_matrix = camera_object.matrix_world |
||||
|
||||
# Save the clipping info from the camera for later use. |
||||
cam_data = camera_object.data |
||||
fov, hither, yonder = cam_data.angle, cam_data.clip_start, cam_data.clip_end |
||||
else: |
||||
exporter.report.msg(f"Building a camera matrix to view: {', '.join((i.name for i in visible_objects))}") |
||||
fov = math.radians(45.0) |
||||
camera_matrix = exporter.gui.calc_camera_matrix( |
||||
bpy.context.scene, |
||||
visible_objects, |
||||
fov |
||||
) |
||||
|
||||
# There isn't a real camera, so just pretend like the user didn't set the clipping info. |
||||
hither, yonder = 0.0, 0.0 |
||||
with exporter.report.indent(): |
||||
exporter.report.msg(str(camera_matrix)) |
||||
|
||||
# If no hither or yonder was specified on the camera, then we need to determine that ourselves. |
||||
if not hither or not yonder: |
||||
exporter.report.msg(f"Incomplete clipping: H:{hither:.02f} Y:{yonder:.02f}; calculating new...") |
||||
with exporter.report.indent(): |
||||
clipping = exporter.gui.calc_clipping( |
||||
camera_matrix, |
||||
bpy.context.scene, |
||||
visible_objects, |
||||
fov |
||||
) |
||||
exporter.report.msg(f"Calculated: H:{clipping.hither:.02f} Y:{clipping.yonder:.02f}") |
||||
if not hither: |
||||
hither = clipping.hither |
||||
if not yonder: |
||||
yonder = clipping.yonder |
||||
exporter.report.msg(f"Corrected clipping: H:{hither:.02f} Y:{yonder:.02f}") |
||||
|
||||
# Both of the objects we export go into the pool. |
||||
scene_node_key = exporter.mgr.get_scene_node(bl=bo) |
||||
|
||||
post_effect = exporter.mgr.find_create_object(plPostEffectMod, bl=bo) |
||||
post_effect.defaultC2W, post_effect.defaultW2C = exporter.gui.convert_post_effect_matrices(camera_matrix) |
||||
post_effect.fovX = math.degrees(fov) |
||||
post_effect.fovY = math.degrees(fov * (3.0 / 4.0)) |
||||
post_effect.hither = min((hither, yonder)) |
||||
post_effect.yon = max((hither, yonder)) |
||||
post_effect.nodeKey = scene_node_key |
||||
|
||||
dialog_mod = exporter.mgr.find_create_object(pfGUIDialogMod, bl=bo) |
||||
dialog_mod.name = bo.plasma_object.page |
||||
dialog_mod.setFlag(pfGUIDialogMod.kModal, self.is_modal) |
||||
dialog_mod.renderMod = post_effect.key |
||||
dialog_mod.sceneNode = scene_node_key |
||||
|
||||
@property |
||||
def has_gui_proc(self) -> bool: |
||||
return False |
||||
|
||||
@classmethod |
||||
def is_game_gui_control(cls) -> bool: |
||||
return False |
||||
|
||||
def post_export(self, exporter: Exporter, bo: bpy.types.Object, so: plSceneObject): |
||||
# All objects have been exported. Now, we can establish linkage to all controls that |
||||
# have been exported. |
||||
dialog = exporter.mgr.find_object(pfGUIDialogMod, bl=bo, so=so) |
||||
control_modifiers: Iterable[_GameGuiMixin] = itertools.chain.from_iterable( |
||||
obj.plasma_modifiers.gui_control.iterate_control_modifiers() |
||||
for obj in exporter.get_objects(bo.plasma_object.page) |
||||
if obj.plasma_modifiers.gui_control.enabled |
||||
) |
||||
for control_modifier in control_modifiers: |
||||
control = control_modifier.get_control(exporter, control_modifier.id_data) |
||||
ctrl_key = control.key |
||||
exporter.report.msg(f"GUIDialog '{bo.name}': [{control.ClassName()}] '{ctrl_key.name}'") |
||||
dialog.addControl(ctrl_key) |
||||
@ -0,0 +1,120 @@
|
||||
# This file is part of Korman. |
||||
# |
||||
# Korman is free software: you can redistribute it and/or modify |
||||
# it under the terms of the GNU General Public License as published by |
||||
# the Free Software Foundation, either version 3 of the License, or |
||||
# (at your option) any later version. |
||||
# |
||||
# Korman is distributed in the hope that it will be useful, |
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
# GNU General Public License for more details. |
||||
# |
||||
# You should have received a copy of the GNU General Public License |
||||
# along with Korman. If not, see <http://www.gnu.org/licenses/>. |
||||
|
||||
from __future__ import annotations |
||||
from typing import * |
||||
|
||||
import bpy.types |
||||
|
||||
from .. import ui_list |
||||
|
||||
if TYPE_CHECKING: |
||||
from ...properties.modifiers.game_gui import GameGuiAnimation, GameGuiAnimationGroup |
||||
|
||||
class GuiAnimListUI(bpy.types.UIList): |
||||
def _iter_target_names(self, item: GameGuiAnimation): |
||||
if item.target_object is not None: |
||||
yield item.target_object.name |
||||
else: |
||||
yield item.id_data.name |
||||
if item.target_material is not None: |
||||
yield item.target_material.name |
||||
if item.target_texture is not None: |
||||
yield item.target_texture.name |
||||
|
||||
def draw_item( |
||||
self, context, layout, data, item: GameGuiAnimation, icon, active_data, |
||||
active_property, index=0, flt_flag=0 |
||||
): |
||||
if item.anim_type == "OBJECT": |
||||
name = item.target_object.name if item.target_object is not None else item.id_data.name |
||||
layout.label(name, icon="OBJECT_DATA") |
||||
elif item.anim_type == "TEXTURE": |
||||
name_seq = list(self._iter_target_names(item)) |
||||
layout.label(" / ".join(name_seq), icon="TEXTURE") |
||||
else: |
||||
raise RuntimeError() |
||||
|
||||
|
||||
def _gui_anim(name: str, group: GameGuiAnimationGroup, layout, context): |
||||
box = layout.box() |
||||
row = box.row(align=True) |
||||
|
||||
exicon = "TRIA_DOWN" if group.show_expanded else "TRIA_RIGHT" |
||||
row.prop(group, "show_expanded", text="", icon=exicon, emboss=False) |
||||
row.prop(group, "animation_name", text=name, icon="ANIM") |
||||
if not group.show_expanded: |
||||
return |
||||
|
||||
ui_list.draw_modifier_list(box, "GuiAnimListUI", group, "animations", "active_anim_index", rows=2) |
||||
try: |
||||
anim: GameGuiAnimation = group.animations[group.active_anim_index] |
||||
except: |
||||
pass |
||||
else: |
||||
col = box.column() |
||||
col.prop(anim, "anim_type") |
||||
col.prop(anim, "target_object") |
||||
if anim.anim_type == "TEXTURE": |
||||
col.prop(anim, "target_material") |
||||
col.prop(anim, "target_texture") |
||||
|
||||
|
||||
def gui_button(modifier, layout, context): |
||||
row = layout.row() |
||||
row.label("Notify On:") |
||||
row.prop(modifier, "notify_type") |
||||
|
||||
_gui_anim("Mouse Click", modifier.mouse_click_anims, layout, context) |
||||
_gui_anim("Mouse Over", modifier.mouse_over_anims, layout, context) |
||||
|
||||
box = layout.box() |
||||
row = box.row(align=True) |
||||
exicon = "TRIA_DOWN" if modifier.show_expanded_sounds else "TRIA_RIGHT" |
||||
row.prop(modifier, "show_expanded_sounds", text="", icon=exicon, emboss=False) |
||||
row.label("Sound Effects") |
||||
if modifier.show_expanded_sounds: |
||||
col = box.column() |
||||
soundemit = modifier.id_data.plasma_modifiers.soundemit |
||||
col.active = soundemit.enabled |
||||
col.prop_search(modifier, "mouse_down_sound", soundemit, "sounds", text="Mouse Down", icon="SPEAKER") |
||||
col.prop_search(modifier, "mouse_up_sound", soundemit, "sounds", text="Mouse Up", icon="SPEAKER") |
||||
col.prop_search(modifier, "mouse_over_sound", soundemit, "sounds", text="Mouse Over", icon="SPEAKER") |
||||
col.prop_search(modifier, "mouse_off_sound", soundemit, "sounds", text="Mouse Off", icon="SPEAKER") |
||||
|
||||
def gui_control(modifier, layout, context): |
||||
split = layout.split() |
||||
col = split.column() |
||||
col.prop(modifier, "visible") |
||||
|
||||
col = split.column() |
||||
col.prop(modifier, "tag_id") |
||||
|
||||
col = layout.column() |
||||
col.active = modifier.has_gui_proc |
||||
col.prop(modifier, "proc") |
||||
row = col.row() |
||||
row.active = col.active and modifier.proc == "console_command" |
||||
row.prop(modifier, "console_command") |
||||
|
||||
def gui_dialog(modifier, layout, context): |
||||
row = layout.row(align=True) |
||||
row.prop(modifier, "camera_object") |
||||
op = row.operator("camera.plasma_create_game_gui_camera", text="", icon="CAMERA_DATA") |
||||
op.mod_id = modifier.pl_id |
||||
op.cam_prop_name = "camera_object" |
||||
op.gui_page = modifier.id_data.plasma_object.page |
||||
|
||||
layout.prop(modifier, "is_modal") |
||||
Loading…
Reference in new issue