/// <summary>
/// Remap specified source material to the target material.
/// </summary>
/// <param name="mappings">Material mappings.</param>
/// <param name="from">Source material.</param>
/// <returns>
/// The remapped material; or source material when no mapping was found or no
/// target material was specified.
/// </returns>
public static Material RemapMaterial(this IMaterialMappings mappings, Material from)
{
if (mappings.MaterialMappingFrom == null || mappings.MaterialMappingTo == null)
{
return(from);
}
int index = Array.IndexOf(mappings.MaterialMappingFrom, from);
return(index >= 0 && index < mappings.MaterialMappingTo.Length
? mappings.MaterialMappingTo[index]
: from);
}
public BrushDesignerMaterialMapper(BrushDesignerView designer)
{
this.brush = designer.Brush;
this.mappings = designer.Brush as IMaterialMappings;
if (this.mappings.MaterialMappingFrom == null)
{
this.mappings.MaterialMappingFrom = new Material[0];
}
if (this.mappings.MaterialMappingTo == null)
{
this.mappings.MaterialMappingTo = new Material[0];
}
// Prepare material preview style.
this.materialPreviewStyle = new GUIStyle(GUI.skin.box);
this.materialPreviewStyle.fixedHeight = this.materialPreviewStyle.fixedWidth = 114;
}
/// <exclude/>
public static void DrawNow(Material previewMaterial, Transform obj, Matrix4x4 matrix, IMaterialMappings materialMappings)
{
Matrix4x4 modelMatrix;
Matrix4x4 inversePrefabMatrix = matrix * obj.localToWorldMatrix.inverse;
try {
s_DrawNowRendererComponents.Clear();
obj.GetComponentsInChildren <Renderer>(true, s_DrawNowRendererComponents);
foreach (var renderer in s_DrawNowRendererComponents)
{
// Skip inactive renderers!
if (!renderer.enabled)
{
continue;
}
// Calculate model matrix for tile preview.
Transform subObject = renderer.transform;
if (subObject != obj)
{
modelMatrix = inversePrefabMatrix * subObject.localToWorldMatrix;
}
else
{
modelMatrix = matrix;
}
// Attempt to render preview!
var spriteRenderer = renderer as SpriteRenderer;
if (spriteRenderer != null)
{
DrawNow(previewMaterial, spriteRenderer, modelMatrix);
continue;
}
var mesh = SharedMeshFromRenderer(renderer);
if (mesh == null)
{
continue;
}
DrawNow(previewMaterial, mesh, renderer, materialMappings, modelMatrix);
}
}
finally {
s_DrawNowRendererComponents.Clear();
}
}
/// <exclude/>
public static void DrawNow(Material previewMaterial, Mesh mesh, Renderer renderer, IMaterialMappings materialMappings, Matrix4x4 matrix)
{
if (renderer == null || !renderer.enabled)
{
return;
}
Material[] materials = renderer.sharedMaterials;
if (materials == null)
{
return;
}
for (int submesh = 0; submesh < materials.Length; ++submesh)
{
// Remap material?
var m = materials[submesh];
if (materialMappings != null)
{
m = materialMappings.RemapMaterial(m);
}
// Use preview material when specified; otherwise just use material from renderer.
if (previewMaterial != null)
{
previewMaterial.mainTexture = m.mainTexture;
m = previewMaterial;
}
int passCount = m.passCount;
for (int pass = 0; pass < passCount; ++pass)
{
m.SetPass(pass);
Graphics.DrawMeshNow(mesh, matrix, submesh);
}
}
}
/// <summary>
/// Copies common brush properties from v1.x brush to v2.x brush.
/// </summary>
/// <remarks>
/// <para>Also copies material mappings and filters materials to use the
/// material assets provided by v2.x where possible.</para>
/// </remarks>
/// <param name="newBrush">The new brush.</param>
/// <param name="oldBrush">The old brush.</param>
private void CopyCommonBrushProperties(Brush newBrush, MonoBehaviour oldBrush)
{
newBrush.visibility = (bool)_fiTileBrush_hideBrush.GetValue(oldBrush)
? BrushVisibility.Hidden
: BrushVisibility.Shown;
newBrush.group = (int)_fiTileBrush_tileGroup.GetValue(oldBrush);
if (_fiTileBrush_overrideTag != null)
{
newBrush.overrideTag = (bool)_fiTileBrush_overrideTag.GetValue(oldBrush);
}
newBrush.tag = oldBrush.gameObject.tag;
if (_fiTileBrush_overrideLayer != null)
{
newBrush.overrideLayer = (bool)_fiTileBrush_overrideLayer.GetValue(oldBrush);
}
newBrush.layer = oldBrush.gameObject.layer;
if (_fiTileBrush_category != null)
{
newBrush.category = (int)_fiTileBrush_category.GetValue(oldBrush);
}
newBrush.applyPrefabTransform = (bool)_fiTileBrush_applyPrefabTransform.GetValue(oldBrush);
if (_fiTileBrush_scaleMode != null)
{
newBrush.scaleMode = (Rotorz.Tile.ScaleMode)_fiTileBrush_scaleMode.GetValue(oldBrush);
}
newBrush.transformScale = oldBrush.transform.localScale;
newBrush.Static = oldBrush.gameObject.isStatic;
newBrush.Smooth = (bool)_fiTileBrush_smooth.GetValue(oldBrush);
if (_fiTileBrush_userFlags != null)
{
_fiBrush_userFlags.SetValue(newBrush, _fiTileBrush_userFlags.GetValue(oldBrush));
}
// Copy material mappings if applicable.
// Note: Material mappings do not apply to all types of brush.
IMaterialMappings materialMappings = newBrush as IMaterialMappings;
if (materialMappings != null)
{
Material[] materialsFrom = (Material[])_fiTileBrush_materialMapFrom.GetValue(oldBrush);
Material[] materialsTo = (Material[])_fiTileBrush_materialMapTo.GetValue(oldBrush);
// Use the new default material asset instead of the old one.
for (int i = 0; i < materialsFrom.Length; ++i)
{
materialsFrom[i] = FilterMaterial(materialsFrom[i]);
}
// Use the new Cave and Grass material assets instead of the old ones.
for (int i = 0; i < materialsTo.Length; ++i)
{
materialsTo[i] = FilterMaterial(materialsTo[i]);
}
materialMappings.MaterialMappingFrom = materialsFrom;
materialMappings.MaterialMappingTo = materialsTo;
}
}
