private void OnUIRemixed(UICore obj)
{
Logger.Log("UICore.OnUIRemixed: UI remixed!");
obj.Panels.ForEach((panel) => { panel.FromThisScene = false; });
obj.RemixUI(true);
}
private void BuildMipmapLevel(int level)
{
var tilesCount = Mathf.Max(1, (BaseLevelSize / Size) >> (MaxLevel - level));
Logger.Log(string.Format("HeightMipmap.BuildMipmapLevel: Build mipmap level: {0}", level));
CurrentLevel = level + 1;
Reset(BaseLevelSize >> (MaxLevel - CurrentLevel), BaseLevelSize >> (MaxLevel - CurrentLevel), Mathf.Min(TopLevelSize << CurrentLevel, Size));
for (int ty = 0; ty < tilesCount; ++ty)
{
for (int tx = 0; tx < tilesCount; ++tx)
{
var offset = (int)0;
var currentTileSize = Mathf.Min(TopLevelSize << level, Size);
for (int j = -2; j <= currentTileSize + 2; ++j)
{
for (int i = -2; i <= currentTileSize + 2; ++i)
{
TileData[offset++] = GetTileHeight(2 * (tx * currentTileSize + i), 2 * (ty * currentTileSize + j));
}
}
SaveTile("Base", level, tx, ty, TileData);
}
}
}
private void SaveScreenshot(Texture2D screenShotTexture, string fileName = "Screenshot")
{
if (screenShotTexture != null)
{
var filePath = string.Format("{0}/{1}_{2:yy.MM.dd-hh.mm.ss}_{3}", Application.dataPath, fileName, DateTime.Now, (int)UnityEngine.Random.Range(0.0f, 100.0f));
switch (Format)
{
case ScreenshotFormat.JPG:
File.WriteAllBytes(filePath + ".jpg", screenShotTexture.EncodeToJPG(100));
break;
case ScreenshotFormat.PNG:
File.WriteAllBytes(filePath + ".png", screenShotTexture.EncodeToPNG());
break;
default:
throw new ArgumentOutOfRangeException();
}
Logger.Log(string.Format("ScreenshotHelper: Screenshot Saved. {0}", filePath));
#if UNITY_EDITOR
AssetDatabase.Refresh();
#endif
}
else
{
Logger.LogError("ScreenshotHelper: screenShotTexture is null!");
}
}
void PreprocessSphericalDem(InputMap source, string tempFolder, string destinationFolder)
{
if (DestinationTileSize % DestinationMinTileSize != 0)
{
throw new InvalidParameterException("DestinationTileSize must be a multiple of DestinationMinTileSize!");
}
var startTime = Time.realtimeSinceStartup;
var destinationSize = DestinationTileSize << DestinationMaxLevel;
IHeightFunction2D function1 = new SphericalHeightFunction(source, ProjectionHelper.Projection1, destinationSize);
IHeightFunction2D function2 = new SphericalHeightFunction(source, ProjectionHelper.Projection2, destinationSize);
IHeightFunction2D function3 = new SphericalHeightFunction(source, ProjectionHelper.Projection3, destinationSize);
IHeightFunction2D function4 = new SphericalHeightFunction(source, ProjectionHelper.Projection4, destinationSize);
IHeightFunction2D function5 = new SphericalHeightFunction(source, ProjectionHelper.Projection5, destinationSize);
IHeightFunction2D function6 = new SphericalHeightFunction(source, ProjectionHelper.Projection6, destinationSize);
HeightMipmap mipmap1 = new HeightMipmap(function1, DestinationMinTileSize, destinationSize, DestinationTileSize, tempFolder);
HeightMipmap mipmap2 = new HeightMipmap(function2, DestinationMinTileSize, destinationSize, DestinationTileSize, tempFolder);
HeightMipmap mipmap3 = new HeightMipmap(function3, DestinationMinTileSize, destinationSize, DestinationTileSize, tempFolder);
HeightMipmap mipmap4 = new HeightMipmap(function4, DestinationMinTileSize, destinationSize, DestinationTileSize, tempFolder);
HeightMipmap mipmap5 = new HeightMipmap(function5, DestinationMinTileSize, destinationSize, DestinationTileSize, tempFolder);
HeightMipmap mipmap6 = new HeightMipmap(function6, DestinationMinTileSize, destinationSize, DestinationTileSize, tempFolder);
HeightMipmap.SetCube(mipmap1, mipmap2, mipmap3, mipmap4, mipmap5, mipmap6);
mipmap1.Compute(); mipmap1.Generate(0, 0, 0, destinationFolder + "/" + FileName + "1" + ".dat");
mipmap2.Compute(); mipmap2.Generate(0, 0, 0, destinationFolder + "/" + FileName + "2" + ".dat");
mipmap3.Compute(); mipmap3.Generate(0, 0, 0, destinationFolder + "/" + FileName + "3" + ".dat");
mipmap4.Compute(); mipmap4.Generate(0, 0, 0, destinationFolder + "/" + FileName + "4" + ".dat");
mipmap5.Compute(); mipmap5.Generate(0, 0, 0, destinationFolder + "/" + FileName + "5" + ".dat");
mipmap6.Compute(); mipmap6.Generate(0, 0, 0, destinationFolder + "/" + FileName + "6" + ".dat");
Logger.Log(string.Format("PreProcessTerrain.PreprocessDem: Computation time: {0} s", (Time.realtimeSinceStartup - startTime)));
}
private void Rotation(int r, int n, int x, int y, out int xp, out int yp)
{
switch (r)
{
case 0:
xp = x;
yp = y;
break;
case 1:
xp = y;
yp = n - 1 - x;
break;
case 2:
xp = n - 1 - x;
yp = n - 1 - y;
break;
case 3:
xp = n - 1 - y;
yp = x;
break;
default:
xp = 0;
yp = 0;
Logger.LogError("HeightMipmap.Rotation: Something goes wrong!");
Debug.Break();
break;
}
}
private void LoadAssembly(string path)
{
try
{
var assembly = Assembly.LoadFile(path);
var attrbutes = assembly.GetCustomAttributes(typeof(SpaceAddonAssembly), false) as SpaceAddonAssembly[];
if (attrbutes == null || attrbutes.Length == 0)
{
Logger.LogError(string.Format("AssemblyLoader.LoadAssembly: This is not an adddon assembly! {0}", path));
}
else
{
var addonAssembly = attrbutes[0];
var mb = GetAllSubclassesOf <Type, SpaceAddonMonoBehaviour, MonoBehaviour>(assembly);
var aet = new AssemblyExternalTypes(typeof(MonoBehaviour), mb);
var ae = new AssemblyExternal(path, addonAssembly.Name, addonAssembly.Version, assembly, aet);
ExternalAssemblies.Add(ae);
TotalLoaded++;
FireHotPlugin(ae);
}
}
catch (Exception ex)
{
Logger.LogError(string.Format("AssemblyLoader.LoadAssembly: LoadAssembly Exception: {0}", ex.Message));
}
}
private void OnSceneWillBeLoadedNow(EntryPoint sceneName, LoadSceneMode loadSceneMode)
{
Logger.Log("UICore.OnSceneWillBeLoadedNow: OnSceneWillBeLoadedNow!");
Panels.ForEach((panel) => { panel.FromThisScene = false; });
RemixUI(true);
}
public void Generate(int rootLevel, int rootTx, int rootTy, string file)
{
for (int level = 1; level <= MaxLevel; ++level)
{
BuildResiduals(level);
}
File.Delete(file);
var tilesCount = MinLevel + ((1 << (Mathf.Max(MaxLevel - MinLevel, 0) * 2 + 2)) - 1) / 3;
Logger.Log(string.Format("HeightMipmap.Generate: tiles count: {0}", tilesCount));
long[] offsets = new long[tilesCount * 2];
byte[] byteArray = new byte[(7 * 4) + (+MaxR.Length * 4) + (offsets.Length * 8)];
long offset = byteArray.Length;
using (Stream stream = new FileStream(file, FileMode.Create))
{
stream.Seek(0, SeekOrigin.Begin);
stream.Write(byteArray, 0, byteArray.Length);
}
for (int l = 0; l < MinLevel; ++l)
{
ProduceTile(l, 0, 0, ref offset, offsets, file);
}
for (int l = MinLevel; l <= MaxLevel; ++l)
{
ProduceTilesLebeguesOrder(l - MinLevel, 0, 0, 0, ref offset, offsets, file);
}
Buffer.BlockCopy(new int[] { MinLevel }, 0, byteArray, 0, 4);
Buffer.BlockCopy(new int[] { MaxLevel }, 0, byteArray, 4, 4);
Buffer.BlockCopy(new int[] { Size }, 0, byteArray, 8, 4);
Buffer.BlockCopy(new int[] { rootLevel }, 0, byteArray, 12, 4);
Buffer.BlockCopy(new int[] { rootTx }, 0, byteArray, 16, 4);
Buffer.BlockCopy(new int[] { rootTy }, 0, byteArray, 20, 4);
Buffer.BlockCopy(new float[] { Scale }, 0, byteArray, 24, 4);
Buffer.BlockCopy(MaxR, 0, byteArray, 28, 4 * MaxR.Length);
Buffer.BlockCopy(offsets, 0, byteArray, 28 + (4 * MaxR.Length), 8 * offsets.Length);
using (Stream stream = new FileStream(file, FileMode.Open))
{
stream.Seek(0, SeekOrigin.Begin);
stream.Write(byteArray, 0, byteArray.Length);
}
for (int i = 0; i < MaxR.Length; i++)
{
Logger.Log(string.Format("HeightMipmap.Generate: Level: {0}; MaxResidual: {1}", i, MaxR[i].ToString("F6")));
}
Logger.Log(string.Format("HeightMipmap.Generate: Saved file path: {0} ", file));
}
public override void Reset(int width, int height, int tileSize)
{
if (Width != width || Height != height)
{
Logger.Log(string.Format("HeightMipmap.Reset: Resetting to width {0} and height {1}; TileSize: {2}", height, width, tileSize));
base.Reset(width, height, tileSize);
if (Left != null)
{
Left.SetCurrentLevel(CurrentLevel);
Left.Reset(width, height, tileSize);
}
if (Right != null)
{
Right.SetCurrentLevel(CurrentLevel);
Right.Reset(width, height, tileSize);
}
if (Bottom != null)
{
Bottom.SetCurrentLevel(CurrentLevel);
Bottom.Reset(width, height, tileSize);
}
if (Top != null)
{
Top.SetCurrentLevel(CurrentLevel);
Top.Reset(width, height, tileSize);
}
}
else
{
if (Left != null)
{
Left.SetCurrentLevel(CurrentLevel);
}
if (Right != null)
{
Right.SetCurrentLevel(CurrentLevel);
}
if (Bottom != null)
{
Bottom.SetCurrentLevel(CurrentLevel);
}
if (Top != null)
{
Top.SetCurrentLevel(CurrentLevel);
}
}
}
private void FirePlugins(List <AssemblyExternal> ExternalAssemblies)
{
int counter = 0;
foreach (AssemblyExternal assembly in ExternalAssemblies)
{
counter += assembly.Types.SelectMany(kvp => kvp.Value).Count(v => FirePlugin(v));
}
Logger.Log(string.Format("{0} plugins fired at scene №: {1}", counter, SceneManager.GetActiveScene().buildIndex));
}
private void FirePlugins(List <AssemblyExternal> ExternalAssemblies, int level)
{
int counter = 0;
foreach (AssemblyExternal assembly in ExternalAssemblies)
{
counter += assembly.Types.SelectMany(kvp => kvp.Value).Count(v => FirePlugin(v, level));
}
Logger.Log(string.Format("{0} plugins fired at scene №: {1}", counter, level));
}
public Texture2D LoadTextureFromResources(string textureName)
{
var path = "Textures/" + textureName;
var textureResource = Resources.Load(path, typeof(Texture2D)) as Texture2D;
if (textureResource == null)
{
Logger.Log(string.Format("UniformsManager.LoadTextureFromResources: Failed to load texture from {0}", path));
}
return(textureResource);
}
/// <summary>
/// Preprocess a map into files that can be used with a <see cref="OrthoCPUProducer"/>.
/// </summary>
/// <param name="source">The map to be preprocessed.</param>
/// <param name="tempFolder">Where temporary files must be saved.</param>
/// <param name="destinationFolder">Where the precomputed file must be saved.</param>
void PreprocessPlaneOrtho(InputMap source, string tempFolder, string destinationFolder)
{
var startTime = Time.realtimeSinceStartup;
var destinationSize = DestinationTileSize << DestinationMaxLevel;
IColorFunction2D function = new PlaneColorFunction(source, destinationSize);
ColorMipmap mipmap = new ColorMipmap(function, destinationSize, DestinationTileSize, 2, DestinationChannels, tempFolder);
mipmap.Compute();
mipmap.Generate(0, 0, 0, destinationFolder + "/" + FileName + ".dat");
Logger.Log(string.Format("PreProcessTerrain.PreprocessPlaneOrtho: Computation time: {0} s", (Time.realtimeSinceStartup - startTime)));
}
public HeightMipmap(IHeightFunction2D heightFunction, int topLevelSize, int baseLevelSize, int tileSize, string tempFolder) : base(baseLevelSize, baseLevelSize, tileSize, 1, 200)
{
HeightFunction = heightFunction;
TopLevelSize = topLevelSize;
BaseLevelSize = baseLevelSize;
TempFolder = tempFolder;
Size = tileSize;
Scale = 1.0f;
MinLevel = 0;
MaxLevel = 0;
var size = tileSize;
while (size > topLevelSize)
{
MinLevel += 1;
size /= 2;
}
size = baseLevelSize;
while (size > topLevelSize)
{
MaxLevel += 1;
size /= 2;
}
MaxR = new float[MaxLevel + 1];
TileData = new float[(tileSize + 5) * (tileSize + 5) * 1];
ConstantTile = -1;
Left = null;
Right = null;
Bottom = null;
Top = null;
if (!Directory.Exists(TempFolder))
{
Directory.CreateDirectory(TempFolder);
}
Logger.Log(string.Format("HeightMipmap.ctor: TopLevelSize: {0}; BaseLevelSize: {1}; TileSize: {2}; Scale: {3}; MinLevel: {4}; MaxLevel: {5}", TopLevelSize,
BaseLevelSize,
Size,
Scale,
MinLevel,
MaxLevel));
}
private void Start()
{
Source = GetComponent <InputMap>();
if (Source == null)
{
throw new NullReferenceException("Input map is null. Have you added a Input map component to PreProcess game object?");
}
ApplicationDataPath = Application.dataPath;
try
{
switch ((int)Mode)
{
case (int)MODE.HEIGHT:
PreprocessDem();
break;
case (int)MODE.COLOR:
PreprocessOrtho();
break;
default:
Logger.LogWarning("PreProcessTerrain.Start: Nothing to produce/precompute!");
break;
}
}
finally
{
if (DeleteTempOnFinish)
{
var directory = new DirectoryInfo(ApplicationDataPath + TempFolder);
if (directory.Exists)
{
foreach (var file in directory.GetFiles())
{
file.Delete();
}
}
}
#if UNITY_EDITOR
AssetDatabase.Refresh();
#endif
}
}
void PreprocessOrtho()
{
switch ((int)Type)
{
case (int)TYPE.PLANE:
PreprocessPlaneOrtho(Source, ApplicationDataPath + TempFolder, ApplicationDataPath + DestinationFolder);
break;
case (int)TYPE.SPHERICAL:
throw new NotImplementedException();
default:
Logger.LogWarning("PreProcessTerrain.Preprocess: Nothing to produce/precompute!");
break;
}
}
private void LoadDetectedAssemblies(List <string> allPaths)
{
if (allPaths == null)
{
DetectAssembies(out allPaths);
Logger.LogError("Something wrong with path's array! Detecting assemblies again!");
}
for (int i = 0; i < allPaths.Count; i++)
{
string path = allPaths[i];
//Delay(0.5f, () => { LoadAssembly(path); });
LoadAssembly(path);
}
}
private void ProduceTile(int level, int tx, int ty, ref long offset, long[] offsets, string file)
{
Logger.Log(string.Format("ColorMipmap.ProduceTile: Producing tile {0}:{1}:{2}!", level, tx, ty));
ProduceTile(level, tx, ty);
var tileID = tx + ty * (1 << level) + ((1 << (2 * level)) - 1) / 3;
var isConstant = true;
var constantValue = TileData[0];
for (int i = 1; i < (Size + 2 * Border) * (Size + 2 * Border); ++i)
{
if (TileData[i] != TileData[i - 1])
{
isConstant = false;
break;
}
}
if (isConstant && ConstantTileIDs.ContainsKey(constantValue))
{
Logger.Log("ColorMipmap.ProduceTile: tile is const (All same value)!");
var constantId = ConstantTileIDs[constantValue];
offsets[2 * tileID] = offsets[2 * constantId];
offsets[2 * tileID + 1] = offsets[2 * constantId + 1];
}
else
{
using (Stream stream = new FileStream(file, FileMode.Open))
{
stream.Seek(offset, SeekOrigin.Begin);
stream.Write(TileData, 0, TileData.Length);
}
offsets[2 * tileID] = offset;
offset += TileData.Length;
offsets[2 * tileID + 1] = offset;
}
if (isConstant && !ConstantTileIDs.ContainsKey(constantValue))
{
ConstantTileIDs.Add(constantValue, tileID);
}
}
void PreprocessDem()
{
switch ((int)Type)
{
case (int)TYPE.PLANE:
PreprocessPlaneDem(Source, ApplicationDataPath + TempFolder, ApplicationDataPath + DestinationFolder);
break;
case (int)TYPE.SPHERICAL:
PreprocessSphericalDem(Source, ApplicationDataPath + TempFolder, ApplicationDataPath + DestinationFolder);
break;
default:
Logger.LogWarning("PreProcessTerrain.Preprocess: Nothing to produce/precompute!");
break;
}
}
/// <summary>
/// Preprocess a map into files that can be used with a <see cref="ResidualProducer"/>.
/// </summary>
/// <param name="source">The map to be preprocessed.</param>
/// <param name="tempFolder">Where temporary files must be saved.</param>
/// <param name="destinationFolder">Where the precomputed file must be saved.</param>
void PreprocessPlaneDem(InputMap source, string tempFolder, string destinationFolder)
{
if (DestinationTileSize % DestinationMinTileSize != 0)
{
throw new InvalidParameterException("DestinationTileSize must be a multiple of DestinationMinTileSize!");
}
var startTime = Time.realtimeSinceStartup;
var destinationSize = DestinationTileSize << DestinationMaxLevel;
IHeightFunction2D function = new PlaneHeightFunction(source, destinationSize);
HeightMipmap mipmap = new HeightMipmap(function, DestinationMinTileSize, destinationSize, DestinationTileSize, tempFolder);
mipmap.Compute();
mipmap.Generate(0, 0, 0, destinationFolder + "/" + FileName + ".dat");
Logger.Log(string.Format("PreProcessTerrain.PreprocessPlaneDem: Computation time: {0} s", (Time.realtimeSinceStartup - startTime)));
}
protected override void Pass()
{
Logger.Log(string.Format("AssemblyLoader Initiated at scene №: {0}", SceneManager.GetActiveScene().buildIndex));
if (!Loaded)
{
DetectAndLoadAssemblies();
Loaded = true;
}
if (SceneManager.GetActiveScene().buildIndex == 0 && Loaded)
{
//Delay((TotalDetected + 1) * 2, () => { SceneManager.LoadScene(1); });
SceneManager.LoadScene(1);
}
base.Pass();
}
protected override void Pass()
{
Logger.Log(string.Format("AssemblyLoader.Pass: AssemblyLoader Initiated at scene: {0}", (EntryPoint)SceneManager.GetActiveScene().buildIndex));
if (!Loaded)
{
DetectAndLoadAssemblies();
Loaded = true;
}
if (SceneManager.GetActiveScene().buildIndex == (int)EntryPoint.Init && Loaded)
{
//Delay((TotalDetected + 1) * 2, () => { SceneManager.LoadScene((int)EntryPoint.MainMenu); });
SceneManager.LoadScene((int)EntryPoint.MainMenu);
}
base.Pass();
}
private void BuildResiduals(int level)
{
var tilesCount = Mathf.Max(1, (BaseLevelSize / Size) >> (MaxLevel - level));
Logger.Log(string.Format("HeightMipmap.BuildResiduals: Build residuals level: {0}", level));
CurrentLevel = level;
Reset(BaseLevelSize >> (MaxLevel - CurrentLevel), BaseLevelSize >> (MaxLevel - CurrentLevel), Mathf.Min(TopLevelSize << CurrentLevel, Size));
var parentTile = new float[(Size + 5) * (Size + 5)];
var currentTile = new float[(Size + 5) * (Size + 5)];
var residualTile = new float[(Size + 5) * (Size + 5)];
var levelMaxR = float.NegativeInfinity;
for (int ty = 0; ty < tilesCount; ++ty)
{
for (int tx = 0; tx < tilesCount; ++tx)
{
float maxR, meanR, maxErr;
GetApproxTile(level - 1, tx / 2, ty / 2, parentTile);
GetTile(level, tx, ty, currentTile);
ComputeResidual(parentTile, currentTile, level, tx, ty, residualTile, out maxR, out meanR);
ComputeApproxTile(parentTile, residualTile, level, tx, ty, currentTile, out maxErr);
if (level < MaxLevel)
{
SaveTile("Approx", level, tx, ty, currentTile);
}
SaveTile("Residual", level, tx, ty, residualTile);
if (maxR > levelMaxR)
{
levelMaxR = maxR;
}
Logger.Log(string.Format("HeightMipmap.BuildResiduals: {0}-{1}-{2}; Max Residual: {3:F6}; Max Error: {4:F6}", level, tx, ty, maxR, maxErr));
}
}
MaxR[level] = levelMaxR;
}
private void DetectAssembies(out List <string> allPaths)
{
var path = PathGlobals.GlobalModFolderPath;
allPaths = new List <string>();
try
{
allPaths.AddRange(Directory.GetFiles(path, "*.dll", SearchOption.AllDirectories));
}
catch (Exception ex)
{
Logger.LogError(string.Format("AssemblyLoader.DetectAssembies: Exception: {0}", ex.Message));
}
TotalDetected = allPaths.Count;
Logger.Log(string.Format("AssemblyLoader.DetectAssembies: Assembies Detected: {0}", allPaths.Count));
}
public void Generate(int rootLevel, int rootTx, int rootTy, string file)
{
File.Delete(file);
var tilesCount = ((1 << (MaxLevel * 2 + 2)) - 1) / 3;
Logger.Log(string.Format("ColorMipmap.Generate: tiles count: {0}", tilesCount));
long[] offsets = new long[tilesCount * 2];
byte[] byteArray = new byte[(7 * 4) + (offsets.Length * 8)];
long offset = byteArray.Length;
using (Stream stream = new FileStream(file, FileMode.Create))
{
stream.Seek(0, SeekOrigin.Begin);
stream.Write(byteArray, 0, byteArray.Length);
}
for (int l = 0; l <= MaxLevel; ++l)
{
ProduceTilesLebeguesOrder(l, 0, 0, 0, ref offset, offsets, file);
}
Buffer.BlockCopy(new int[] { MaxLevel }, 0, byteArray, 0, 4);
Buffer.BlockCopy(new int[] { Size }, 0, byteArray, 4, 4);
Buffer.BlockCopy(new int[] { Channels }, 0, byteArray, 8, 4);
Buffer.BlockCopy(new int[] { Border }, 0, byteArray, 12, 4);
Buffer.BlockCopy(new int[] { rootLevel }, 0, byteArray, 16, 4);
Buffer.BlockCopy(new int[] { rootTx }, 0, byteArray, 20, 4);
Buffer.BlockCopy(new int[] { rootTy }, 0, byteArray, 24, 4);
Buffer.BlockCopy(offsets, 0, byteArray, 28, 8 * offsets.Length);
using (Stream stream = new FileStream(file, FileMode.Open))
{
stream.Seek(0, SeekOrigin.Begin);
stream.Write(byteArray, 0, byteArray.Length);
}
ConstantTileIDs.Clear();
Logger.Log(string.Format("ColorMipmap.Generate: Saved file path: {0} ", file));
}
private void BuildBaseLevelTiles()
{
int tilesCount = BaseLevelSize / Size;
Logger.Log(string.Format("ColorMipmap.BuildBaseLevelTiles: Build mipmap level: {0}!", MaxLevel));
for (int ty = 0; ty < tilesCount; ++ty)
{
for (int tx = 0; tx < tilesCount; ++tx)
{
var offset = (int)0;
for (int j = -Border; j < Size + Border; ++j)
{
for (int i = -Border; i < Size + Border; ++i)
{
var color = ColorFunction.GetValue(tx * Size + i, ty * Size + j) * 255.0f;
TileData[offset++] = (byte)Mathf.Round(color.x);
if (Channels > 1)
{
TileData[offset++] = (byte)Mathf.Round(color.y);
}
if (Channels > 2)
{
TileData[offset++] = (byte)Mathf.Round(color.z);
}
if (Channels > 3)
{
TileData[offset++] = (byte)Mathf.Round(color.w);
}
}
}
SaveTile("Base", MaxLevel, tx, ty, TileData);
}
}
}
protected override void Awake()
{
base.Awake();
ApplicationDataPath = Application.dataPath;
if (!UseCaching)
{
// If caching not used load all data into memory.
if (Bytes == BYTES.BIT8)
{
LoadRawFile8(ApplicationDataPath + FileName);
}
else if (Bytes == BYTES.BIT16)
{
LoadRawFile16(ApplicationDataPath + FileName, ByteOrder == BYTE_ORDER.MAC);
}
Logger.Log(string.Format("RawInputMap.Awake: {0} loaded!", FileName));
}
}
public ColorMipmap(IColorFunction2D colorFunction, int baseLevelSize, int tileSize, int border, int channels, string tempFolder) : base(baseLevelSize, baseLevelSize, tileSize, channels, 200)
{
ColorFunction = colorFunction;
BaseLevelSize = baseLevelSize;
Size = tileSize;
Border = Mathf.Max(0, border);
TempFolder = tempFolder;
MaxLevel = 0;
var size = BaseLevelSize;
while (size > this.Size)
{
MaxLevel += 1;
size /= 2;
}
TileData = new byte[(this.Size + 2 * this.Border) * (this.Size + 2 * this.Border) * Channels];
ConstantTileIDs = new Dictionary <int, int>();
Left = null;
Right = null;
Bottom = null;
Top = null;
if (!Directory.Exists(TempFolder))
{
Directory.CreateDirectory(TempFolder);
}
Logger.Log(string.Format("ColorMipmap.ctor: BaseLevelSize: {0}; TileSize: {1}; Border: {2}; MaxLevel: {3}; Channels: {4}", BaseLevelSize,
Size,
Border,
MaxLevel,
Channels));
}
private void BuildBaseLevelTiles()
{
var tilesCount = BaseLevelSize / Size;
Logger.Log(string.Format("HeightMipmap.BuildBaseLevelTiles: Build mipmap level: {0}", MaxLevel));
var maxR = float.NegativeInfinity;
for (int ty = 0; ty < tilesCount; ++ty)
{
for (int tx = 0; tx < tilesCount; ++tx)
{
var offset = (int)0;
for (int j = -2; j <= Size + 2; ++j)
{
for (int i = -2; i <= Size + 2; ++i)
{
var h = HeightFunction.GetValue(tx * Size + i, ty * Size + j);
TileData[offset++] = h;
if (h > maxR)
{
maxR = h;
}
}
}
SaveTile("Base", MaxLevel, tx, ty, TileData);
}
}
Logger.Log(string.Format("HeightMipmap.BuildBaseLevelTiles: Max Residual: {0}", maxR.ToString("F6")));
MaxR[0] = maxR / Scale;
}
private void ProduceTile(int level, int tx, int ty, ref long offset, long[] offsets, string file)
{
var tileSize = Mathf.Min(TopLevelSize << level, this.Size);
Logger.Log(string.Format("HeightMipmap.ProduceTile: Producing tile {0}:{1}:{2}!", level, tx, ty));
if (level == 0)
{
CurrentLevel = 0;
Reset(tileSize, tileSize, tileSize);
for (int j = 0; j <= tileSize + 4; ++j)
{
for (int i = 0; i <= tileSize + 4; ++i)
{
var index = i + j * (tileSize + 5);
TileData[index] = GetTileHeight(i - 2, j - 2) / Scale;
}
}
}
else
{
LoadTile("Residual", level, tx, ty, TileData);
}
int tileid;
if (level < MinLevel)
{
tileid = level;
}
else
{
var levelLength = Mathf.Max(level - MinLevel, 0);
tileid = MinLevel + tx + ty * (1 << levelLength) + ((1 << (2 * levelLength)) - 1) / 3;
}
var isConstant = true;
for (int i = 0; i < (tileSize + 5) * (tileSize + 5) * 1; ++i)
{
if (!BrainFuckMath.AlmostEquals(TileData[i], 0.0f))
{
isConstant = false;
break;
}
}
if (isConstant && ConstantTile != -1)
{
Logger.Log("HeightMipmap.ProduceTile: tile is const (All zeros)!");
offsets[2 * tileid] = offsets[2 * ConstantTile];
offsets[2 * tileid + 1] = offsets[2 * ConstantTile + 1];
}
else
{
var data = new byte[TileData.Length * 2];
for (int i = 0; i < TileData.Length; i++)
{
short z = (short)Mathf.Round(TileData[i] / MaxR[level] * (float)short.MaxValue);
data[2 * i] = (byte)(z & 0xFF);
data[2 * i + 1] = (byte)(z >> 8);
}
using (Stream stream = new FileStream(file, FileMode.Open))
{
stream.Seek(offset, SeekOrigin.Begin);
stream.Write(data, 0, data.Length);
}
offsets[2 * tileid] = offset;
offset += data.Length;
offsets[2 * tileid + 1] = offset;
}
if (isConstant && ConstantTile == -1)
{
ConstantTile = tileid;
}
}
