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(); } }