private BabylonShadowGenerator ExportShadowGenerator(Node lightNode, BabylonScene babylonScene)
{
var maxLight = (lightNode.Object as Light);
var babylonShadowGenerator = new BabylonShadowGenerator();
RaiseMessage("Exporting shadow map", true, false, true);
babylonShadowGenerator.lightId = lightNode.GetGuid().ToString();
babylonShadowGenerator.mapSize = maxLight.GetMapSize(0, Interval.Forever);
var maxScene = Kernel.Scene;
var list = new List<string>();
var inclusion = maxLight._Light.ExclList.TestFlag(1); //NT_INCLUDE
var checkExclusionList = maxLight._Light.ExclList.TestFlag(4); //NT_AFFECT_SHADOWCAST
foreach (var meshNode in maxScene.NodesListBySuperClass(SuperClassID.GeometricObject))
{
if (meshNode._Node.CastShadows == 1)
{
var inList = maxLight._Light.ExclList.FindNode(meshNode._Node) != -1;
if (!checkExclusionList || (inList && inclusion) || (!inList && !inclusion))
{
list.Add(meshNode.GetGuid().ToString());
}
}
}
babylonShadowGenerator.renderList = list.ToArray();
babylonScene.ShadowGeneratorsList.Add(babylonShadowGenerator);
return babylonShadowGenerator;
}
private BabylonShadowGenerator ExportShadowGenerator(IINode lightNode, BabylonScene babylonScene)
{
var maxLight = (lightNode.ObjectRef as ILightObject);
var babylonShadowGenerator = new BabylonShadowGenerator();
RaiseMessage("Exporting shadow map", 2);
babylonShadowGenerator.lightId = lightNode.GetGuid().ToString();
babylonShadowGenerator.mapSize = maxLight.GetMapSize(0, Tools.Forever);
babylonShadowGenerator.usePoissonSampling = maxLight.AbsMapBias >= 1;
var list = new List<string>();
var inclusion = maxLight.ExclList.TestFlag(1); //NT_INCLUDE
var checkExclusionList = maxLight.ExclList.TestFlag(4); //NT_AFFECT_SHADOWCAST
foreach (var meshNode in Loader.Core.RootNode.NodesListBySuperClass(SClass_ID.Geomobject))
{
if (meshNode.CastShadows == 1)
{
var inList = maxLight.ExclList.FindNode(meshNode) != -1;
if (!checkExclusionList || (inList && inclusion) || (!inList && !inclusion))
{
list.Add(meshNode.GetGuid().ToString());
}
}
}
babylonShadowGenerator.renderList = list.ToArray();
babylonScene.ShadowGeneratorsList.Add(babylonShadowGenerator);
return babylonShadowGenerator;
}
private void GenerateShadowsGenerator(Light light)
{
var generator = new BabylonShadowGenerator
{
lightId = GetID(light.gameObject),
usePoissonSampling = light.shadows == LightShadows.Soft,
mapSize = 256 + 256 * QualitySettings.GetQualityLevel(),
bias = light.shadowBias / 10.0f
};
var renderList = new List<string>();
foreach (var gameObject in gameObjects)
{
var meshFilter = gameObject.GetComponent<MeshFilter>();
var renderer = gameObject.GetComponent<Renderer>();
if (meshFilter != null && renderer != null && renderer.shadowCastingMode != ShadowCastingMode.Off)
{
renderList.Add(GetID(gameObject));
continue;
}
var skinnedMesh = gameObject.GetComponent<SkinnedMeshRenderer>();
if (skinnedMesh != null && renderer != null && renderer.shadowCastingMode != ShadowCastingMode.Off)
{
renderList.Add(GetID(gameObject));
}
}
generator.renderList = renderList.ToArray();
babylonScene.ShadowGeneratorsList.Add(generator);
}
private BabylonShadowGenerator ExportShadowGenerator(IINode lightNode, BabylonScene babylonScene)
{
var maxLight = (lightNode.ObjectRef as ILightObject);
var babylonShadowGenerator = new BabylonShadowGenerator();
RaiseMessage("Exporting shadow map", 2);
babylonShadowGenerator.lightId = lightNode.GetGuid().ToString();
babylonShadowGenerator.mapSize = maxLight.GetMapSize(0, Tools.Forever);
babylonShadowGenerator.bias = lightNode.GetFloatProperty("babylonjs_shadows_bias", 0.00005f);
babylonShadowGenerator.forceBackFacesOnly = lightNode.GetBoolProperty("babylonjs_forcebackfaces");
var shadowsType = lightNode.GetStringProperty("babylonjs_shadows_type", "Blurred Variance");
switch (shadowsType)
{
case "Hard shadows":
break;
case "Poisson Sampling":
babylonShadowGenerator.usePoissonSampling = true;
break;
case "Variance":
babylonShadowGenerator.useVarianceShadowMap = true;
break;
case"Blurred Variance":
babylonShadowGenerator.useBlurVarianceShadowMap = true;
babylonShadowGenerator.blurScale = lightNode.GetFloatProperty("babylonjs_shadows_blurScale", 2);
babylonShadowGenerator.blurBoxOffset = lightNode.GetFloatProperty("babylonjs_shadows_blurBoxOffset", 1);
break;
}
var list = new List<string>();
var inclusion = maxLight.ExclList.TestFlag(1); //NT_INCLUDE
var checkExclusionList = maxLight.ExclList.TestFlag(4); //NT_AFFECT_SHADOWCAST
foreach (var meshNode in Loader.Core.RootNode.NodesListBySuperClass(SClass_ID.Geomobject))
{
#if MAX2017
if (meshNode.CastShadows)
#else
if (meshNode.CastShadows == 1)
#endif
{
var inList = maxLight.ExclList.FindNode(meshNode) != -1;
if (!checkExclusionList || (inList && inclusion) || (!inList && !inclusion))
{
list.Add(meshNode.GetGuid().ToString());
}
}
}
babylonShadowGenerator.renderList = list.ToArray();
babylonScene.ShadowGeneratorsList.Add(babylonShadowGenerator);
return babylonShadowGenerator;
}
private void GenerateShadowsGenerator(Light light, float progress)
{
var generator = new BabylonShadowGenerator
{
lightId = GetID(light.gameObject),
mapSize = exportationOptions.ShadowMapSize,
blurScale = exportationOptions.ShadowBlurScale,
bias = exportationOptions.ShadowMapBias,
forceBackFacesOnly = false
};
BabylonLightingFilter filter = (BabylonLightingFilter)exportationOptions.DefaultLightFilter;
switch (filter)
{
case BabylonLightingFilter.PoissonSampling:
generator.usePoissonSampling = true;
break;
case BabylonLightingFilter.VarianceShadowMap:
generator.useVarianceShadowMap = true;
break;
case BabylonLightingFilter.BlurVarianceShadowMap:
generator.useBlurVarianceShadowMap = true;
break;
case BabylonLightingFilter.SoftPoissonSampling:
generator.usePoissonSampling = (light.shadows == LightShadows.Soft);
break;
}
var renderList = new List<string>();
foreach (var gameObject in gameObjects)
{
var shadowBake = gameObject.GetComponent<BabylonShadowBake>();
bool realtimeShadows = (shadowBake != null && shadowBake.shadowOption == BabylonShadowOptions.Realtime);
if (realtimeShadows)
{
var renderer = gameObject.GetComponent<Renderer>();
var meshFilter = gameObject.GetComponent<MeshFilter>();
if (meshFilter != null && renderer != null && renderer.shadowCastingMode != ShadowCastingMode.Off)
{
renderList.Add(GetID(gameObject));
continue;
}
var skinnedMesh = gameObject.GetComponent<SkinnedMeshRenderer>();
if (skinnedMesh != null && renderer != null && renderer.shadowCastingMode != ShadowCastingMode.Off)
{
renderList.Add(GetID(gameObject));
}
}
}
generator.renderList = renderList.ToArray();
babylonScene.ShadowGeneratorsList.Add(generator);
}
private void GenerateShadowsGenerator(BabylonLight babylonLight, Light light, float progress)
{
var shadows = light.gameObject.GetComponent <UnityEditor.ShadowGenerator>();
if (shadows != null && shadows.isActiveAndEnabled)
{
if (babylonLight is BabylonDirectionalLight)
{
((BabylonDirectionalLight)babylonLight).shadowOrthoScale = shadows.shadowOrthoScale;
}
float strength = light.shadowStrength * shadows.shadowStrengthScale;
var generator = new BabylonExport.Entities.BabylonShadowGenerator
{
lightId = GetID(light.gameObject),
bias = shadows.shadowMapBias,
mapSize = shadows.shadowMapSize,
darkness = (1.0f - strength),
depthScale = shadows.shadowDepthScale,
blurScale = shadows.shadowBlurScale,
blurBoxOffset = shadows.shadowBlurOffset,
forceBackFacesOnly = shadows.forceBackFacesOnly
};
switch (shadows.shadowMapFilter)
{
case BabylonLightingFilter.PoissonSampling:
generator.usePoissonSampling = true;
break;
case BabylonLightingFilter.ExponentialShadowMap:
generator.useExponentialShadowMap = true;
break;
case BabylonLightingFilter.BlurExponentialShadowMap:
generator.useBlurExponentialShadowMap = true;
break;
}
// Light Shadow Generator Render List
var renderList = new List <string>();
foreach (var gameObject in gameObjects)
{
if (gameObject.layer != ExporterWindow.PrefabIndex)
{
if (!gameObject.IsLightapStatic())
{
var shadowmap = gameObject.GetComponent <ShadowMap>();
if (shadowmap != null && shadowmap.runtimeShadows == BabylonEnabled.Enabled)
{
var renderer = gameObject.GetComponent <Renderer>();
var meshFilter = gameObject.GetComponent <MeshFilter>();
if (meshFilter != null && renderer != null && renderer.shadowCastingMode != ShadowCastingMode.Off)
{
renderList.Add(GetID(gameObject));
continue;
}
var skinnedMesh = gameObject.GetComponent <SkinnedMeshRenderer>();
if (skinnedMesh != null && renderer != null && renderer.shadowCastingMode != ShadowCastingMode.Off)
{
renderList.Add(GetID(gameObject));
}
}
}
}
}
if (renderList.Count > 0)
{
generator.renderList = renderList.ToArray();
babylonScene.ShadowGeneratorsList.Add(generator);
}
}
}
private void GenerateShadowsGenerator(BabylonLight babylonLight, Light light, float progress)
{
BabylonLightingFilter shadowMapFilter = BabylonLightingFilter.BlurCloseExponentialShadowMap;
int shadowMapSize = 1024;
float shadowMapBias = 0.00005f;
float normalMapBias = 0.0f;
float shadowNearPlane = 0.1f;
float shadowFarPlane = 100.0f;
bool shadowKernelBlur = false;
float shadowBlurKernel = 1.0f;
float shadowBlurScale = 2.0f;
float shadowBlurOffset = 0.0f;
float shadowOrthoScale = 0.1f;
float shadowStrengthScale = 1.0f;
float shadowDepthScale = 50.0f;
float frustumEdgeFalloff = 0.0f;
bool forceBackFacesOnly = true;
bool transparencyShadow = false;
float contactHardening = 0.1f;
var shadows = light.gameObject.GetComponent <UnityEditor.ShadowGenerator>();
if (shadows != null && shadows.isActiveAndEnabled)
{
shadowMapSize = shadows.shadowMapSize;
shadowMapBias = shadows.shadowMapBias;
normalMapBias = shadows.shadowNormBias;
shadowNearPlane = shadows.shadowNearPlane;
shadowFarPlane = shadows.shadowFarPlane;
shadowMapFilter = shadows.shadowMapFilter;
shadowKernelBlur = shadows.shadowKernelBlur;
shadowBlurKernel = shadows.shadowBlurKernel;
shadowBlurScale = shadows.shadowBlurScale;
shadowBlurOffset = shadows.shadowBlurOffset;
shadowOrthoScale = shadows.shadowOrthoScale;
shadowStrengthScale = shadows.shadowStrengthScale;
shadowDepthScale = shadows.shadowDepthScale;
forceBackFacesOnly = shadows.forceBackFacesOnly;
transparencyShadow = shadows.transparencyShadow;
contactHardening = shadows.contactHardening;
frustumEdgeFalloff = shadows.frustumEdgeFalloff;
}
babylonLight.shadowMinZ = shadowNearPlane;
babylonLight.shadowMaxZ = shadowFarPlane;
if (babylonLight is BabylonDirectionalLight)
{
((BabylonDirectionalLight)babylonLight).shadowOrthoScale = shadowOrthoScale;
}
float strength = light.shadowStrength * shadowStrengthScale;
var generator = new BabylonExport.Entities.BabylonShadowGenerator
{
lightId = GetID(light.gameObject),
bias = shadowMapBias,
normalBias = normalMapBias,
mapSize = shadowMapSize,
darkness = (1.0f - strength),
depthScale = shadowDepthScale,
blurScale = shadowBlurScale,
blurKernel = shadowBlurKernel,
blurBoxOffset = shadowBlurOffset,
useKernelBlur = shadowKernelBlur,
forceBackFacesOnly = forceBackFacesOnly,
transparencyShadow = transparencyShadow,
frustumEdgeFalloff = frustumEdgeFalloff,
contactHardeningLightSizeUVRatio = contactHardening
};
switch (shadowMapFilter)
{
case BabylonLightingFilter.PoissonSampling:
generator.usePoissonSampling = true;
break;
case BabylonLightingFilter.ExponentialShadowMap:
generator.useExponentialShadowMap = true;
break;
case BabylonLightingFilter.BlurExponentialShadowMap:
generator.useBlurExponentialShadowMap = true;
break;
case BabylonLightingFilter.CloseExponentialShadowMap:
generator.useCloseExponentialShadowMap = true;
break;
case BabylonLightingFilter.BlurCloseExponentialShadowMap:
generator.useBlurCloseExponentialShadowMap = true;
break;
case BabylonLightingFilter.PercentageCloserFiltering:
generator.usePercentageCloserFiltering = true;
break;
case BabylonLightingFilter.ContactHardeningShadowMap:
generator.useContactHardeningShadow = true;
break;
}
// ..
// Light Shadow Generator Render List (TODO: Support Specific Meshes Or Layers Or Tags)
// ..
var renderList = new List <string>();
renderList.Add(rootInstance.id);
foreach (var gameObject in gameObjects)
{
if (gameObject.layer != ExporterWindow.PrefabIndex)
{
if (!gameObject.IsLightapStatic())
{
var meshFilter = gameObject.GetComponent <MeshFilter>();
var meshRender = gameObject.GetComponent <MeshRenderer>();
if (meshFilter != null && meshRender != null && meshRender.enabled == true && meshRender.shadowCastingMode != ShadowCastingMode.Off)
{
renderList.Add(GetID(gameObject));
continue;
}
var skinnedMesh = gameObject.GetComponent <SkinnedMeshRenderer>();
if (skinnedMesh != null && skinnedMesh.enabled == true && skinnedMesh.shadowCastingMode != ShadowCastingMode.Off)
{
renderList.Add(GetID(gameObject));
}
}
}
}
generator.renderList = renderList.ToArray();
babylonScene.ShadowGeneratorsList.Add(generator);
}
