public void SetCurrentToFrom()
{
if (_material = material)
{
_material.SetTextureScale(propertyName, from);
}
}
protected MaterialDesc[] ProcessSharedMaterials( Material[] mats )
{
MaterialDesc[] matsDesc = new MaterialDesc [ mats.Length ];
for ( int i = 0; i < mats.Length; i++ )
{
matsDesc[ i ].material = mats[ i ];
bool legacyCoverage = ( mats[ i ].GetTag( "RenderType", false ) == "TransparentCutout" );
#if UNITY_4
bool isCoverage = legacyCoverage;
matsDesc[ i ].coverage = mats[ i ].HasProperty( "_MainTex" ) && isCoverage;
#else
bool isCoverage = legacyCoverage || mats[ i ].IsKeywordEnabled( "_ALPHATEST_ON" );
matsDesc[ i ].propertyBlock = new MaterialPropertyBlock();
matsDesc[ i ].coverage = mats[ i ].HasProperty( "_MainTex" ) && isCoverage;
#endif
matsDesc[ i ].cutoff = mats[ i ].HasProperty( "_Cutoff" );
if ( isCoverage && !matsDesc[ i ].coverage && !m_materialWarnings.Contains( matsDesc[ i ].material ) )
{
Debug.LogWarning( "[AmplifyMotion] TransparentCutout material \"" + matsDesc[ i ].material.name + "\" {" + matsDesc[ i ].material.shader.name + "} not using _MainTex standard property." );
m_materialWarnings.Add( matsDesc[ i ].material );
}
}
return matsDesc;
}
public void SetCurrentToTo()
{
if (_material = material)
{
_material.SetTextureScale(propertyName, to);
}
}
public void SetFromToCurrent()
{
if (_material = material)
{
from = _material.GetTextureScale(propertyName);
}
}
public void SetMaterial(Material mat)
{
Material = mat;
for (int index = 0; index < Renderers.Length; index++)
Renderers[index].sharedMaterial = Material;
}
private void ImportTexturesFromXml(XDocument xml)
{
var texData = xml.Root.Elements("ImportTexture");
foreach (var tex in texData)
{
string name = tex.Attribute("filename").Value;
string data = tex.Value;
// The data is gzip compressed base64 string. We need the raw bytes.
//byte[] bytes = ImportUtils.GzipBase64ToBytes(data);
byte[] bytes = ImportUtils.Base64ToBytes(data);
// Save and import the texture asset
{
string pathToSave = GetTextureAssetPath(name);
ImportUtils.ReadyToWrite(pathToSave);
File.WriteAllBytes(pathToSave, bytes);
AssetDatabase.ImportAsset(pathToSave, ImportAssetOptions.ForceSynchronousImport);
}
// Create a material if needed in prepartion for the texture being successfully imported
{
string materialPath = GetMaterialAssetPath(name);
Material material = AssetDatabase.LoadAssetAtPath(materialPath, typeof(Material)) as Material;
if (material == null)
{
// We need to create the material afterall
// Use our custom shader
material = new Material(Shader.Find("Tiled/TextureTintSnap"));
ImportUtils.ReadyToWrite(materialPath);
AssetDatabase.CreateAsset(material, materialPath);
}
}
}
}
public FourierGPU(int size)
{
if(size > 256)
{
Debug.Log("FourierGPU::FourierGPU - fourier grid size must not be greater than 256, changing to 256");
size = 256;
}
if(!Mathf.IsPowerOfTwo(size))
{
Debug.Log("FourierGPU::FourierGPU - fourier grid size must be pow2 number, changing to nearest pow2 number");
size = Mathf.NextPowerOfTwo(size);
}
// Shader shader = Shader.Find("Math/Fourier");
Shader shader = ShaderTool.GetShader2 ("CompiledFourier.shader");
if(shader == null) Debug.Log("FourierGPU::FourierGPU - Could not find shader Math/Fourier");
m_fourier = new Material(shader);
m_size = size; //must be pow2 num
m_fsize = (float)m_size;
m_passes = (int)(Mathf.Log(m_fsize)/Mathf.Log(2.0f));
m_butterflyLookupTable = new Texture2D[m_passes];
ComputeButterflyLookupTable();
m_fourier.SetFloat("_Size", m_fsize);
}
void Start()
{
m_depthBufferShader = ShaderTool.GetMatFromShader2 ("CompiledViewDepthBuffer.shader");
// GetComponent<Camera>().depthTextureMode |= DepthTextureMode.DepthNormals;
GetComponent<Camera>().depthTextureMode |= DepthTextureMode.Depth;
}
public Minimap()
{
// Init minimap
m_gameObject = new GameObject();
m_icons = new List<MinimapIcon>();
m_origBounds = new Rect(1920 - 224, 16, 209, 184);
UpdateBounds();
// Create the minimap render texture
m_minimap = (Material)UnityEngine.Resources.Load("textures/minimapRT");
// Create Camera
m_camera = m_gameObject.AddComponent<Camera>();
m_camera.isOrthoGraphic = true;
m_camera.orthographicSize = 500f;
m_camera.nearClipPlane = 10f;
m_camera.farClipPlane = 1000f;
m_camera.clearFlags = CameraClearFlags.Color;
m_camera.backgroundColor = Color.black;
m_camera.targetTexture = (RenderTexture)m_minimap.mainTexture;
m_camera.rect = new Rect(0f, 0f, 1f, 1f);
m_camera.cullingMask = 1 << LayerMask.NameToLayer("Terrain");
m_gameObject.transform.position = new Vector3(0f, 100f, 0f);
m_gameObject.transform.eulerAngles = new Vector3(90f, 0f, 0f);
m_gameObject.layer = LayerMask.NameToLayer("Minimap");
m_gameObject.name = "Minimap";
}
public OceanProperties(string texture, Vector2 textureScale, string material, Vector3 scale)
{
this.texture = Resources.Load<Texture2D> (texture);
this.textureScale = textureScale;
this.material = Resources.Load<Material> (material);
this.scale = scale;
}
public static void Create(Vector3 position, Vector3 normal)
{
var effect = new GameObject("Particle Effect");
effect.transform.position = position;
effect.transform.rotation = Quaternion.LookRotation(normal);
var particleSystem = effect.AddComponent<ParticleSystem>();
particleSystem.startLifetime = 0.4f;
particleSystem.startSpeed = 15;
particleSystem.startSize = 0.13f;
particleSystem.emissionRate = 100;
particleSystem.loop = false;
Material material = new Material(Shader.Find(" Diffuse"));
material.color = Color.black;
effect.GetComponent<ParticleSystemRenderer>().sharedMaterial = material;
GameObject.Destroy(effect, 0.2f);
/*for (int i = 0; i < 30; i++)
{
ParticleSystem.Particle p = new ParticleSystem.Particle();
p.velocity = normal*5;
//p.position = position;
p.lifetime = 5;
particleSystem.Emit(p);
}
particleSystem.Play();*/
}
private void OnDisable()
{
if (m_Material != null)
DestroyImmediate(m_Material);
m_Material = null;
}
public static SMaterial FromMaterial(Material mat)
{
if (mat == null)
return null;
Shader shader = mat.shader;
if (shader == null)
return null;
SMaterial result = new SMaterial();
result.instanceID = mat.GetInstanceID();
result.materialName = mat.name;
result.shaderName = shader.name;
ShaderProperties.Info info = ShaderPropertyHelper.GetShaderInfo(shader.name);
if (info != null){
ComposedByteStream rawData = new ComposedByteStream();
int iMax = info.propertyNames.Length;
for (int i = 0; i < iMax; i++)
{
string propName = info.propertyNames[i];
switch (info.propertyTypes[i])
{
case ShaderProperties.PropType.Color:
Color color = mat.GetColor(propName);
rawData.AddStream(new float[] { color.r, color.g, color.b, color.a });
break;
case ShaderProperties.PropType.Range:
case ShaderProperties.PropType.Float:
rawData.AddStream(new float[] { mat.GetFloat(propName) });
break;
case ShaderProperties.PropType.TexEnv:
Texture texture = mat.GetTexture(propName);
Vector2 offset = mat.GetTextureOffset(propName);
Vector2 scale = mat.GetTextureScale(propName);
rawData.AddStream(new int[] { texture != null ? texture.GetInstanceID() : -1 });
rawData.AddStream(texture != null ? texture.name : "" );
rawData.AddStream(new float[] { offset.x, offset.y });
rawData.AddStream(new float[] { scale.x, scale.y });
break;
case ShaderProperties.PropType.Vector:
Vector4 vector = mat.GetVector(propName);
rawData.AddStream(new float[] { vector.x, vector.y, vector.z, vector.w });
break;
}
}
result.rawData = rawData.Compose();
return result;
} else {
if (vBug.settings.general.debugMode)
Debug.LogError("No shader-info found @" + shader.name);
return null;
}
}
static void CustomGraphicsBlit(RenderTexture source, RenderTexture dest, Material fxMaterial, int passNr)
{
RenderTexture.active = dest;
fxMaterial.SetTexture ("_MainTex", source);
GL.PushMatrix ();
GL.LoadOrtho ();
fxMaterial.SetPass (passNr);
GL.Begin (GL.QUADS);
GL.MultiTexCoord2 (0, 0.0f, 0.0f);
GL.Vertex3 (0.0f, 0.0f, 3.0f); // BL
GL.MultiTexCoord2 (0, 1.0f, 0.0f);
GL.Vertex3 (1.0f, 0.0f, 2.0f); // BR
GL.MultiTexCoord2 (0, 1.0f, 1.0f);
GL.Vertex3 (1.0f, 1.0f, 1.0f); // TR
GL.MultiTexCoord2 (0, 0.0f, 1.0f);
GL.Vertex3 (0.0f, 1.0f, 0.0f); // TL
GL.End ();
GL.PopMatrix ();
}
public void CreatePrefab()
{
if (prefabAtmosphere == null)
{
prefabAtmosphere = new GameObject ("RefractiveAtmosphere");
prefabAtmosphere.SetActive (false);
var mf = prefabAtmosphere.AddComponent<MeshFilter> ();
var mr = prefabAtmosphere.AddComponent<MeshRenderer> ();
mr.castShadows = false;
mr.receiveShadows = false;
var material = new Material (Shaders.RefractiveAtmosphere);
var _normals = new Texture2D (4, 4, TextureFormat.ARGB32, false);
_normals.LoadImage (Textures.RefractiveAtmosphereNormals);
material.SetTexture ("_BumpMap", _normals);
material.SetTextureScale ("_BumpMap", new Vector2 (4f, 4f));
material.SetVector ("_BumpMapOffset", new Vector4 (0, 0, 1, 0));
mr.sharedMaterial = material;
var sphere = GameObject.CreatePrimitive (PrimitiveType.Sphere);
var sphereMesh = sphere.GetComponent<MeshFilter> ().mesh;
DestroyImmediate (sphere);
mf.sharedMesh = sphereMesh;
var behaviour = prefabAtmosphere.AddComponent<RefractiveAtmosphere> ();
prefabAtmosphere.transform.localScale = Vector3.one * 1250f;
DontDestroyOnLoad (prefabAtmosphere);
}
}
private void Awake()
{
_cellController = GetComponentInParent<CellController>();
_firstMaterial = _cellController.FirstSide.GetComponent<MeshRenderer>().material;
_secondMaterial = _cellController.SecondSide.GetComponent<MeshRenderer>().material;
}
void OnRenderImage(RenderTexture src, RenderTexture dst)
{
if (m_material == null)
{
m_material = new Material(m_shader);
}
if (m_edge_highlighting)
{
m_material.EnableKeyword("ENABLE_EDGE_HIGHLIGHTING");
}
else
{
m_material.DisableKeyword("ENABLE_EDGE_HIGHLIGHTING");
}
if (m_mul_smoothness)
{
m_material.EnableKeyword("ENABLE_SMOOTHNESS_ATTENUAION");
}
else
{
m_material.DisableKeyword("ENABLE_SMOOTHNESS_ATTENUAION");
}
m_material.SetVector("_Color", GetLinearColor());
m_material.SetVector("_Params1", new Vector4(m_fresnel_bias, m_fresnel_scale, m_fresnel_pow, m_intensity));
m_material.SetVector("_Params2", new Vector4(m_edge_intensity, m_edge_threshold, m_edge_radius, 0.0f));
Graphics.Blit(src, dst, m_material);
}
public static GameObject CreateDecal(Material mat, Rect uvCoords, float scale)
{
GameObject decal = new GameObject();
decal.name = "Decal" + decal.GetInstanceID();
decal.AddComponent<MeshFilter>().sharedMesh = DecalMesh("DecalMesh" + decal.GetInstanceID(), mat, uvCoords, scale);
decal.AddComponent<MeshRenderer>().sharedMaterial = mat;
#if UNITY_5
decal.GetComponent<MeshRenderer>().shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
#else
decal.GetComponent<MeshRenderer>().castShadows = false;
#endif
qd_Decal decalComponent = decal.AddComponent<qd_Decal>();
decalComponent.SetScale(scale);
decalComponent.SetTexture( (Texture2D)mat.mainTexture );
decalComponent.SetUVRect(uvCoords);
#if DEBUG
decal.AddComponent<qd_DecalDebug>();
#endif
return decal;
}
public SpriteAnimator(Material material, int columnCount)
{
this.material = material;
this.spriteSheetColumnCount = columnCount;
this.Sequences = new List<SpriteAnimationSequence>();
this.Settings = new SpriteAnimationSettings();
}
public void Apply(CloudsMaterial material, float radius, Transform parent)
{
Remove();
particleMaterial.MaxScale = size.y;
particleMaterial.MaxTrans = maxTranslation;
particleMaterial.NoiseScale = new Vector3(noiseScale.x, noiseScale.y, noiseScale.z / radius);
ParticleMaterial = new Material(ParticleCloudShader);
particleMaterial.ApplyMaterialProperties(ParticleMaterial);
material.ApplyMaterialProperties(ParticleMaterial);
ParticleMaterial.EnableKeyword("SOFT_DEPTH_ON");
volumeHolder = new GameObject();
//Add the renderer here so othe rentities (shadows)
//can easily access it.
Renderer r = volumeHolder.AddComponent<MeshRenderer>();
r.material = ParticleMaterial;
ParticleMaterial.SetMatrix(ShaderProperties._ShadowBodies_PROPERTY, Matrix4x4.zero);
ParticleMaterial.renderQueue = (int)Tools.Queue.Transparent + 2;
r.enabled = false;
volumeHolder.transform.parent = parent;
volumeHolder.transform.localPosition = Vector3.zero;
volumeHolder.transform.localScale = Vector3.one;
volumeHolder.transform.localRotation = Quaternion.identity;
volumeHolder.layer = (int)Tools.Layer.Local;
volumeManager = new VolumeManager(radius, size, ParticleMaterial, volumeHolder.transform, area.x, (int)area.y);
}
public override void OnRecord()
{
if (_material = material)
{
_original = _material.GetTextureScale(propertyName);
}
}
static void SetKeyword(Material m, string keyword, bool state)
{
if (state)
m.EnableKeyword(keyword);
else
m.DisableKeyword(keyword);
}
void OnEnable()
{
foreach(Transform child in transform)
{
//Search for child Loading Background to get the mesh renderer for the background texture
if(child.name == "Loading Background")
{
m_MeshRenderer = child.GetComponent<MeshRenderer>();
}
if(child.name == "Loading Percent")
{
m_LoadingText = child.GetComponent<TextMesh>();
}
}
if(m_MeshRenderer == null)
{
Debug.LogError("Missing a gameobject with the name \'Loading Background\' and a \'MeshRenderer\' component.");
gameObject.SetActive(false);
return;
}
if(m_LoadingText == null)
{
Debug.LogError("Missing a gameobject with the name \'Loading Text\' and a \'TextMesh\' component.");
gameObject.SetActive(false);
return;
}
Material material = new Material(m_MeshRenderer.sharedMaterial);
material.SetTexture("_MainTex", m_TextureToDisplay);
m_MeshRenderer.material = material;
}
// 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;
}
}
}
}
protected Material CheckShaderAndCreateMaterial(Shader s, Material m2Create)
{
if (!s)
{
Debug.Log("Missing shader in " + this.ToString());
enabled = false;
return null;
}
if (s.isSupported && m2Create && m2Create.shader == s)
return m2Create;
if (!s.isSupported)
{
enabled = false;
isSupported = false;
Debug.Log("The shader " + s.ToString() + " on effect " + this.ToString() + " is not supported on this platform!");
return null;
}
else
{
//Debug.Log("Creating material");
m2Create = new Material(s);
m2Create.hideFlags = HideFlags.DontSave;
if (m2Create)
{
return m2Create;
}
else
return null;
}
}
public override void OnRestore()
{
if (_material = material)
{
_material.SetTextureScale(propertyName, _original);
}
}
public override void AssignNewShaderToMaterial(Material material, Shader oldShader, Shader newShader)
{
if (material.HasProperty("_Emission"))
{
material.SetColor("_EmissionColor", material.GetColor("_Emission"));
}
base.AssignNewShaderToMaterial(material, oldShader, newShader);
if ((oldShader == null) || !oldShader.name.Contains("Legacy Shaders/"))
{
SetupMaterialWithBlendMode(material, (BlendMode) ((int) material.GetFloat("_Mode")));
}
else
{
BlendMode opaque = BlendMode.Opaque;
if (oldShader.name.Contains("/Transparent/Cutout/"))
{
opaque = BlendMode.Cutout;
}
else if (oldShader.name.Contains("/Transparent/"))
{
opaque = BlendMode.Fade;
}
material.SetFloat("_Mode", (float) opaque);
Material[] mats = new Material[] { material };
this.DetermineWorkflow(MaterialEditor.GetMaterialProperties(mats));
MaterialChanged(material, this.m_WorkflowMode);
}
}
public static pb_Renderable CreateInstance(Mesh InMesh, Material InMaterial)
{
pb_Renderable ren = ScriptableObject.CreateInstance<pb_Renderable>();
ren.mesh = InMesh;
ren.materials = new Material[] { InMaterial };
return ren;
}
IEnumerator Grow()
{
float f = 0;
float t = 0;
Vector3 originalScale = transform.localScale;
Vector3 targetScale = originalScale * EndScale;
Material originalMaterial = new Material(renderer.material);
Color originalColor = originalMaterial.GetColor("_TintColor");
Color targetColor = new Color(originalColor.r, originalColor.g, originalColor.b, 0F);
renderer.material = originalMaterial;
while (f <= duration)
{
t = f / duration;
transform.localScale = Vector3.Lerp(originalScale, targetScale, t);
originalMaterial.SetColor("_TintColor", Color.Lerp(originalColor, targetColor, t));
f += Time.deltaTime;
yield return new WaitForEndOfFrame();
}
if (mode == FXmode.DestroyAtEnd)
Destroy(gameObject);
else if (mode == FXmode.Loop)
Play();
}
protected override bool CheckResources()
{
CheckSupport(mode == ColorCorrectionMode.Advanced);
ccMaterial = CheckShaderAndCreateMaterial(simpleColorCorrectionCurvesShader, ccMaterial);
ccDepthMaterial = CheckShaderAndCreateMaterial(colorCorrectionCurvesShader, ccDepthMaterial);
selectiveCcMaterial = CheckShaderAndCreateMaterial(colorCorrectionSelectiveShader, selectiveCcMaterial);
if (!rgbChannelTex)
rgbChannelTex = new Texture2D(256, 4, TextureFormat.ARGB32, false, true);
if (!rgbDepthChannelTex)
rgbDepthChannelTex = new Texture2D(256, 4, TextureFormat.ARGB32, false, true);
if (!zCurveTex)
zCurveTex = new Texture2D(256, 1, TextureFormat.ARGB32, false, true);
rgbChannelTex.hideFlags = HideFlags.DontSave;
rgbDepthChannelTex.hideFlags = HideFlags.DontSave;
zCurveTex.hideFlags = HideFlags.DontSave;
rgbChannelTex.wrapMode = TextureWrapMode.Clamp;
rgbDepthChannelTex.wrapMode = TextureWrapMode.Clamp;
zCurveTex.wrapMode = TextureWrapMode.Clamp;
if (!isSupported)
ReportAutoDisable();
return isSupported;
}
public static string GetMaterialPath(UnityEngine.Material material)
{
var mat = material;
string path = UnityEditor.AssetDatabase.GetAssetPath(mat);
if (path == "Resources/unity_builtin_extra")
{
path = "Library/" + mat.name + ".mat";
}
if (!path.Contains(".mat"))
{
path += "." + mat.name + ".mat";//.obj文件此时应该导出不同的材质文件，GetAssetPath获取的确实同一个
}
path = PathHelper.CheckFileName(path + ".json");
return(path);
}
static public int SetBuffer(IntPtr l)
{
try{
UnityEngine.Material self = (UnityEngine.Material)checkSelf(l);
System.String a1;
checkType(l, 2, out a1);
UnityEngine.ComputeBuffer a2;
checkType(l, 3, out a2);
self.SetBuffer(a1, a2);
return(0);
}
catch (Exception e) {
LuaDLL.luaL_error(l, e.ToString());
return(0);
}
}
void LoadTextures()
{
if (textures == null)
{
int len = _textures.Length;
textures = new UnityEngine.Texture2D[len];
allmaterials = new UnityEngine.Material[len];
for (int i = 0; i < len; i++)
{
string[] parts = new string(_textures[i].name).Split('/');
textures[i] = Resources.Load(parts[parts.Length - 1]) as Texture2D;
allmaterials[i] = new UnityEngine.Material(Shader.Find("Diffuse"));
allmaterials[i].mainTexture = textures[i];
}
}
}
//create changePokemon
//create generateId
/// <summary>
/// generates a new Load RenderMesh value using the given values
/// </summary>
/// <param name="pokemonName"></param>
/// <returns></returns>
/* public static RenderMesh LoadPokemonRenderMesh(string pokemonName)
* {
* /// string dataPath = Application.dataPath + "/Resources/Pokemon/" + pokemonName + "/" + pokemonName + ".prefab";
* // if (!File.Exists(dataPath))
* // {
* // Debug.LogError(dataPath);
* // }
* GameObject go = Resources.Load("Pokemon/" + pokemonName + "/" + pokemonName, typeof(GameObject)) as GameObject;
* if (go == null) Debug.LogError("Failed to get the render mesh gameobject");
* else Debug.Log("Succesfully Loaded \""+pokemonName+"\"");
* //verify this works with physics
* RenderMesh renderer = new RenderMesh
* {
* mesh = go.GetComponent<MeshFilter>().sharedMesh,
* material = go.GetComponent<MeshRenderer>().sharedMaterial,
* castShadows = UnityEngine.Rendering.ShadowCastingMode.On,
* receiveShadows = true
* };
*
* return renderer;
* }*/
public static RenderMesh LoadEnviromentRenderMesh(EnviromentData enviromentData, string startPath)
{
startPath += enviromentData.entityName.ToString() + "/" + enviromentData.entityName.ToString();
Debug.Log("adasdadasd" + startPath);
GameObject go = Resources.Load("Enviroment/Models/" + startPath, typeof(GameObject)) as GameObject;
UnityEngine.Material _mat = Resources.Load("Enviroment/Models/" + startPath, typeof(UnityEngine.Material)) as UnityEngine.Material;
UnityEngine.Mesh _mesh = go.GetComponent <MeshFilter>().sharedMesh;
RenderMesh renderer = new RenderMesh
{
mesh = _mesh,
material = _mat
};
return(renderer);
}
private NormalTextureInfo ExportNormalTextureInfo(
UnityEngine.Texture texture,
TextureMapType textureMapType,
UnityEngine.Material material)
{
var info = new NormalTextureInfo();
info.Index = ExportTexture(texture, textureMapType);
if (material.HasProperty("_BumpScale"))
{
info.Scale = material.GetFloat("_BumpScale");
}
return(info);
}
private void DrawMaterialField()
{
if (_material == null)
{
_tmpRect.Set(2, 2, 152, 22);
EditorGUI.DrawRect(_tmpRect, UnityEngine.Color.magenta);
}
_tmpRect.Set(3, 3, 150, 20);
UnityEngine.Material newMaterial = (UnityEngine.Material)EditorGUI.ObjectField(_tmpRect, "", _material, typeof(UnityEngine.Material), false);
if (_material != newMaterial)
{
_material = newMaterial;
_assetPath = AssetDatabase.GetAssetPath(_material);
TriggerChangeEvent();
}
}
static public int Add_s(IntPtr l)
{
try{
UnityEngine.Material a1;
checkType(l, 1, out a1);
System.Int32 a2;
checkType(l, 2, out a2);
UnityEngine.Material ret = UnityEngine.UI.StencilMaterial.Add(a1, a2);
pushValue(l, ret);
return(1);
}
catch (Exception e) {
LuaDLL.luaL_error(l, e.ToString());
return(0);
}
}
private OcclusionTextureInfo ExportOcclusionTextureInfo(
UnityEngine.Texture texture,
TextureMapType textureMapType,
UnityEngine.Material material)
{
var info = new OcclusionTextureInfo();
info.Index = ExportTexture(texture, textureMapType);
if (material.HasProperty("_OcclusionStrength"))
{
info.Strength = material.GetFloat("_OcclusionStrength");
}
return(info);
}
static bool Graphics_DrawMesh__Mesh__Vector3__Quaternion__Material__Int32(JSVCall vc, int argc)
{
int len = argc;
if (len == 5)
{
UnityEngine.Mesh arg0 = (UnityEngine.Mesh)JSMgr.datax.getObject((int)JSApi.GetType.Arg);
UnityEngine.Vector3 arg1 = (UnityEngine.Vector3)JSApi.getVector3S((int)JSApi.GetType.Arg);
UnityEngine.Quaternion arg2 = (UnityEngine.Quaternion)JSMgr.datax.getObject((int)JSApi.GetType.Arg);
UnityEngine.Material arg3 = (UnityEngine.Material)JSMgr.datax.getObject((int)JSApi.GetType.Arg);
System.Int32 arg4 = (System.Int32)JSApi.getInt32((int)JSApi.GetType.Arg);
UnityEngine.Graphics.DrawMesh(arg0, arg1, arg2, arg3, arg4);
}
return(true);
}
static bool Graphics_DrawMesh__Mesh__Matrix4x4__Material__Int32__Camera(JSVCall vc, int argc)
{
int len = argc;
if (len == 5)
{
UnityEngine.Mesh arg0 = (UnityEngine.Mesh)JSMgr.datax.getObject((int)JSApi.GetType.Arg);
UnityEngine.Matrix4x4 arg1 = (UnityEngine.Matrix4x4)JSMgr.datax.getObject((int)JSApi.GetType.Arg);
UnityEngine.Material arg2 = (UnityEngine.Material)JSMgr.datax.getObject((int)JSApi.GetType.Arg);
System.Int32 arg3 = (System.Int32)JSApi.getInt32((int)JSApi.GetType.Arg);
UnityEngine.Camera arg4 = (UnityEngine.Camera)JSMgr.datax.getObject((int)JSApi.GetType.Arg);
UnityEngine.Graphics.DrawMesh(arg0, arg1, arg2, arg3, arg4);
}
return(true);
}
private static void ToUnityMaterialProperties <T, U>(UnityEngine.Material unity_material, Dictionary <string, T> values, Action <UnityEngine.Material, string, T> setter)
{
if (values != null && setter != null && unity_material != null)
{
lock (values)
{
foreach (KeyValuePair <string, T> pair in values)
{
if (unity_material.HasProperty(pair.Key))
{
setter(unity_material, pair.Key, pair.Value);
}
}
}
}
}
public int GetUnityMaterialIndex(UnityEngine.Material material)
{
int index = -1;
if (material != null)
{
if (!unityMaterials.TryGetValue(material, out index))
{
index = unityMaterials.Count;
unityMaterials.Add(material, index);
}
}
return(index);
}
public MaterialId GetMaterialId(UnityEngine.Material materialObj)
{
for (var i = 0; i < Materials.Count; i++)
{
if (Materials[i].ContentsWithoutVC == materialObj || Materials[i].ContentsWithVC == materialObj)
{
return(new MaterialId
{
Id = i,
Root = this
});
}
}
return(null);
}
public MaterialId GetMaterialId(GLTFRoot root, UnityEngine.Material materialObj)
{
for (var i = 0; i < _materials.Count; i++)
{
if (_materials[i] == materialObj)
{
return(new MaterialId
{
Id = i,
Root = root
});
}
}
return(null);
}
static public int SetTextureOffset(IntPtr l)
{
try {
UnityEngine.Material self = (UnityEngine.Material)checkSelf(l);
System.String a1;
checkType(l, 2, out a1);
UnityEngine.Vector2 a2;
checkType(l, 3, out a2);
self.SetTextureOffset(a1, a2);
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
protected override void OnRebuildRenderData()
{
base.OnRebuildRenderData();
if (this.texture == null)
{
return;
}
this.ensureMaterial();
if (this.material == null)
{
return;
}
if (this.renderMaterial == null)
{
UnityEngine.Material material = new UnityEngine.Material(this.material)
{
hideFlags = HideFlags.DontSave,
name = string.Concat(this.material.name, " (copy)")
};
this.renderMaterial = material;
}
this.renderMaterial.mainTexture = this.texture;
this.renderData.Material = this.renderMaterial;
float units = base.PixelsToUnits();
float single = 0f;
float single1 = 0f;
float single2 = this.size.x * units;
float single3 = -this.size.y * units;
Vector3 num = this.pivot.TransformToUpperLeft(this.size).RoundToInt() * units;
this.renderData.Vertices.Add(new Vector3(single, single1, 0f) + num);
this.renderData.Vertices.Add(new Vector3(single2, single1, 0f) + num);
this.renderData.Vertices.Add(new Vector3(single2, single3, 0f) + num);
this.renderData.Vertices.Add(new Vector3(single, single3, 0f) + num);
this.renderData.Triangles.AddRange(dfTextureSprite.TRIANGLE_INDICES);
this.rebuildUV(this.renderData);
Color32 color32 = base.ApplyOpacity(this.color);
this.renderData.Colors.Add(color32);
this.renderData.Colors.Add(color32);
this.renderData.Colors.Add(color32);
this.renderData.Colors.Add(color32);
if (this.fillAmount < 1f)
{
this.doFill(this.renderData);
}
}
public override DrawStackNode Allocate(DrawInfo info, SurfaceTexture tex, ref int stackID)
{
// Stack required.
// Allocate a target stack now:
int targetStack = stackID;
DrawStack stack = tex.GetStack(targetStack, info);
stackID++;
float curAmplitude = 1f;
float curFrequency = (float)Frequency.GetValue(0, 0);
float lacunarity = (float)Lacunarity.GetValue(0, 0);
float persistence = (float)Persistence.GetValue(0, 0);
int mOctaveCount = (int)OctaveCount.GetValue(0, 0);
Material[] materials = new Material[mOctaveCount];
// Stack up "OctaveCount" quads.
for (int currentOctave = 0; currentOctave < mOctaveCount; currentOctave++)
{
// Update seed:
long seed = (Seed + currentOctave) & 0xffffffff;
// And a material.
UnityEngine.Material material = GetMaterial(TypeID, SubMaterialID);
// _Data (Seed, Frequency, Amplitude, Jitter):
material.SetVector("_Data", new Vector4(seed, curFrequency, curAmplitude, 0f));
// Add to set:
materials[currentOctave] = material;
curFrequency *= lacunarity;
curAmplitude *= persistence;
}
// Create our node:
BlockStackNode bsn = new BlockStackNode();
DrawStore = bsn;
bsn.Mesh = info.Mesh;
bsn.Materials = materials;
bsn.Stack = stack;
return(bsn);
}
private UnityEngine.Material CreateMaterialFromXml(XElement xml)
{
// Does this material support alpha color key?
string htmlColor = ImportUtils.GetAttributeAsString(xml, "alphaColorKey", "");
bool usesDepthShader = ImportUtils.GetAttributeAsBoolean(xml, "usesDepthShaders", false);
// Determine which shader we sould be using
string shaderName = "Tiled2Unity/";
// Are we using depth shaders?
if (usesDepthShader)
{
shaderName += "Depth";
}
else
{
shaderName += "Default";
}
// Are we using color key shaders?
Color?keyColor = null;
if (!String.IsNullOrEmpty(htmlColor))
{
shaderName += " Color Key";
// Sometimes Tiled saves out color without the leading # but we expect it to be there
if (!htmlColor.StartsWith("#"))
{
htmlColor = "#" + htmlColor;
}
byte r = byte.Parse(htmlColor.Substring(1, 2), System.Globalization.NumberStyles.HexNumber);
byte g = byte.Parse(htmlColor.Substring(3, 2), System.Globalization.NumberStyles.HexNumber);
byte b = byte.Parse(htmlColor.Substring(5, 2), System.Globalization.NumberStyles.HexNumber);
keyColor = new Color32(r, g, b, 255);
}
UnityEngine.Material material = new UnityEngine.Material(UnityEngine.Shader.Find(shaderName));
if (keyColor.HasValue)
{
material.SetColor("_AlphaColorKey", keyColor.Value);
}
return(material);
}
protected void RestShader(UnityEngine.Material targetMat)
{
if (targetMat == null)
{
return;
}
Shader tshader = Shader.Find(targetMat.shader.name);
if (tshader != null)
{
targetMat.shader = tshader;
}
else
{
Debug.LogError("未能找到对应的shader.name = " + targetMat.shader.name);
}
}
private static void CreateMaterialAsset(UnityEngine.Material material, string assetName)
{
var prefabName = Path.GetFileNameWithoutExtension(assetName);
var directorty = Path.GetDirectoryName(assetName);
var noiseTexture = material.GetTexture("_NoiseTexture");
if (noiseTexture != null && !AssetDatabase.Contains(noiseTexture))
{
AssetDatabase.CreateAsset(noiseTexture, Path.Combine(directorty, prefabName + "_noiseTexture.asset"));
}
if (!AssetDatabase.Contains(material))
{
AssetDatabase.CreateAsset(material, Path.Combine(directorty, prefabName + ".mat"));
}
}
protected virtual void ApplyTextureTransform(GLTF.Schema.TextureInfo def, UnityEngine.Material mat, string texName)
{
GLTF.Schema.Extension extension;
if (_root.ExtensionsUsed != null &&
_root.ExtensionsUsed.Contains(ExtTextureTransformExtensionFactory.EXTENSION_NAME) &&
def.Extensions != null &&
def.Extensions.TryGetValue(ExtTextureTransformExtensionFactory.EXTENSION_NAME, out extension))
{
ExtTextureTransformExtension ext = (ExtTextureTransformExtension)extension;
Vector2 temp = ext.Offset.ToUnityVector2();
temp = new Vector2(temp.x, -temp.y);
mat.SetTextureOffset(texName, temp);
mat.SetTextureScale(texName, ext.Scale.ToUnityVector2());
}
}
public UnityEngine.Material ReturnColour(AtlasColours inColour, Constants.RossColour rossCol)
{
if (myMaterialWithColour[(int)inColour] == null)
{
myMaterialWithColour[(int)inColour] = new UnityEngine.Material(Shader.Find("Pi/OpaqueOverlay"));
UnityEngine.Color tempC = new UnityEngine.Color();
tempC.a = 0.8f;
tempC.r = rossCol.cRed;
tempC.g = rossCol.cGreen;
tempC.b = rossCol.cBlue;
myMaterialWithColour[(int)inColour].color = tempC;
}
return(myMaterialWithColour[(int)inColour]);
}
private void LoadPrimitive(Primitive primitive, string name, Matrix4x4 matrix)
{
if (primitive.Mode != Primitive.ModeEnum.TRIANGLES)
{
throw new System.NotImplementedException("Unsupported primitive mode");
}
GameObject obj = new GameObject(name);
MeshRenderer renderer = obj.AddComponent <MeshRenderer>();
MeshFilter filter = obj.AddComponent <MeshFilter>();
filter.mesh = new UnityEngine.Mesh();
string posID = primitive.Attributes["POSITION"];
Vector3[] positions = new AccessorReader(m_model, posID).ReadVector3Array();
for (int i = 0; i < positions.Length; ++i)
{
positions[i] = matrix * new Vector4(positions[i].x, positions[i].y, positions[i].z, 1);
}
filter.mesh.vertices = positions;
string indicesID = primitive.Indices;
int[] indices = new AccessorReader(m_model, indicesID).ReadIntArray();
filter.mesh.triangles = indices;
if (primitive.Attributes.ContainsKey("TEXCOORD_0"))
{
string texCoordID = primitive.Attributes["TEXCOORD_0"];
try
{
Vector2[] texCoord = new AccessorReader(m_model, texCoordID).ReadVector2Array();
filter.mesh.uv = texCoord;
}
catch (System.TypeLoadException e) {; }
}
string materialID = primitive.Material;
UnityEngine.Material material = LoadMaterial(m_model.Materials[materialID]);
renderer.material = material;
filter.mesh.RecalculateBounds();
filter.mesh.RecalculateNormals();
}
public override DrawStackNode Allocate(DrawInfo info, SurfaceTexture tex, ref int stackID)
{
// RandomVectors required.
if (RandomVectors == null)
{
RandomVectors = Resources.Load("Loonim-Random-Vectors") as Texture2D;
}
// Stack required.
// Get a material:
UnityEngine.Material material = GetMaterial(TypeID, SubMaterialID);
// _Data:
material.SetVector(
"_Data",
DataVector
);
// Allocate a target stack now:
int targetStack = stackID;
DrawStack stack = tex.GetStack(targetStack, info);
stackID++;
// Allocate sources:
AllocateSources(material, info, tex, targetStack, 2);
// Random vectors are always SRC2:
material.SetTexture("_Src2", RandomVectors);
// Create our node:
MaterialStackNode matNode = DrawStore as MaterialStackNode;
if (matNode == null)
{
matNode = new MaterialStackNode();
DrawStore = matNode;
matNode.Mesh = info.Mesh;
}
matNode.Material = material;
matNode.Stack = stack;
return(matNode);
}
protected static bool TrySetTexture(
Schema.TextureInfo textureInfo,
UnityEngine.Material material,
int propertyId,
ref Schema.Texture[] textures,
ref Schema.Image[] schemaImages,
ref Dictionary <int, Texture2D>[] imageVariants
)
{
if (textureInfo != null && textureInfo.index >= 0)
{
int bcTextureIndex = textureInfo.index;
if (textures != null && textures.Length > bcTextureIndex)
{
var txt = textures[bcTextureIndex];
var imageIndex = txt.GetImageIndex();
Texture2D img = null;
if (imageVariants != null &&
imageIndex >= 0 &&
imageVariants.Length > imageIndex &&
imageVariants[imageIndex] != null &&
imageVariants[imageIndex].TryGetValue(txt.sampler, out img)
)
{
if (textureInfo.texCoord != 0)
{
Debug.LogError(ERROR_MULTI_UVS);
}
material.SetTexture(propertyId, img);
var isKtx = txt.isKtx;
TrySetTextureTransform(textureInfo, material, propertyId, isKtx);
return(true);
}
else
{
Debug.LogErrorFormat("Image #{0} not found", imageIndex);
}
}
else
{
Debug.LogErrorFormat("Texture #{0} not found", bcTextureIndex);
}
}
return(false);
}
static bool Material_Material2(JSVCall vc, int argc)
{
int _this = JSApi.getObject((int)JSApi.GetType.Arg);
JSApi.attachFinalizerObject(_this);
--argc;
int len = argc;
if (len == 1)
{
UnityEngine.Material arg0 = (UnityEngine.Material)JSMgr.datax.getObject((int)JSApi.GetType.Arg);
JSMgr.addJSCSRel(_this, new UnityEngine.Material(arg0));
}
return(true);
}
private void ApplyTexture(UnityEngine.Material mat, string propertyName, string textureFile)
{
var tex = LoadTexture(textureFile, out var texType);
if (tex == null)
{
return;
}
mat.SetTexture(propertyName, tex);
// Unity is stupid and flips DXT textures upside down (or more likely fails to flip them right side up). so we need to do it ourselves...
if (texType == TextureHelper.TextureType.DXT)
{
mat.SetTextureScale(propertyName, new Vector2(1f, -1f));
}
}
public StandardMaterial(UnityEngine.Material source, UnityEngine.MeshRenderer instanceData) :
base(source, instanceData)
{
diffuseColor = source.color;
uvOffset = source.mainTextureOffset;
uvScale = source.mainTextureScale;
diffuseTexture = ResourceCache.Instance.GetTexture(source.mainTexture);
if (diffuseTexture == null)
{
diffuseTexture = ResourceCache.Instance.GetTexture(UnityEngine.Texture2D.whiteTexture);
}
normalTexture = ResourceCache.Instance.GetTexture(source.GetTexture("_BumpMap"));
if (instanceData.lightmapIndex >= 0)
{
lightmapTexture = ResourceCache.Instance.GetTexture(LightmapSettings.lightmaps[instanceData.lightmapIndex].lightmapColor);
}
}
static public int Lerp(IntPtr l)
{
try {
UnityEngine.Material self = (UnityEngine.Material)checkSelf(l);
UnityEngine.Material a1;
checkType(l, 2, out a1);
UnityEngine.Material a2;
checkType(l, 3, out a2);
System.Single a3;
checkType(l, 4, out a3);
self.Lerp(a1, a2, a3);
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int Lerp(IntPtr l)
{
try {
UnityEngine.Material self = (UnityEngine.Material)checkSelf(l);
UnityEngine.Material a1;
checkType(l, 2, out a1);
UnityEngine.Material a2;
checkType(l, 3, out a2);
System.Single a3;
checkType(l, 4, out a3);
self.Lerp(a1, a2, a3);
return(0);
}
catch (Exception e) {
LuaDLL.luaL_error(l, e.ToString());
return(0);
}
}
