Hoikas
/
korman
mirror of https://github.com/H-uru/korman.git
3
2
Fork 0
Code Releases Activity
Browse Source

Merge pull request #175 from Hoikas/fix_phys_xform 

Fix #101
pull/176/head
Adam Johnson 5 years ago committed by GitHub
parent
d153f06af9 09d82b95e5
commit
c98f3fe919
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 155 additions and 135 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 132
      korman/exporter/physics.py
  2. 39
      korman/nodes/node_conditions.py
  3. 23
      korman/nodes/node_logic.py
  4. 10
      korman/properties/modifiers/avatar.py
  5. 35
      korman/properties/modifiers/physics.py
  6. 21
      korman/properties/modifiers/region.py
  7. 30
      korman/properties/modifiers/water.py

132
korman/exporter/physics.py
Unescape View File

@ -30,6 +30,22 @@ def _set_phys_prop(prop, sim, phys, value=True):
class PhysicsConverter: class PhysicsConverter:
def __init__(self, exporter): def __init__(self, exporter):
self._exporter = weakref.ref(exporter) self._exporter = weakref.ref(exporter)
self._bounds_converters = {
"box": self._export_box,
"sphere": self._export_sphere,
"hull": self._export_hull,
"trimesh": self._export_trimesh,
}
def _apply_props(self, simIface, physical, props):
for i in props.get("properties", []):
_set_phys_prop(getattr(plSimulationInterface, i), simIface, physical)
for i in props.get("losdbs", []):
physical.LOSDBs |= getattr(plSimDefs, i)
for i in props.get("report_groups", []):
physical.reportGroup |= 1 << getattr(plSimDefs, i)
for i in props.get("collide_groups", []):
physical.collideGroup |= 1 << getattr(plSimDefs, i)
def _convert_indices(self, mesh): def _convert_indices(self, mesh):
indices = [] indices = []
@ -42,7 +58,7 @@ class PhysicsConverter:
indices += (v[0], v[2], v[3],) indices += (v[0], v[2], v[3],)
return indices return indices
def _convert_mesh_data(self, bo, physical, indices=True, mesh_func=None): def _convert_mesh_data(self, bo, physical, local_space, indices=True, mesh_func=None):
try: try:
mesh = bo.to_mesh(bpy.context.scene, True, "RENDER", calc_tessface=False) mesh = bo.to_mesh(bpy.context.scene, True, "RENDER", calc_tessface=False)
except: except:
@ -54,8 +70,7 @@ class PhysicsConverter:
if mesh_func is not None: if mesh_func is not None:
mesh_func(mesh) mesh_func(mesh)
# We can only use the plPhysical xforms if there is a CI... if local_space:
if self._exporter().has_coordiface(bo):
mesh.update(calc_tessface=indices) mesh.update(calc_tessface=indices)
physical.pos = hsVector3(*mat.to_translation()) physical.pos = hsVector3(*mat.to_translation())
physical.rot = utils.quaternion(mat.to_quaternion()) physical.rot = utils.quaternion(mat.to_quaternion())
@ -79,12 +94,11 @@ class PhysicsConverter:
else: else:
return vertices return vertices
def generate_flat_proxy(self, bo, so, z_coord=None, name=None): def generate_flat_proxy(self, bo, so, **kwargs):
"""Generates a flat physical object""" """Generates a flat physical object"""
if so.sim is None: z_coord = kwargs.pop("z_coord", None)
if name is None:
name = bo.name
if so.sim is None:
simIface = self._mgr.add_object(pl=plSimulationInterface, bl=bo) simIface = self._mgr.add_object(pl=plSimulationInterface, bl=bo)
physical = self._mgr.add_object(pl=plGenericPhysical, bl=bo, name=name) physical = self._mgr.add_object(pl=plGenericPhysical, bl=bo, name=name)
@ -94,7 +108,7 @@ class PhysicsConverter:
mesh = bo.to_mesh(bpy.context.scene, True, "RENDER", calc_tessface=False) mesh = bo.to_mesh(bpy.context.scene, True, "RENDER", calc_tessface=False)
with TemporaryObject(mesh, bpy.data.meshes.remove): with TemporaryObject(mesh, bpy.data.meshes.remove):
# We will apply all xform, seeing as how this is a special case... # No mass and no emedded xform, so we force worldspace collision.
mesh.transform(bo.matrix_world) mesh.transform(bo.matrix_world)
mesh.update(calc_tessface=True) mesh.update(calc_tessface=True)
@ -111,22 +125,36 @@ class PhysicsConverter:
physical.verts = vertices physical.verts = vertices
physical.indices = self._convert_indices(mesh) physical.indices = self._convert_indices(mesh)
physical.boundsType = plSimDefs.kProxyBounds physical.boundsType = plSimDefs.kProxyBounds
group_name = kwargs.get("member_group")
if group_name:
physical.memberGroup = getattr(plSimDefs, group_name)
else: else:
simIface = so.sim.object simIface = so.sim.object
physical = simIface.physical.object physical = simIface.physical.object
if name is not None:
physical.key.name = name
return (simIface, physical)
def generate_physical(self, bo, so, bounds, name=None): member_group = getattr(plSimDefs, kwargs.get("member_group", "kGroupLOSOnly"))
"""Generates a physical object for the given object pair""" if physical.memberGroup != member_group and member_group != plSimDefs.kGroupLOSOnly:
self._report.warn("{}: Physical memberGroup overwritten!", bo.name)
physical.memberGroup = member_group
self._apply_props(simIface, physical, kwargs)
def generate_physical(self, bo, so, **kwargs):
"""Generates a physical object for the given object pair.
The following optional arguments are allowed:
- bounds: (defaults to collision modifier setting)
- member_group: str attribute of plSimDefs, defaults to kGroupStatic
NOTE that kGroupLOSOnly generation will only succeed if no one else
has generated this physical in another group
- properties: sequence of str bit names from plSimulationInterface
- losdbs: sequence of str bit names from plSimDefs
- report_groups: sequence of str bit names from plSimDefs
- collide_groups: sequence of str bit names from plSimDefs
"""
if so.sim is None: if so.sim is None:
if name is None:
name = bo.name
simIface = self._mgr.add_object(pl=plSimulationInterface, bl=bo) simIface = self._mgr.add_object(pl=plSimulationInterface, bl=bo)
physical = self._mgr.add_object(pl=plGenericPhysical, bl=bo, name=name) physical = self._mgr.add_object(pl=plGenericPhysical, bl=bo)
ver = self._mgr.getVer()
simIface.physical = physical.key simIface.physical = physical.key
physical.object = so.key physical.object = so.key
@ -137,6 +165,37 @@ class PhysicsConverter:
if self.is_dedicated_subworld(subworld, sanity_check=False): if self.is_dedicated_subworld(subworld, sanity_check=False):
physical.subWorld = self._mgr.find_create_key(plHKSubWorld, bl=subworld) physical.subWorld = self._mgr.find_create_key(plHKSubWorld, bl=subworld)
# Export the collision modifier here since we like stealing from it anyway.
mod = bo.plasma_modifiers.collision
bounds = kwargs.get("bounds", mod.bounds)
if mod.enabled:
physical.friction = mod.friction
physical.restitution = mod.restitution
if mod.dynamic:
if ver <= pvPots:
physical.collideGroup = (1 << plSimDefs.kGroupDynamic) | \
(1 << plSimDefs.kGroupStatic)
physical.memberGroup = plSimDefs.kGroupDynamic
physical.mass = mod.mass
_set_phys_prop(plSimulationInterface.kStartInactive, simIface, physical,
value=mod.start_asleep)
elif not mod.avatar_blocker:
physical.memberGroup = plSimDefs.kGroupLOSOnly
else:
physical.memberGroup = plSimDefs.kGroupStatic
# Line of Sight DB
if mod.camera_blocker:
physical.LOSDBs |= plSimDefs.kLOSDBCameraBlockers
_set_phys_prop(plSimulationInterface.kCameraAvoidObject, simIface, physical)
if mod.terrain:
physical.LOSDBs |= plSimDefs.kLOSDBAvatarWalkable
else:
group_name = kwargs.get("member_group")
if group_name:
physical.memberGroup = getattr(plSimDefs, group_name)
# Ensure this thing is set up properly for animations. # Ensure this thing is set up properly for animations.
# This was previously the collision modifier's postexport method, but that # This was previously the collision modifier's postexport method, but that
# would miss cases where we have animated detectors (subworlds!!!) # would miss cases where we have animated detectors (subworlds!!!)
@ -147,7 +206,6 @@ class PhysicsConverter:
yield bo yield bo
bo = bo.parent bo = bo.parent
ver = self._mgr.getVer()
for i in _iter_object_tree(bo, ver == pvMoul): for i in _iter_object_tree(bo, ver == pvMoul):
if i.plasma_object.has_transform_animation: if i.plasma_object.has_transform_animation:
tree_xformed = True tree_xformed = True
@ -176,23 +234,30 @@ class PhysicsConverter:
if physical.mass == 0.0: if physical.mass == 0.0:
physical.mass = 1.0 physical.mass = 1.0
getattr(self, "_export_{}".format(bounds))(bo, physical) if ver <= pvPots:
local_space = physical.mass > 0.0
else:
local_space = self._exporter().has_coordiface(bo)
self._bounds_converters[bounds](bo, physical, local_space)
else: else:
simIface = so.sim.object simIface = so.sim.object
physical = simIface.physical.object physical = simIface.physical.object
if name is not None:
physical.key.name = name
return (simIface, physical) member_group = getattr(plSimDefs, kwargs.get("member_group", "kGroupLOSOnly"))
if physical.memberGroup != member_group and member_group != plSimDefs.kGroupLOSOnly:
self._report.warn("{}: Physical memberGroup overwritten!", bo.name, indent=2)
physical.memberGroup = member_group
def _export_box(self, bo, physical): self._apply_props(simIface, physical, kwargs)
def _export_box(self, bo, physical, local_space):
"""Exports box bounds based on the object""" """Exports box bounds based on the object"""
physical.boundsType = plSimDefs.kBoxBounds physical.boundsType = plSimDefs.kBoxBounds
vertices = self._convert_mesh_data(bo, physical, indices=False) vertices = self._convert_mesh_data(bo, physical, local_space, indices=False)
physical.calcBoxBounds(vertices) physical.calcBoxBounds(vertices)
def _export_hull(self, bo, physical): def _export_hull(self, bo, physical, local_space):
"""Exports convex hull bounds based on the object""" """Exports convex hull bounds based on the object"""
physical.boundsType = plSimDefs.kHullBounds physical.boundsType = plSimDefs.kHullBounds
@ -212,20 +277,21 @@ class PhysicsConverter:
bpy.ops.mesh.convex_hull(use_existing_faces=False) bpy.ops.mesh.convex_hull(use_existing_faces=False)
bpy.ops.object.mode_set(mode="OBJECT") bpy.ops.object.mode_set(mode="OBJECT")
physical.verts = self._convert_mesh_data(bo, physical, indices=False, mesh_func=_bake_hull) physical.verts = self._convert_mesh_data(bo, physical, local_space, indices=False,
mesh_func=_bake_hull)
def _export_sphere(self, bo, physical): def _export_sphere(self, bo, physical, local_space):
"""Exports sphere bounds based on the object""" """Exports sphere bounds based on the object"""
physical.boundsType = plSimDefs.kSphereBounds physical.boundsType = plSimDefs.kSphereBounds
vertices = self._convert_mesh_data(bo, physical, indices=False) vertices = self._convert_mesh_data(bo, physical, local_space, indices=False)
physical.calcSphereBounds(vertices) physical.calcSphereBounds(vertices)
def _export_trimesh(self, bo, physical): def _export_trimesh(self, bo, physical, local_space):
"""Exports an object's mesh as exact physical bounds""" """Exports an object's mesh as exact physical bounds"""
physical.boundsType = plSimDefs.kExplicitBounds physical.boundsType = plSimDefs.kExplicitBounds
vertices, indices = self._convert_mesh_data(bo, physical) vertices, indices = self._convert_mesh_data(bo, physical, local_space)
physical.verts = vertices physical.verts = vertices
physical.indices = indices physical.indices = indices
@ -244,3 +310,7 @@ class PhysicsConverter:
@property @property
def _mgr(self): def _mgr(self):
return self._exporter().mgr return self._exporter().mgr
@property
def _report(self):
return self._exporter().report

39
korman/nodes/node_conditions.py
Unescape View File

@ -91,17 +91,10 @@ class PlasmaClickableNode(idprops.IDPropObjectMixin, PlasmaNodeBase, bpy.types.N
bounds = phys_mod.bounds if phys_mod.enabled else self.bounds bounds = phys_mod.bounds if phys_mod.enabled else self.bounds
# The actual physical object that does the cursor LOS # The actual physical object that does the cursor LOS
made_the_phys = (clickable_so.sim is None) exporter.physics.generate_physical(clickable_bo, clickable_so, bounds=bounds,
phys_name = "{}_ClickableLOS".format(clickable_bo.name) member_group="kGroupLOSOnly",
simIface, physical = exporter.physics.generate_physical(clickable_bo, clickable_so, bounds, phys_name) properties=["kPinned"],
simIface.setProperty(plSimulationInterface.kPinned, True) losdbs=["kLOSDBUIItems"])
physical.setProperty(plSimulationInterface.kPinned, True)
if made_the_phys:
# we assume that the collision modifier will do this if they want it to be intangible
physical.memberGroup = plSimDefs.kGroupLOSOnly
if physical.mass == 0.0:
physical.mass = 1.0
physical.LOSDBs |= plSimDefs.kLOSDBUIItems
# Picking Detector -- detect when the physical is clicked # Picking Detector -- detect when the physical is clicked
detector = self._find_create_object(plPickingDetector, exporter, bl=clickable_bo, so=clickable_so) detector = self._find_create_object(plPickingDetector, exporter, bl=clickable_bo, so=clickable_so)
@ -195,10 +188,9 @@ class PlasmaClickableRegionNode(idprops.IDPropObjectMixin, PlasmaNodeBase, bpy.t
bounds = phys_mod.bounds if phys_mod.enabled else self.bounds bounds = phys_mod.bounds if phys_mod.enabled else self.bounds
# Our physical is a detector and it only detects avatars... # Our physical is a detector and it only detects avatars...
phys_name = "{}_ClickableAvRegion".format(region_bo.name) exporter.physics.generate_physical(region_bo, region_so, bounds=bounds,
simIface, physical = exporter.physics.generate_physical(region_bo, region_so, bounds, phys_name) member_group="kGroupDetector",
physical.memberGroup = plSimDefs.kGroupDetector report_groups=["kGroupAvatar"])
physical.reportGroup |= 1 << plSimDefs.kGroupAvatar
# I'm glad this crazy mess made sense to someone at Cyan... # I'm glad this crazy mess made sense to someone at Cyan...
# ObjectInVolumeDetector can notify multiple logic mods. This implies we could share this # ObjectInVolumeDetector can notify multiple logic mods. This implies we could share this
@ -352,9 +344,9 @@ class PlasmaVolumeSensorNode(idprops.IDPropObjectMixin, PlasmaNodeBase, bpy.type
report_on = EnumProperty(name="Triggerers", report_on = EnumProperty(name="Triggerers",
description="What triggers this region?", description="What triggers this region?",
options={"ANIMATABLE", "ENUM_FLAG"}, options={"ANIMATABLE", "ENUM_FLAG"},
items=[("avatar", "Avatars", "Avatars trigger this region"), items=[("kGroupAvatar", "Avatars", "Avatars trigger this region"),
("dynamics", "Dynamics", "Any non-avatar dynamic physical object (eg kickables)")], ("kGroupDynamic", "Dynamics", "Any non-avatar dynamic physical object (eg kickables)")],
default={"avatar"}) default={"kGroupAvatar"})
input_sockets = OrderedDict([ input_sockets = OrderedDict([
("enter", { ("enter", {
@ -436,14 +428,9 @@ class PlasmaVolumeSensorNode(idprops.IDPropObjectMixin, PlasmaNodeBase, bpy.type
interface.addIntfKey(key) interface.addIntfKey(key)
# Don't forget to export the physical object itself! # Don't forget to export the physical object itself!
# [trollface.jpg] exporter.physics.generate_physical(region_bo, region_so, bounds=self.bounds,
simIface, physical = exporter.physics.generate_physical(region_bo, region_so, self.bounds, "{}_VolumeSensor".format(region_bo.name)) member_group="kGroupDetector",
report_groups=self.report_on)
physical.memberGroup = plSimDefs.kGroupDetector
if "avatar" in self.report_on:
physical.reportGroup |= 1 << plSimDefs.kGroupAvatar
if "dynamics" in self.report_on:
physical.reportGroup |= 1 << plSimDefs.kGroupDynamic
def _export_volume_event(self, exporter, bo, so, event, settings): def _export_volume_event(self, exporter, bo, so, event, settings):
if event == plVolumeSensorConditionalObject.kTypeEnter: if event == plVolumeSensorConditionalObject.kTypeEnter:

23
korman/nodes/node_logic.py
Unescape View File

@ -19,7 +19,7 @@ from collections import OrderedDict
from PyHSPlasma import * from PyHSPlasma import *
from .node_core import * from .node_core import *
from ..properties.modifiers.physics import bounds_types, bounds_type_index from ..properties.modifiers.physics import bounds_types, bounds_type_index, bounds_type_str
from .. import idprops from .. import idprops
class PlasmaExcludeRegionNode(idprops.IDPropObjectMixin, PlasmaNodeBase, bpy.types.Node): class PlasmaExcludeRegionNode(idprops.IDPropObjectMixin, PlasmaNodeBase, bpy.types.Node):
@ -37,7 +37,7 @@ class PlasmaExcludeRegionNode(idprops.IDPropObjectMixin, PlasmaNodeBase, bpy.typ
return bounds_type_index("hull") return bounds_type_index("hull")
def _set_bounds(self, value): def _set_bounds(self, value):
if self.region_object is not None: if self.region_object is not None:
self.region_object.plasma_modifiers.collision.bounds = value self.region_object.plasma_modifiers.collision.bounds = bounds_type_str(value)
region_object = PointerProperty(name="Region", region_object = PointerProperty(name="Region",
description="Region object's name", description="Region object's name",
@ -99,14 +99,17 @@ class PlasmaExcludeRegionNode(idprops.IDPropObjectMixin, PlasmaNodeBase, bpy.typ
excludergn.addSafePoint(exporter.mgr.find_create_key(plSceneObject, bl=safept)) excludergn.addSafePoint(exporter.mgr.find_create_key(plSceneObject, bl=safept))
# Ensure the region is exported # Ensure the region is exported
phys_name = "{}_XRgn".format(self.region_object.name) if exporter.mgr.getVer() <= pvPots:
simIface, physical = exporter.physics.generate_physical(self.region_object, region_so, self.bounds, phys_name) member_group = "kGroupDetector"
simIface.setProperty(plSimulationInterface.kPinned, True) collide_groups = ["kGroupDynamic"]
physical.setProperty(plSimulationInterface.kPinned, True) else:
physical.LOSDBs |= plSimDefs.kLOSDBUIBlockers member_group = "kGroupStatic"
if exporter.mgr.getVer() < pvMoul: collide_groups = []
physical.memberGroup = plSimDefs.kGroupDetector exporter.physics.generate_physical(self.region_object, region_so, bounds=self.bounds,
physical.collideGroup |= 1 << plSimDefs.kGroupDynamic properties=["kPinned"],
losdbs=["kLOSDBUIBlockers"],
member_group=member_group,
collide_groups=collide_groups)
@property @property
def export_once(self): def export_once(self):

10
korman/properties/modifiers/avatar.py
Unescape View File

@ -72,15 +72,9 @@ class PlasmaLadderModifier(PlasmaModifierProperties):
mod.ladderView.normalize() mod.ladderView.normalize()
# Generate the detector's physical bounds # Generate the detector's physical bounds
det_name = "{}_LadderDetector".format(self.id_data.name)
bounds = "hull" if not bo.plasma_modifiers.collision.enabled else bo.plasma_modifiers.collision.bounds bounds = "hull" if not bo.plasma_modifiers.collision.enabled else bo.plasma_modifiers.collision.bounds
simIface, physical = exporter.physics.generate_physical(bo, so, bounds, det_name) exporter.physics.generate_physical(bo, so, bounds=bounds, member_group="kGroupDetector",
physical.memberGroup = plSimDefs.kGroupDetector report_groups=["kGroupAvatar"], properties=["kPinned"])
physical.reportGroup |= 1 << plSimDefs.kGroupAvatar
physical.setProperty(plSimulationInterface.kPinned, True)
simIface.setProperty(plSimulationInterface.kPinned, True)
if physical.mass == 0.0:
physical.mass = 1.0
@property @property
def requires_actor(self): def requires_actor(self):

35
korman/properties/modifiers/physics.py
Unescape View File

@ -32,6 +32,9 @@ bounds_types = (
def bounds_type_index(key): def bounds_type_index(key):
return list(zip(*bounds_types))[0].index(key) return list(zip(*bounds_types))[0].index(key)
def bounds_type_str(idx):
return bounds_types[idx][0]
def _set_phys_prop(prop, sim, phys, value=True): def _set_phys_prop(prop, sim, phys, value=True):
"""Sets properties on plGenericPhysical and plSimulationInterface (seeing as how they are duped)""" """Sets properties on plGenericPhysical and plSimulationInterface (seeing as how they are duped)"""
sim.setProperty(prop, value) sim.setProperty(prop, value)
@ -60,36 +63,8 @@ class PlasmaCollider(PlasmaModifierProperties):
start_asleep = BoolProperty(name="Start Asleep", description="Object is not active until influenced by another object", default=False) start_asleep = BoolProperty(name="Start Asleep", description="Object is not active until influenced by another object", default=False)
def export(self, exporter, bo, so): def export(self, exporter, bo, so):
simIface, physical = exporter.physics.generate_physical(bo, so, self.bounds, self.key_name) # All modifier properties are examined by this little stinker...
exporter.physics.generate_physical(bo, so)
# Common props
physical.friction = self.friction
physical.restitution = self.restitution
# Collision groups and such
if self.dynamic:
if exporter.mgr.getVer() < pvMoul:
physical.collideGroup = (1 << plSimDefs.kGroupDynamic) | (1 << plSimDefs.kGroupStatic)
physical.memberGroup = plSimDefs.kGroupDynamic
physical.mass = self.mass
_set_phys_prop(plSimulationInterface.kStartInactive, simIface, physical, value=self.start_asleep)
elif not self.avatar_blocker:
# the UI is kind of misleading on this count. oh well.
physical.memberGroup = plSimDefs.kGroupLOSOnly
else:
physical.memberGroup = plSimDefs.kGroupStatic
# Line of Sight DB
if self.camera_blocker:
physical.LOSDBs |= plSimDefs.kLOSDBCameraBlockers
# This appears to be dead in CWE, but we'll set it anyway
_set_phys_prop(plSimulationInterface.kCameraAvoidObject, simIface, physical)
if self.terrain:
physical.LOSDBs |= plSimDefs.kLOSDBAvatarWalkable
@property
def key_name(self):
return "{}_Collision".format(self.id_data.name)
@property @property
def requires_actor(self): def requires_actor(self):

21
korman/properties/modifiers/region.py
Unescape View File

@ -97,11 +97,9 @@ class PlasmaCameraRegion(PlasmaModifierProperties):
# Setup physical stuff # Setup physical stuff
phys_mod = bo.plasma_modifiers.collision phys_mod = bo.plasma_modifiers.collision
simIface, physical = exporter.physics.generate_physical(bo, so, phys_mod.bounds, self.key_name) exporter.physics.generate_physical(bo, so, member_group="kGroupDetector",
physical.memberGroup = plSimDefs.kGroupDetector report_groups=["kGroupAvatar"],
physical.reportGroup = 1 << plSimDefs.kGroupAvatar properties=["kPinned"])
simIface.setProperty(plSimulationInterface.kPinned, True)
physical.setProperty(plSimulationInterface.kPinned, True)
# I don't feel evil enough to make this generate a logic tree... # I don't feel evil enough to make this generate a logic tree...
msg = plCameraMsg() msg = plCameraMsg()
@ -188,12 +186,8 @@ class PlasmaPanicLinkRegion(PlasmaModifierProperties):
default=True) default=True)
def export(self, exporter, bo, so): def export(self, exporter, bo, so):
phys_mod = bo.plasma_modifiers.collision exporter.physics.generate_physical(bo, so, member_group="kGroupDetector",
simIface, physical = exporter.physics.generate_physical(bo, so, phys_mod.bounds, self.key_name) report_groups=["kGroupAvatar"])
# Now setup the region detector properties
physical.memberGroup = plSimDefs.kGroupDetector
physical.reportGroup = 1 << plSimDefs.kGroupAvatar
# Finally, the panic link region proper # Finally, the panic link region proper
reg = exporter.mgr.add_object(plPanicLinkRegion, name=self.key_name, so=so) reg = exporter.mgr.add_object(plPanicLinkRegion, name=self.key_name, so=so)
@ -375,6 +369,5 @@ class PlasmaSubworldRegion(PlasmaModifierProperties):
raise ExportAssertionError() raise ExportAssertionError()
# Fancy pants region collider type shit # Fancy pants region collider type shit
simIface, physical = exporter.physics.generate_physical(bo, so, self.id_data.plasma_modifiers.collision.bounds, self.key_name) exporter.physics.generate_physical(bo, so, member_group="kGroupDetector",
physical.memberGroup = plSimDefs.kGroupDetector report_groups=["kGroupAvatar"])
physical.reportGroup |= 1 << plSimDefs.kGroupAvatar

30
korman/properties/modifiers/water.py
Unescape View File

@ -111,28 +111,26 @@ class PlasmaSwimRegion(idprops.IDPropObjectMixin, PlasmaModifierProperties, bpy.
# the surface of the water BUT wave sets are supposed to conform to the bottom of the # the surface of the water BUT wave sets are supposed to conform to the bottom of the
# pool. Therefore, we need to flatten out a temporary mesh in that case. # pool. Therefore, we need to flatten out a temporary mesh in that case.
# Ohey! CWE doesn't let you swim at all if the surface isn't flat... # Ohey! CWE doesn't let you swim at all if the surface isn't flat...
swim_phys_name = "{}_SwimSurfaceLOS".format(bo.name) losdbs = ["kLOSDBSwimRegion"]
member_group = "kGroupLOSOnly" if exporter.mgr.getVer() != pvMoul else "kGroupStatic"
if bo.plasma_modifiers.water_basic.enabled: if bo.plasma_modifiers.water_basic.enabled:
simIface, physical = exporter.physics.generate_flat_proxy(bo, so, bo.location[2], swim_phys_name) exporter.physics.generate_flat_proxy(bo, so, z_coord=bo.location[2],
member_group=member_group,
losdbs=losdbs)
else: else:
simIface, physical = exporter.physics.generate_physical(bo, so, "trimesh", swim_phys_name) exporter.physics.generate_physical(bo, so, bounds="trimesh",
physical.LOSDBs |= plSimDefs.kLOSDBSwimRegion member_group=member_group,
if exporter.mgr.getVer() != pvMoul: losdbs=losdbs)
physical.memberGroup = plSimDefs.kGroupLOSOnly
# Detector region bounds # Detector region bounds
if self.region is not None: if self.region is not None:
region_so = exporter.mgr.find_create_object(plSceneObject, bl=self.region) region_so = exporter.mgr.find_create_object(plSceneObject, bl=self.region)
# Good news: if this phys has already been exported, this is basically a noop # Good news: if this phys has already been exported, this is basically a noop
det_name = "{}_SwimDetector".format(self.region.name) member_group = "kGroupDetector" if exporter.mgr.getVer() == "pvMoul" else "kGroupLOSOnly"
bounds = self.region.plasma_modifiers.collision.bounds exporter.physics.generate_physical(self.region, region_so,
simIface, physical = exporter.physics.generate_physical(self.region, region_so, bounds, det_name) member_group=member_group,
if exporter.mgr.getVer() == pvMoul: report_groups=["kGroupAvatar"])
physical.memberGroup = plSimDefs.kGroupDetector
else:
physical.memberGroup = plSimDefs.kGroupLOSOnly
physical.reportGroup |= 1 << plSimDefs.kGroupAvatar
# I am a little concerned if we already have a plSwimDetector... I am not certain how # I am a little concerned if we already have a plSwimDetector... I am not certain how
# well Plasma would tolerate having a plSwimMsg with multiple regions referenced. # well Plasma would tolerate having a plSwimMsg with multiple regions referenced.
@ -140,7 +138,7 @@ class PlasmaSwimRegion(idprops.IDPropObjectMixin, PlasmaModifierProperties, bpy.
# What? Me test it? # What? Me test it?
# I are chicken. # I are chicken.
# Mmmmm chicken ***drool*** # Mmmmm chicken ***drool***
if exporter.mgr.find_key(plSwimDetector, name=det_name, so=region_so) is None: if exporter.mgr.find_key(plSwimDetector, so=region_so) is None:
enter_msg, exit_msg = plSwimMsg(), plSwimMsg() enter_msg, exit_msg = plSwimMsg(), plSwimMsg()
for i in (enter_msg, exit_msg): for i in (enter_msg, exit_msg):
i.BCastFlags = plMessage.kLocalPropagate | plMessage.kPropagateToModifiers i.BCastFlags = plMessage.kLocalPropagate | plMessage.kPropagateToModifiers
@ -149,7 +147,7 @@ class PlasmaSwimRegion(idprops.IDPropObjectMixin, PlasmaModifierProperties, bpy.
enter_msg.isEntering = True enter_msg.isEntering = True
exit_msg.isEntering = False exit_msg.isEntering = False
detector = exporter.mgr.add_object(plSwimDetector, name=det_name, so=region_so) detector = exporter.mgr.add_object(plSwimDetector, so=region_so)
detector.enterMsg = enter_msg detector.enterMsg = enter_msg
detector.exitMsg = exit_msg detector.exitMsg = exit_msg
else: else:

Write Preview
Loading…
Cancel
Save