expose shadow bias and max distance wip

libraries/entities-renderer/src/RenderableZoneEntityItem.cpp

@@ -317,6 +317,8 @@ void ZoneEntityRenderer::updateKeySunFromEntity(const TypedEntityPointer& entity
     sunLight->setIntensity(_keyLightProperties.getIntensity());
     sunLight->setDirection(_lastRotation * _keyLightProperties.getDirection());
     sunLight->setCastShadows(_keyLightProperties.getCastShadows());
+    sunLight->setShadowsBiasScale(_keyLightProperties.getShadowBias());
+    sunLight->setShadowsMaxDistance(_keyLightProperties.getShadowMaxDistance());
 }
 
 void ZoneEntityRenderer::updateAmbientLightFromEntity(const TypedEntityPointer& entity) {

libraries/entities/src/EntityItemProperties.cpp

@@ -2746,6 +2746,8 @@ bool EntityItemProperties::getPropertyInfo(const QString& propertyName, EntityPr
             ADD_GROUP_PROPERTY_TO_MAP(PROP_KEYLIGHT_INTENSITY, KeyLight, keyLight, Intensity, intensity);
             ADD_GROUP_PROPERTY_TO_MAP(PROP_KEYLIGHT_DIRECTION, KeyLight, keylight, Direction, direction);
             ADD_GROUP_PROPERTY_TO_MAP(PROP_KEYLIGHT_CAST_SHADOW, KeyLight, keyLight, CastShadows, castShadows);
+            ADD_GROUP_PROPERTY_TO_MAP_WITH_RANGE(PROP_KEYLIGHT_SHADOW_BIAS, KeyLight, keyLight, ShadowBias, shadowBias, 0.0f, 1.0f);
+            ADD_GROUP_PROPERTY_TO_MAP_WITH_RANGE(PROP_KEYLIGHT_SHADOW_MAX_DISTANCE, KeyLight, keyLight, ShadowMaxDistance, shadowMaxDistance, 0.0f, 500.0f);
         }
         { // Ambient light
             ADD_GROUP_PROPERTY_TO_MAP(PROP_AMBIENT_LIGHT_INTENSITY, AmbientLight, ambientLight, Intensity, intensity);

libraries/entities/src/EntityPropertyFlags.h

@@ -159,6 +159,8 @@ enum EntityPropertyList {
     PROP_DERIVED_29,
     PROP_DERIVED_30,
     PROP_DERIVED_31,
+    PROP_DERIVED_32,
+    PROP_DERIVED_33,
 
     PROP_AFTER_LAST_ITEM,
 
@@ -248,39 +250,41 @@ enum EntityPropertyList {
     PROP_KEYLIGHT_INTENSITY = PROP_DERIVED_1,
     PROP_KEYLIGHT_DIRECTION = PROP_DERIVED_2,
     PROP_KEYLIGHT_CAST_SHADOW = PROP_DERIVED_3,
+    PROP_KEYLIGHT_SHADOW_BIAS = PROP_DERIVED_4,
+    PROP_KEYLIGHT_SHADOW_MAX_DISTANCE = PROP_DERIVED_5,
     // Ambient light
-    PROP_AMBIENT_LIGHT_INTENSITY = PROP_DERIVED_4,
+    PROP_AMBIENT_LIGHT_INTENSITY = PROP_DERIVED_6,
-    PROP_AMBIENT_LIGHT_URL = PROP_DERIVED_5,
+    PROP_AMBIENT_LIGHT_URL = PROP_DERIVED_7,
     // Skybox
-    PROP_SKYBOX_COLOR = PROP_DERIVED_6,
+    PROP_SKYBOX_COLOR = PROP_DERIVED_8,
-    PROP_SKYBOX_URL = PROP_DERIVED_7,
+    PROP_SKYBOX_URL = PROP_DERIVED_9,
     // Haze
-    PROP_HAZE_RANGE = PROP_DERIVED_8,
+    PROP_HAZE_RANGE = PROP_DERIVED_10,
-    PROP_HAZE_COLOR = PROP_DERIVED_9,
+    PROP_HAZE_COLOR = PROP_DERIVED_11,
-    PROP_HAZE_GLARE_COLOR = PROP_DERIVED_10,
+    PROP_HAZE_GLARE_COLOR = PROP_DERIVED_12,
-    PROP_HAZE_ENABLE_GLARE = PROP_DERIVED_11,
+    PROP_HAZE_ENABLE_GLARE = PROP_DERIVED_13,
-    PROP_HAZE_GLARE_ANGLE = PROP_DERIVED_12,
+    PROP_HAZE_GLARE_ANGLE = PROP_DERIVED_14,
-    PROP_HAZE_ALTITUDE_EFFECT = PROP_DERIVED_13,
+    PROP_HAZE_ALTITUDE_EFFECT = PROP_DERIVED_15,
-    PROP_HAZE_CEILING = PROP_DERIVED_14,
+    PROP_HAZE_CEILING = PROP_DERIVED_16,
-    PROP_HAZE_BASE_REF = PROP_DERIVED_15,
+    PROP_HAZE_BASE_REF = PROP_DERIVED_17,
-    PROP_HAZE_BACKGROUND_BLEND = PROP_DERIVED_16,
+    PROP_HAZE_BACKGROUND_BLEND = PROP_DERIVED_18,
-    PROP_HAZE_ATTENUATE_KEYLIGHT = PROP_DERIVED_17,
+    PROP_HAZE_ATTENUATE_KEYLIGHT = PROP_DERIVED_19,
-    PROP_HAZE_KEYLIGHT_RANGE = PROP_DERIVED_18,
+    PROP_HAZE_KEYLIGHT_RANGE = PROP_DERIVED_20,
-    PROP_HAZE_KEYLIGHT_ALTITUDE = PROP_DERIVED_19,
+    PROP_HAZE_KEYLIGHT_ALTITUDE = PROP_DERIVED_21,
     // Bloom
-    PROP_BLOOM_INTENSITY = PROP_DERIVED_20,
+    PROP_BLOOM_INTENSITY = PROP_DERIVED_22,
-    PROP_BLOOM_THRESHOLD = PROP_DERIVED_21,
+    PROP_BLOOM_THRESHOLD = PROP_DERIVED_23,
-    PROP_BLOOM_SIZE = PROP_DERIVED_22,
+    PROP_BLOOM_SIZE = PROP_DERIVED_24,
-    PROP_FLYING_ALLOWED = PROP_DERIVED_23,
+    PROP_FLYING_ALLOWED = PROP_DERIVED_25,
-    PROP_GHOSTING_ALLOWED = PROP_DERIVED_24,
+    PROP_GHOSTING_ALLOWED = PROP_DERIVED_26,
-    PROP_FILTER_URL = PROP_DERIVED_25,
+    PROP_FILTER_URL = PROP_DERIVED_27,
-    PROP_KEY_LIGHT_MODE = PROP_DERIVED_26,
+    PROP_KEY_LIGHT_MODE = PROP_DERIVED_28,
-    PROP_AMBIENT_LIGHT_MODE = PROP_DERIVED_27,
+    PROP_AMBIENT_LIGHT_MODE = PROP_DERIVED_29,
-    PROP_SKYBOX_MODE = PROP_DERIVED_28,
+    PROP_SKYBOX_MODE = PROP_DERIVED_30,
-    PROP_HAZE_MODE = PROP_DERIVED_29,
+    PROP_HAZE_MODE = PROP_DERIVED_31,
-    PROP_BLOOM_MODE = PROP_DERIVED_30,
+    PROP_BLOOM_MODE = PROP_DERIVED_32,
     // Avatar priority
-    PROP_AVATAR_PRIORITY = PROP_DERIVED_31,
+    PROP_AVATAR_PRIORITY = PROP_DERIVED_33,
 
     // Polyvox
     PROP_VOXEL_VOLUME_SIZE = PROP_DERIVED_0,

libraries/entities/src/KeyLightPropertyGroup.cpp

@@ -22,6 +22,8 @@ const float KeyLightPropertyGroup::DEFAULT_KEYLIGHT_INTENSITY = 1.0f;
 const float KeyLightPropertyGroup::DEFAULT_KEYLIGHT_AMBIENT_INTENSITY = 0.5f;
 const glm::vec3 KeyLightPropertyGroup::DEFAULT_KEYLIGHT_DIRECTION = { 0.0f, -1.0f, 0.0f };
 const bool KeyLightPropertyGroup::DEFAULT_KEYLIGHT_CAST_SHADOWS { false };
+const float KeyLightPropertyGroup::DEFAULT_KEYLIGHT_SHADOW_BIAS { 0.5f };
+const float KeyLightPropertyGroup::DEFAULT_KEYLIGHT_SHADOW_MAX_DISTANCE { 40.0f };
 
 void KeyLightPropertyGroup::copyToScriptValue(const EntityPropertyFlags& desiredProperties, QScriptValue& properties, 
     QScriptEngine* engine, bool skipDefaults, EntityItemProperties& defaultEntityProperties) const {
@@ -30,6 +32,8 @@ void KeyLightPropertyGroup::copyToScriptValue(const EntityPropertyFlags& desired
     COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_KEYLIGHT_INTENSITY, KeyLight, keyLight, Intensity, intensity);
     COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_KEYLIGHT_DIRECTION, KeyLight, keyLight, Direction, direction);
     COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_KEYLIGHT_CAST_SHADOW, KeyLight, keyLight, CastShadows, castShadows);
+    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_KEYLIGHT_SHADOW_BIAS, KeyLight, keyLight, ShadowBias, shadowBias);
+    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_KEYLIGHT_SHADOW_MAX_DISTANCE, KeyLight, keyLight, ShadowMaxDistance, shadowMaxDistance);
 }
 
 void KeyLightPropertyGroup::copyFromScriptValue(const QScriptValue& object, bool& _defaultSettings) {
@@ -37,6 +41,8 @@ void KeyLightPropertyGroup::copyFromScriptValue(const QScriptValue& object, bool
     COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(keyLight, intensity, float, setIntensity);
     COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(keyLight, direction, vec3, setDirection);
     COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(keyLight, castShadows, bool, setCastShadows);
+    COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(keyLight, shadowBias, float, setShadowBias);
+    COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(keyLight, shadowMaxDistance, float, setShadowMaxDistance);
 
     // legacy property support
     COPY_PROPERTY_FROM_QSCRIPTVALUE_GETTER(keyLightColor, u8vec3Color, setColor, getColor);
@@ -50,14 +56,18 @@ void KeyLightPropertyGroup::merge(const KeyLightPropertyGroup& other) {
     COPY_PROPERTY_IF_CHANGED(intensity);
     COPY_PROPERTY_IF_CHANGED(direction);
     COPY_PROPERTY_IF_CHANGED(castShadows);
+    COPY_PROPERTY_IF_CHANGED(shadowBias);
+    COPY_PROPERTY_IF_CHANGED(shadowMaxDistance);
 }
 
 void KeyLightPropertyGroup::debugDump() const {
     qCDebug(entities) << "   KeyLightPropertyGroup: ---------------------------------------------";
-    qCDebug(entities) << "        color:" << getColor(); // << "," << getColor()[1] << "," << getColor()[2];
+    qCDebug(entities) << "                   color:" << getColor();
-    qCDebug(entities) << "        intensity:" << getIntensity();
+    qCDebug(entities) << "               intensity:" << getIntensity();
-    qCDebug(entities) << "        direction:" << getDirection();
+    qCDebug(entities) << "               direction:" << getDirection();
-    qCDebug(entities) << "        castShadows:" << getCastShadows();
+    qCDebug(entities) << "             castShadows:" << getCastShadows();
+    qCDebug(entities) << "              shadowBias:" << getShadowBias();
+    qCDebug(entities) << "       shadowMaxDistance:" << getShadowMaxDistance();
 }
 
 void KeyLightPropertyGroup::listChangedProperties(QList<QString>& out) {
@@ -73,6 +83,12 @@ void KeyLightPropertyGroup::listChangedProperties(QList<QString>& out) {
     if (castShadowsChanged()) {
         out << "keyLight-castShadows";
     }
+    if (shadowBiasChanged()) {
+        out << "keyLight-shadowBias";
+    }
+    if (shadowMaxDistanceChanged()) {
+        out << "keyLight-shadowMaxDistance";
+    }
 }
 
 bool KeyLightPropertyGroup::appendToEditPacket(OctreePacketData* packetData,
@@ -88,6 +104,8 @@ bool KeyLightPropertyGroup::appendToEditPacket(OctreePacketData* packetData,
     APPEND_ENTITY_PROPERTY(PROP_KEYLIGHT_INTENSITY, getIntensity());
     APPEND_ENTITY_PROPERTY(PROP_KEYLIGHT_DIRECTION, getDirection());
     APPEND_ENTITY_PROPERTY(PROP_KEYLIGHT_CAST_SHADOW, getCastShadows());
+    APPEND_ENTITY_PROPERTY(PROP_KEYLIGHT_SHADOW_BIAS, getShadowBias());
+    APPEND_ENTITY_PROPERTY(PROP_KEYLIGHT_SHADOW_MAX_DISTANCE, getShadowMaxDistance());
 
     return true;
 }
@@ -103,11 +121,15 @@ bool KeyLightPropertyGroup::decodeFromEditPacket(EntityPropertyFlags& propertyFl
     READ_ENTITY_PROPERTY(PROP_KEYLIGHT_INTENSITY, float, setIntensity);
     READ_ENTITY_PROPERTY(PROP_KEYLIGHT_DIRECTION, glm::vec3, setDirection);
     READ_ENTITY_PROPERTY(PROP_KEYLIGHT_CAST_SHADOW, bool, setCastShadows);
+    READ_ENTITY_PROPERTY(PROP_KEYLIGHT_SHADOW_BIAS, float, setShadowBias);
+    READ_ENTITY_PROPERTY(PROP_KEYLIGHT_SHADOW_MAX_DISTANCE, float, setShadowMaxDistance);
 
     DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_KEYLIGHT_COLOR, Color);
     DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_KEYLIGHT_INTENSITY, Intensity);
     DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_KEYLIGHT_DIRECTION, Direction);
     DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_KEYLIGHT_CAST_SHADOW, CastShadows);
+    DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_KEYLIGHT_SHADOW_BIAS, ShadowBias);
+    DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_KEYLIGHT_SHADOW_MAX_DISTANCE, ShadowMaxDistance);
 
     processedBytes += bytesRead;
 
@@ -121,6 +143,8 @@ void KeyLightPropertyGroup::markAllChanged() {
     _intensityChanged = true;
     _directionChanged = true;
     _castShadowsChanged = true;
+    _shadowBiasChanged = true;
+    _shadowMaxDistanceChanged = true;
 }
 
 EntityPropertyFlags KeyLightPropertyGroup::getChangedProperties() const {
@@ -130,6 +154,8 @@ EntityPropertyFlags KeyLightPropertyGroup::getChangedProperties() const {
     CHECK_PROPERTY_CHANGE(PROP_KEYLIGHT_INTENSITY, intensity);
     CHECK_PROPERTY_CHANGE(PROP_KEYLIGHT_DIRECTION, direction);
     CHECK_PROPERTY_CHANGE(PROP_KEYLIGHT_CAST_SHADOW, castShadows);
+    CHECK_PROPERTY_CHANGE(PROP_KEYLIGHT_SHADOW_BIAS, shadowBias);
+    CHECK_PROPERTY_CHANGE(PROP_KEYLIGHT_SHADOW_MAX_DISTANCE, shadowMaxDistance);
 
     return changedProperties;
 }
@@ -139,6 +165,8 @@ void KeyLightPropertyGroup::getProperties(EntityItemProperties& properties) cons
     COPY_ENTITY_GROUP_PROPERTY_TO_PROPERTIES(KeyLight, Intensity, getIntensity);
     COPY_ENTITY_GROUP_PROPERTY_TO_PROPERTIES(KeyLight, Direction, getDirection);
     COPY_ENTITY_GROUP_PROPERTY_TO_PROPERTIES(KeyLight, CastShadows, getCastShadows);
+    COPY_ENTITY_GROUP_PROPERTY_TO_PROPERTIES(KeyLight, ShadowBias, getShadowBias);
+    COPY_ENTITY_GROUP_PROPERTY_TO_PROPERTIES(KeyLight, ShadowMaxDistance, getShadowMaxDistance);
 }
 
 bool KeyLightPropertyGroup::setProperties(const EntityItemProperties& properties) {
@@ -148,6 +176,8 @@ bool KeyLightPropertyGroup::setProperties(const EntityItemProperties& properties
     SET_ENTITY_GROUP_PROPERTY_FROM_PROPERTIES(KeyLight, Intensity, intensity, setIntensity);
     SET_ENTITY_GROUP_PROPERTY_FROM_PROPERTIES(KeyLight, Direction, direction, setDirection);
     SET_ENTITY_GROUP_PROPERTY_FROM_PROPERTIES(KeyLight, CastShadows, castShadows, setCastShadows);
+    SET_ENTITY_GROUP_PROPERTY_FROM_PROPERTIES(KeyLight, ShadowBias, shadowBias, setShadowBias);
+    SET_ENTITY_GROUP_PROPERTY_FROM_PROPERTIES(KeyLight, ShadowMaxDistance, shadowMaxDistance, setShadowMaxDistance);
 
     return somethingChanged;
 }
@@ -159,6 +189,8 @@ EntityPropertyFlags KeyLightPropertyGroup::getEntityProperties(EncodeBitstreamPa
     requestedProperties += PROP_KEYLIGHT_INTENSITY;
     requestedProperties += PROP_KEYLIGHT_DIRECTION;
     requestedProperties += PROP_KEYLIGHT_CAST_SHADOW;
+    requestedProperties += PROP_KEYLIGHT_SHADOW_BIAS;
+    requestedProperties += PROP_KEYLIGHT_SHADOW_MAX_DISTANCE;
 
     return requestedProperties;
 }
@@ -177,6 +209,8 @@ void KeyLightPropertyGroup::appendSubclassData(OctreePacketData* packetData, Enc
     APPEND_ENTITY_PROPERTY(PROP_KEYLIGHT_INTENSITY, getIntensity());
     APPEND_ENTITY_PROPERTY(PROP_KEYLIGHT_DIRECTION, getDirection());
     APPEND_ENTITY_PROPERTY(PROP_KEYLIGHT_CAST_SHADOW, getCastShadows());
+    APPEND_ENTITY_PROPERTY(PROP_KEYLIGHT_SHADOW_BIAS, getShadowBias());
+    APPEND_ENTITY_PROPERTY(PROP_KEYLIGHT_SHADOW_MAX_DISTANCE, getShadowMaxDistance());
 }
 
 int KeyLightPropertyGroup::readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead, 
@@ -191,6 +225,8 @@ int KeyLightPropertyGroup::readEntitySubclassDataFromBuffer(const unsigned char*
     READ_ENTITY_PROPERTY(PROP_KEYLIGHT_INTENSITY, float, setIntensity);
     READ_ENTITY_PROPERTY(PROP_KEYLIGHT_DIRECTION, glm::vec3, setDirection);
     READ_ENTITY_PROPERTY(PROP_KEYLIGHT_CAST_SHADOW, bool, setCastShadows);
+    READ_ENTITY_PROPERTY(PROP_KEYLIGHT_SHADOW_BIAS, float, setShadowBias);
+    READ_ENTITY_PROPERTY(PROP_KEYLIGHT_SHADOW_MAX_DISTANCE, float, setShadowMaxDistance);
 
     return bytesRead;
 }

libraries/entities/src/KeyLightPropertyGroup.h

@@ -37,6 +37,10 @@ class ReadBitstreamToTreeParams;
  *     are cast by avatars, plus {@link Entities.EntityProperties-Model|Model} and 
  *     {@link Entities.EntityProperties-Shape|Shape} entities that have their 
  *     <code>{@link Entities.EntityProperties|canCastShadow}</code> property set to <code>true</code>.
+ * @property {number} shadowBias=0.5 - The bias of the shadows cast by the light.  Use this to fine-tune your shadows to your scene
+ *     to prevent shadow acne and peter panning.  In the range <code>0.0</code> &ndash; <code>1.0</code>.
+ * @property {number} shadowMaxDistance=40.0 - The max distance from your view at which shadows will be computed.  Higher values will
+ *     cover more of your scene, but with less precision.  In the range <code>0.0</code> &ndash; <code>500.0</code>.
  */
 class KeyLightPropertyGroup : public PropertyGroup {
 public:
@@ -90,11 +94,15 @@ public:
     static const float DEFAULT_KEYLIGHT_AMBIENT_INTENSITY;
     static const glm::vec3 DEFAULT_KEYLIGHT_DIRECTION;
     static const bool DEFAULT_KEYLIGHT_CAST_SHADOWS;
+    static const float DEFAULT_KEYLIGHT_SHADOW_BIAS;
+    static const float DEFAULT_KEYLIGHT_SHADOW_MAX_DISTANCE;
 
     DEFINE_PROPERTY_REF(PROP_KEYLIGHT_COLOR, Color, color, glm::u8vec3, DEFAULT_KEYLIGHT_COLOR);
     DEFINE_PROPERTY(PROP_KEYLIGHT_INTENSITY, Intensity, intensity, float, DEFAULT_KEYLIGHT_INTENSITY);
     DEFINE_PROPERTY_REF(PROP_KEYLIGHT_DIRECTION, Direction, direction, glm::vec3, DEFAULT_KEYLIGHT_DIRECTION);
     DEFINE_PROPERTY(PROP_KEYLIGHT_CAST_SHADOW, CastShadows, castShadows, bool, DEFAULT_KEYLIGHT_CAST_SHADOWS);
+    DEFINE_PROPERTY(PROP_KEYLIGHT_SHADOW_BIAS, ShadowBias, shadowBias, float, DEFAULT_KEYLIGHT_SHADOW_BIAS);
+    DEFINE_PROPERTY(PROP_KEYLIGHT_SHADOW_MAX_DISTANCE, ShadowMaxDistance, shadowMaxDistance, float, DEFAULT_KEYLIGHT_SHADOW_MAX_DISTANCE);
 };
 
 #endif // hifi_KeyLightPropertyGroup_h

libraries/networking/src/udt/PacketHeaders.h

@@ -271,6 +271,7 @@ enum class EntityVersion : PacketVersion {
     ParticleShapeType,
     ParticleShapeTypeDeadlockFix,
     PrivateUserData,
+    ShadowBiasAndDistance,
 
     // Add new versions above here
     NUM_PACKET_TYPE,

scripts/simplifiedUI/system/assets/data/createAppTooltips.json

@@ -74,6 +74,12 @@
     "keyLight.castShadows": {
         "tooltip": "If enabled, shadows are cast. The entity or avatar casting the shadow must also have Cast Shadows enabled."
     },
+    "keyLight.shadowBias": {
+        "tooltip": "The bias of the shadows cast by the light.  Use this to fine-tune your shadows to your scene to prevent shadow acne and peter panning."
+    },
+    "keyLight.shadowMaxDistance": {
+        "tooltip": "The max distance from your view at which shadows will be computed."
+    },
     "skyboxMode": {
         "tooltip": "Configures the skybox in the zone. The skybox is a cube map image."
     },
@@ -135,7 +141,7 @@
         "tooltip": "The radius of bloom. The higher the value, the larger the bloom."
     },
     "avatarPriority": {
-        "tooltip":  "Alter Avatars' update priorities."
+        "tooltip": "Alter Avatars' update priorities."
     },
     "modelURL": {
         "tooltip": "A mesh model from an FBX or OBJ file."

scripts/simplifiedUI/system/html/js/entityProperties.js

@@ -300,6 +300,26 @@ const GROUPS = [
                 propertyID: "keyLight.castShadows",
                 showPropertyRule: { "keyLightMode": "enabled" },
             },
+            {
+                label: "Shadow Bias",
+                type: "number-draggable",
+                min: 0,
+                max: 1,
+                step: 0.01,
+                decimals: 2,
+                propertyID: "keyLight.shadowBias",
+                showPropertyRule: { "keyLightMode": "enabled" },
+            },
+            {
+                label: "Shadow Max Distance",
+                type: "number-draggable",
+                min: 0,
+                max: 500,
+                step: 0.1,
+                decimals: 2,
+                propertyID: "keyLight.shadowMaxDistance",
+                showPropertyRule: { "keyLightMode": "enabled" },
+            },
             {
                 label: "Skybox",
                 type: "dropdown",

scripts/system/create/assets/data/createAppTooltips.json

@@ -74,6 +74,12 @@
     "keyLight.castShadows": {
         "tooltip": "If enabled, shadows are cast. The entity or avatar casting the shadow must also have Cast Shadows enabled."
     },
+    "keyLight.shadowBias": {
+        "tooltip": "The bias of the shadows cast by the light.  Use this to fine-tune your shadows to your scene to prevent shadow acne and peter panning."
+    },
+    "keyLight.shadowMaxDistance": {
+        "tooltip": "The max distance from your view at which shadows will be computed."
+    },
     "skyboxMode": {
         "tooltip": "Configures the skybox in the zone. The skybox is a cube map image."
     },
@@ -135,7 +141,7 @@
         "tooltip": "The radius of bloom. The higher the value, the larger the bloom."
     },
     "avatarPriority": {
-        "tooltip":  "Alter Avatars' update priorities."
+        "tooltip": "Alter Avatars' update priorities."
     },
     "modelURL": {
         "tooltip": "A mesh model from an FBX or OBJ file."

scripts/system/create/entityProperties/html/js/entityProperties.js

@@ -300,6 +300,26 @@ const GROUPS = [
                 propertyID: "keyLight.castShadows",
                 showPropertyRule: { "keyLightMode": "enabled" },
             },
+            {
+                label: "Shadow Bias",
+                type: "number-draggable",
+                min: 0,
+                max: 1,
+                step: 0.01,
+                decimals: 2,
+                propertyID: "keyLight.shadowBias",
+                showPropertyRule: { "keyLightMode": "enabled" },
+            },
+            {
+                label: "Shadow Max Distance",
+                type: "number-draggable",
+                min: 0,
+                max: 500,
+                step: 0.1,
+                decimals: 2,
+                propertyID: "keyLight.shadowMaxDistance",
+                showPropertyRule: { "keyLightMode": "enabled" },
+            },
             {
                 label: "Skybox",
                 type: "dropdown",