public static UVData CreateUVData(GameObject target)
{
Mesh targetMesh = null;
SkinnedMeshRenderer skin = target.GetComponent <SkinnedMeshRenderer>();
MeshFilter meshFilter = target.GetComponent <MeshFilter>();
if (skin)
{
targetMesh = skin.sharedMesh;
}
else if (meshFilter)
{
targetMesh = meshFilter.sharedMesh;
}
if (targetMesh == null)
{
return(null);
}
UVData dt = new UVData();
dt.m_Target = target;
dt.m_UvMeshes = new Mesh[4];
dt.m_UvMeshes[0] = CreateUVMesh(targetMesh, 0);
dt.m_UvMeshes[1] = CreateUVMesh(targetMesh, 1);
dt.m_UvMeshes[2] = CreateUVMesh(targetMesh, 2);
dt.m_UvMeshes[3] = CreateUVMesh(targetMesh, 3);
return(dt);
}
public void SetBaseTexture(AtlasTexture atlasTexture)
{
selectedSideTexture = atlasTexture;
UVData uvData = customTerrain.GetUVDataFor(selectedSideTexture);
float width = uvData.uMax - uvData.uMin;
float height = uvData.vMax - uvData.vMin;
sideTextureRawImage.uvRect = new Rect(uvData.uMin, uvData.vMin, width, height);
}
void AddQuadTexture(AtlasTexture atlasTexture)
{
UVData uvData = GetUVDataFor(atlasTexture);
uvs.Add(new Vector2(uvData.uMin, uvData.vMin));
uvs.Add(new Vector2(uvData.uMin, uvData.vMax));
uvs.Add(new Vector2(uvData.uMax, uvData.vMax));
uvs.Add(new Vector2(uvData.uMax, uvData.vMin));
}
private void CreateUVData(GameObject gameObject)
{
if (gameObject && gameObject.activeSelf)
{
UVData uvData = UVData.CreateUVData(gameObject);
if (uvData != null)
{
m_UVDatas.Add(uvData);
}
}
}
public void Initialize()
{
if (!((UnityEngine.Object)maskAtlas == (UnityEngine.Object)null) && maskAtlas.items != null)
{
biomeMasks = new Dictionary <string, BiomeMaskData>();
TextureAtlas.Item[] items = maskAtlas.items;
for (int i = 0; i < items.Length; i++)
{
TextureAtlas.Item item = items[i];
string name = item.name;
int num = name.IndexOf('/');
string text = name.Substring(0, num);
string value = name.Substring(num + 1, 4);
text = text.ToLower();
for (int num2 = text.IndexOf('_'); num2 != -1; num2 = text.IndexOf('_'))
{
text = text.Remove(num2, 1);
}
BiomeMaskData value2 = null;
if (!biomeMasks.TryGetValue(text, out value2))
{
value2 = new BiomeMaskData(text);
biomeMasks[text] = value2;
}
int num3 = Convert.ToInt32(value, 2);
Tile tile = value2.tiles[num3];
if (tile.variationUVs == null)
{
tile.isSource = true;
tile.variationUVs = new UVData[1];
}
else
{
UVData[] array = new UVData[tile.variationUVs.Length + 1];
Array.Copy(tile.variationUVs, array, tile.variationUVs.Length);
tile.variationUVs = array;
}
Vector4 vector = new Vector4(item.uvBox.x, item.uvBox.w, item.uvBox.z, item.uvBox.y);
Vector2 bl = new Vector2(vector.x, vector.y);
Vector2 br = new Vector2(vector.z, vector.y);
Vector2 tl = new Vector2(vector.x, vector.w);
Vector2 tr = new Vector2(vector.z, vector.w);
UVData uVData = new UVData(bl, br, tl, tr);
tile.variationUVs[tile.variationUVs.Length - 1] = uVData;
value2.tiles[num3] = tile;
}
foreach (KeyValuePair <string, BiomeMaskData> biomeMask in biomeMasks)
{
biomeMask.Value.GenerateRotations();
biomeMask.Value.Validate();
}
}
}
void AddTriangleTexture(AtlasTexture atlasTexture, RelativeDirection rightAngle)
{
UVData uvData = GetUVDataFor(atlasTexture);
if (rightAngle == RelativeDirection.LL)
{
uvs.Add(new Vector2(uvData.uMin, uvData.vMin));
uvs.Add(new Vector2(uvData.uMin, uvData.vMax));
uvs.Add(new Vector2(uvData.uMax, uvData.vMin));
}
else if (rightAngle == RelativeDirection.LR)
{
uvs.Add(new Vector2(uvData.uMin, uvData.vMin));
uvs.Add(new Vector2(uvData.uMax, uvData.vMax));
uvs.Add(new Vector2(uvData.uMax, uvData.vMin));
}
}
public UVData[] GetNonNullRotationUVs(int dest_mask)
{
UVData[] array = null;
int num = dest_mask;
for (int i = 0; i < 3; i++)
{
int num2 = (num & 1) >> 0;
int num3 = (num & 2) >> 1;
int num4 = (num & 4) >> 2;
int num5 = (num & 8) >> 3;
int num6 = (num5 << 2) | (num4 << 0) | (num3 << 3) | (num2 << 1);
if (tiles[num6].isSource)
{
array = new UVData[tiles[num6].variationUVs.Length];
for (int j = 0; j < tiles[num6].variationUVs.Length; j++)
{
UVData uVData = tiles[num6].variationUVs[j];
UVData uVData2 = uVData;
switch (i)
{
case 2:
uVData2 = new UVData(uVData.br, uVData.tr, uVData.bl, uVData.tl);
break;
case 1:
uVData2 = new UVData(uVData.tr, uVData.tl, uVData.br, uVData.bl);
break;
case 0:
uVData2 = new UVData(uVData.tl, uVData.bl, uVData.tr, uVData.br);
break;
default:
Debug.LogError("Unhandled rotation case");
break;
}
array[j] = uVData2;
}
break;
}
num = num6;
}
return(array);
}
bool DrawSheet(Rect rect, UVData uvset, bool withBG = false, Texture2D tex = null)
{
var result = true;
if (_drawMatT == null)
{
var shader = Shader.Find("Unlit/Texture");
_drawMatT = new Material(shader);
}
if (_drawMatC == null)
{
var shader = Shader.Find("Hidden/Internal-Colored");
_drawMatC = new Material(shader);
}
if (Event.current.type == EventType.Repaint)
{
GUI.BeginClip(rect);
GL.PushMatrix();
GL.Clear(true, false, Color.black);
// background
if (withBG && tex != null && _drawMatT.HasProperty("_MainTex"))
{
_drawMatT.mainTexture = tex;
}
else
{
_drawMatT.mainTexture = Texture2D.blackTexture;
}
_drawMatT.SetPass(0);
GL.Begin(GL.QUADS);
GL.Color(Color.black);
GL.TexCoord2(0, 1);
GL.Vertex3(0, 0, 0);
GL.TexCoord2(1, 1);
GL.Vertex3(rect.width, 0, 0);
GL.TexCoord2(1, 0);
GL.Vertex3(rect.width, rect.height, 0);
GL.TexCoord2(0, 0);
GL.Vertex3(0, rect.height, 0);
GL.End();
_drawMatC.SetPass(0);
// draw grid
GL.Begin(GL.LINES);
int count = 25;
var sx = 0;
var sy = 0;
var dx = ( float )rect.width / count;
var dy = ( float )rect.height / count;
for (int i = 0; i <= count; ++i)
{
float f = (i % 5 == 0) ? 0.5f : 0.2f;
GL.Color(new Color(f, f, f, 1));
sx = ( int )Math.Ceiling(dx * i);
sy = ( int )Math.Ceiling(dy * i);
GL.Vertex3(sx, 0, 0);
GL.Vertex3(sx, rect.height, 0);
GL.Vertex3(0, sy, 0);
GL.Vertex3(rect.width, sy, 0);
}
GL.End();
var scale = new Vector2(rect.width, rect.height);
var subMeshes = uvset.subMeshes;
var uv = uvset.uvs[( int )m_selectUVChannel];
if (uv != null && uv.Length > 0)
{
GL.Begin(GL.LINES);
GL.Color(Color.green);
GL.TexCoord2(0, 0);
for (int j = 0; j < subMeshes.Count; ++j)
{
var tri = subMeshes[j];
for (int t = 0; t < tri.Length; t += 3)
{
var pt0 = uv[tri[t]];
var pt1 = uv[tri[t + 1]];
var pt2 = uv[tri[t + 2]];
var b = false;
if (pt0.x < 0 || pt0.x > 1)
{
result = false;
}
if (pt0.y < 0 || pt0.y > 1)
{
result = false;
}
if (pt1.x < 0 || pt1.x > 1)
{
result = false;
}
if (pt1.y < 0 || pt1.y > 1)
{
result = false;
}
if (pt2.x < 0 || pt2.x > 1)
{
result = false;
}
if (pt2.y < 0 || pt2.y > 1)
{
result = false;
}
pt0.x = ClampRepeatUV(pt0.x, ref b);
pt0.y = ClampRepeatUV(pt0.y, ref b);
pt1.x = ClampRepeatUV(pt1.x, ref b);
pt1.y = ClampRepeatUV(pt1.y, ref b);
pt2.x = ClampRepeatUV(pt2.x, ref b);
pt2.y = ClampRepeatUV(pt2.y, ref b);
pt0.y = 1 - pt0.y;
pt1.y = 1 - pt1.y;
pt2.y = 1 - pt2.y;
pt0.Scale(scale);
pt1.Scale(scale);
pt2.Scale(scale);
if (b)
{
GL.Color(Color.red);
}
else
{
GL.Color(Color.green);
}
GL.Vertex3(pt0.x, pt0.y, 0);
GL.Vertex3(pt1.x, pt1.y, 0);
GL.Vertex3(pt1.x, pt1.y, 0);
GL.Vertex3(pt2.x, pt2.y, 0);
GL.Vertex3(pt2.x, pt2.y, 0);
GL.Vertex3(pt0.x, pt0.y, 0);
}
}
GL.End();
}
GL.PopMatrix();
GUI.EndClip();
}
return(result);
}
static UVData GetMeshUVData(Mesh mesh)
{
var assetPath = AssetDatabase.GetAssetPath(mesh);
UVData result = null;
if (String.IsNullOrEmpty(assetPath))
{
result = null;
}
else
{
UVData md = null;
var importer = AssetImporter.GetAtPath(assetPath) as ModelImporter;
var isReadable = true;
var meshCompression = ModelImporterMeshCompression.Off;
if (importer != null)
{
isReadable = importer.isReadable;
meshCompression = importer.meshCompression;
}
Func <Mesh, UVData> readMeshData = _mesh => {
var _md = new UVData();
_md.name = _mesh.name;
_md.uvs[0] = _mesh.uv;
_md.uvs[1] = _mesh.uv2;
_md.uvs[2] = _mesh.uv3;
_md.uvs[3] = _mesh.uv4;
_md.subMeshes = new List <int[]>(_mesh.subMeshCount);
for (int s = 0; s < _mesh.subMeshCount; ++s)
{
UDebug.Assert(_mesh.GetTopology(s) == MeshTopology.Triangles);
_md.subMeshes.Add(_mesh.GetTriangles(s));
}
return(_md);
};
UVData _cachedMeshData = null;
var key = GetMeshAssetHash(assetPath, mesh);
if (m_MeshUVCache.TryGetValue(key, out _cachedMeshData))
{
md = _cachedMeshData;
}
else
{
if (!isReadable || meshCompression != ModelImporterMeshCompression.Off)
{
if (importer != null)
{
importer.isReadable = true;
importer.meshCompression = ModelImporterMeshCompression.Off;
AssetDatabase.ImportAsset(assetPath);
}
}
try {
md = readMeshData(mesh);
} finally {
if (!isReadable || meshCompression != ModelImporterMeshCompression.Off)
{
if (importer != null)
{
importer.isReadable = isReadable;
importer.meshCompression = meshCompression;
AssetDatabase.ImportAsset(assetPath);
}
}
if (md != null)
{
m_MeshUVCache.Add(key, md);
}
}
}
result = md;
}
return(result);
}
