Match lamp export settings to PlasmaMax's settings.

korman/exporter/rtlight.py

@@ -36,11 +36,11 @@ class LightConverter:
 
     def _convert_point_lamp(self, bl, pl):
         print("    [OmniLightInfo '{}']".format(bl.name))
-        self._convert_shared_pointspot(bl, pl)
+        self._convert_attenuation(bl, pl)
 
     def _convert_spot_lamp(self, bl, pl):
         print("    [SpotLightInfo '{}']".format(bl.name))
-        self._convert_shared_pointspot(bl, pl)
+        self._convert_attenuation(bl, pl)
 
         # Spot lights have a few more things...
         spot_size = bl.spot_size
@@ -54,38 +54,45 @@ class LightConverter:
         else:
             pl.falloff = 1.0
 
-    def _convert_shared_pointspot(self, bl, pl):
+
-        # So sue me, this was taken from pyprp2...
+    def _convert_attenuation(self, bl, pl):
-        dist = bl.distance
+        intens = bl.energy
-        if bl.falloff_type == "LINEAR_QUADRATIC_WEIGHTED":
+
-            print("        Attenuation: Linear Quadratic Weighted")
+        if intens < 0:
-            pl.attenQuadratic = bl.quadratic_attenuation / dist
+            intens = -intens
-            pl.attenLinear = bl.linear_attenuation / dist
+
-            pl.attenConst = 1.0
+        if bl.use_sphere:
-        elif bl.falloff_type == "CONSTANT":
+            attenEnd = bl.distance
-            print("        Attenuation: Konstant")
+        else:
-            pl.attenQuadratic = 0.0
+            attenEnd = bl.distance * 2
-            pl.attenLinear = 0.0
+
-            pl.attenConst = 1.0
+        kFarPowerConst = 15.0 # From Plasma's plSillyLightKonstants
-        elif bl.falloff_type == "INVERSE_SQUARE":
+
-            print("        Attenuation: Inverse Square")
+        if bl.falloff_type == "CONSTANT":
-            pl.attenQuadratic = bl.quadratic_attenuation / dist
+            print("        Attenuation: No Falloff")
+            pl.attenConst = intens
             pl.attenLinear = 0.0
-            pl.attenConst = 1.0
+            pl.attenQuadratic = 0.0
+            pl.attenCutoff = attenEnd
         elif bl.falloff_type == "INVERSE_LINEAR":
             print("        Attenuation: Inverse Linear")
+            pl.attenConst = 1.0
+            pl.attenLinear = (intens * kFarPowerConst - 1.0) / attenEnd
+            if pl.attenLinear < 0:
+                pl.attenLinear = 0
             pl.attenQuadratic = 0.0
-            pl.attenLinear = bl.quadratic_attenuation / dist
+            pl.attenCutoff = attenEnd
+        elif bl.falloff_type == "INVERSE_SQUARE":
+            print("        Attenuation: Inverse Square")
             pl.attenConst = 1.0
+            pl.attenLinear = 0.0
+            pl.attenQuadratic = (intens * kFarPowerConst - 1.0) / (attenEnd * attenEnd)
+            if pl.attenQuadratic < 0:
+                pl.attenQuadratic = 0
+            pl.attenCutoff = attenEnd
         else:
             raise BlenderOptionNotSupportedError(bl.falloff_type)
 
-        if bl.use_sphere:
-            print("        Sphere Cutoff: {}".format(dist))
-            pl.attenCutoff = dist
-        else:
-            pl.attenCutoff = dist * 2
-
     def _convert_sun_lamp(self, bl, pl):
         print("    [DirectionalLightInfo '{}']".format(bl.name))
 
@@ -97,31 +104,38 @@ class LightConverter:
         self._converter_funcs[bl_light.type](bl_light, pl_light)
 
         # Light color nonsense
-        energy = bl_light.energy * 2
+        energy = bl_light.energy
         if bl_light.use_negative:
-            color = [(0.0 - i) * energy for i in bl_light.color]
+            diff_color = [(0.0 - i) * energy for i in bl_light.color]
+            spec_color = [(0.0 - i) for i in bl_light.color]
         else:
-            color = [i * energy for i in bl_light.color]
+            diff_color = [i * energy for i in bl_light.color]
-        color_str = "({:.4f}, {:.4f}, {:.4f})".format(color[0], color[1], color[2])
+            spec_color = [i for i in bl_light.color]
-        color.append(1.0)
+
+        diff_str = "({:.4f}, {:.4f}, {:.4f})".format(diff_color[0], diff_color[1], diff_color[2])
+        diff_color.append(energy)
+
+        spec_str = "({:.4f}, {:.4f}, {:.4f})".format(spec_color[0], spec_color[1], spec_color[2])
+        spec_color.append(energy)
 
         # Do we *only* want a shadow?
         shadow_only = bl_light.shadow_method != "NOSHADOW" and bl_light.use_only_shadow
 
         # Apply the colors
         if bl_light.use_diffuse and not shadow_only:
-            print("        Diffuse: {}".format(color_str))
+            print("        Diffuse: {}".format(diff_str))
-            pl_light.diffuse = hsColorRGBA(*color)
+            pl_light.diffuse = hsColorRGBA(*diff_color)
         else:
             print("        Diffuse: OFF")
-            pl_light.diffuse = hsColorRGBA(0.0, 0.0, 0.0, 1.0)
+            pl_light.diffuse = hsColorRGBA(0.0, 0.0, 0.0, energy)
+
         if bl_light.use_specular and not shadow_only:
-            print("        Specular: {}".format(color_str))
+            print("        Specular: {}".format(spec_str))
             pl_light.setProperty(plLightInfo.kLPHasSpecular, True)
-            pl_light.specular = hsColorRGBA(*color)
+            pl_light.specular = hsColorRGBA(*spec_color)
         else:
             print("        Specular: OFF")
-            pl_light.specular = hsColorRGBA(0.0, 0.0, 0.0, 1.0)
+            pl_light.specular = hsColorRGBA(0.0, 0.0, 0.0, energy)
 
         # Crazy flags
         rtlamp = bl_light.plasma_lamp