public void SetSharedMaterials(Material newSharedMaterial)
{
var surfaceCount = SGT_SurfaceConfiguration_.SurfaceCount(configuration);
for (var i = 0; i < surfaceCount; i++)
{
SetSharedMaterial(newSharedMaterial, i);
}
}
private void UpdateMaterial()
{
var targetSurfaceTechnique = "Variant";
var targetAtmosphereTechnique = "Variant";
if (starObserver != null)
{
if (InsideAtmosphere(starObserver.transform.position) == false)
{
targetSurfaceTechnique += "Outer";
targetAtmosphereTechnique += "Outer";
}
}
if (atmosphereSurfacePerPixel == true)
{
targetSurfaceTechnique += "PerPixel";
}
// Update surface?
if (surfaceMaterials == null || (surfaceTechnique != targetSurfaceTechnique || SGT_ArrayHelper.ContainsSomething(surfaceMaterials) == false || surfaceMaterials.Length != SGT_SurfaceConfiguration_.SurfaceCount(SurfaceConfiguration)))
{
SGT_Helper.DestroyObjects(surfaceMaterials);
surfaceTechnique = targetSurfaceTechnique;
surfaceMaterials = SGT_SurfaceConfiguration_.CreateMaterials(surfaceMultiMesh.Configuration, "Hidden/SGT/StarSurface/" + surfaceTechnique, surfaceRenderQueue);
}
else
{
SGT_Helper.SetRenderQueues(surfaceMaterials, surfaceRenderQueue);
}
// Update atmosphere?
if (atmosphereTechnique != targetAtmosphereTechnique || atmosphereMaterial == null)
{
SGT_Helper.DestroyObject(atmosphereMaterial);
atmosphereTechnique = targetAtmosphereTechnique;
atmosphereMaterial = SGT_Helper.CreateMaterial("Hidden/SGT/StarAtmosphere/" + atmosphereTechnique, atmosphereRenderQueue);
}
else
{
SGT_Helper.SetRenderQueue(atmosphereMaterial, atmosphereRenderQueue);
}
}
private void UpdateTechnique()
{
var targetSurfaceTechnique = "Variant";
var targetAtmosphereTechnique = string.Empty;
var tagetCloudsTechnique = string.Empty;
if (atmosphere == true)
{
targetSurfaceTechnique += "Atmosphere";
targetAtmosphereTechnique = "Variant";
if (planetObserver != null)
{
if (InsideAtmosphere(planetObserver.transform.position) == false)
{
targetSurfaceTechnique += "Outer";
targetAtmosphereTechnique += "Outer";
}
}
if (atmosphereScattering == true)
{
//targetSurfaceTechnique += "Scattering";
targetAtmosphereTechnique += "Scattering";
}
}
if (clouds == true)
{
tagetCloudsTechnique = "Variant";
}
if (surfaceTextureNormal.ContainsSomething == true)
{
targetSurfaceTechnique += "Normal";
}
if (surfaceTextureSpecular.ContainsSomething == true)
{
targetSurfaceTechnique += "Specular";
}
if (shadow == true)
{
switch (shadowCasterType)
{
case SGT_ShadowOccluder.Ring:
{
targetSurfaceTechnique += "RingShadow";
if (atmosphere == true)
{
targetAtmosphereTechnique += "RingShadow";
}
if (clouds == true)
{
tagetCloudsTechnique += "RingShadow";
}
}
break;
case SGT_ShadowOccluder.Planet:
{
targetSurfaceTechnique += "PlanetShadow";
if (atmosphere == true)
{
targetAtmosphereTechnique += "PlanetShadow";
}
if (clouds == true)
{
tagetCloudsTechnique += "PlanetShadow";
}
}
break;
}
}
if (surfaceTextureDetail != null)
{
targetSurfaceTechnique += "Detail";
}
if (surfaceMaterials != null && (surfaceTechnique != targetSurfaceTechnique || SGT_ArrayHelper.ContainsSomething(surfaceMaterials) == false || surfaceMaterials.Length != SGT_SurfaceConfiguration_.SurfaceCount(SurfaceConfiguration)))
{
surfaceMaterials = SGT_Helper.DestroyObjects(surfaceMaterials);
}
if (atmosphereMaterial != null && (atmosphere == false || atmosphereTechnique != targetAtmosphereTechnique))
{
atmosphereMaterial = SGT_Helper.DestroyObject(atmosphereMaterial);
}
if (cloudsMaterials != null && (clouds == false || cloudsTechnique != tagetCloudsTechnique || SGT_ArrayHelper.ContainsSomething(cloudsMaterials) == false || cloudsMaterials.Length != SGT_SurfaceConfiguration_.SurfaceCount(CloudsConfiguration)))
{
cloudsMaterials = SGT_Helper.DestroyObjects(cloudsMaterials);
}
// Create planet surface shaders?
if (surfaceMaterials == null)
{
updateShader |= ShaderFlags.Surface;
surfaceTechnique = targetSurfaceTechnique;
surfaceMaterials = SGT_SurfaceConfiguration_.CreateMaterials(SurfaceConfiguration, "Hidden/SGT/PlanetSurface/" + surfaceTechnique, surfaceRenderQueue);
}
else
{
SGT_Helper.SetRenderQueues(surfaceMaterials, surfaceRenderQueue);
}
// Create planet atmosphere shaders?
if (atmosphere == true)
{
if (atmosphereMaterial == null)
{
updateShader |= ShaderFlags.Atmosphere;
atmosphereTechnique = targetAtmosphereTechnique;
atmosphereMaterial = SGT_Helper.CreateMaterial("Hidden/SGT/PlanetAtmosphere/" + atmosphereTechnique, atmosphereRenderQueue);
}
else
{
SGT_Helper.SetRenderQueue(atmosphereMaterial, atmosphereRenderQueue);
}
}
// Create planet cloud shaders?
if (clouds == true)
{
if (cloudsMaterials == null)
{
updateShader |= ShaderFlags.Clouds;
cloudsTechnique = tagetCloudsTechnique;
cloudsMaterials = SGT_SurfaceConfiguration_.CreateMaterials(CloudsConfiguration, "Hidden/SGT/PlanetClouds/" + cloudsTechnique, atmosphereRenderQueue);
}
else
{
SGT_Helper.SetRenderQueues(cloudsMaterials, atmosphereRenderQueue);
}
}
else
{
if (cloudsMaterials != null)
{
cloudsMaterials = SGT_Helper.DestroyObjects(cloudsMaterials);
}
}
}
private System.Collections.IEnumerator Update_Coroutine()
{
if (patchIndices == null)
{
RebuildPatchIndices();
}
sideCombinedMeshes = new Mesh[6][];
// Main loop
for (;;)
{
if (sides != null)
{
var sgtVector3 = new SGT_FillVector3();
SendMessage("FillSurfaceObserverPosition", sgtVector3, SendMessageOptions.DontRequireReceiver);
surfaceObserverPosition = sgtVector3.Vector3;
var splitList = new PatchList();
// Begin budgeting
budgetUsage.Reset();
budgetUsage.Start();
// Update all patches
for (var i = 0; i < sides.Length; i++)
{
UpdatePatch(sides[i], surfaceObserverPosition, splitList);
/* Defer operation? */ if (OverBudgetCheck("Update Patches") == true)
{
yield return(new WaitForEndOfFrame()); budgetUsage.Reset(); budgetUsage.Start();
}
}
// Split patches?
if (splitList.Count > 0)
{
var splitCount = 0;
for (var i = 0; i < splitList.Count; i++)
{
splitCount += 1;
SplitPatch(splitList[i]);
if (splitCount == maxSplitsPerFrame)
{
splitCount = 0;
/* Defer operation? */ if (OverBudgetCheck("Split Patches") == true)
{
yield return(new WaitForEndOfFrame()); budgetUsage.Reset(); budgetUsage.Start();
}
}
}
}
// Rebuild mesh?
if (rebuild == true)
{
rebuild = false;
var totalSurfaces = SGT_SurfaceConfiguration_.SurfaceCount(surfaceConfiguration);
var newSideCombinedMeshes = new Mesh[6][];
for (var surfaceIndex = 0; surfaceIndex < totalSurfaces; surfaceIndex++)
{
var buildList = new PatchList();
// Begin budgeting
budgetUsage.Reset();
budgetUsage.Start();
switch (surfaceConfiguration)
{
case SGT_SurfaceConfiguration.Sphere:
{
for (var i = 0; i < 6; i++)
{
BuildPatch(sides[i], buildList);
/* Defer operation? */ if (OverBudgetCheck("Build Patches") == true)
{
yield return(new WaitForEndOfFrame()); budgetUsage.Reset(); budgetUsage.Start();
}
}
}
break;
case SGT_SurfaceConfiguration.Cube:
{
BuildPatch(sides[surfaceIndex], buildList);
/* Defer operation? */ if (OverBudgetCheck("Build Patches") == true)
{
yield return(new WaitForEndOfFrame()); budgetUsage.Reset(); budgetUsage.Start();
}
}
break;
}
// Stitch patches
var stitchCount = 0;
for (var i = 0; i < buildList.Count; i++)
{
stitchCount += 1;
StitchPatch(buildList[i]);
if (stitchCount == maxStitchesPerFrame)
{
stitchCount = 0;
/* Defer operation? */ if (OverBudgetCheck("Sitch Patches") == true)
{
yield return(new WaitForEndOfFrame()); budgetUsage.Reset(); budgetUsage.Start();
}
}
}
var combinedMeshesList = new MeshList();
var combineFrom = 0;
var patchesPerMesh = verticesPerMesh / ((patchResolution + 1) * (patchResolution + 1));
// Create sub meshes
for (var i = 0; i < buildList.Count; i++)
{
var combineCount = (i + 1) - combineFrom;
if (combineCount == patchesPerMesh || i == (buildList.Count - 1))
{
var combinedMesh = CombinePatches(buildList, combineFrom, combineFrom + combineCount);
combinedMeshesList.Add(combinedMesh);
combineFrom = i + 1;
/* Defer operation? */ if (OverBudgetCheck("Combine Patches") == true)
{
yield return(new WaitForEndOfFrame()); budgetUsage.Reset(); budgetUsage.Start();
}
}
}
var combinedMeshes = combinedMeshesList.ToArray();
// Append index to name?
if (combinedMeshes.Length > 1)
{
for (var i = 0; i < combinedMeshes.Length; i++)
{
combinedMeshes[i].name = "(" + (i + 1) + "/" + combinedMeshes.Length + ") " + combinedMeshes[i].name;
}
}
newSideCombinedMeshes[surfaceIndex] = combinedMeshes;
}
// Delete old meshes and swap
for (var i = 0; i < 6; i++)
{
SGT_Helper.DestroyObjects(sideCombinedMeshes[i]);
}
sideCombinedMeshes = newSideCombinedMeshes;
var generatedSurfaceMultiMesh = new SGT_SurfaceMultiMesh();
generatedSurfaceMultiMesh.Configuration = surfaceConfiguration;
for (var i = 0; i < totalSurfaces; i++)
{
generatedSurfaceMultiMesh.ReplaceAll(sideCombinedMeshes[i], i);
}
SendMessage("SetSurfaceMultiMesh", generatedSurfaceMultiMesh, SendMessageOptions.DontRequireReceiver);
SendMessage("TessellationFinished", this, SendMessageOptions.DontRequireReceiver);
}
}
if (minUpdateInterval > 0.0f)
{
yield return(new WaitForSeconds(minUpdateInterval));
}
else
{
yield return(new WaitForEndOfFrame());
}
}
}
