private static bool UpdateMesh(CSGModel model,
string baseName,
GeneratedMeshDescription meshDescription,
RenderSurfaceType renderSurfaceType,
ref bool outputHasGeneratedNormals,
ref Mesh sharedMesh,
bool editorOnly = false)
{
// create our arrays on the C# side with the correct size
GeneratedMeshContents generatedMesh;
var startGetModelMeshesTime = EditorApplication.timeSinceStartup;
{
generatedMesh = External.GetModelMesh(model.modelNodeID, meshDescription);
if (generatedMesh == null)
{
return(false);
}
}
getModelMeshesTime += EditorApplication.timeSinceStartup - startGetModelMeshesTime;
UpdateMesh(baseName,
generatedMesh,
meshDescription,
renderSurfaceType,
ref outputHasGeneratedNormals,
ref sharedMesh,
editorOnly);
return(true);
}
private ChiselColliderComponents CreateColliderComponents(ChiselModel model, GeneratedMeshDescription meshDescription)
{
var gameObject = CreateComponentGameObject(model, GeneratedMeshColliderName, typeof(MeshCollider));
var colliderComponents = new ChiselColliderComponents
{
meshCollider = gameObject.GetComponent <MeshCollider>(),
gameObject = gameObject,
transform = gameObject.transform
};
return(colliderComponents);
}
private CSGRenderComponents CreateRenderComponents(CSGModel model, GeneratedMeshDescription meshDescription)
{
var gameObject = CreateComponentGameObject(model, GeneratedMeshRendererName, typeof(MeshFilter), typeof(MeshRenderer));
var renderComponents = new CSGRenderComponents
{
meshFilter = gameObject.GetComponent <MeshFilter>(),
meshRenderer = gameObject.GetComponent <MeshRenderer>(),
gameObject = gameObject,
transform = gameObject.transform
};
return(renderComponents);
}
public bool RetrieveUnityMesh(ChiselModel model, GeneratedMeshDescription meshDescription, UnityEngine.Mesh sharedMesh)
{
// Retrieve the generatedMesh, and store it in the Unity Mesh
model.generatedMeshContents = model.Node.GetGeneratedMesh(meshDescription, model.generatedMeshContents);
if (model.generatedMeshContents == null)
{
return(false);
}
model.generatedMeshContents.CopyTo(sharedMesh);
SetHasLightmapUVs(sharedMesh, false);
return(true);
}
private static bool ValidateMesh(GeneratedMeshDescription meshDescription)
{
var indexCount = meshDescription.indexCount;
var vertexCount = meshDescription.vertexCount;
if ((vertexCount <= 0 || vertexCount > MaxVertexCount) || (indexCount <= 0))
{
if (vertexCount > 0 && indexCount > 0)
{
Debug.LogError("Mesh has too many vertices (vertexCount > " + MaxVertexCount + ")");
}
return(false);
}
return(true);
}
public static bool UpdateMesh(string baseName,
GeneratedMeshContents generatedMesh,
GeneratedMeshDescription inputMeshDescription,
RenderSurfaceType renderSurfaceType,
ref bool outputHasGeneratedNormals,
ref Mesh sharedMesh,
bool editorOnly)
{
var startUpdateMeshTime = EditorApplication.timeSinceStartup;
{
MeshInstanceManager.ClearOrCreateMesh(baseName, editorOnly, ref outputHasGeneratedNormals, ref sharedMesh);
// finally, we start filling our (sub)meshes using the C# arrays
sharedMesh.vertices = generatedMesh.positions;
if (generatedMesh.normals != null)
{
sharedMesh.normals = generatedMesh.normals;
}
if (generatedMesh.tangents != null)
{
sharedMesh.tangents = generatedMesh.tangents;
}
// if (generatedMesh.colors != null) sharedMesh.colors = generatedMesh.colors;
if (generatedMesh.uv0 != null)
{
sharedMesh.uv = generatedMesh.uv0;
}
// fill the mesh with the given indices
sharedMesh.SetTriangles(generatedMesh.indices, 0, calculateBounds: true);
//sharedMesh.RecalculateBounds();
//sharedMesh.bounds = generatedMesh.bounds; // why doesn't this work?
}
updateMeshTime += EditorApplication.timeSinceStartup - startUpdateMeshTime;
if (renderSurfaceType != RenderSurfaceType.Normal)
{
outputHasGeneratedNormals = ((inputMeshDescription.meshQuery.UsedVertexChannels & VertexChannelFlags.Normal) != 0);
}
return(true);
}
private static bool UpdateMesh(CSGModel model,
GeneratedMeshDescription meshDescription,
RenderSurfaceType renderSurfaceType,
ref GeneratedMeshContents outputGeneratedMeshContents,
ref bool outputHasGeneratedNormals,
ref Mesh sharedMesh)
{
// create our arrays on the C# side with the correct size
GeneratedMeshContents generatedMesh;
var startGetModelMeshesTime = EditorApplication.timeSinceStartup;
{
generatedMesh = External.GetModelMesh(model.modelNodeID, meshDescription);
if (generatedMesh == null)
{
return(false);
}
}
getModelMeshesTime += EditorApplication.timeSinceStartup - startGetModelMeshesTime;
UpdateMesh(generatedMesh,
meshDescription,
renderSurfaceType,
ref outputHasGeneratedNormals,
ref sharedMesh);
/*
#if UNITY_2018_3_OR_NEWER
* var modelGameObject = model.gameObject;
* var prefabStage = UnityEditor.Experimental.SceneManagement.PrefabStageUtility.GetPrefabStage(modelGameObject);
* if (prefabStage != null && string.IsNullOrEmpty(AssetDatabase.GetAssetPath(sharedMesh)))
* {
* var prefabAssetPath = prefabStage.prefabAssetPath;
* if (!string.IsNullOrEmpty(prefabAssetPath))
* AssetDatabase.AddObjectToAsset(sharedMesh, prefabAssetPath);
* UnityEditor.SceneManagement.EditorSceneManager.MarkSceneDirty(modelGameObject.scene);
* }
#endif
*/
outputGeneratedMeshContents = generatedMesh;
return(true);
}
static int MeshDescriptionSorter(GeneratedMeshDescription x, GeneratedMeshDescription y)
{
if (x.meshQuery.LayerParameterIndex != y.meshQuery.LayerParameterIndex)
{
return(((int)x.meshQuery.LayerParameterIndex) - ((int)y.meshQuery.LayerParameterIndex));
}
if (x.meshQuery.LayerQuery != y.meshQuery.LayerQuery)
{
return(((int)x.meshQuery.LayerQuery) - ((int)y.meshQuery.LayerQuery));
}
if (x.surfaceParameter != y.surfaceParameter)
{
return(((int)x.surfaceParameter) - ((int)y.surfaceParameter));
}
if (x.geometryHashValue != y.geometryHashValue)
{
return(((int)x.geometryHashValue) - ((int)y.geometryHashValue));
}
return(0);
}
public void Update(ChiselModel model, GeneratedMeshDescription meshDescription)
{
// Retrieve the generatedMesh, and store it in the Unity Mesh
var generatedMeshContents = model.Node.GetGeneratedMesh(meshDescription);
if (generatedMeshContents == null || generatedMeshContents.indices.Length == 0)
{
if (sharedMesh.vertexCount > 0)
{
sharedMesh.Clear(keepVertexLayout: true);
}
}
else
{
sharedMesh.CopyFromPositionOnly(generatedMeshContents);
}
if (meshCollider.sharedMesh != sharedMesh)
{
meshCollider.sharedMesh = sharedMesh;
}
meshCollider.enabled = sharedMesh.vertexCount > 0;
generatedMeshContents?.Dispose();
}
private void UpdateRenderComponents(CSGModel model, ModelState modelState, GeneratedMeshDescription meshDescription, CSGRenderComponents renderComponents)
{
var meshRenderer = renderComponents.meshRenderer;
#if UNITY_EDITOR
updateMeshRenderers.Add(meshRenderer);
#endif
var query = meshDescription.meshQuery.LayerQuery;
meshRenderer.receiveShadows = ((query & LayerUsageFlags.ReceiveShadows) == LayerUsageFlags.ReceiveShadows);
switch (query & (LayerUsageFlags.Renderable | LayerUsageFlags.CastShadows))
{
case LayerUsageFlags.None: meshRenderer.enabled = false; break;
case LayerUsageFlags.Renderable: meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off; meshRenderer.enabled = true; break;
case LayerUsageFlags.CastShadows: meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.ShadowsOnly; meshRenderer.enabled = true; break;
case LayerUsageFlags.RenderCastShadows: meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On; meshRenderer.enabled = true; break;
}
#if UNITY_EDITOR
UnityEditor.EditorUtility.SetSelectedRenderState(meshRenderer, UnityEditor.EditorSelectedRenderState.Hidden);
#endif
}
private static HelperSurfaceDescription GenerateHelperSurfaceDescription(GeneratedMeshes meshContainer, CSGModel model, ModelSettingsFlags modelSettings, GeneratedMeshDescription meshDescription, RenderSurfaceType renderSurfaceType)
{
HelperSurfaceDescription helperSurfaceDescription = MeshInstanceManager.CreateHelperSurfaceDescription(meshContainer, modelSettings, meshDescription, renderSurfaceType);
helperSurfaceDescription.MeshDescription = meshDescription;
if (!UpdateMesh(model, renderSurfaceMeshNames[(int)renderSurfaceType],
helperSurfaceDescription.MeshDescription,
helperSurfaceDescription.RenderSurfaceType,
ref helperSurfaceDescription.HasGeneratedNormals,
ref helperSurfaceDescription.SharedMesh,
editorOnly: true))
{
return(null);
}
return(helperSurfaceDescription);
}
private static bool TryGetHelperSurfaceDescription(GeneratedMeshes meshContainer, CSGModel model, ModelSettingsFlags modelSettings, GeneratedMeshDescription meshDescription, RenderSurfaceType renderSurfaceType, out HelperSurfaceDescription helperSurfaceDescription)
{
var startGetMeshInstanceTime = EditorApplication.timeSinceStartup;
helperSurfaceDescription = MeshInstanceManager.GetHelperSurfaceDescription(meshContainer, modelSettings, meshDescription, renderSurfaceType);
getMeshInstanceTime += EditorApplication.timeSinceStartup - startGetMeshInstanceTime;
if (helperSurfaceDescription != null &&
meshDescription == helperSurfaceDescription.MeshDescription &&
helperSurfaceDescription.SharedMesh &&
helperSurfaceDescription.IsValid())
{
return(true);
}
helperSurfaceDescription = null;
return(true);
}
private static GeneratedMeshInstance GenerateMeshInstance(GeneratedMeshes meshContainer, CSGModel model, ModelSettingsFlags modelSettings, GeneratedMeshDescription meshDescription, RenderSurfaceType renderSurfaceType, List <GameObject> unusedInstances)
{
GeneratedMeshInstance meshInstance = MeshInstanceManager.CreateMeshInstance(meshContainer, meshDescription, modelSettings, renderSurfaceType, unusedInstances);
string baseName;
switch (renderSurfaceType)
{
case RenderSurfaceType.Collider: baseName = "Collider"; break;
case RenderSurfaceType.Normal: baseName = "Renderable"; break;
default: baseName = "Unknown"; break;
}
meshInstance.MeshDescription = meshDescription;
if (!UpdateMesh(model, baseName,
meshInstance.MeshDescription,
meshInstance.RenderSurfaceType,
ref meshInstance.HasGeneratedNormals,
ref meshInstance.SharedMesh))
{
return(null);
}
return(meshInstance);
}
private static bool TryGetMeshInstance(GeneratedMeshes meshContainer, CSGModel model, ModelSettingsFlags modelSettings, GeneratedMeshDescription meshDescription, RenderSurfaceType renderSurfaceType, out GeneratedMeshInstance meshInstance)
{
var startGetMeshInstanceTime = EditorApplication.timeSinceStartup;
meshInstance = MeshInstanceManager.GetMeshInstance(meshContainer, meshDescription, modelSettings, renderSurfaceType);
getMeshInstanceTime += EditorApplication.timeSinceStartup - startGetMeshInstanceTime;
if (meshInstance &&
meshDescription == meshInstance.MeshDescription &&
meshInstance.SharedMesh &&
meshInstance.IsValid())
{
return(true);
}
meshInstance = null;
return(true);
}
// NOTE: assumes that if a renderComponents are passed to this, they are -valid-
// do any checking outside of this method, and make sure everything that
// needs to be cleaned up, IS cleaned up
private bool UpdateOrCreateRenderComponents(CSGModel model, ModelState modelState, GeneratedMeshDescription meshDescription, ref CSGRenderComponents renderComponents)
{
bool updated = false;
if (renderComponents == null)
{
renderComponents = CreateRenderComponents(model, meshDescription);
updated = true;
}
UpdateRenderComponents(model, modelState, meshDescription, renderComponents);
UpdateComponentFlags(model, modelState, renderComponents.meshRenderer, renderComponents.gameObject, renderComponents.transform, GeneratedMeshRendererName, notEditable: true);
if (!renderComponents.meshRenderer.enabled)
{
renderComponents.meshRenderer.enabled = true;
}
return(updated);
}
private void UpdateColliderComponents(ChiselModel model, ModelState modelState, GeneratedMeshDescription meshDescription, ChiselColliderComponents colliderComponents)
{
var meshCollider = colliderComponents.meshCollider;
updateMeshColliders.Add(meshCollider);
}
private static HelperSurfaceDescription GenerateHelperSurfaceDescription(GeneratedMeshes meshContainer, CSGModel model, ModelSettingsFlags modelSettings, GeneratedMeshDescription meshDescription, RenderSurfaceType renderSurfaceType)
{
HelperSurfaceDescription helperSurfaceDescription;
var startGetMeshInstanceTime = EditorApplication.timeSinceStartup;
{
helperSurfaceDescription = MeshInstanceManager.GetHelperSurfaceDescription(meshContainer, modelSettings, meshDescription, renderSurfaceType);
}
getMeshInstanceTime += EditorApplication.timeSinceStartup - startGetMeshInstanceTime;
if (meshDescription == helperSurfaceDescription.MeshDescription &&
helperSurfaceDescription.SharedMesh &&
helperSurfaceDescription.IsValid())
{
return(helperSurfaceDescription);
}
helperSurfaceDescription.MeshDescription = meshDescription;
if (!UpdateMesh(model,
helperSurfaceDescription.MeshDescription,
helperSurfaceDescription.RenderSurfaceType,
ref helperSurfaceDescription.HasGeneratedNormals,
ref helperSurfaceDescription.SharedMesh))
{
return(null);
}
return(helperSurfaceDescription);
}
private static GeneratedMeshInstance GenerateMeshInstance(GeneratedMeshes meshContainer, CSGModel model, ModelSettingsFlags modelSettings, GeneratedMeshDescription meshDescription, RenderSurfaceType renderSurfaceType)
{
GeneratedMeshInstance meshInstance;
var startGetMeshInstanceTime = EditorApplication.timeSinceStartup;
{
meshInstance = MeshInstanceManager.GetMeshInstance(meshContainer, meshDescription, modelSettings, renderSurfaceType);
if (!meshInstance)
{
return(null);
}
}
getMeshInstanceTime += EditorApplication.timeSinceStartup - startGetMeshInstanceTime;
if (meshDescription == meshInstance.MeshDescription &&
meshInstance.SharedMesh &&
meshInstance.IsValid())
{
return(meshInstance);
}
meshInstance.MeshDescription = meshDescription;
if (!UpdateMesh(model,
meshInstance.MeshDescription,
meshInstance.RenderSurfaceType,
ref meshInstance.HasGeneratedNormals,
ref meshInstance.SharedMesh))
{
return(null);
}
return(meshInstance);
}
// NOTE: assumes that if a meshCollider is passed to this, it is -valid-
// do any checking outside of this method, and make sure everything that
// needs to be cleaned up, IS cleaned up
private bool UpdateOrCreateColliderComponents(ChiselModel model, ModelState modelState, GeneratedMeshDescription meshDescription, ref ChiselColliderComponents colliderComponents)
{
bool updated = false;
if (colliderComponents == null)
{
colliderComponents = CreateColliderComponents(model, meshDescription);
updated = true;
}
UpdateColliderComponents(model, modelState, meshDescription, colliderComponents);
UpdateComponentFlags(model, modelState, colliderComponents.meshCollider, colliderComponents.gameObject, colliderComponents.transform, GeneratedMeshColliderName, notEditable: true);
if (!colliderComponents.meshCollider.enabled)
{
colliderComponents.meshCollider.enabled = true;
}
return(updated);
}
