Merge remote-tracking branch 'hoikas/waveset7'

korman/exporter/material.py

@@ -211,6 +211,22 @@ class MaterialConverter:
         # Looks like we're done...
         return hsgmat.key
 
+    def export_waveset_material(self, bo, bm):
+        print("    Exporting WaveSet Material '{}'".format(bm.name))
+
+        # WaveSets MUST have their own material
+        unique_name = "{}_WaveSet7".format(bm.name)
+        hsgmat = self._mgr.add_object(hsGMaterial, name=unique_name, bl=bo)
+
+        # Materials MUST have one layer. Wavesets need alpha blending...
+        layer = self._mgr.add_object(plLayer, name=unique_name, bl=bo)
+        self._propagate_material_settings(bm, layer)
+        layer.state.blendFlags |= hsGMatState.kBlendAlpha
+        hsgmat.addLayer(layer.key)
+
+        # Wasn't that easy?
+        return hsgmat.key
+
     def _export_texture_slot(self, bo, bm, hsgmat, slots, idx):
         slot = slots[idx]
         num_exported = 1
@@ -370,37 +386,31 @@ class MaterialConverter:
                 pl_env = plDynamicCamMap
             else:
                 pl_env = plDynamicEnvMap
-            pl_env = self._export_dynamic_env(bo, hsgmat, layer, texture, pl_env)
+            pl_env = self.export_dynamic_env(bo, hsgmat, layer, texture, pl_env)
         else:
             # We should really export a CubicEnvMap here, but we have a good setup for DynamicEnvMaps
             # that create themselves when the explorer links in, so really... who cares about CEMs?
             self._exporter().report.warn("IMAGE EnvironmentMaps are not supported. '{}' will not be exported!".format(layer.key.name))
             pl_env = None
         layer.state.shadeFlags |= hsGMatState.kShadeEnvironMap
-        layer.texture = pl_env
+        layer.texture = pl_env.key
 
-    def _export_dynamic_env(self, bo, hsgmat, layer, texture, pl_class):
+    def export_dynamic_env(self, bo, hsgmat, layer, texture, pl_class):
         # To protect the user from themselves, let's check to make sure that a DEM/DCM matching this
         # viewpoint object has not already been exported...
         bl_env = texture.environment_map
         viewpt = bl_env.viewpoint_object
+        if viewpt is None:
+            viewpt = bo
         name = "{}_DynEnvMap".format(viewpt.name)
-        pl_env = self._mgr.find_key(pl_class, bl=bo, name=name)
+        pl_env = self._mgr.find_object(pl_class, bl=bo, name=name)
         if pl_env is not None:
             print("            EnvMap for viewpoint {} already exported... NOTE: Your settings here will be overridden by the previous object!".format(viewpt.name))
-            pl_env_obj = pl_env.object
+            if isinstance(pl_env, plDynamicCamMap):
-            if isinstance(pl_env_obj, plDynamicCamMap):
+                pl_env.addTargetNode(self._mgr.find_key(plSceneObject, bl=bo))
-                pl_env_obj.addTargetNode(self._mgr.find_key(plSceneObject, bl=bo))
+                pl_env.addMatLayer(layer.key)
-                pl_env_obj.addMatLayer(layer.key)
             return pl_env
 
-        # It matters not whether or not the viewpoint object is a Plasma Object, it is exported as at
-        # least a SceneObject and CoordInterface so that we can touch it...
-        # NOTE: that harvest_actor makes sure everyone alread knows we're going to have a CI
-        root = self._mgr.find_create_key(plSceneObject, bl=bo, name=viewpt.name)
-        self._exporter()._export_coordinate_interface(root.object, bl=bo, name=viewpt.name)
-        # FIXME: DynamicCamMap Camera
-
         # Ensure POT
         oRes = bl_env.resolution
         eRes = helpers.ensure_power_of_two(oRes)
@@ -413,7 +423,6 @@ class MaterialConverter:
         pl_env.yon = bl_env.clip_end
         pl_env.refreshRate = 0.01 if bl_env.source == "ANIMATED" else 0.0
         pl_env.incCharacters = True
-        pl_env.rootNode = root # FIXME: DCM camera
 
         # Perhaps the DEM/DCM fog should be separately configurable at some point?
         pl_fog = bpy.context.scene.world.plasma_fni
@@ -423,6 +432,13 @@ class MaterialConverter:
         if isinstance(pl_env, plDynamicCamMap):
             faces = (pl_env,)
 
+            # It matters not whether or not the viewpoint object is a Plasma Object, it is exported as at
+            # least a SceneObject and CoordInterface so that we can touch it...
+            # NOTE: that harvest_actor makes sure everyone alread knows we're going to have a CI
+            root = self._mgr.find_create_key(plSceneObject, bl=viewpt)
+            pl_env.rootNode = root # FIXME: DCM camera
+            # FIXME: DynamicCamMap Camera
+
             pl_env.addTargetNode(self._mgr.find_key(plSceneObject, bl=bo))
             pl_env.addMatLayer(layer.key)
 
@@ -442,6 +458,11 @@ class MaterialConverter:
         else:
             faces = pl_env.faces + (pl_env,)
 
+            # DEMs can do just a position vector. We actually prefer this because the WaveSet exporter
+            # will probably want to steal it for diabolical purposes...
+            pl_env.position = hsVector3(*viewpt.location)
+
+            if layer is not None:
                 layer.UVWSrc = plLayerInterface.kUVWReflect
                 layer.state.miscFlags |= hsGMatState.kMiscUseRefractionXform
 
@@ -459,7 +480,7 @@ class MaterialConverter:
             i.viewportBottom = eRes
             i.ZDepth = 24
 
-        return pl_env.key
+        return pl_env
 
     def _export_texture_type_image(self, bo, hsgmat, layer, slot):
         """Exports a Blender ImageTexture to a plLayer"""

korman/exporter/mesh.py

@@ -37,10 +37,9 @@ class _RenderLevel:
     _MAJOR_SHIFT = 28
     _MINOR_MASK = ((1 << _MAJOR_SHIFT) - 1)
 
-    def __init__(self, hsgmat, pass_index, blendSpan=False):
+    def __init__(self, bo, hsgmat, pass_index, blendSpan=False):
         self.level = 0
 
-        # Naive... BlendSpans (any blending on the first layer) are MAJOR_BLEND
         if blendSpan:
             self.major = self.MAJOR_DEFAULT
 
@@ -68,15 +67,22 @@ class _RenderLevel:
 
 
 class _DrawableCriteria:
-    def __init__(self, hsgmat, pass_index):
+    def __init__(self, bo, hsgmat, pass_index):
         for layer in hsgmat.layers:
             if layer.object.state.blendFlags & hsGMatState.kBlendMask:
                 self.blend_span = True
                 break
         else:
             self.blend_span = False
-        self.criteria = 0 # TODO
+
-        self.render_level = _RenderLevel(hsgmat, pass_index, self.blend_span)
+        self.criteria = 0
+        if self.blend_span:
+            for mod in bo.plasma_modifiers.modifiers:
+                if mod.requires_face_sort:
+                    self.criteria |= plDrawable.kCritSortFaces
+                if mod.requires_span_sort:
+                    self.sort_spans |= plDrawable.kCritSortSpans
+        self.render_level = _RenderLevel(bo, hsgmat, pass_index, self.blend_span)
 
     def __eq__(self, other):
         if not isinstance(other, _DrawableCriteria):
@@ -304,6 +310,20 @@ class MeshConverter:
 
     def _export_material_spans(self, bo, mesh, materials):
         """Exports all Materials and creates plGeometrySpans"""
+        waveset_mod = bo.plasma_modifiers.water_basic
+        if waveset_mod.enabled:
+            if len(materials) > 1:
+                msg = "'{}' is a WaveSet -- only one material is supported".format(bo.name)
+                self._exporter().report.warn(msg, indent=1)
+            matKey = self.material.export_waveset_material(bo, materials[0])
+            geospan = self._create_geospan(bo, mesh, materials[0], matKey)
+
+            # FIXME: Can some of this be generalized?
+            geospan.props |= (plGeometrySpan.kWaterHeight | plGeometrySpan.kLiteVtxNonPreshaded |
+                              plGeometrySpan.kPropReverseSort | plGeometrySpan.kPropNoShadow)
+            geospan.waterHeight = bo.location[2]
+            return [(geospan, 0)]
+        else:
             geospans = [None] * len(materials)
             for i, blmat in enumerate(materials):
                 matKey = self.material.export_material(bo, blmat)
@@ -312,11 +332,12 @@ class MeshConverter:
 
     def _export_static_lighting(self, bo):
         helpers.make_active_selection(bo)
-        lm = bo.plasma_modifiers.lightmap
+        mods = bo.plasma_modifiers
+        lm = mods.lightmap
         if lm.enabled:
             print("    Baking lightmap...")
             bpy.ops.object.plasma_lightmap_autobake(light_group=lm.light_group)
-        else:
+        elif not mods.water_basic.enabled:
             for vcol_layer in bo.data.vertex_colors:
                 name = vcol_layer.name.lower()
                 if name in _VERTEX_COLOR_LAYERS:
@@ -325,7 +346,6 @@ class MeshConverter:
                 print("    Baking crappy vertex color lighting...")
                 bpy.ops.object.plasma_vertexlight_autobake()
 
-
     def _find_create_dspan(self, bo, hsgmat, pass_index):
         location = self._mgr.get_location(bo)
         if location not in self._dspans:
@@ -333,10 +353,11 @@ class MeshConverter:
 
         # This is where we figure out which DSpan this goes into. To vaguely summarize the rules...
         # BlendSpans: anything with an alpha blended layer
-        # [... document me ...]
+        # SortSpans: means we should sort the spans in this DSpan with all other span in this pass
+        # SortFaces: means we should sort the faces in this span only
         # We're using pass index to do just what it was designed for. Cyan has a nicer "depends on"
         # draw component, but pass index is the Blender way, so that's what we're doing.
-        crit = _DrawableCriteria(hsgmat, pass_index)
+        crit = _DrawableCriteria(bo, hsgmat, pass_index)
 
         if crit not in self._dspans[location]:
             # AgeName_[District_]_Page_RenderLevel_Crit[Blend]Spans
@@ -345,8 +366,12 @@ class MeshConverter:
             name = "{}_{:08X}_{:X}{}".format(node.name, crit.render_level.level, crit.criteria, crit.span_type)
             dspan = self._mgr.add_object(pl=plDrawableSpans, name=name, loc=location)
 
-            dspan.criteria = crit.criteria
+            criteria = crit.criteria
-            # TODO: props
+            dspan.criteria = criteria
+            if criteria & plDrawable.kCritSortFaces:
+                dspan.props |= plDrawable.kPropSortFaces
+            if criteria & plDrawable.kCritSortSpans:
+                dspan.props |= plDrawable.kPropSortSpans
             dspan.renderLevel = crit.render_level.level
             dspan.sceneNode = node # AddViaNotify
 

korman/nodes/node_python.py

@@ -423,7 +423,8 @@ class PlasmaAttribObjectNode(PlasmaAttribNodeBase, bpy.types.Node):
     bl_idname = "PlasmaAttribObjectNode"
     bl_label = "Object Attribute"
 
-    pl_attrib = ("ptAttribSceneobject", "ptAttribSceneobjectList", "ptAttribAnimation")
+    pl_attrib = ("ptAttribSceneobject", "ptAttribSceneobjectList", "ptAttribAnimation",
+                 "ptAttribWaveSet")
 
     object_name = StringProperty(name="Object",
                                  description="Object containing the required data")
@@ -456,6 +457,11 @@ class PlasmaAttribObjectNode(PlasmaAttribNodeBase, bpy.types.Node):
             agmod = exporter.mgr.find_create_key(plAGModifier, so=ref_so, name=anim.display_name)
             agmaster = exporter.mgr.find_create_key(plAGMasterModifier, so=ref_so, name=anim.display_name)
             return agmaster
+        elif attrib == "ptAttribWaveSet":
+            waveset = bo.plasma_modifiers.water_basic
+            if not waveset.enabled:
+                self.raise_error("water modifier not enabled on '{}'".format(self.object_name))
+            return exporter.mgr.find_create_key(plWaveSet7, so=ref_so, bl=bo)
 
 
 class PlasmaAttribStringNode(PlasmaAttribNodeBase, bpy.types.Node):

korman/properties/modifiers/__init__.py

@@ -22,6 +22,7 @@ from .logic import *
 from .physics import *
 from .region import *
 from .render import *
+from .water import *
 
 class PlasmaModifiers(bpy.types.PropertyGroup):
     def determine_next_id(self):

korman/properties/modifiers/base.py

@@ -37,6 +37,17 @@ class PlasmaModifierProperties(bpy.types.PropertyGroup):
         """Indicates if this modifier requires the object to be a movable actor"""
         return False
 
+    @property
+    def requires_face_sort(self):
+        """Indicates that the geometry's faces must be sorted by the engine"""
+        return False
+
+    @property
+    def requires_span_sort(self):
+        """Indicates that the geometry's Spans must be sorted with those from other Drawables that
+           will render in the same pass"""
+        return False
+
     # Guess what?
     # You can't register properties on a base class--Blender isn't smart enough to do inheritance,
     # you see... So, we'll store our definitions in a dict and make those properties on each subclass

korman/properties/modifiers/water.py

@@ -0,0 +1,316 @@
+#    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 PyHSPlasma import *
+
+from .base import PlasmaModifierProperties
+from ...exporter import ExportError
+
+class PlasmaWaterModifier(PlasmaModifierProperties, bpy.types.PropertyGroup):
+    pl_id = "water_basic"
+
+    bl_category = "Water"
+    bl_label = "Basic Water"
+    bl_description = "Basic water properties"
+
+    wind_object_name = StringProperty(name="Wind Object",
+                                      description="Object whose Y axis represents the wind direction")
+    wind_speed = FloatProperty(name="Wind Speed",
+                               description="Magnitude of the wind",
+                               default=1.0)
+    envmap_name = StringProperty(name="EnvMap",
+                                 description="Texture defining an environment map for this water object")
+    envmap_radius = FloatProperty(name="Environment Sphere Radius",
+                                  description="How far away the first object you want to see is",
+                                  min=5.0, max=10000.0,
+                                  default=500.0)
+
+    specular_tint = FloatVectorProperty(name="Specular Tint",
+                                        subtype="COLOR",
+                                        min=0.0, max=1.0,
+                                        default=(1.0, 1.0, 1.0))
+    specular_alpha = FloatProperty(name="Specular Alpha",
+                                   min=0.0, max=1.0,
+                                   default=0.3)
+    noise = IntProperty(name="Noise",
+                        subtype="PERCENTAGE",
+                        min=0, max=300,
+                        default=50)
+    specular_start = FloatProperty(name="Specular Start",
+                                   min=0.0, max=1000.0,
+                                   default=50.0)
+    specular_end = FloatProperty(name="Specular End",
+                                 min=0.0, max=10000.0,
+                                 default=1000.0)
+    ripple_scale = FloatProperty(name="Ripple Scale",
+                                 min=5.0, max=1000.0,
+                                 default=25.0)
+
+    depth_opacity = FloatProperty(name="Opacity End",
+                                  min=0.5, max=20.0,
+                                  default=3.0)
+    depth_reflection = FloatProperty(name="Reflection End",
+                                     min=0.5, max=20.0,
+                                     default=3.0)
+    depth_wave = FloatProperty(name="Wave End",
+                               min=0.5, max=20.0,
+                               default=4.0)
+    zero_opacity = FloatProperty(name="Opacity Start",
+                                 min=-10.0, max=10.0,
+                                 default=-1.0)
+    zero_reflection = FloatProperty(name="Reflection Start",
+                                    min=-10.0, max=10.0,
+                                    default=0.0)
+    zero_wave = FloatProperty(name="Wave Start",
+                              min=-10.0, max=10.0,
+                              default=0.0)
+
+    def created(self, obj):
+        self.display_name = "{}_WaveSet7".format(obj.name)
+
+    def export(self, exporter, bo, so):
+        waveset = exporter.mgr.find_create_object(plWaveSet7, name=bo.name, so=so)
+        if self.wind_object_name:
+            wind_obj = bpy.data.objects.get(self.wind_object_name, None)
+            if wind_obj is None:
+                raise ExportError("{}: Wind Object '{}' not found".format(self.display_name, self.wind_object_name))
+            if wind_obj.plasma_object.enabled and wind_obj.plasma_modifiers.animation.enabled:
+                waveset.refObj = exporter.mgr.find_create_key(plSceneObject, bl=wind_obj)
+                waveset.setFlag(plWaveSet7.kHasRefObject, True)
+
+            # This is much like what happened in PyPRP
+            speed = self.wind_speed
+            matrix = wind_obj.maitrx_world
+            wind_dir = hsVector3(matrix[1][0] * speed, matrix[1][1] * speed, matrix[1][2] * speed)
+        else:
+            # Stolen shamelessly from PyPRP
+            wind_dir = hsVector3(0.0871562, 0.996195, 0.0)
+
+        # Stuff we expose
+        state = waveset.state
+        state.rippleScale = self.ripple_scale
+        state.waterHeight = bo.location[2]
+        state.windDir = wind_dir
+        state.specVector = hsVector3(self.noise / 100.0, self.specular_start, self.specular_end)
+        state.specularTint = hsColorRGBA(*self.specular_tint, alpha=self.specular_alpha)
+        state.waterOffset = hsVector3(self.zero_opacity * -1.0, self.zero_reflection * -1.0, self.zero_wave * -1.0)
+        state.depthFalloff = hsVector3(self.depth_opacity, self.depth_reflection, self.depth_wave)
+
+        # Environment Map
+        if self.envmap_name:
+            texture = bpy.data.textures.get(self.envmap_name, None)
+            if texture is None:
+                raise ExportError("{}: Texture '{}' not found".format(self.display_name, self.envmap_name))
+            if texture.type != "ENVIRONMENT_MAP":
+                raise ExportError("{}: Texture '{}' is not an ENVIRONMENT MAP".format(self.display_name, self.envmap_name))
+
+            # maybe, just maybe, we're absuing our privledges?
+            dem = exporter.mesh.material.export_dynamic_env(bo, None, None, texture, plDynamicEnvMap)
+            waveset.envMap = dem.key
+            state.envCenter = dem.position
+            state.envRefresh = dem.refreshRate
+        else:
+            state.envCenter = hsVector3(*bo.location)
+            state.envRefresh = 0.0
+        state.envRadius = self.envmap_radius
+
+        # These are either unused, set from somewhere else at runtime, or hardcoded
+        state.waterTint = hsColorRGBA(1.0, 1.0, 1.0, 1.0)
+        state.maxColor = hsColorRGBA(1.0, 1.0, 1.0, 1.0)
+        state.shoreTint = hsColorRGBA(1.0, 1.0, 1.0, 1.0)
+        state.maxAtten = hsVector3(1.0, 1.0, 1.0)
+        state.minAtten = hsVector3(0.0, 0.0, 0.0)
+
+        # Now, we have some related modifiers that may or may not be enabled... If not, we should
+        # make them export their defaults.
+        mods = bo.plasma_modifiers
+        if not mods.water_geostate.enabled:
+            mods.water_geostate.convert_default_wavestate(state.geoState)
+        if not mods.water_texstate.enabled:
+            mods.water_texstate.convert_default_wavestate(state.texState)
+        if not mods.water_shore.enabled:
+            mods.water_shore.convert_default(state)
+
+
+class PlasmaShoreObject(bpy.types.PropertyGroup):
+    display_name = StringProperty(name="Display Name")
+    object_name = StringProperty(name="Shore Object",
+                                 description="Object that waves crash upon")
+
+
+class PlasmaWaterShoreModifier(PlasmaModifierProperties):
+    pl_depends = {"water_basic"}
+    pl_id = "water_shore"
+
+    bl_category = "Water"
+    bl_label = "Water Shore"
+    bl_description = ""
+
+    # The basic modifier may want to export a default copy of us
+    _shore_tint_default = (0.2, 0.4, 0.4)
+    _shore_opacity_default = 40
+    _wispiness_default = 50
+    _period_default = 100.0
+    _finger_default = 100.0
+    _edge_opacity_default = 100
+    _edge_radius_default = 100.0
+
+    shores = CollectionProperty(type=PlasmaShoreObject)
+    active_shore_index = IntProperty(options={"HIDDEN"})
+
+    shore_tint = FloatVectorProperty(name="Shore Tint",
+                                     subtype="COLOR",
+                                     min=0.0, max=1.0,
+                                     default=_shore_tint_default)
+    shore_opacity = IntProperty(name="Shore Opacity",
+                                subtype="PERCENTAGE",
+                                min=0, max=100,
+                                default=_shore_opacity_default)
+    wispiness = IntProperty(name="Wispiness",
+                            subtype="PERCENTAGE",
+                            min=0, max=200,
+                            default=_wispiness_default)
+
+    period = FloatProperty(name="Period",
+                           min=0.0, max=200.0,
+                           default=_period_default)
+    finger = FloatProperty(name="Finger",
+                           min=50.0, max=300.0,
+                           default=_finger_default)
+    edge_opacity = IntProperty(name="Edge Opacity",
+                               subtype="PERCENTAGE",
+                               min=0, max=100,
+                               default=_edge_opacity_default)
+    edge_radius = FloatProperty(name="Edge Radius",
+                                subtype="PERCENTAGE",
+                                min=50, max=300,
+                                default=_edge_radius_default)
+
+    def convert_default(self, wavestate):
+        wavestate.wispiness = self._wispiness_default / 100.0
+        wavestate.minColor = hsColorRGBA(*self._shore_tint_default, alpha=(self._shore_opacity_default / 100.0))
+        wavestate.edgeOpacity = self._edge_opacity_default / 100.0
+        wavestate.edgeRadius = self._edge_radius_default / 100.0
+        wavestate.period = self._period_default / 100.0
+        wavestate.fingerLength = self._finger_default / 100.0
+
+    def created(self, obj):
+        self.display_name = "{}_WaterShore".format(obj.name)
+
+    def export(self, exporter, bo, so):
+        waveset = exporter.mgr.find_create_object(plWaveSet7, name=bo.name, so=so)
+        wavestate = waveset.state
+
+        for i in self.shores:
+            shore = bpy.data.objects.get(i.object_name, None)
+            if shore is None:
+                raise ExportError("'{}': Shore Object '{}' does not exist".format(self.display_name, i.object_name))
+            waveset.addShore(exporter.mgr.find_create_key(plSceneObject, bl=shore))
+
+        wavestate.wispiness = self.wispiness / 100.0
+        wavestate.minColor = hsColorRGBA(*self.shore_tint, alpha=(self.shore_opacity / 100.0))
+        wavestate.edgeOpacity = self.edge_opacity / 100.0
+        wavestate.edgeRadius = self.edge_radius / 100.0
+        wavestate.period = self.period / 100.0
+        wavestate.fingerLength = self.finger / 100.0
+
+
+class PlasmaWaveState:
+    pl_depends = {"water_basic"}
+
+    def convert_wavestate(self, state):
+        state.minLength = self.min_length
+        state.maxLength = self.max_length
+        state.ampOverLen = self.amplitude / 100.0
+        state.chop = self.chop / 100.0
+        state.angleDev = self.angle_dev
+
+    def convert_default_wavestate(self, state):
+        cls = self.__class__
+        state.minLength = cls._min_length_default
+        state.maxLength = cls._max_length_default
+        state.ampOverLen = cls._amplitude_default / 100.0
+        state.chop = cls._chop_default / 100.0
+        state.angleDev = cls._angle_dev_default
+
+    @classmethod
+    def register(cls):
+        cls.min_length = FloatProperty(name="Min Length",
+                                       description="Smallest wave length",
+                                       min=0.1, max=50.0,
+                                       default=cls._min_length_default)
+        cls.max_length = FloatProperty(name="Max Length",
+                                       description="Largest wave length",
+                                       min=0.1, max=50.0,
+                                       default=cls._max_length_default)
+        cls.amplitude = IntProperty(name="Amplitude",
+                                    description="Multiplier for wave height",
+                                    subtype="PERCENTAGE",
+                                    min=0, max=100,
+                                    default=cls._amplitude_default)
+        cls.chop = IntProperty(name="Choppiness",
+                               description="Sharpness of wave crests",
+                               subtype="PERCENTAGE",
+                               min=0, max=500,
+                               default=cls._chop_default)
+        cls.angle_dev = FloatProperty(name="Wave Spread",
+                                      subtype="ANGLE",
+                                      min=math.radians(0.0), max=math.radians(180.0),
+                                      default=cls._angle_dev_default)
+
+
+class PlasmaWaveGeoState(PlasmaWaveState, PlasmaModifierProperties):
+    pl_id = "water_geostate"
+
+    bl_category = "Water"
+    bl_label = "Geometry Waves"
+    bl_description = "Mesh wave settings"
+
+    _min_length_default = 4.0
+    _max_length_default = 8.0
+    _amplitude_default = 10
+    _chop_default = 50
+    _angle_dev_default = math.radians(20.0)
+
+    def created(self, obj):
+        self.display_name = "{}_WaveGeoState".format(obj.name)
+
+    def export(self, exporter, bo, so):
+        waveset = exporter.mgr.find_create_object(plWaveSet7, name=bo.name, so=so)
+        self.convert_wavestate(waveset.state.geoState)
+
+
+class PlasmaWaveTexState(PlasmaWaveState, PlasmaModifierProperties):
+    pl_id = "water_texstate"
+
+    bl_category = "Water"
+    bl_label = "Texture Waves"
+    bl_description = "Texture wave settings"
+
+    _min_length_default = 0.1
+    _max_length_default = 4.0
+    _amplitude_default = 10
+    _chop_default = 50
+    _angle_dev_default = math.radians(20.0)
+
+    def created(self, obj):
+        self.display_name = "{}_WaveTexState".format(obj.name)
+
+    def export(self, exporter, bo, so):
+        waveset = exporter.mgr.find_create_object(plWaveSet7, name=bo.name, so=so)
+        self.convert_wavestate(waveset.state.texState)

korman/ui/modifiers/__init__.py

@@ -19,3 +19,4 @@ from .logic import *
 from .physics import *
 from .region import *
 from .render import *
+from .water import *

korman/ui/modifiers/water.py

@@ -0,0 +1,106 @@
+#    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
+
+def water_basic(modifier, layout, context):
+    layout.prop_search(modifier, "wind_object_name", bpy.data, "objects")
+    layout.prop_search(modifier, "envmap_name", bpy.data, "textures")
+
+    row = layout.row()
+    row.prop(modifier, "wind_speed")
+    row.prop(modifier, "envmap_radius")
+    layout.separator()
+
+    split = layout.split()
+    col = split.column()
+    col.prop(modifier, "specular_tint")
+    col.prop(modifier, "specular_alpha", text="Alpha")
+
+    col.label("Specular:")
+    col.prop(modifier, "specular_start", text="Start")
+    col.prop(modifier, "specular_end", text="End")
+
+    col.label("Misc:")
+    col.prop(modifier, "noise")
+    col.prop(modifier, "ripple_scale")
+
+    col = split.column()
+    col.label("Opacity:")
+    col.prop(modifier, "zero_opacity", text="Start")
+    col.prop(modifier, "depth_opacity", text="End")
+
+    col.label("Reflection:")
+    col.prop(modifier, "zero_reflection", text="Start")
+    col.prop(modifier, "depth_reflection", text="End")
+
+    col.label("Wave:")
+    col.prop(modifier, "zero_wave", text="Start")
+    col.prop(modifier, "depth_wave", text="End")
+
+def _wavestate(modifier, layout, context):
+    split = layout.split()
+    col = split.column()
+    col.label("Size:")
+    col.prop(modifier, "min_length")
+    col.prop(modifier, "max_length")
+    col.prop(modifier, "amplitude")
+
+    col = split.column()
+    col.label("Behavior:")
+    col.prop(modifier, "chop")
+    col.prop(modifier, "angle_dev")
+
+water_geostate = _wavestate
+water_texstate = _wavestate
+
+class ShoreListUI(bpy.types.UIList):
+    def draw_item(self, context, layout, data, item, icon, active_data, active_property, index=0, flt_flag=0):
+        layout.prop(item, "display_name", emboss=False, text="", icon="MOD_WAVE")
+
+
+def water_shore(modifier, layout, context):
+    row = layout.row()
+    row.template_list("ShoreListUI", "shores", modifier, "shores", modifier, "active_shore_index",
+                      rows=2, maxrows=3)
+    col = row.column(align=True)
+    op = col.operator("object.plasma_modifier_collection_add", icon="ZOOMIN", text="")
+    op.modifier = modifier.pl_id
+    op.collection = "shores"
+    op.name_prefix = "Shore"
+    op.name_prop = "display_name"
+    op = col.operator("object.plasma_modifier_collection_remove", icon="ZOOMOUT", text="")
+    op.modifier = modifier.pl_id
+    op.collection = "shores"
+    op.index = modifier.active_shore_index
+
+    # Display the active shore
+    if modifier.shores:
+        shore = modifier.shores[modifier.active_shore_index]
+        layout.prop_search(shore, "object_name", bpy.data, "objects", icon="MESH_DATA")
+
+    split = layout.split()
+    col = split.column()
+    col.label("Basic:")
+    col.prop(modifier, "shore_tint")
+    col.prop(modifier, "shore_opacity")
+    col.prop(modifier, "wispiness")
+
+    col = split.column()
+    col.label("Advanced:")
+    col.prop(modifier, "period")
+    col.prop(modifier, "finger")
+    col.prop(modifier, "edge_opacity")
+    col.prop(modifier, "edge_radius")