|
private CopyPropertiesFromMaterial ( |
||
| mat | ||
| Résultat | void | |
// Use this for initialization
void Start () {
currentOutsideMaterial = new Material (dissolveMaterial.shader);
currentOutsideMaterial.CopyPropertiesFromMaterial(dissolveMaterial);
currentGlassMaterial = new Material (glassMaterial.shader);
currentGlassMaterial.CopyPropertiesFromMaterial(glassMaterial);
foreach (Transform t in outside.GetComponentsInChildren<Transform>()) {
var renderer = t.gameObject.GetComponent<SpriteRenderer>();
if (renderer != null) {
if (t.CompareTag(Tags.Glass)){
renderer.material = currentGlassMaterial;
} else {
renderer.material = currentOutsideMaterial;
}
}
}
}
public override void Explode()
{
//try to early out if we can't draw this (not sure if this also gets us out of Unity Indie)
if (SystemInfo.supportsImageEffects)
{
if ((detailThreshold > detail) || !on) return;
if (!_delayedExplosionStarted)
{
_explodeDelay = explodeDelayMin + (Random.value * (explodeDelayMax - explodeDelayMin));
}
if (_explodeDelay <= 0)
{
//incoming size is based on 1, so we multiply here
_startSize = 0f;
_maxSize = size * 10f;
_material = new Material(Shader.Find("HeatDistort"));
_heatwave = GameObject.CreatePrimitive(PrimitiveType.Plane);
Destroy(_heatwave.GetComponent(typeof(MeshCollider)));
if (!heatwaveMaterial) heatwaveMaterial = MyDetonator().heatwaveMaterial;
_material.CopyPropertiesFromMaterial(heatwaveMaterial);
_heatwave.renderer.material = _material;
_heatwave.transform.parent = this.transform;
_delayedExplosionStarted = false;
_explodeDelay = 0f;
}
else
{
_delayedExplosionStarted = true;
}
}
}
static void CreateMaterial (GameObject go) {
// Create a simple material asset
if (go.GetComponent<Renderer>() != null)
{
Material material = new Material(go.GetComponent<Renderer>().sharedMaterial);
material.CopyPropertiesFromMaterial(go.GetComponent<Renderer>().sharedMaterial);
go.GetComponent<Renderer>().sharedMaterial = material;
MaterialPropertyBlock block = new MaterialPropertyBlock();
go.GetComponent<Renderer>().GetPropertyBlock(block);
#if UNITY_EDITOR
if(!Directory.Exists("Assets/Materials")) {
AssetDatabase.CreateFolder("Assets", "Materials");
AssetDatabase.Refresh();
}
string textureName = null;
if (block.GetTexture(0).name != null) {
textureName = block.GetTexture(0).name;
} else {
textureName = material.mainTexture.name;
}
AssetDatabase.CreateAsset(material, "Assets/Materials/" + textureName + ".mat");
Debug.Log("Created material " + textureName + " for " + go.name);
#endif
}
}
public static void Create ()
{
if (Selection.activeGameObject != null) {
GameObject o = Selection.activeGameObject;
SkinnedMeshRenderer skin = o.GetComponent<SkinnedMeshRenderer>();
SpriteRenderer spriteRenderer = o.GetComponent<SpriteRenderer>();
if (skin == null && spriteRenderer != null) {
Sprite thisSprite = spriteRenderer.sprite;
SpriteMesh spriteMesh = new SpriteMesh();
spriteMesh.spriteRenderer = spriteRenderer;
spriteMesh.CreateSpriteMesh();
Texture2D spriteTexture = UnityEditor.Sprites.SpriteUtility.GetSpriteTexture(spriteRenderer.sprite, false);
// Copy the sprite material
Material spriteMaterial = new Material(spriteRenderer.sharedMaterial);
spriteMaterial.CopyPropertiesFromMaterial(spriteRenderer.sharedMaterial);
spriteMaterial.mainTexture = spriteTexture;
string sortLayerName = spriteRenderer.sortingLayerName;
int sortOrder = spriteRenderer.sortingOrder;
DestroyImmediate(spriteRenderer);
Skin2D skin2D = o.AddComponent<Skin2D>();
skin2D.sprite = thisSprite;
skin = o.GetComponent<SkinnedMeshRenderer>();
MeshFilter filter = o.GetComponent<MeshFilter>();
skin.material = spriteMaterial;
// Save out the material from the sprite so we have a default material
if(!Directory.Exists("Assets/Materials")) {
AssetDatabase.CreateFolder("Assets", "Materials");
AssetDatabase.Refresh();
}
AssetDatabase.CreateAsset(spriteMaterial, "Assets/Materials/" + spriteMaterial.mainTexture.name + ".mat");
Debug.Log("Created material " + spriteMaterial.mainTexture.name + " for " + skin.gameObject.name);
skin2D.referenceMaterial = spriteMaterial;
skin.sortingLayerName = sortLayerName;
skin.sortingOrder = sortOrder;
// Create the mesh from the selection
filter.mesh = (Mesh)Selection.activeObject;
if (filter.sharedMesh != null && skin.sharedMesh == null) {
skin.sharedMesh = filter.sharedMesh;
}
// Recalculate the bone weights for the new mesh
skin2D.RecalculateBoneWeights();
}
else
{
o = new GameObject ("Skin2D");
Undo.RegisterCreatedObjectUndo (o, "Create Skin2D");
o.AddComponent<Skin2D> ();
}
}
else
{
GameObject o = new GameObject ("Skin2D");
Undo.RegisterCreatedObjectUndo (o, "Create Skin2D");
o.AddComponent<Skin2D> ();
}
}
void UpdateTextures() {
attackAnimationTextures = loadTextures (charName + "Attack");
moveAnimationTextures = loadTextures (charName + "Walk");
var clonedMaterial = new Material (Shader.Find("Standard"));
clonedMaterial.CopyPropertiesFromMaterial (characterMaterial);
characterMaterial = clonedMaterial;
transform.GetChild(1).GetComponent<MeshRenderer> ().material = clonedMaterial;
characterMaterial.SetTexture ("_MainTex", attackAnimationTextures [0]);
}
IEnumerator DelayedInit() {
yield return new WaitForSeconds (0.2f) ;
currMaterial = new Material (hairMaterial.shader);
currMaterial.CopyPropertiesFromMaterial (hairMaterial);
GetComponent<Anima2D.SpriteMeshInstance>().sharedMaterial = currMaterial;
lastPosition = transform.position;
isInitialized = true;
}
public override void OnInspectorGUI() {
Skin2D skin = (Skin2D)target;
DrawDefaultInspector();
EditorGUILayout.Separator();
if (skin.GetComponent<SkinnedMeshRenderer>().sharedMesh != null && GUILayout.Button("Save as Prefab")) {
skin.SaveAsPrefab();
}
EditorGUILayout.Separator();
if (skin.GetComponent<SkinnedMeshRenderer>().sharedMesh != null && GUILayout.Button("Recalculate Bone Weights")) {
skin.RecalculateBoneWeights();
}
EditorGUILayout.Separator();
if (skin.GetComponent<SkinnedMeshRenderer>().sharedMesh != null && GUILayout.Button("Create Control Points")) {
ControlPoint.CreateControlPoints(skin.GetComponent<SkinnedMeshRenderer>());
}
if (skin.GetComponent<SkinnedMeshRenderer>().sharedMesh != null && GUILayout.Button("Reset Control Points")) {
skin.ResetControlPointPositions();
}
EditorGUILayout.Separator();
if (skin.GetComponent<SkinnedMeshRenderer>().sharedMesh != null && GUILayout.Button("Generate Mesh Asset")) {
#if UNITY_EDITOR
// Check if the Meshes directory exists, if not, create it.
if(!Directory.Exists("Assets/Meshes")) {
AssetDatabase.CreateFolder("Assets", "Meshes");
AssetDatabase.Refresh();
}
ScriptableObjectUtility.CreateAsset(skin.GetComponent<SkinnedMeshRenderer>().sharedMesh, "Meshes/" + skin.gameObject.name + ".Mesh");
#endif
}
if (skin.GetComponent<SkinnedMeshRenderer>().sharedMaterial != null && GUILayout.Button("Generate Material Asset")) {
#if UNITY_EDITOR
Material material = new Material(skin.GetComponent<SkinnedMeshRenderer>().sharedMaterial);
material.CopyPropertiesFromMaterial(skin.GetComponent<SkinnedMeshRenderer>().sharedMaterial);
skin.GetComponent<SkinnedMeshRenderer>().sharedMaterial = material;
if(!Directory.Exists("Assets/Materials")) {
AssetDatabase.CreateFolder("Assets", "Materials");
AssetDatabase.Refresh();
}
AssetDatabase.CreateAsset(material, "Assets/Materials/" + material.mainTexture.name + ".mat");
Debug.Log("Created material " + material.mainTexture.name + " for " + skin.gameObject.name);
#endif
}
}
static public int CopyPropertiesFromMaterial(IntPtr l)
{
try {
UnityEngine.Material self = (UnityEngine.Material)checkSelf(l);
UnityEngine.Material a1;
checkType(l, 2, out a1);
self.CopyPropertiesFromMaterial(a1);
return(0);
}
catch (Exception e) {
LuaDLL.luaL_error(l, e.ToString());
return(0);
}
}
public Material MergeMaterials(PbrMaterial vpxMaterial, Material texturedMaterial)
{
var nonTexturedMaterial = CreateMaterial(vpxMaterial, null);
var mergedMaterial = new Material(GetShader());
mergedMaterial.CopyPropertiesFromMaterial(texturedMaterial);
mergedMaterial.name = nonTexturedMaterial.name;
mergedMaterial.SetColor(BaseColor, nonTexturedMaterial.GetColor(BaseColor));
mergedMaterial.SetFloat(Metallic, nonTexturedMaterial.GetFloat(Metallic));
mergedMaterial.SetFloat(Smoothness, nonTexturedMaterial.GetFloat(Smoothness));
return(mergedMaterial);
}
static public int CopyPropertiesFromMaterial(IntPtr l)
{
try {
UnityEngine.Material self = (UnityEngine.Material)checkSelf(l);
UnityEngine.Material a1;
checkType(l, 2, out a1);
self.CopyPropertiesFromMaterial(a1);
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
static int CopyPropertiesFromMaterial(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 2);
UnityEngine.Material obj = (UnityEngine.Material)ToLua.CheckObject(L, 1, typeof(UnityEngine.Material));
UnityEngine.Material arg0 = (UnityEngine.Material)ToLua.CheckUnityObject(L, 2, typeof(UnityEngine.Material));
obj.CopyPropertiesFromMaterial(arg0);
return(0);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
// Use this for initialization
void Start () {
this.charName = characterNames [Random.Range (0, characterNames.Length)];
attackAnimationTextures = loadTextures (charName + "Attack");
moveAnimationTextures = loadTextures (charName + "Walk");
var clonedMaterial = new Material (Shader.Find("Standard"));
clonedMaterial.CopyPropertiesFromMaterial (characterMaterial);
characterMaterial = clonedMaterial;
transform.GetChild(1).GetComponent<MeshRenderer> ().material = clonedMaterial;
characterMaterial.SetTexture ("_MainTex", attackAnimationTextures [0]);
characters.Add (this);
Spawn ();
}
public static void Create ()
{
if (Selection.activeGameObject != null) {
GameObject o = Selection.activeGameObject;
SkinnedMeshRenderer skin = o.GetComponent<SkinnedMeshRenderer>();
SpriteRenderer spriteRenderer = o.GetComponent<SpriteRenderer>();
if (skin == null && spriteRenderer != null) {
Sprite thisSprite = spriteRenderer.sprite;
SpriteMesh spriteMesh = new SpriteMesh();
spriteMesh.spriteRenderer = spriteRenderer;
spriteMesh.CreateSpriteMesh();
Texture2D spriteTexture = UnityEditor.Sprites.SpriteUtility.GetSpriteTexture(spriteRenderer.sprite, false);
Material spriteMaterial = new Material(spriteRenderer.sharedMaterial);
spriteMaterial.CopyPropertiesFromMaterial(spriteRenderer.sharedMaterial);
spriteMaterial.mainTexture = spriteTexture;
string sortLayerName = spriteRenderer.sortingLayerName;
int sortOrder = spriteRenderer.sortingOrder;
DestroyImmediate(spriteRenderer);
Skin2D skin2D = o.AddComponent<Skin2D>();
skin2D.sprite = thisSprite;
skin = o.GetComponent<SkinnedMeshRenderer>();
MeshFilter filter = o.GetComponent<MeshFilter>();
skin.material = spriteMaterial;
skin.sortingLayerName = sortLayerName;
skin.sortingOrder = sortOrder;
filter.mesh = (Mesh)Selection.activeObject;
if (filter.sharedMesh != null && skin.sharedMesh == null) {
skin.sharedMesh = filter.sharedMesh;
}
// Recalculate the bone weights for the new mesh
skin2D.RecalculateBoneWeights();
}
else
{
o = new GameObject ("Skin2D");
Undo.RegisterCreatedObjectUndo (o, "Create Skin2D");
o.AddComponent<Skin2D> ();
}
}
else
{
GameObject o = new GameObject ("Skin2D");
Undo.RegisterCreatedObjectUndo (o, "Create Skin2D");
o.AddComponent<Skin2D> ();
}
}
void AssignNewMaterial(GameObject grass)
{
currMaterial = new Material (grassMaterial.shader);
currMaterial.CopyPropertiesFromMaterial (grassMaterial);
Color color = new Color ( Random.Range(minColor.r , maxColor.r) , Random.Range(minColor.g , maxColor.g) , Random.Range(minColor.b , maxColor.b) , Random.Range(minColor.a , maxColor.a) );
currMaterial.color = color;
// MeshRenderer meshRenderer = grass.GetComponent<MeshRenderer>();
// meshRenderer.material = currMaterial;
// meshRenderer.materials[0] = currMaterial;
currMaterial.SetColor ( "_GrassColor" , color);
Anima2D.SpriteMeshInstance spriteMI = grass.GetComponent<Anima2D.SpriteMeshInstance>();
spriteMI.sharedMaterial = currMaterial;
grass.GetComponent<Grass>().myMaterial = currMaterial;
}
public Dictionary<string, UITextureInfo> textureDetails; // texture details loaded from the TexturePacker config file
#endregion;
#region MonoBehaviour Functions
virtual protected void Awake()
{
_meshFilter = gameObject.AddComponent<MeshFilter>();
_meshRenderer = gameObject.AddComponent<MeshRenderer>();
// Duplicate the standard material so that we're not changing the
// supplied one - it may be used by more than one UIToolkit object
Material duplicateMaterial = new Material (material.shader);
duplicateMaterial.CopyPropertiesFromMaterial(material);
material = duplicateMaterial;
_meshRenderer.renderer.material = material;
_mesh = _meshFilter.mesh;
// Move the object to the origin so the objects drawn will not be offset from the objects they are intended to represent.
// Offset on z axis according to the specified layer
transform.position = new Vector3(0, 0, layer);
transform.rotation = Quaternion.identity;
}
public override void Explode()
{
//try to early out if we can't draw this (not sure if this also gets us out of Unity Indie)
if (SystemInfo.supportsImageEffects)
{
if ((detailThreshold > detail) || !on) return;
if (!_delayedExplosionStarted)
{
_explodeDelay = explodeDelayMin + (Random.value * (explodeDelayMax - explodeDelayMin));
}
if (_explodeDelay <= 0)
{
//incoming size is based on 1, so we multiply here
_startSize = 0f;
_maxSize = size * 10f;
_material = new Material(Shader.Find("HeatDistort"));
_heatwave = GameObject.CreatePrimitive(PrimitiveType.Plane);
_heatwave.name = "Heatwave";
_heatwave.transform.parent = this.transform;
// billboard it so it always faces the camera - can't use regular lookat because the built in Unity plane is lame
_heatwave.transform.rotation = Quaternion.FromToRotation(Vector3.up, Camera.main.transform.position - _heatwave.transform.position);
Destroy(_heatwave.GetComponent(typeof(MeshCollider)));
if (!heatwaveMaterial) heatwaveMaterial = MyDetonator().heatwaveMaterial;
_material.CopyPropertiesFromMaterial(heatwaveMaterial);
_heatwave.GetComponent<Renderer>().material = _material;
_heatwave.transform.parent = this.transform;
_delayedExplosionStarted = false;
_explodeDelay = 0f;
}
else
{
_delayedExplosionStarted = true;
}
}
}
public static IEnumerator GetAssetFromBundles( string bundlePath )
{
EditorWww www = EditorWww.Create( bundlePath );
while( !www.Finished ){
yield return null;
}
Object asset = www.GetAsset();
if( asset ){
string assetPath = Path.ChangeExtension( bundlePath, Defines.AssetExt.UnityAsset );
if( asset is Material ){
var old = asset as Material;
Shader shader = Shader.Find( old.shader.name );
if( shader ){
var newMaterial = new Material( shader );
newMaterial.CopyPropertiesFromMaterial( old );
AssetDatabase.CreateAsset( newMaterial, assetPath );
}
else{
EditorUtility.DisplayDialog( "错误", string.Format( "Shader:{0} 不存在于本地资源", old.shader.name ), "确定" );
}
}
else if( asset is ScriptableObject ){
Object scriptableObject = ScriptableObject.CreateInstance( asset.GetType() );
EditorUtility.CopySerialized( asset, scriptableObject );
AssetDatabase.CreateAsset( scriptableObject, assetPath );
}
else if( asset is GameObject ){
Object[] all = www.AssetBundle.LoadAllAssets();//LoadAll() change in unity5
Debug.Log( all.Length );
Object.Instantiate( asset );
}
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
else{
Debug.Log( "Error: " + bundlePath );
}
www.Unload();
}
/// <summary>
/// Rebuild the draw call's material.
/// </summary>
public void RebuildMaterial()
{
NGUITools.DestroyImmediate(mMat);
mMat = new Material(mSharedMat);
mMat.hideFlags = HideFlags.DontSave;
mMat.CopyPropertiesFromMaterial(mSharedMat);
mMat.renderQueue = mSharedMat.renderQueue + mRenderQueue;
}
public void loadTextureAndPrepareForUse()
{
Debug.Log("loadTextureAndPrepareForUse");
if (_meshRendererPUBLIC == null)
{
Awake();
}
// Duplicate the standard material so that we're not changing the
// supplied one - it may be used by more than one UIToolkit object
Material duplicateMaterial = new Material (material.shader);
duplicateMaterial.CopyPropertiesFromMaterial(material);
material = duplicateMaterial;
// load our texture, at 2x if necessary
if( UI.isHD )
texturePackerConfigName = texturePackerConfigName + UI.instance.hdExtension;
var texture = (Texture)Resources.Load( texturePackerConfigName, typeof(Texture) );
if( texture == null )
Debug.Log( "UI texture is being autoloaded and it doesn't exist. Cannot find texturePackerConfigName: " + texturePackerConfigName );
material.mainTexture = texture;
// assign the duplicate material to the mesh renderer
if (_meshRendererPUBLIC != null)
Debug.Log("_meshRendererPUBLIC != null");
if (_meshRendererPUBLIC.renderer != null)
Debug.Log("_meshRendererPUBLIC.renderer != null");
if (_meshRendererPUBLIC.renderer.material != null)
Debug.Log("_meshRendererPUBLIC.renderer.material != null");
_meshRendererPUBLIC.renderer.material = material;
// Cache our texture size
var t = material.mainTexture;
textureSize = new Vector2( t.width, t.height );
// load up the config file
textureDetails = loadTexturesFromTexturePackerJSON( texturePackerConfigName, textureSize );
}
void Start () {
// Copy the skybox material to a new instance so the original skybox material is not modified and saved by accident
skyboxInstance = new Material(skybox.shader);
skyboxInstance.CopyPropertiesFromMaterial(skybox);
}
public Material CreateMaterial(PbrMaterial vpxMaterial, ITextureProvider textureProvider, StringBuilder debug = null)
{
Material defaultMaterial = GetDefaultMaterial(vpxMaterial.MapBlendMode);
var unityMaterial = new Material(GetShader(vpxMaterial));
unityMaterial.CopyPropertiesFromMaterial(defaultMaterial);
unityMaterial.name = vpxMaterial.Id;
// apply some basic manipulations to the color. this just makes very
// very white colors be clipped to 0.8204 aka 204/255 is 0.8
// this is to give room to lighting values. so there is more modulation
// of brighter colors when being lit without blow outs too soon.
var col = vpxMaterial.Color.ToUnityColor();
if (vpxMaterial.Color.IsGray() && col.grayscale > 0.8)
{
debug?.AppendLine("Color manipulation performed, brightness reduced.");
col.r = col.g = col.b = 0.8f;
}
if (vpxMaterial.MapBlendMode == BlendMode.Translucent)
{
col.a = Mathf.Min(1, Mathf.Max(0, vpxMaterial.Opacity));
}
unityMaterial.SetColor(BaseColor, col);
// validate IsMetal. if true, set the metallic value.
// found VPX authors setting metallic as well as translucent at the
// same time, which does not render correctly in unity so we have
// to check if this value is true and also if opacity <= 1.
float metallicValue = 0f;
if (vpxMaterial.IsMetal && (!vpxMaterial.IsOpacityActive || vpxMaterial.Opacity >= 1))
{
metallicValue = 1f;
debug?.AppendLine("Metallic set to 1.");
}
unityMaterial.SetFloat(Metallic, metallicValue);
// roughness / glossiness
SetSmoothness(unityMaterial, vpxMaterial.Roughness);
// map
if (vpxMaterial.HasMap)
{
unityMaterial.SetTexture(BaseMap, textureProvider.GetTexture(vpxMaterial.Map.Name));
}
// normal map
if (vpxMaterial.HasNormalMap)
{
unityMaterial.EnableKeyword("_NORMALMAP");
unityMaterial.EnableKeyword("_NORMALMAP_TANGENT_SPACE");
unityMaterial.SetTexture(NormalMap, textureProvider.GetTexture(vpxMaterial.NormalMap.Name));
}
return(unityMaterial);
}
void updateMaterial(int archive, int record, int frame, Texture2D albedoMap, Texture2D normalMap, Texture2D metallicGlossMap)
{
CachedMaterial cmat;
if (dfUnity.MaterialReader.GetCachedMaterial(archive, record, frame, out cmat))
{
Material newMat;
if (useDeferredReflections)
{
newMat = cmat.material;
//newMat = new Material(Shader.Find("Standard (Specular setup)"));
//newMat.CopyPropertiesFromMaterial(cmat.material);
}
else
{
newMat = new Material(Shader.Find("Daggerfall/ReflectionsMod/FloorMaterialWithReflections"));
newMat.CopyPropertiesFromMaterial(cmat.material);
newMat.name = cmat.material.name;
}
if (texReflectionGround)
{
newMat.SetTexture("_ReflectionGroundTex", texReflectionGround);
}
if (texReflectionLowerLevel)
{
newMat.SetTexture("_ReflectionLowerLevelTex", texReflectionLowerLevel);
}
newMat.EnableKeyword("_METALLICGLOSSMAP");
//newMat.EnableKeyword("_SPECGLOSSMAP");
newMat.DisableKeyword("_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A");
newMat.SetTexture("_MetallicGlossMap", metallicGlossMap);
if (albedoMap != null)
{
newMat.SetTexture("_MainTex", albedoMap);
}
if (normalMap != null)
{
newMat.SetTexture("_BumpMap", normalMap);
}
cmat.material = newMat;
dfUnity.MaterialReader.SetCachedMaterial(archive, record, frame, cmat);
}
}
private IEnumerator UpdateTerrainsTransitionRing()
{
for (int i = 0; i < terrainTransitionRingArray.Length; i++)
{
if (terrainTransitionRingArray[i].terrainDesc.active)
{
if (terrainTransitionRingArray[i].terrainDesc.updateData)
{
PlaceTerrainOfTransitionRing(i);
//UpdateTerrainData(terrainTransitionRingArray[i]);
terrainTransitionRingArray[i].terrainDesc.updateData = false;
yield return new WaitForEndOfFrame();
}
if (terrainTransitionRingArray[i].terrainDesc.updateNature)
{
streamingWorld.UpdateTerrainNature(terrainTransitionRingArray[i].terrainDesc);
terrainTransitionRingArray[i].terrainDesc.updateNature = false;
MeshRenderer meshRenderer = terrainTransitionRingArray[i].terrainDesc.billboardBatchObject.GetComponent<MeshRenderer>();
Material[] rendererMaterials = meshRenderer.materials;
for (int m = 0; m < rendererMaterials.Length; m++)
{
Material newMaterial = new Material(Shader.Find("Daggerfall/BillboardBatchFaded"));
newMaterial.CopyPropertiesFromMaterial(rendererMaterials[m]);
newMaterial.SetInt("_TerrainDistance", streamingWorld.TerrainDistance);
newMaterial.SetFloat("_TerrainBlockSize", (MapsFile.WorldMapTerrainDim * MeshReader.GlobalScale));
rendererMaterials[m] = newMaterial;
}
meshRenderer.materials = rendererMaterials;
//if (!terrainTransitionRingUpdateRunning) //(!transitionRingUpdateFinished)
yield return new WaitForEndOfFrame();
}
terrainTransitionRingArray[i].ready = true;
}
}
UpdateNeighboursTransitionRing();
terrainMaterial.SetInt("_TerrainDistance", streamingWorld.TerrainDistance); // after of transition ring update - restore far terrain rendering to streamingWorld.TerrainDistance
terrainTransitionRingUpdateRunning = false;
transitionRingAllBlocksReady = true;
}
void InjectMaterialPropertiesIndoor()
{
List<TextureRecord> listInjectedTextures = new List<TextureRecord>();
// mages guild 4 floors debuging worldpos: 704,337
IniParser.Model.IniData textureInjectionData = iniData;
if (iniData != null)
{
foreach (IniParser.Model.SectionData section in iniData.Sections)
{
int textureArchive = int.Parse(textureInjectionData[section.SectionName]["textureArchive"]);
int textureRecord = int.Parse(textureInjectionData[section.SectionName]["textureRecord"]);
int textureFrame = int.Parse(textureInjectionData[section.SectionName]["textureFrame"]);
TextureRecord texRecord = new TextureRecord();
texRecord.archive = textureArchive;
texRecord.record = textureRecord;
texRecord.frame = textureFrame;
texRecord.albedoMap = null;
texRecord.normalMap = null;
texRecord.useMetallicGlossMap = false;
texRecord.metallicGlossMap = null;
texRecord.reflectivity = 0.0f;
texRecord.smoothness = 0.0f;
Texture2D albedoTexture = null;
if (textureInjectionData[section.SectionName].ContainsKey("filenameAlbedoMap"))
{
string fileAlbedoMap = textureInjectionData[section.SectionName]["filenameAlbedoMap"];
albedoTexture = Resources.Load(fileAlbedoMap) as Texture2D;
texRecord.albedoMap = albedoTexture;
}
Texture2D normalTexture = null;
if (textureInjectionData[section.SectionName].ContainsKey("filenameNormalMap"))
{
string fileNormalMap = textureInjectionData[section.SectionName]["filenameNormalMap"];
normalTexture = Resources.Load(fileNormalMap) as Texture2D;
texRecord.normalMap = normalTexture;
}
bool useMetallicGlossMap = bool.Parse(textureInjectionData[section.SectionName]["useMetallicGlossMap"]);
texRecord.useMetallicGlossMap = useMetallicGlossMap;
if (useMetallicGlossMap)
{
string fileNameMetallicGlossMap = textureInjectionData[section.SectionName]["filenameMetallicGlossMap"];
Texture2D metallicGlossMapTexture = Resources.Load(fileNameMetallicGlossMap) as Texture2D;
updateMaterial(textureArchive, textureRecord, textureFrame, albedoTexture, normalTexture, metallicGlossMapTexture);
texRecord.metallicGlossMap = metallicGlossMapTexture;
}
else
{
float reflectivity = float.Parse(textureInjectionData[section.SectionName]["reflectivity"]);
float smoothness = float.Parse(textureInjectionData[section.SectionName]["smoothness"]);
updateMaterial(textureArchive, textureRecord, textureFrame, albedoTexture, normalTexture, reflectivity, smoothness);
texRecord.reflectivity = reflectivity;
texRecord.smoothness = smoothness;
}
listInjectedTextures.Add(texRecord);
}
}
// force update to textures loaded in current interior/dungeon models
Renderer[] renderers = null;
if (GameManager.Instance.IsPlayerInsideBuilding)
{
renderers = gameObjectInterior.GetComponentsInChildren<Renderer>();
}
else if (GameManager.Instance.IsPlayerInsideDungeon || GameManager.Instance.IsPlayerInsidePalace)
{
renderers = gameObjectDungeon.GetComponentsInChildren<Renderer>();
}
if (renderers != null)
{
//Debug.Log(String.Format("renderers: {0}", renderers.Length));
foreach (Renderer r in renderers)
{
Material[] mats = r.sharedMaterials;
for (int i = 0; i < mats.Length; i++)
{
Material m = mats[i];
try
{
// name is in format TEXTURE.xxx [Index=y] - if atlas texture - different format then exception will be thrown - so everything is in try-catch block
string[] parts = m.name.Split('.');
parts = parts[1].Split(' ');
int archive = Convert.ToInt32(parts[0]);
string tmp = parts[1].Replace("[Index=", "").Replace("]", "");
//Debug.Log(String.Format("archive: {0}, record: {1}", parts[0], tmp));
int record = Convert.ToInt32(tmp);
int frame = 0;
if (listInjectedTextures.Exists(x => (x.archive == archive) && (x.record == record) && (x.frame == frame)))
{
TextureRecord? texRecord = listInjectedTextures.Find(x => (x.archive == archive) && (x.record == record) && (x.frame == frame));
if (texRecord.HasValue)
{
CachedMaterial cmat;
if (dfUnity.MaterialReader.GetCachedMaterial(archive, record, frame, out cmat))
{
if (!texRecord.Value.useMetallicGlossMap)
{
if (useDeferredReflections)
{
updateMaterial(archive, record, frame, texRecord.Value.albedoMap, texRecord.Value.normalMap, texRecord.Value.reflectivity, texRecord.Value.smoothness);
}
else
{
Material newMat = new Material(Shader.Find("Daggerfall/ReflectionsMod/FloorMaterialWithReflections"));
newMat.CopyPropertiesFromMaterial(cmat.material);
newMat.name = cmat.material.name;
if (texReflectionGround)
{
newMat.SetTexture("_ReflectionGroundTex", texReflectionGround);
}
if (texReflectionLowerLevel)
{
newMat.SetTexture("_ReflectionLowerLevelTex", texReflectionLowerLevel);
}
newMat.SetFloat("_Metallic", texRecord.Value.reflectivity);
newMat.SetFloat("_Smoothness", texRecord.Value.smoothness);
if (texRecord.Value.albedoMap != null)
{
newMat.SetTexture("_MainTex", texRecord.Value.albedoMap);
}
if (texRecord.Value.normalMap != null)
{
newMat.SetTexture("_BumpMap", texRecord.Value.normalMap);
}
m = newMat;
}
}
else
{
if (useDeferredReflections)
{
updateMaterial(archive, record, frame, texRecord.Value.albedoMap, texRecord.Value.normalMap, texRecord.Value.metallicGlossMap);
}
else
{
Material newMat = new Material(Shader.Find("Daggerfall/ReflectionsMod/FloorMaterialWithReflections"));
newMat.CopyPropertiesFromMaterial(cmat.material);
newMat.name = cmat.material.name;
if (texReflectionGround)
{
newMat.SetTexture("_ReflectionGroundTex", texReflectionGround);
}
if (texReflectionLowerLevel)
{
newMat.SetTexture("_ReflectionLowerLevelTex", texReflectionLowerLevel);
}
newMat.EnableKeyword("USE_METALLICGLOSSMAP");
newMat.SetTexture("_MetallicGlossMap", texRecord.Value.metallicGlossMap);
if (texRecord.Value.albedoMap != null)
{
newMat.SetTexture("_MainTex", texRecord.Value.albedoMap);
}
if (texRecord.Value.normalMap != null)
{
newMat.SetTexture("_BumpMap", texRecord.Value.normalMap);
}
m = newMat;
}
}
}
}
}
}
catch
{
}
mats[i] = m;
}
r.sharedMaterials = mats;
}
}
}
void updateMaterial(int archive, int record, int frame, Texture2D albedoMap, Texture2D normalMap, float reflectivity, float smoothness)
{
CachedMaterial cmat;
if (dfUnity.MaterialReader.GetCachedMaterial(archive, record, frame, out cmat))
{
Material newMat;
if (useDeferredReflections)
{
newMat = cmat.material;
//newMat = new Material(Shader.Find("Standard (Specular setup)"));
//newMat.CopyPropertiesFromMaterial(cmat.material);
}
else
{
newMat = new Material(Shader.Find("Daggerfall/ReflectionsMod/FloorMaterialWithReflections"));
newMat.CopyPropertiesFromMaterial(cmat.material);
newMat.name = cmat.material.name;
}
if (texReflectionGround)
{
newMat.SetTexture("_ReflectionGroundTex", texReflectionGround);
}
if (texReflectionLowerLevel)
{
newMat.SetTexture("_ReflectionLowerLevelTex", texReflectionLowerLevel);
}
newMat.SetFloat("_Metallic", reflectivity);
//newMat.SetColor("_SpecColor", new Color(reflectivity, reflectivity, reflectivity));
newMat.SetFloat("_Glossiness", smoothness);
if (albedoMap != null)
{
newMat.SetTexture("_MainTex", albedoMap);
}
if (normalMap != null)
{
newMat.SetTexture("_BumpMap", normalMap);
}
cmat.material = newMat;
dfUnity.MaterialReader.SetCachedMaterial(archive, record, frame, cmat);
}
}
void Start()
{
// Calculate last things
numOfPoints = resolution + 2;
splittingIndex = Random.Range((int)((numOfPoints/2) - (numOfPoints/4)), (int)((numOfPoints/2) + (numOfPoints/4)));
splittingDistance += Vector3.Distance(nodeA.transform.position, nodeB.transform.position);
// Setup line renderer
lineA = nodeA.AddComponent<LineRenderer>();
lineB = nodeB.AddComponent<LineRenderer>();
lineA.SetVertexCount(splittingIndex + 1);
lineB.SetVertexCount(numOfPoints - splittingIndex);
// Make copy of material and tile it according to length of vine (Approx.)
Material mat = new Material(Shader.Find("Unlit/Transparent"));
mat.CopyPropertiesFromMaterial(lineMaterials[(int)Random.Range(0, lineMaterials.Length)]);
mat.mainTextureScale = new Vector2(Vector3.Distance(nodeA.transform.position, nodeB.transform.position) * 3, 1);
lineA.material = mat;
lineB.material = mat;
// Instantiate Rigid points between the nodes
rigidPoints = new GameObject[numOfPoints]; // resolution + node A & B
rigidPoints[0] = nodeA;
rigidPoints[numOfPoints-1] = nodeB;
for(int i = 1; i < numOfPoints-1; i++) {
// Instantiate Object and its position
rigidPoints[i] = new GameObject();
rigidPoints[i].name = "RigidPoint_"+i;
rigidPoints[i].transform.position = Vector3.Lerp(nodeA.transform.position, nodeB.transform.position, (1f / (numOfPoints-1)) * i);
rigidPoints[i].transform.parent = transform;
// Add components
rigidPoints[i].AddComponent<Rigidbody>();
rigidPoints[i].AddComponent<SpringJoint>();
rigidPoints[i].GetComponent<SpringJoint>().connectedBody = rigidPoints[i-1].GetComponent<Rigidbody>();
rigidPoints[i].GetComponent<SpringJoint>().spring = 512f;
rigidPoints[i].GetComponent<SpringJoint>().damper = 1f;
rigidPoints[i].GetComponent<SpringJoint>().minDistance = 0.00125f;
rigidPoints[i].GetComponent<SpringJoint>().maxDistance = 0.005f;
}
nodeA.GetComponent<FixedJoint>().connectedBody = rigidPoints[1].GetComponent<Rigidbody>();
nodeB.GetComponent<FixedJoint>().connectedBody = rigidPoints[numOfPoints-2].GetComponent<Rigidbody>();
if(transformA)
nodeA.transform.parent = transformA;
if(transformB)
nodeB.transform.parent = transformB;
isSplit = false;
}
public static Material CloneMaterial(Material original)
{
if(original == null) return null;
Material material = new Material(original.shader);
material.CopyPropertiesFromMaterial(original);
return material;
}
/// <summary>
/// Rebuild the draw call's material.
/// </summary>
public void RebuildMaterial()
{
NGUITools.DestroyImmediate(mMat);
mMat = new Material(mSharedMat);
mMat.hideFlags = HideFlags.DontSave;
mMat.CopyPropertiesFromMaterial(mSharedMat);
// Automatically replace "GUI/Text Shader" with "Unlit/Text"
if (mMat.shader != null && mMat.shader.name == "GUI/Text Shader")
{
Shader shader = Shader.Find("Unlit/Text");
if (shader != null) mMat.shader = shader;
}
mMat.renderQueue = mSharedMat.renderQueue + mRenderQueue;
}
using UnityEngine; using System.Collections;
/// <summary>
/// Create an appropriate material for the draw call.
/// </summary>
void CreateMaterial ()
{
const string alpha = " (AlphaClip)";
const string soft = " (SoftClip)";
string shaderName = (mShader != null) ? mShader.name :
((mMaterial != null) ? mMaterial.shader.name : "Unlit/Transparent Colored");
// Figure out the normal shader's name
shaderName = shaderName.Replace("GUI/Text Shader", "Unlit/Text");
shaderName = shaderName.Replace(alpha, "");
shaderName = shaderName.Replace(soft, "");
// Try to find the new shader
Shader shader;
if (mClipping == Clipping.SoftClip)
{
shader = Shader.Find(shaderName + soft);
}
else if (mClipping == Clipping.AlphaClip)
{
shader = Shader.Find(shaderName + alpha);
}
else // No clipping
{
shader = (mShader != null) ? mShader : Shader.Find(shaderName);
}
if (mMaterial != null)
{
mDynamicMat = new Material(mMaterial);
mDynamicMat.hideFlags = HideFlags.DontSave;
mDynamicMat.CopyPropertiesFromMaterial(mMaterial);
// If there is a valid shader, assign it to the custom material
if (shader != null)
{
mDynamicMat.shader = shader;
}
else if (mClipping != Clipping.None)
{
Debug.LogError(shaderName + " doesn't have a clipped shader version for " + mClipping);
mClipping = Clipping.None;
}
}
else
{
mDynamicMat = new Material(shader);
mDynamicMat.hideFlags = HideFlags.DontSave;
}
}
void GetMats()
{
Transform par = transform.parent;
if (!par)
return;
Renderer[] rds = par.GetComponentsInChildren<Renderer>();
mats = new List<Material>();
foreach (Renderer rd in rds)
{
if (rd is ParticleSystemRenderer || rd is ParticleRenderer)
continue;
foreach (Material mat in rd.materials)
{
if (!IsThisMatSupportMatFx(mat))
continue;
mats.Add(mat);
}
}
oriMaterials = new Material[mats.Count];
for (int i = 0; i < oriMaterials.Length; i++)
{
Material oriMat = new Material(mats[i]);
oriMat.hideFlags = HideFlags.DontSave | HideFlags.NotEditable;
oriMat.CopyPropertiesFromMaterial(mats[i]);
oriMaterials[i] = oriMat;
}
}
public static void ConfigureNewMaterialToMatchOld(Material newMat, Material original){
if (original == null){
Debug.LogWarning("Original material is null, could not copy properties to " + newMat + ". Setting shader to " + newMat.shader);
return;
}
newMat.shader = original.shader;
newMat.CopyPropertiesFromMaterial(original);
ShaderTextureProperty[] texPropertyNames = MB3_TextureCombiner.shaderTexPropertyNames;
for (int j = 0; j < texPropertyNames.Length; j++){
Vector2 scale = Vector2.one;
Vector2 offset = Vector2.zero;
if (newMat.HasProperty(texPropertyNames[j].name)){
newMat.SetTextureOffset(texPropertyNames[j].name,offset);
newMat.SetTextureScale(texPropertyNames[j].name,scale);
}
}
}
public static void Create()
{
if (Selection.activeGameObject != null) {
GameObject o = Selection.activeGameObject;
SkinnedMeshRenderer skin = o.GetComponent<SkinnedMeshRenderer>();
SpriteRenderer spriteRenderer = o.GetComponent<SpriteRenderer>();
if (skin == null && spriteRenderer != null) {
Sprite thisSprite = spriteRenderer.sprite;
SpriteMesh.CreateSpriteMeshAsset(spriteRenderer.transform, thisSprite);
Texture2D spriteTexture = UnityEditor.Sprites.SpriteUtility.GetSpriteTexture(spriteRenderer.sprite, false);
Material spriteMaterial = new Material(spriteRenderer.sharedMaterial);
spriteMaterial.CopyPropertiesFromMaterial(spriteRenderer.sharedMaterial);
spriteMaterial.mainTexture = spriteTexture;
DestroyImmediate(spriteRenderer);
Skin2D skin2D = o.AddComponent<Skin2D>();
skin2D.sprite = thisSprite;
skin = o.GetComponent<SkinnedMeshRenderer>();
MeshFilter filter = o.GetComponent<MeshFilter>();
skin.material = spriteMaterial;
filter.mesh = (Mesh)Selection.activeObject;
if (filter.sharedMesh != null && skin.sharedMesh == null) {
skin.sharedMesh = filter.sharedMesh;
}
Skeleton skeleton = o.transform.root.GetComponent<Skeleton>();
if (skeleton != null)
{
// Generate the mesh and calculate the weights if the root transform has a skeleton
skeleton.CalculateWeights(true);
// Debug.Log("Calculated weights for " + o.name);
// Try to initialize the parent bone to this skin
Bone bone = o.transform.parent.GetComponent<Bone>();
if (bone != null)
{
Mesh m = skin.sharedMesh.Clone();
List<BoneWeight> weights = m.boneWeights.ToList();
for (int i = 0; i < m.vertices.Length; i++) {
BoneWeight bw = weights[i];
bw = bw.SetWeight(bone.index, 1);
weights[i] = bw.Clone();
}
skin.sharedMesh.boneWeights = weights.ToArray();
EditorUtility.SetDirty(skin.gameObject);
if (PrefabUtility.GetPrefabType(skin.gameObject) != PrefabType.None) {
AssetDatabase.SaveAssets();
}
}
}
}
else
{
o = new GameObject ("Skin2D");
Undo.RegisterCreatedObjectUndo (o, "Create Skin2D");
o.AddComponent<Skin2D> ();
}
}
else
{
GameObject o = new GameObject ("Skin2D");
Undo.RegisterCreatedObjectUndo (o, "Create Skin2D");
o.AddComponent<Skin2D> ();
}
}
/* ********************************************************* */
//! Change Texture in Material-table
/*!
* @param tableMaterial
* Material-Table
* @param indexCellMap
* index of CellMap
* @param texture
* Texture
* @param flagMaterialNew
* Whether make a new material or overwrite<br>
* true == Create new material<br>
* false == Overwrite exist material
* @retval Return-Value
* true == Success<br>
* false == Failure(Error)
*
* Change materials' texture corresponding to specified CellMap in Material-Table.<br>
* When "flagMaterialNew" is set true, new materials are created.<br>
* When false, materials are overwritten.
*/
public static bool TextureSet(UnityEngine.Material[] tableMaterial, int indexCellMap, Texture2D texture, bool flagMaterialNew)
{
int indexTop = IndexGetTable(indexCellMap, Library_SpriteStudio6.KindOperationBlendEffect.INITIATOR, Library_SpriteStudio6.KindMasking.THROUGH);
if (0 > indexTop)
{
return(false);
}
UnityEngine.Material material;
int index;
for (int i = (int)Library_SpriteStudio6.KindMasking.THROUGH; i < (int)Library_SpriteStudio6.KindMasking.TERMINATOR; i++)
{
for (int j = (int)Library_SpriteStudio6.KindOperationBlendEffect.INITIATOR; j < (int)Library_SpriteStudio6.KindOperationBlendEffect.TERMINATOR; j++)
{
index = IndexGetTable(0, (Library_SpriteStudio6.KindOperationBlendEffect)j, (Library_SpriteStudio6.KindMasking)i);
index += indexTop;
material = tableMaterial[index];
if (true == flagMaterialNew)
{ /* Create Material */
#if false
/* MEMO: Before Ver.1.0.26 */
if (null == material)
{
material = new UnityEngine.Material(Library_SpriteStudio6.Data.Shader.ShaderGetEffect((Library_SpriteStudio6.KindOperationBlendEffect)j,
(Library_SpriteStudio6.KindMasking)i
)
);
}
else
{
material = new UnityEngine.Material(material);
}
#else
/* MEMO: After Ver.1.0.26 */
if (null == material)
{
material = Library_SpriteStudio6.Data.Shader.MaterialCreateEffect((Library_SpriteStudio6.KindOperationBlendEffect)j,
(Library_SpriteStudio6.KindMasking)i
);
}
else
{
UnityEngine.Material materialNew = new UnityEngine.Material(material);
if (null != materialNew)
{
materialNew.CopyPropertiesFromMaterial(material);
}
material = materialNew;
}
#endif
}
else
{ /* Overwrite Material */
#if false
/* MEMO: Before Ver.1.0.26 */
if (null == material)
{
material = new UnityEngine.Material(Library_SpriteStudio6.Data.Shader.ShaderGetEffect((Library_SpriteStudio6.KindOperationBlendEffect)j,
(Library_SpriteStudio6.KindMasking)i
)
);
}
#else
/* MEMO: After Ver.1.0.26 */
if (null == material)
{
material = Library_SpriteStudio6.Data.Shader.MaterialCreateEffect((Library_SpriteStudio6.KindOperationBlendEffect)j,
(Library_SpriteStudio6.KindMasking)i
);
}
#endif
}
material.mainTexture = texture;
tableMaterial[index] = material;
}
}
return(true);
}
/// <summary>
/// Update the renderer's materials.
/// </summary>
void UpdateMaterials()
{
bool useClipping = (mClipping != Clipping.None);
// Create a temporary material
if (mMat == null)
{
mMat = new Material(mSharedMat);
mMat.hideFlags = HideFlags.DontSave;
mMat.CopyPropertiesFromMaterial(mSharedMat);
mMat.renderQueue = mSharedMat.renderQueue + mDepth;
}
// If clipping should be used, we need to find a replacement shader
if (useClipping && mClipping != Clipping.None)
{
Shader shader = null;
const string alpha = " (AlphaClip)";
const string soft = " (SoftClip)";
// Figure out the normal shader's name
string shaderName = mSharedMat.shader.name;
shaderName = shaderName.Replace(alpha, "");
shaderName = shaderName.Replace(soft, "");
// Try to find the new shader
if (mClipping == Clipping.HardClip ||
mClipping == Clipping.AlphaClip) shader = Shader.Find(shaderName + alpha);
else if (mClipping == Clipping.SoftClip) shader = Shader.Find(shaderName + soft);
// If there is a valid shader, assign it to the custom material
if (shader != null)
{
mMat.shader = shader;
}
else
{
mClipping = Clipping.None;
Debug.LogError(shaderName + " doesn't have a clipped shader version for " + mClipping);
}
}
// If depth pass should be used, create the depth material
if (mUseDepth)
{
if (mDepthMat == null)
{
Shader shader = Shader.Find("Unlit/Depth Cutout");
mDepthMat = new Material(shader);
mDepthMat.hideFlags = HideFlags.DontSave;
}
mDepthMat.mainTexture = mSharedMat.mainTexture;
}
else if (mDepthMat != null)
{
NGUITools.Destroy(mDepthMat);
mDepthMat = null;
}
if (mDepthMat != null)
{
// If we're already using this material, do nothing
if (mRen.sharedMaterials != null && mRen.sharedMaterials.Length == 2 && mRen.sharedMaterials[1] == mMat) return;
// Set the double material
mRen.sharedMaterials = new Material[] { mDepthMat, mMat };
}
else if (mRen.sharedMaterial != mMat)
{
mRen.sharedMaterials = new Material[] { mMat };
}
}
void updateMaterial(int archive, int record, int frame, Texture2D albedoMap, Texture2D normalMap, Texture2D metallicGlossMap)
{
CachedMaterial cmat;
if (dfUnity.MaterialReader.GetCachedMaterial(archive, record, frame, out cmat))
{
Material newMat = new Material(Shader.Find("Daggerfall/FloorMaterialWithReflections"));
newMat.CopyPropertiesFromMaterial(cmat.material);
newMat.name = cmat.material.name;
Texture tex = GameObject.Find("ReflectionPlaneBottom").GetComponent<MirrorReflection>().m_ReflectionTexture;
if (tex)
{
newMat.SetTexture("_ReflectionGroundTex", tex);
}
tex = GameObject.Find("ReflectionPlaneSeaLevel").GetComponent<MirrorReflection>().m_ReflectionTexture;
if (tex)
{
newMat.SetTexture("_ReflectionLowerLevelTex", tex);
}
newMat.EnableKeyword("USE_METALLICGLOSSMAP");
newMat.SetTexture("_MetallicGlossMap", metallicGlossMap);
if (albedoMap != null)
{
newMat.SetTexture("_MainTex", albedoMap);
}
if (normalMap != null)
{
newMat.SetTexture("_BumpMap", normalMap);
}
cmat.material = newMat;
dfUnity.MaterialReader.SetCachedMaterial(archive, record, frame, cmat);
}
}