private Material[] gatherMaterials()
{
int renderQueueBase = this.renderQueueBase;
MaterialCache.Reset();
if (< > f__am$cache27 == null)
{
//private void FossilFuelCacheInitialization()
//{
// this.baseIndex = 0;
// this.panel.Click += new EventHandler(panel_Click);
// this.materialCache = new FossilFuelCache(FossilFuelCatalog.Instance);
// this.materialCache.MaterialComponentsChanged += new MaterialComponentsChangedEventHandler(materialCache_MaterialComponentsChanged);
//}
public void SetMaterialComponents(MaterialCache materialCache, INumericFormat iNumericFormat)
{
this.materialCache = materialCache;
this.numericFormat = iNumericFormat;
this.materialCache.MaterialComponentsChanged += new MaterialComponentsChangedEventHandler(materialCache_MaterialComponentsChanged);
this.UpdateTheUI(this.materialCache.MaterialComponentList, iNumericFormat);
}
void OnBuildGameObject(RpcContext <BuildGameObject> ctx)
{
var materialCache = new MaterialCache {
Materials = ctx.Data.Materials
};
var meshCache = new MeshCache {
Meshes = ctx.Data.Meshes
};
var configs = new SyncObjectImportConfig
{
settings = new SyncObjectImportSettings
{
defaultMaterial = ReflectMaterialManager.defaultMaterial,
importLights = true
},
materialCache = materialCache,
meshCache = meshCache
};
var gameObject = m_Importer.Import(ctx.Data.InstanceData.SourceId, ctx.Data.Object, configs);
gameObject.name = ctx.Data.Instance.Name;
gameObject.transform.SetParent(m_Settings.Root);
ImportersUtils.SetTransform(gameObject.transform, ctx.Data.Instance.Transform);
ImportersUtils.SetMetadata(gameObject, ctx.Data.Instance.Metadata);
ctx.SendSuccess(gameObject);
}
public void UpdateSelectedMaterials()
{
if (outlineMesh)
{
SyncOutlineGameObject();
}
UpdateOutlineGameObjectSelected();
int materialLength = outlineGameObject ? unselectedMaterials.Length : unselectedMaterials.Length * 2;
if (selectedMaterials == null || materialLength != selectedMaterials.Length) // avoid GC alloc on subsequent calls
{
selectedMaterials = new Material[materialLength];
}
for (int i = 0; i < unselectedMaterials.Length; i++)
{
Color color;
if (unselectedMaterials[i].HasProperty("_Color"))
{
color = unselectedMaterials[i].color + highlightMaterial.GetColor("_TintColor") / 3;
}
else
{
color = unselectedMaterials[i].GetColor("_TintColor") + highlightMaterial.GetColor("_TintColor") / 3;
}
color.a = 1.0f;
Material material = MaterialCache.MaterialByColor(color, renderMesh, renderWireframe, renderNormals, textureCacheId);
selectedMaterials[i] = material;
if (!outlineGameObject)
{
selectedMaterials[i + unselectedMaterials.Length] = outlineMaterial;
}
}
}
// Token: 0x06000352 RID: 850 RVA: 0x0001C3E0 File Offset: 0x0001A5E0
public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] properties)
{
this.FindProperties(properties);
Material[] array = new Material[materialEditor.targets.Length];
for (int i = 0; i < materialEditor.targets.Length; i++)
{
array[i] = (Material)materialEditor.targets[i];
}
bool flag = false;
EditorGUI.BeginChangeCheck();
this.OnShaderGUI(materialEditor, array);
if (EditorGUI.EndChangeCheck())
{
flag = true;
}
if ((Event.current.type == (EventType)13 || Event.current.type == (EventType)14) && Event.current.commandName == "UndoRedoPerformed")
{
flag = true;
}
if (flag)
{
MaterialCache.ClearCache();
}
if (this.bool_0)
{
foreach (Material material in array)
{
this.MaterialChanged(material);
}
this.bool_0 = false;
}
}
public void SetUp()
{
_materialCache = new MaterialCache();
_parentMtl = _materialCache.Add("testmtl1");
_childMtl = _materialCache.Add("testmtl2");
_epicModel = new EpicModel();
_parentCuboid = Cuboid.CreateCuboid();
_parentCuboid.Size = new Vector3(2, 2, 2);
_parentCuboid.Rotation = new Vector3(0, 0, -(float)Math.PI / 4.0f);
_parentCuboid.MaterialId = _parentMtl.Id;
_connector = _parentCuboid.AddAnchor("Connector");
_connector.Position = new Vector3(1, 1, 0);
_childCuboid = Cuboid.CreateCuboid();
_childCuboid.Position = new Vector3(-1, -1, 0);
_childCuboid.Rotation = new Vector3(0, 0, -(float)Math.PI / 2.0f);
_childCuboid.MaterialId = _childMtl.Id;
_epicModel.ModelParts.Add(_parentCuboid);
_childCuboid.Pivot.SetParent(_connector);
_compiler = new EpicModelCompiler(_epicModel);
_compiledModel = _compiler.Compile();
_modelInstance = new ModelInstance(_compiledModel, _materialCache);
_modelInstance.Update(1 / 24.0f);
}
void MaterialPropertyGUI(MaterialCache materialCache, ExternalObjectCache externalObjectCache)
{
GUIContent nameLabel = EditorGUIUtility.TextContent(materialCache.name);
nameLabel.tooltip = materialCache.name;
EditorGUI.BeginChangeCheck();
SerializedProperty property = externalObjectCache.property;
EditorGUILayout.PropertyField(property, nameLabel, false);
Material material = property.objectReferenceValue != null ? property.objectReferenceValue as Material : null;
if (EditorGUI.EndChangeCheck())
{
if (material == null)
{
m_ExternalObjects.DeleteArrayElementAtIndex(externalObjectCache.propertyIdx);
}
else
{
var pair = m_ExternalObjects.GetArrayElementAtIndex(externalObjectCache.propertyIdx);
pair.FindPropertyRelative("second").objectReferenceValue = material;
}
BuildExternalObjectsCache();
}
}
void MaterialPropertyGUI(MaterialCache materialCache)
{
GUIContent nameLabel = EditorGUIUtility.TextContent(materialCache.name);
nameLabel.tooltip = materialCache.name;
EditorGUI.BeginChangeCheck();
Material material = EditorGUILayout.ObjectField(nameLabel, null, typeof(Material), false) as Material;
if (EditorGUI.EndChangeCheck())
{
m_ExternalObjects.arraySize++;
var pair = m_ExternalObjects.GetArrayElementAtIndex(m_ExternalObjects.arraySize - 1);
pair.FindPropertyRelative("first.name").stringValue = materialCache.name;
pair.FindPropertyRelative("first.type").stringValue = materialCache.type;
pair.FindPropertyRelative("first.assembly").stringValue = materialCache.assembly;
pair.FindPropertyRelative("second").objectReferenceValue = material;
// ExternalObjects is serialized as a map, so items are reordered when deserializing.
// We need to update the serializedObject to trigger the reordering before rebuilding the cache.
serializedObject.ApplyModifiedProperties();
serializedObject.Update();
BuildExternalObjectsCache();
}
}
public void UpdateStickySelectedMaterial()
{
Color color = material.color * stickySelectedMaterial.color;
color.a = 1.0f;
blendedStickySelectedMaterial = MaterialCache.MaterialByColor(color, true, true, true);
}
void OnDestroy()
{
if (Instance == this)
{
Logger.LogError("MaterialCache OnDestroy called so Instance == null");
Instance = null;
}
}
internal void SetNumericFormat(INumericFormat iNumericFormat)
{
this.materialCache = new FossilFuelCache(FossilFuelCatalog.Instance);
this.materialCache.MaterialComponentsChanged += new MaterialComponentsChangedEventHandler(materialCache_MaterialComponentsChanged);
this.numericFormat = iNumericFormat;
this.UpdateTheUI(this.materialCache.MaterialComponentList, iNumericFormat);
}
void Awake()
{
if (Instance != null)
{
Logger.LogWarning("MaterialCache.Instance != null but awake called");
return;
}
Instance = this;
}
/// <summary>
/// Modifies the material.
/// </summary>
public override void ModifyMaterial()
{
bool isTpImage = false;
Texture _AlphaTex = null;
string key = "";
if (graphic is LImageForTP)
{
var image = graphic as LImageForTP;
isTpImage = true;
_AlphaTex = AtlasManager.Instance.GetAtlasInfoBySpriteName(image.m_SpriteName).m_Mat.GetTexture("_AlphaTex");
string noiseKey = (m_NoiseTexture ? m_NoiseTexture.GetInstanceID().ToString() : "null");
string spriteKey = _AlphaTex.GetInstanceID().ToString();
key = string.Format("{0}{1}{2}", noiseKey, spriteKey, m_ColorMode);
}
else
{
string noiseKey = (m_NoiseTexture ? m_NoiseTexture.GetInstanceID().ToString() : "null");
key = string.Format("{0}{1}", noiseKey, m_ColorMode);
}
if (_materialCache != null && (_materialCache.key != key || !isActiveAndEnabled || !m_EffectMaterial))
{
MaterialCache.Unregister(_materialCache);
_materialCache = null;
}
if (!isActiveAndEnabled || !m_EffectMaterial)
{
material = null;
}
else if (!m_NoiseTexture)
{
material = m_EffectMaterial;
}
else if (_materialCache != null && _materialCache.key == key)
{
material = _materialCache.material;
}
else
{
_materialCache = MaterialCache.Register(key, () =>
{
var mat = new Material(m_EffectMaterial);
mat.name += "_" + m_NoiseTexture.name;
if (isTpImage)
{
mat.SetTexture("_AlphaTex", _AlphaTex);
}
mat.SetTexture("_NoiseTex", m_NoiseTexture);
return(mat);
});
material = _materialCache.material;
}
}
private Material GetMaterial(string fullId)
{
if (MaterialCache.ContainsKey(fullId))
{
if (MaterialCache.TryGetValue(fullId, out Material mat))
{
return(mat);
}
}
return(null);
}
public override void SetUp()
{
base.SetUp();
Compiler = new EpicModelCompiler(Model);
CompiledModel = Compiler.Compile();
MaterialCache = new MaterialCache();
MaterialCache.Add("example_material");
ModelInstance = new ModelInstance(CompiledModel, MaterialCache);
}
public Editor(EditorWindow editorWindow)
{
_editorWindow = editorWindow;
Materials = new MaterialCache();
CameraRotation = new EasedVector();
CameraPosition = new EasedVector();
LoadDefaultModel();
SelectedAnimationType = AnimationType.Standing;
}
public void SetUp()
{
_materialCache = new MaterialCache();
var material = _materialCache.Add("mat");
_instances = new List <ModelInstance>();
for (int i = 0; i < InstanceCount; i++)
{
_instances.Add(CreateModel(material));
}
}
public static List <UnityEngine.Material> GetMaterials(Mesh mesh)
{
List <UnityEngine.Material> materials = new List <UnityEngine.Material>();
List <Material> mmMaterials = mesh.materials.GetMaterials();
foreach (Material mmMaterial in mmMaterials)
{
UnityEngine.Material material = MaterialCache.MaterialByColor(mmMaterial.color, mesh.GetRenderMesh(), mesh.GetRenderWireframe(), mesh.GetRenderNormals());
materials.Add(material);
}
return(materials);
}
internal bool RemoveMaterial(string fullId)
{
if (fullId == null)
{
return(false);
}
if (MaterialCache.TryGetValue(fullId, out Material mat))
{
CameraManager?.RemoveMaterial(mat);
return(MaterialCache.Remove(fullId));
}
return(false);
}
public static void Unregister(MaterialCache cache)
{
if (cache == null)
{
return;
}
cache.referenceCount--;
if (cache.referenceCount <= 0)
{
MaterialCache.materialCaches.Remove(cache);
cache.material = null;
}
}
void drawAnimation(LumarcaAnimation la)
{
LumarcaFrame lf = la.GetCurrentFrame();
foreach (LumarcaLine ll in lf.lines)
{
if (ll.hasDots)
{
DrawLine(ll.top, ll.bottom, MaterialCache.GetMaterial(ll.material));
}
else
{
DrawLineWithoutDots(ll.top, ll.bottom, MaterialCache.GetMaterial(ll.material));
}
}
}
/// <summary>
/// Modifies the material.
/// </summary>
public override void ModifyMaterial()
{
if (graphic is LImageForTP)
{
Texture _AlphaTex = null;
var image = graphic as LImageForTP;
_AlphaTex = AtlasManager.Instance.GetAtlasInfoBySpriteName(image.m_SpriteName).m_Mat.GetTexture("_AlphaTex");
string key = _AlphaTex.GetInstanceID().ToString();
//清理旧的matCache
if (_materialCache != null && (_materialCache.material == null || _materialCache.key != key || !isActiveAndEnabled || !m_EffectMaterial))
{
MaterialCache.Unregister(_materialCache);
_materialCache = null;
}
//创建matCache
if (_materialCache != null && _materialCache.key == key && _materialCache.material != null)
{
material = _materialCache.material;
}
else
{
_materialCache = MaterialCache.Register(key, () =>
{
var mat = new Material(m_EffectMaterial);
mat.name += "_" + _AlphaTex.name;
mat.SetTexture("_AlphaTex", _AlphaTex);
return(mat);
});
material = _materialCache.material;
}
}
else
{
//清理旧的matCache
if (_materialCache != null)
{
MaterialCache.Unregister(_materialCache);
_materialCache = null;
}
material = m_EffectMaterial;
}
if (!isActiveAndEnabled || !m_EffectMaterial)
{
material = null;
}
}
/// <summary>
/// Adds a Material based of the ShaderEffect sfx with the specified identifier id
/// </summary>
/// <param name="id">the id assigned</param>
/// <param name="sfx">the shader used</param>
/// <returns>The created Material</returns>
public Material AddMaterial(string id, ShaderEffectData sfx)
{
string fullId = GetFID(id, sfx);
Material mat;
if (!MaterialCache.ContainsKey(fullId))
{
mat = new Material(sfx.Material);
MaterialCache.Add(fullId, mat);
}
else
{
return(GetMaterial(id, sfx));
}
CameraManager?.AddMaterial(mat);
return(mat);
}
Material GetTargetMaterial()
{
if (materialIndex < 0)
{
return(null);
}
if ((optimizationLevel & OptimizationLevel.CacheMaterials) != 0)
{
if (_materialCache.mats == null)
{
_materialCache = new MaterialCache()
{
shared = _useSharedMaterial,
mats = Application.isPlaying && !_useSharedMaterial
? rend.materials
: rend.sharedMaterials,
};
}
if (_materialCache.mats != null && materialIndex < _materialCache.mats.Length)
{
return(_materialCache.mats[materialIndex]);
}
else
{
return(null);
}
}
else
{
Material[] materials = Application.isPlaying && !_useSharedMaterial
? rend.materials
: rend.sharedMaterials;
if (materials != null && materialIndex < materials.Length)
{
return(materials[materialIndex]);
}
else
{
return(null);
}
}
}
private void BuildMaterialsCache()
{
// do not set if multiple selection.
if (m_Materials.hasMultipleDifferentValues)
{
return;
}
m_MaterialsCache.Clear();
for (int materialIdx = 0; materialIdx < m_Materials.arraySize; ++materialIdx)
{
var mat = new MaterialCache();
var id = m_Materials.GetArrayElementAtIndex(materialIdx);
mat.name = id.FindPropertyRelative("name").stringValue;
mat.type = id.FindPropertyRelative("type").stringValue;
mat.assembly = id.FindPropertyRelative("assembly").stringValue;
m_MaterialsCache.Add(mat);
}
}
public void UpdateStickySelectedMaterials()
{
blendedStickySelectedMaterials = new Material[unselectedMaterials.Length];
for (int i = 0; i < unselectedMaterials.Length; i++)
{
if (stickySelectedMaterial)
{
Color color = unselectedMaterials[i].color * stickySelectedMaterial.color;
color.a = 1.0f;
blendedStickySelectedMaterials[i] = MaterialCache.MaterialByColor(color, renderMesh, renderWireframe, renderNormals, textureCacheId);
}
else
{
Color color = unselectedMaterials[i].color * Color.red;
color.a = 1.0f;
blendedStickySelectedMaterials[i] = MaterialCache.MaterialByColor(color, renderMesh, renderWireframe, renderNormals, textureCacheId);
}
}
}
void UpdateMaterial()
{
if (SpriteRenderer?.sprite == null)
{
return;
}
var sprite = SpriteRenderer.sprite;
if (LastSprite == sprite)
{
return;
}
var data = MaterialCache.GetMaterial(sprite);
if (data == null)
{
Logger.LogWarning($"GetMaterial returned null");
return;
}
CurrentMaterial = new Material(data.Material);
MeshRenderer.material = CurrentMaterial;
UpdateMaterialColour();
if (SpriteRenderer.flipX)
{
data.Width *= -1;
data.XPos *= -1;
}
if (SpriteRenderer.flipY)
{
data.Height *= -1;
data.YPos *= -1;
}
transform.localScale = new Vector3(data.Width, data.Height, 1);
transform.localPosition = new Vector3(data.XPos, data.YPos, 0);
LastSprite = sprite;
}
public void SetUp()
{
_materialCache = new MaterialCache();
var testmtl = _materialCache.Add("testmtl");
_epicModel = new Psy.Core.EpicModel.EpicModel();
var cuboid = Cuboid.CreateCuboid();
cuboid.Size = new Vector3(1.0f, 1.0f, 1.0f);
cuboid.MaterialId = testmtl.Id;
_epicModel.ModelParts.Add(cuboid);
_compiler = new EpicModelCompiler(_epicModel);
_compiledModel = _compiler.Compile();
_modelInstance = new ModelInstance(_compiledModel, _materialCache);
_modelInstance.Update(1 / 24.0f);
}
void MaterialPropertyGUI(MaterialCache materialCache, ExternalObjectCache externalObjectCache)
{
GUIContent nameLabel = EditorGUIUtility.TextContent(materialCache.name);
nameLabel.tooltip = materialCache.name;
EditorGUI.BeginChangeCheck();
SerializedProperty property = externalObjectCache.property;
var previousMaterial = property.objectReferenceValue as Material;
EditorGUILayout.ObjectField(property, typeof(Material), nameLabel);
Material material = property.objectReferenceValue as Material;
if (EditorGUI.EndChangeCheck())
{
if (material == null)
{
m_ExternalObjects.DeleteArrayElementAtIndex(externalObjectCache.propertyIdx);
BuildExternalObjectsCache();
}
else
{
var importer = target as ModelImporter;
if (AssetDatabase.GetAssetPath(material) == importer.assetPath)
{
Debug.LogError(string.Format("{0} is a sub-asset of {1} and cannot be used as an external material.", material.name, Path.GetFileName(importer.assetPath)));
property.objectReferenceValue = previousMaterial;
}
else
{
var pair = m_ExternalObjects.GetArrayElementAtIndex(externalObjectCache.propertyIdx);
pair.FindPropertyRelative("second").objectReferenceValue = material;
BuildExternalObjectsCache();
}
}
EvaluateMaterialExtractionState();
}
}
void MaterialPropertyGUI(MaterialCache materialCache)
{
GUIContent nameLabel = EditorGUIUtility.TextContent(materialCache.name);
nameLabel.tooltip = materialCache.name;
EditorGUI.BeginChangeCheck();
Material material = ObjectFieldWithPPtrHashID(nameLabel, null, typeof(Material), false) as Material;
if (EditorGUI.EndChangeCheck())
{
if (material != null)
{
var importer = target as ModelImporter;
if (AssetDatabase.GetAssetPath(material) == importer.assetPath)
{
Debug.LogError(string.Format("{0} is a sub-asset of {1} and cannot be used as an external material.", material.name, Path.GetFileName(importer.assetPath)));
}
else
{
m_ExternalObjects.arraySize++;
var pair = m_ExternalObjects.GetArrayElementAtIndex(m_ExternalObjects.arraySize - 1);
pair.FindPropertyRelative("first.name").stringValue = materialCache.name;
pair.FindPropertyRelative("first.type").stringValue = materialCache.type;
pair.FindPropertyRelative("first.assembly").stringValue = materialCache.assembly;
pair.FindPropertyRelative("second").objectReferenceValue = material;
// ExternalObjects is serialized as a map, so items are reordered when deserializing.
// We need to update the serializedObject to trigger the reordering before rebuilding the cache.
serializedObject.ApplyModifiedProperties();
serializedObject.Update();
BuildExternalObjectsCache();
}
}
EvaluateMaterialExtractionState();
}
}
