mirror of https://github.com/H-uru/korman.git
GitHub
13 changed files with 1032 additions and 38 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/>. |
||||||
|
|
||||||
|
import bpy |
||||||
|
import math |
||||||
|
from PyHSPlasma import * |
||||||
|
import weakref |
||||||
|
|
||||||
|
from .explosions import * |
||||||
|
from .. import helpers |
||||||
|
from . import utils |
||||||
|
|
||||||
|
class CameraConverter: |
||||||
|
def __init__(self, exporter): |
||||||
|
self._exporter = weakref.ref(exporter) |
||||||
|
|
||||||
|
def _convert_brain(self, so, bo, camera_props, brain): |
||||||
|
trans_props = camera_props.transition |
||||||
|
|
||||||
|
brain.poaOffset = hsVector3(*camera_props.poa_offset) |
||||||
|
if camera_props.poa_type == "object": |
||||||
|
brain.subject = self._mgr.find_create_key(plSceneObject, bl=camera_props.poa_object) |
||||||
|
|
||||||
|
brain.xPanLimit = camera_props.x_pan_angle / 2.0 |
||||||
|
brain.zPanLimit = camera_props.y_pan_angle / 2.0 |
||||||
|
brain.panSpeed = camera_props.pan_rate |
||||||
|
if camera_props.limit_zoom: |
||||||
|
brain.setFlags(plCameraBrain1.kZoomEnabled, True) |
||||||
|
brain.zoomMax = camera_props.zoom_max * (4.0 / 3.0) |
||||||
|
brain.zoomMin = camera_props.zoom_min * (4.0 / 3.0) |
||||||
|
brain.zoomRate = camera_props.zoom_rate |
||||||
|
|
||||||
|
brain.acceleration = trans_props.pos_acceleration |
||||||
|
brain.deceleration = trans_props.pos_deceleration |
||||||
|
brain.velocity = trans_props.pos_velocity |
||||||
|
brain.poaAcceleration = trans_props.poa_acceleration |
||||||
|
brain.poaDeceleration = trans_props.poa_deceleration |
||||||
|
brain.poaVelocity = trans_props.poa_velocity |
||||||
|
|
||||||
|
if isinstance(brain, plCameraBrain1_Avatar): |
||||||
|
brain.setFlags(plCameraBrain1.kCutPos, trans_props.pos_cut) |
||||||
|
brain.setFlags(plCameraBrain1.kCutPOA, trans_props.poa_cut) |
||||||
|
else: |
||||||
|
brain.setFlags(plCameraBrain1.kCutPos, True) |
||||||
|
brain.setFlags(plCameraBrain1.kCutPOA, True) |
||||||
|
if camera_props.poa_type == "avatar": |
||||||
|
brain.setFlags(plCameraBrain1.kFollowLocalAvatar, True) |
||||||
|
if camera_props.maintain_los: |
||||||
|
brain.setFlags(plCameraBrain1.kMaintainLOS, True) |
||||||
|
if camera_props.poa_worldspace: |
||||||
|
brain.setFlags(plCameraBrain1.kWorldspacePOA, True) |
||||||
|
if camera_props.pos_worldspace: |
||||||
|
brain.setFlags(plCameraBrain1.kWorldspacePos, True) |
||||||
|
if camera_props.ignore_subworld: |
||||||
|
brain.setFlags(plCameraBrain1.kIgnoreSubworldMovement, True) |
||||||
|
if camera_props.fall_vertical: |
||||||
|
brain.setFlags(plCameraBrain1.kVerticalWhenFalling, True) |
||||||
|
if camera_props.fast_run: |
||||||
|
brain.setFlags(plCameraBrain1.kSpeedUpWhenRunning, True) |
||||||
|
|
||||||
|
def export_camera(self, so, bo, camera_type, camera_props, camera_trans=[]): |
||||||
|
brain = getattr(self, "_export_{}_camera".format(camera_type))(so, bo, camera_props) |
||||||
|
mod = self._export_camera_modifier(so, bo, camera_props, camera_trans) |
||||||
|
mod.brain = brain.key |
||||||
|
|
||||||
|
def _export_camera_modifier(self, so, bo, props, trans): |
||||||
|
mod = self._mgr.find_create_object(plCameraModifier, so=so) |
||||||
|
|
||||||
|
# PlasmaMAX allows the user to specify the horizontal OR vertical FOV, but not both. |
||||||
|
# We only allow setting horizontal FOV (how often do you look up?), however. |
||||||
|
# Plasma assumes 4:3 aspect ratio.. |
||||||
|
fov = props.fov |
||||||
|
mod.fovW, mod.fovH = math.degrees(fov), math.degrees(fov * (3.0 / 4.0)) |
||||||
|
|
||||||
|
# This junk is only valid for animated cameras... |
||||||
|
# Animation exporter should have already run by this point :) |
||||||
|
if mod.animated: |
||||||
|
mod.startAnimOnPush = props.start_on_push |
||||||
|
mod.stopAnimOnPop = props.stop_on_pop |
||||||
|
mod.resetAnimOnPop = props.reset_on_pop |
||||||
|
|
||||||
|
for manual_trans in trans: |
||||||
|
if not manual_trans.enabled or manual_trans.mode == "auto": |
||||||
|
continue |
||||||
|
cam_trans = plCameraModifier.CamTrans() |
||||||
|
if manual_trans.camera: |
||||||
|
cam_trans.transTo = self._mgr.find_create_key(plCameraModifier, bl=manual_trans.camera) |
||||||
|
cam_trans.ignore = manual_trans.mode == "ignore" |
||||||
|
|
||||||
|
trans_info = manual_trans.transition |
||||||
|
cam_trans.cutPos = trans_info.pos_cut |
||||||
|
cam_trans.cutPOA = trans_info.poa_cut |
||||||
|
cam_trans.accel = trans_info.pos_acceleration |
||||||
|
cam_trans.decel = trans_info.pos_deceleration |
||||||
|
cam_trans.velocity = trans_info.pos_velocity |
||||||
|
cam_trans.poaAccel = trans_info.poa_acceleration |
||||||
|
cam_trans.poaDecel = trans_info.poa_deceleration |
||||||
|
cam_trans.poaVelocity = trans_info.poa_velocity |
||||||
|
mod.addTrans(cam_trans) |
||||||
|
|
||||||
|
return mod |
||||||
|
|
||||||
|
def _export_circle_camera(self, so, bo, props): |
||||||
|
brain = self._mgr.find_create_object(plCameraBrain1_Circle, so=so) |
||||||
|
self._convert_brain(so, bo, props, brain) |
||||||
|
|
||||||
|
# Circle Camera specific stuff ahoy! |
||||||
|
if props.poa_type == "avatar": |
||||||
|
brain.circleFlags |= plCameraBrain1_Circle.kCircleLocalAvatar |
||||||
|
elif props.poa_type == "object": |
||||||
|
brain.poaObject = self._mgr.find_create_key(plSceneObject, bl=props.poa_object) |
||||||
|
else: |
||||||
|
self._report.warn("Circle Camera '{}' has no Point of Attention. Is this intended?", bo.name, indent=3) |
||||||
|
if props.circle_pos == "farthest": |
||||||
|
brain.circleFlags |= plCameraBrain1_Circle.kFarthest |
||||||
|
|
||||||
|
# If no center object is specified, we will use the camera object's location. |
||||||
|
# We will use a simple vector for this object to make life simpler, however, |
||||||
|
# specifying an actual center allows you to do interesting things like animate the center... |
||||||
|
# Fascinating! Therefore, we will expose the Plasma Object... |
||||||
|
if props.circle_center is None: |
||||||
|
brain.center = hsVector3(*bo.location) |
||||||
|
else: |
||||||
|
brain.centerObject = self._mgr.find_create_key(plSceneObject, bl=props.circle_center) |
||||||
|
# This flag has no effect in CWE, but I'm using it for correctness' sake |
||||||
|
brain.circleFlags |= plCameraBrain1_Circle.kHasCenterObject |
||||||
|
|
||||||
|
# PlasmaMAX forces these values so the circle camera is rather slow, which is somewhat |
||||||
|
# sensible to me. Fast circular motion seems like a poor idea to me... If we want these |
||||||
|
# values to be customizable, we probably want add some kind of range limitation or at least |
||||||
|
# a flashing red light in the UI... |
||||||
|
brain.acceleration = 10.0 |
||||||
|
brain.deceleration = 10.0 |
||||||
|
brain.velocity = 15.0 |
||||||
|
|
||||||
|
# Related to above, circle cameras use a slightly different velocity method. |
||||||
|
# This is stored in Plasma as a fraction of the circle's circumference. It makes |
||||||
|
# more sense to me to present it in terms of degrees per second, however. |
||||||
|
# NOTE that Blender returns radians!!! |
||||||
|
brain.cirPerSec = props.circle_velocity / (2 * math.pi) |
||||||
|
|
||||||
|
# I consider this clever... If we have a center object, we use the magnitude of the displacement |
||||||
|
# of the camera's object to the center object (at frame 0) to determine the radius. If no center |
||||||
|
# object is specified, we allow the user to specify the radius. |
||||||
|
# Well, it's clever until you realize it's the same thing Cyan did in PlasmaMAX... But it's harder |
||||||
|
# here because Blendsucks. |
||||||
|
brain.radius = props.get_circle_radius(bo) |
||||||
|
|
||||||
|
# Done already? |
||||||
|
return brain |
||||||
|
|
||||||
|
def _export_fixed_camera(self, so, bo, props): |
||||||
|
if props.anim_enabled: |
||||||
|
self._exporter().animation.convert_object_animations(bo, so) |
||||||
|
brain = self._mgr.find_create_object(plCameraBrain1_Fixed, so=so) |
||||||
|
self._convert_brain(so, bo, props, brain) |
||||||
|
return brain |
||||||
|
|
||||||
|
def _export_follow_camera(self, so, bo, props): |
||||||
|
brain = self._mgr.find_create_object(plCameraBrain1_Avatar, so=so) |
||||||
|
self._convert_brain(so, bo, props, brain) |
||||||
|
|
||||||
|
# Follow camera specific stuff ahoy! |
||||||
|
brain.offset = hsVector3(*props.pos_offset) |
||||||
|
return brain |
||||||
|
|
||||||
|
def _export_rail_camera(self, so, bo, props): |
||||||
|
brain = self._mgr.find_create_object(plCameraBrain1_Fixed, so=so) |
||||||
|
self._convert_brain(so, bo, props, brain) |
||||||
|
|
||||||
|
rail = self._mgr.find_create_object(plRailCameraMod, so=so) |
||||||
|
rail.followFlags |= plLineFollowMod.kForceToLine |
||||||
|
if props.poa_type == "object": |
||||||
|
rail.followMode = plLineFollowMod.kFollowObject |
||||||
|
rail.refObj = self._mgr.find_create_key(plSceneObject, bl=props.poa_object) |
||||||
|
else: |
||||||
|
rail.followMode = plLineFollowMod.kFollowLocalAvatar |
||||||
|
if bo.parent: |
||||||
|
rail.pathParent = self._mgr.find_create_key(plSceneObject, bl=bo.parent) |
||||||
|
|
||||||
|
# The rail is defined by a position controller in Plasma. Cyan uses a separate |
||||||
|
# path object, but it makes more sense to me to just animate the camera with |
||||||
|
# the details of the path... |
||||||
|
pos_fcurves = tuple(i for i in helpers.fetch_fcurves(bo, False) if i.data_path == "location") |
||||||
|
pos_ctrl = self._exporter().animation.convert_transform_controller(pos_fcurves, bo.matrix_basis) |
||||||
|
if pos_ctrl is None: |
||||||
|
raise ExportError("'{}': Rail Camera lacks appropriate rail keyframes".format(bo.name)) |
||||||
|
path = plAnimPath() |
||||||
|
path.controller = pos_ctrl |
||||||
|
path.affineParts = utils.affine_parts(bo.matrix_local) |
||||||
|
begin, end = bo.animation_data.action.frame_range |
||||||
|
for fcurve in pos_fcurves: |
||||||
|
f1, f2 = fcurve.evaluate(begin), fcurve.evaluate(end) |
||||||
|
if abs(f1 - f2) > 0.001: |
||||||
|
break |
||||||
|
else: |
||||||
|
# The animation is a loop |
||||||
|
path.flags |= plAnimPath.kWrap |
||||||
|
if props.rail_pos == "farthest": |
||||||
|
path.flags |= plAnimPath.kFarthest |
||||||
|
path.length = end / bpy.context.scene.render.fps |
||||||
|
rail.path = path |
||||||
|
brain.rail = rail.key |
||||||
|
|
||||||
|
return brain |
||||||
|
|
||||||
|
@property |
||||||
|
def _mgr(self): |
||||||
|
return self._exporter().mgr |
||||||
|
|
||||||
|
@property |
||||||
|
def _report(self): |
||||||
|
return self._exporter().report |
||||||
@ -0,0 +1,246 @@ |
|||||||
|
# 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/>. |
||||||
|
|
||||||
|
import bpy |
||||||
|
from bpy.props import * |
||||||
|
import math |
||||||
|
|
||||||
|
from .. import idprops |
||||||
|
|
||||||
|
camera_types = [("circle", "Circle Camera", "The camera circles a fixed point"), |
||||||
|
("follow", "Follow Camera", "The camera follows an object"), |
||||||
|
("fixed", "Fixed Camera", "The camera is fixed in one location"), |
||||||
|
("rail", "Rail Camera", "The camera follows an object by moving along a line")] |
||||||
|
|
||||||
|
class PlasmaTransition(bpy.types.PropertyGroup): |
||||||
|
poa_acceleration = FloatProperty(name="PoA Acceleration", |
||||||
|
description="Rate the camera's Point of Attention tracking velocity increases in feet per second squared", |
||||||
|
min=-100.0, max=100.0, precision=0, default=60.0, |
||||||
|
unit="ACCELERATION", options=set()) |
||||||
|
poa_deceleration = FloatProperty(name="PoA Deceleration", |
||||||
|
description="Rate the camera's Point of Attention tracking velocity decreases in feet per second squared", |
||||||
|
min=-100.0, max=100.0, precision=0, default=60.0, |
||||||
|
unit="ACCELERATION", options=set()) |
||||||
|
poa_velocity = FloatProperty(name="PoA Velocity", |
||||||
|
description="Maximum velocity of the camera's Point of Attention tracking", |
||||||
|
min=-100.0, max=100.0, precision=0, default=60.0, |
||||||
|
unit="VELOCITY", options=set()) |
||||||
|
poa_cut = BoolProperty(name="Cut", |
||||||
|
description="The camera immediately begins tracking the Point of Attention", |
||||||
|
options=set()) |
||||||
|
|
||||||
|
pos_acceleration = FloatProperty(name="Position Acceleration", |
||||||
|
description="Rate the camera's positional velocity increases in feet per second squared", |
||||||
|
min=-100.0, max=100.0, precision=0, default=60.0, |
||||||
|
unit="ACCELERATION", options=set()) |
||||||
|
pos_deceleration = FloatProperty(name="Position Deceleration", |
||||||
|
description="Rate the camera's positional velocity decreases in feet per second squared", |
||||||
|
min=-100.0, max=100.0, precision=0, default=60.0, |
||||||
|
unit="ACCELERATION", options=set()) |
||||||
|
pos_velocity = FloatProperty(name="Position Max Velocity", |
||||||
|
description="Maximum positional velocity of the camera", |
||||||
|
min=-100.0, max=100.0, precision=0, default=60.0, |
||||||
|
unit="VELOCITY", options=set()) |
||||||
|
pos_cut = BoolProperty(name="Cut", |
||||||
|
description="The camera immediately moves to its new position", |
||||||
|
options=set()) |
||||||
|
|
||||||
|
|
||||||
|
class PlasmaManualTransition(bpy.types.PropertyGroup): |
||||||
|
camera = PointerProperty(name="Camera", |
||||||
|
description="The camera from which this transition is intended", |
||||||
|
type=bpy.types.Object, |
||||||
|
poll=idprops.poll_camera_objects, |
||||||
|
options=set()) |
||||||
|
transition = PointerProperty(type=PlasmaTransition, options=set()) |
||||||
|
mode = EnumProperty(name="Transition Mode", |
||||||
|
description="Type of transition that should occur between the two cameras", |
||||||
|
items=[("ignore", "Ignore Camera", "Ignore this camera and do not transition"), |
||||||
|
("auto", "Auto", "Auto transition as defined by the two cameras' properies"), |
||||||
|
("manual", "Manual", "Manually defined transition")], |
||||||
|
default="auto", |
||||||
|
options=set()) |
||||||
|
enabled = BoolProperty(name="Enabled", |
||||||
|
description="Export this transition", |
||||||
|
default=True, |
||||||
|
options=set()) |
||||||
|
|
||||||
|
|
||||||
|
class PlasmaCameraProperties(bpy.types.PropertyGroup): |
||||||
|
# Point of Attention |
||||||
|
poa_type = EnumProperty(name="Point of Attention", |
||||||
|
description="The point of attention that this camera tracks", |
||||||
|
items=[("avatar", "Track Local Player", "Camera tracks the player's avatar"), |
||||||
|
("object", "Track Object", "Camera tracks an object in the scene"), |
||||||
|
("none", "Don't Track", "Camera does not track anything")], |
||||||
|
options=set()) |
||||||
|
poa_object = PointerProperty(name="PoA Object", |
||||||
|
description="Object the camera should track as its Point of Attention", |
||||||
|
type=bpy.types.Object, |
||||||
|
options=set()) |
||||||
|
poa_offset = FloatVectorProperty(name="PoA Offset", |
||||||
|
description="Offset from the point of attention's origin to track", |
||||||
|
soft_min=-50.0, soft_max=50.0, |
||||||
|
size=3, default=(0.0, 0.0, 3.0), |
||||||
|
options=set()) |
||||||
|
poa_worldspace = BoolProperty(name="Worldspace Offset", |
||||||
|
description="Point of Attention Offset is in worldspace coordinates", |
||||||
|
options=set()) |
||||||
|
|
||||||
|
# Position Offset |
||||||
|
pos_offset = FloatVectorProperty(name="Position Offset", |
||||||
|
description="Offset the camera's position", |
||||||
|
soft_min=-50.0, soft_max=50.0, |
||||||
|
size=3, default=(0.0, 10.0, 3.0), |
||||||
|
options=set()) |
||||||
|
pos_worldspace = BoolProperty(name="Worldspace Offset", |
||||||
|
description="Position offset is in worldspace coordinates", |
||||||
|
options=set()) |
||||||
|
|
||||||
|
# Default Transition |
||||||
|
transition = PointerProperty(type=PlasmaTransition, options=set()) |
||||||
|
|
||||||
|
# Limit Panning |
||||||
|
x_pan_angle = FloatProperty(name="X Degrees", |
||||||
|
description="Maximum camera pan angle in the X direction", |
||||||
|
min=0.0, max=math.radians(180.0), precision=0, default=math.radians(90.0), |
||||||
|
subtype="ANGLE", options=set()) |
||||||
|
y_pan_angle = FloatProperty(name="Y Degrees", |
||||||
|
description="Maximum camera pan angle in the Y direction", |
||||||
|
min=0.0, max=math.radians(180.0), precision=0, default=math.radians(90.0), |
||||||
|
subtype="ANGLE", options=set()) |
||||||
|
pan_rate = FloatProperty(name="Pan Velocity", |
||||||
|
description="", |
||||||
|
min=0.0, precision=1, default=50.0, |
||||||
|
unit="VELOCITY", options=set()) |
||||||
|
|
||||||
|
# Zooming |
||||||
|
fov = FloatProperty(name="Default FOV", |
||||||
|
description="Horizontal Field of View angle", |
||||||
|
min=0.0, max=math.radians(180.0), precision=0, default=math.radians(70.0), |
||||||
|
subtype="ANGLE") |
||||||
|
limit_zoom = BoolProperty(name="Limit Zoom", |
||||||
|
description="The camera allows zooming per artist limitations", |
||||||
|
options=set()) |
||||||
|
zoom_max = FloatProperty(name="Max FOV", |
||||||
|
description="Maximum camera FOV when zooming", |
||||||
|
min=0.0, max=math.radians(180.0), precision=0, default=math.radians(120.0), |
||||||
|
subtype="ANGLE", options=set()) |
||||||
|
zoom_min = FloatProperty(name="Min FOV", |
||||||
|
description="Minimum camera FOV when zooming", |
||||||
|
min=0.0, max=math.radians(180.0), precision=0, default=math.radians(35.0), |
||||||
|
subtype="ANGLE", options=set()) |
||||||
|
zoom_rate = FloatProperty(name="Zoom Velocity", |
||||||
|
description="Velocity of the camera's zoom in degrees per second", |
||||||
|
min=0.0, max=180.0, precision=0, default=90.0, |
||||||
|
unit="VELOCITY", options=set()) |
||||||
|
|
||||||
|
# Miscellaneous Movement Props |
||||||
|
maintain_los = BoolProperty(name="Maintain LOS", |
||||||
|
description="The camera should maintain line-of-sight with the object it's tracking", |
||||||
|
options=set()) |
||||||
|
fall_vertical = BoolProperty(name="Fall Camera", |
||||||
|
description="The camera will orient itself vertically when the local player begins falling", |
||||||
|
options=set()) |
||||||
|
fast_run = BoolProperty(name="Faster When Falling", |
||||||
|
description="The camera's velocity will have a floor when the local player is falling", |
||||||
|
options=set()) |
||||||
|
ignore_subworld = BoolProperty(name="Ignore Subworld Movement", |
||||||
|
description="The camera will not be parented to any subworlds", |
||||||
|
options=set()) |
||||||
|
|
||||||
|
# Core Type Properties |
||||||
|
primary_camera = BoolProperty(name="Primary Camera", |
||||||
|
description="The camera should be considered the Age's primary camera.", |
||||||
|
options=set()) |
||||||
|
|
||||||
|
# Cricle Camera |
||||||
|
def _get_circle_radius(self): |
||||||
|
# This is coming from the UI, so we need to get the active object from |
||||||
|
# Blender's context and pass that on to the actual getter. |
||||||
|
return self.get_circle_radius(bpy.context.object) |
||||||
|
def _set_circle_radius(self, value): |
||||||
|
# Don't really care about error checking... |
||||||
|
self.circle_radius_value = value |
||||||
|
|
||||||
|
circle_center = PointerProperty(name="Center", |
||||||
|
description="Center of the circle camera's orbit", |
||||||
|
type=bpy.types.Object, |
||||||
|
options=set()) |
||||||
|
circle_pos = EnumProperty(name="Position on Circle", |
||||||
|
description="The point on the circle the camera moves to", |
||||||
|
items=[("closest", "Closest Point", "The camera moves to the point on the circle closest to the Point of Attention"), |
||||||
|
("farthest", "Farthest Point", "The camera moves to the point on the circle farthest from the Point of Attention")], |
||||||
|
options=set()) |
||||||
|
circle_velocity = FloatProperty(name="Velocity", |
||||||
|
description="Velocity of the circle camera in degrees per second", |
||||||
|
min=0.0, max=math.radians(360.0), precision=0, default=math.radians(36.0), |
||||||
|
subtype="ANGLE", options=set()) |
||||||
|
circle_radius_ui = FloatProperty(name="Radius", |
||||||
|
description="Radius at which the circle camera should orbit the Point of Attention", |
||||||
|
min=0.0, get=_get_circle_radius, set=_set_circle_radius, options=set()) |
||||||
|
circle_radius_value = FloatProperty(name="INTERNAL: Radius", |
||||||
|
description="Radius at which the circle camera should orbit the Point of Attention", |
||||||
|
min=0.0, default=8.5, options={"HIDDEN"}) |
||||||
|
|
||||||
|
# Animation |
||||||
|
anim_enabled = BoolProperty(name="Animation Enabled", |
||||||
|
description="Export the camera's animation", |
||||||
|
default=True, |
||||||
|
options=set()) |
||||||
|
start_on_push = BoolProperty(name="Start on Push", |
||||||
|
description="Start playing the camera's animation when the camera is activated", |
||||||
|
default=True, |
||||||
|
options=set()) |
||||||
|
stop_on_pop = BoolProperty(name="Pause on Pop", |
||||||
|
description="Pauses the camera's animation when the camera is no longer activated", |
||||||
|
default=True, |
||||||
|
options=set()) |
||||||
|
reset_on_pop = BoolProperty(name="Reset on Pop", |
||||||
|
description="Reset the camera's animation to the beginning when the camera is no longer activated", |
||||||
|
options=set()) |
||||||
|
|
||||||
|
# Rail |
||||||
|
rail_pos = EnumProperty(name="Position on Rail", |
||||||
|
description="The point on the rail the camera moves to", |
||||||
|
items=[("closest", "Closest Point", "The camera moves to the point on the rail closest to the Point of Attention"), |
||||||
|
("farthest", "Farthest Point", "The camera moves to the point on the rail farthest from the Point of Attention")], |
||||||
|
options=set()) |
||||||
|
|
||||||
|
def get_circle_radius(self, bo): |
||||||
|
"""Gets the circle camera radius for this camera when it is attached to the given Object""" |
||||||
|
assert bo is not None |
||||||
|
if self.circle_center is not None: |
||||||
|
vec = bo.location - self.circle_center.location |
||||||
|
return vec.magnitude |
||||||
|
return self.circle_radius_value |
||||||
|
|
||||||
|
def harvest_actors(self): |
||||||
|
if self.poa_type == "object": |
||||||
|
return set((self.poa_object.name),) |
||||||
|
return set() |
||||||
|
|
||||||
|
|
||||||
|
class PlasmaCamera(bpy.types.PropertyGroup): |
||||||
|
camera_type = EnumProperty(name="Camera Type", |
||||||
|
description="", |
||||||
|
items=camera_types, |
||||||
|
options=set()) |
||||||
|
settings = PointerProperty(type=PlasmaCameraProperties, options=set()) |
||||||
|
transitions = CollectionProperty(type=PlasmaManualTransition, |
||||||
|
name="Transitions", |
||||||
|
description="", |
||||||
|
options=set()) |
||||||
|
active_transition_index = IntProperty(options={"HIDDEN"}) |
||||||
@ -0,0 +1,272 @@ |
|||||||
|
# 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/>. |
||||||
|
|
||||||
|
import bpy |
||||||
|
|
||||||
|
from .. import helpers |
||||||
|
from . import ui_list |
||||||
|
|
||||||
|
def _draw_alert_prop(layout, props, the_prop, cam_type, alert_cam="", min=None, max=None, **kwargs): |
||||||
|
can_alert = not alert_cam or alert_cam == cam_type |
||||||
|
if can_alert: |
||||||
|
value = getattr(props, the_prop) |
||||||
|
if min is not None and value < min: |
||||||
|
layout.alert = True |
||||||
|
if max is not None and value > max: |
||||||
|
layout.alert = True |
||||||
|
layout.prop(props, the_prop, **kwargs) |
||||||
|
layout.alert = False |
||||||
|
else: |
||||||
|
layout.prop(props, the_prop, **kwargs) |
||||||
|
|
||||||
|
def _draw_gated_prop(layout, props, gate_prop, actual_prop): |
||||||
|
row = layout.row(align=True) |
||||||
|
row.prop(props, gate_prop, text="") |
||||||
|
row = row.row(align=True) |
||||||
|
row.active = getattr(props, gate_prop) |
||||||
|
row.prop(props, actual_prop) |
||||||
|
|
||||||
|
def draw_camera_manipulation_props(layout, cam_type, props): |
||||||
|
# Camera Panning |
||||||
|
split = layout.split() |
||||||
|
col = split.column() |
||||||
|
col.label("Limit Panning:") |
||||||
|
col.prop(props, "x_pan_angle") |
||||||
|
col.prop(props, "y_pan_angle") |
||||||
|
|
||||||
|
# Camera Zoom |
||||||
|
col = split.column() |
||||||
|
col.label("Field of View:") |
||||||
|
col.prop(props, "fov") |
||||||
|
_draw_gated_prop(col, props, "limit_zoom", "zoom_min") |
||||||
|
_draw_gated_prop(col, props, "limit_zoom", "zoom_max") |
||||||
|
_draw_gated_prop(col, props, "limit_zoom", "zoom_rate") |
||||||
|
|
||||||
|
def draw_camera_mode_props(layout, cam_type, props): |
||||||
|
# Point of Attention |
||||||
|
split = layout.split() |
||||||
|
col = split.column() |
||||||
|
col.label("Camera Mode:") |
||||||
|
col = col.column() |
||||||
|
col.alert = cam_type != "fixed" and props.poa_type == "none" |
||||||
|
col.prop(props, "poa_type", text="") |
||||||
|
col.alert = False |
||||||
|
row = col.row() |
||||||
|
row.active = props.poa_type == "object" |
||||||
|
row.prop(props, "poa_object", text="") |
||||||
|
col.separator() |
||||||
|
col.prop(props, "primary_camera") |
||||||
|
|
||||||
|
# Miscellaneous |
||||||
|
col = split.column() |
||||||
|
col.label("Tracking Settings:") |
||||||
|
col.prop(props, "maintain_los") |
||||||
|
col.prop(props, "fall_vertical") |
||||||
|
col.prop(props, "fast_run") |
||||||
|
col.prop(props, "ignore_subworld") |
||||||
|
|
||||||
|
def draw_camera_poa_props(layout, cam_type, props): |
||||||
|
trans = props.transition |
||||||
|
|
||||||
|
# PoA Tracking |
||||||
|
split = layout.split() |
||||||
|
col = split.column() |
||||||
|
col.label("Default Tracking Transition:") |
||||||
|
col.prop(trans, "poa_acceleration", text="Acceleration") |
||||||
|
col.prop(trans, "poa_deceleration", text="Deceleration") |
||||||
|
col.prop(trans, "poa_velocity", text="Maximum Velocity") |
||||||
|
col = col.column() |
||||||
|
col.active = cam_type == "follow" |
||||||
|
col.prop(trans, "poa_cut", text="Cut Animation") |
||||||
|
|
||||||
|
# PoA Offset |
||||||
|
col = split.column() |
||||||
|
col.label("Point of Attention Offset:") |
||||||
|
col.prop(props, "poa_offset", text="") |
||||||
|
col.prop(props, "poa_worldspace") |
||||||
|
|
||||||
|
def draw_camera_pos_props(layout, cam_type, props): |
||||||
|
trans = props.transition |
||||||
|
|
||||||
|
# Position Tracking (only for follow cams) |
||||||
|
split = layout.split() |
||||||
|
col = split.column() |
||||||
|
|
||||||
|
# Position Transitions |
||||||
|
col.active = cam_type != "circle" |
||||||
|
col.label("Default Position Transition:") |
||||||
|
_draw_alert_prop(col, trans, "pos_acceleration", cam_type, |
||||||
|
alert_cam="rail", max=10.0, text="Acceleration") |
||||||
|
_draw_alert_prop(col, trans, "pos_deceleration", cam_type, |
||||||
|
alert_cam="rail", max=10.0, text="Deceleration") |
||||||
|
_draw_alert_prop(col, trans, "pos_velocity", cam_type, |
||||||
|
alert_cam="rail", max=10.0, text="Maximum Velocity") |
||||||
|
col = col.column() |
||||||
|
col.active = cam_type == "follow" |
||||||
|
col.prop(trans, "pos_cut", text="Cut Animation") |
||||||
|
|
||||||
|
# Position Offsets |
||||||
|
col = split.column() |
||||||
|
col.active = cam_type == "follow" |
||||||
|
col.label("Position Offset:") |
||||||
|
col.prop(props, "pos_offset", text="") |
||||||
|
col.prop(props, "pos_worldspace") |
||||||
|
|
||||||
|
def draw_circle_camera_props(layout, props): |
||||||
|
# Circle Camera Stuff |
||||||
|
layout.prop(props, "circle_center") |
||||||
|
layout.prop(props, "circle_pos") |
||||||
|
layout.prop(props, "circle_velocity") |
||||||
|
row = layout.row(align=True) |
||||||
|
row.active = props.circle_center is None |
||||||
|
row.prop(props, "circle_radius_ui") |
||||||
|
|
||||||
|
class CameraButtonsPanel: |
||||||
|
bl_space_type = "PROPERTIES" |
||||||
|
bl_region_type = "WINDOW" |
||||||
|
bl_context = "data" |
||||||
|
|
||||||
|
@classmethod |
||||||
|
def poll(cls, context): |
||||||
|
return (context.camera and context.scene.render.engine == "PLASMA_GAME") |
||||||
|
|
||||||
|
|
||||||
|
class PlasmaCameraTypePanel(CameraButtonsPanel, bpy.types.Panel): |
||||||
|
bl_label = "" |
||||||
|
bl_options = {"HIDE_HEADER"} |
||||||
|
|
||||||
|
def draw(self, context): |
||||||
|
camera = context.camera.plasma_camera |
||||||
|
self.layout.prop(camera, "camera_type") |
||||||
|
|
||||||
|
|
||||||
|
class PlasmaCameraModePanel(CameraButtonsPanel, bpy.types.Panel): |
||||||
|
bl_label = "Camera Tracking" |
||||||
|
|
||||||
|
def draw(self, context): |
||||||
|
camera = context.camera.plasma_camera |
||||||
|
draw_camera_mode_props(self.layout, camera.camera_type, camera.settings) |
||||||
|
|
||||||
|
|
||||||
|
class PlasmaCameraAttentionPanel(CameraButtonsPanel, bpy.types.Panel): |
||||||
|
bl_label = "Point of Attention Tracking" |
||||||
|
|
||||||
|
def draw(self, context): |
||||||
|
camera = context.camera.plasma_camera |
||||||
|
draw_camera_poa_props(self.layout, camera.camera_type, camera.settings) |
||||||
|
|
||||||
|
|
||||||
|
class PlasmaCameraPositionPanel(CameraButtonsPanel, bpy.types.Panel): |
||||||
|
bl_label = "Position Tracking" |
||||||
|
|
||||||
|
def draw(self, context): |
||||||
|
camera = context.camera.plasma_camera |
||||||
|
draw_camera_pos_props(self.layout, camera.camera_type, camera.settings) |
||||||
|
|
||||||
|
|
||||||
|
class PlasmaCameraCirclePanel(CameraButtonsPanel, bpy.types.Panel): |
||||||
|
bl_label = "Circle Camera" |
||||||
|
|
||||||
|
def draw(self, context): |
||||||
|
camera = context.camera.plasma_camera |
||||||
|
draw_circle_camera_props(self.layout, camera.settings) |
||||||
|
|
||||||
|
@classmethod |
||||||
|
def poll(cls, context): |
||||||
|
return super().poll(context) and context.camera.plasma_camera.camera_type == "circle" |
||||||
|
|
||||||
|
|
||||||
|
class PlasmaCameraAnimationPanel(CameraButtonsPanel, bpy.types.Panel): |
||||||
|
bl_label = "Camera Animation" |
||||||
|
bl_options = {"DEFAULT_CLOSED"} |
||||||
|
|
||||||
|
def draw(self, context): |
||||||
|
layout = self.layout |
||||||
|
camera = context.camera.plasma_camera |
||||||
|
props = camera.settings |
||||||
|
|
||||||
|
split = layout.split() |
||||||
|
col = split.column() |
||||||
|
col.label("Animation:") |
||||||
|
col.active = props.anim_enabled and any(helpers.fetch_fcurves(context.object)) |
||||||
|
col.prop(props, "start_on_push") |
||||||
|
col.prop(props, "stop_on_pop") |
||||||
|
col.prop(props, "reset_on_pop") |
||||||
|
|
||||||
|
col = split.column() |
||||||
|
col.active = camera.camera_type == "rail" |
||||||
|
col.label("Rail:") |
||||||
|
col.prop(props, "rail_pos", text="") |
||||||
|
|
||||||
|
def draw_header(self, context): |
||||||
|
self.layout.active = any(helpers.fetch_fcurves(context.object)) |
||||||
|
self.layout.prop(context.camera.plasma_camera.settings, "anim_enabled", text="") |
||||||
|
|
||||||
|
|
||||||
|
class PlasmaCameraViewPanel(CameraButtonsPanel, bpy.types.Panel): |
||||||
|
bl_label = "Camera Lens" |
||||||
|
|
||||||
|
def draw(self, context): |
||||||
|
camera = context.camera.plasma_camera |
||||||
|
draw_camera_manipulation_props(self.layout, camera.camera_type, camera.settings) |
||||||
|
|
||||||
|
|
||||||
|
class TransitionListUI(bpy.types.UIList): |
||||||
|
def draw_item(self, context, layout, data, item, icon, active_data, active_property, index=0, flt_flag=0): |
||||||
|
if item.camera is None: |
||||||
|
layout.label("[Default Transition]") |
||||||
|
else: |
||||||
|
layout.label(item.camera.name, icon="CAMERA_DATA") |
||||||
|
layout.prop(item, "enabled", text="") |
||||||
|
|
||||||
|
|
||||||
|
class PlasmaCameraTransitionPanel(CameraButtonsPanel, bpy.types.Panel): |
||||||
|
bl_label = "Transitions" |
||||||
|
|
||||||
|
def draw(self, context): |
||||||
|
layout = self.layout |
||||||
|
camera = context.camera.plasma_camera |
||||||
|
|
||||||
|
ui_list.draw_list(layout, "TransitionListUI", "camera", camera, "transitions", |
||||||
|
"active_transition_index", rows=3, maxrows=4) |
||||||
|
|
||||||
|
try: |
||||||
|
item = camera.transitions[camera.active_transition_index] |
||||||
|
trans = item.transition |
||||||
|
except: |
||||||
|
pass |
||||||
|
else: |
||||||
|
layout.separator() |
||||||
|
box = layout.box() |
||||||
|
box.prop(item, "camera", text="Transition From") |
||||||
|
box.prop(item, "mode") |
||||||
|
|
||||||
|
box.separator() |
||||||
|
split = box.split() |
||||||
|
split.active = item.mode == "manual" |
||||||
|
|
||||||
|
col = split.column() |
||||||
|
col.label("Tracking Transition:") |
||||||
|
col.prop(trans, "poa_acceleration", text="Acceleration") |
||||||
|
col.prop(trans, "poa_deceleration", text="Deceleration") |
||||||
|
col.prop(trans, "poa_velocity", text="Maximum Velocity") |
||||||
|
col.prop(trans, "poa_cut", text="Cut Transition") |
||||||
|
|
||||||
|
col = split.column() |
||||||
|
col.label("Position Transition:") |
||||||
|
col.prop(trans, "pos_acceleration", text="Acceleration") |
||||||
|
col.prop(trans, "pos_deceleration", text="Deceleration") |
||||||
|
col.prop(trans, "pos_velocity", text="Maximum Velocity") |
||||||
|
col.prop(trans, "pos_cut", text="Cut Transition") |
||||||
Loading…
Reference in new issue