public bool IsMatch(string path)
{
int index = path.IndexOf(BuildConfig.ResourceRootPath);
if (index != -1)
{
path = path.Substring(index + BuildConfig.ResourceRootPath.Length);
}
string packagePath = EditorPath.NormalizePathSplash(path);
if (packagePath.StartsWith("/"))
{
packagePath = packagePath.Substring(1);
}
string formatPath = EditorPath.NormalizePathSplash(RootPath);
if (!string.IsNullOrEmpty(formatPath) &&
!packagePath.StartsWith(formatPath, System.StringComparison.OrdinalIgnoreCase))
{
return(false);
}
EditorRegex regex = EditorRegex.Create(FileNameMatch);
return(regex == null ? false : regex.IsMatch(packagePath));
}
void SpawnUnits(GameObject unit, List <Transform> path, EditorPath pathToFollow)
{
unit.name = "Enemy";
unit.tag = "Enemy";
unit.GetComponent <MoveOnPath>().PathToFollow = pathToFollow;
Instantiate(unit, path[0].position, path[0].rotation);
}
public static ParticleInfo[] CreateParticleInfo(string assetPath)
{
if (!EditorPath.IsPrefab(assetPath))
{
return(null);
}
GameObject prefab = AssetDatabase.LoadAssetAtPath <GameObject>(assetPath);
ParticleSystem[] particleSystem = prefab.GetComponentsInChildren <ParticleSystem>();
ParticleInfo[] particleInfo = new ParticleInfo[particleSystem.Length];
for (int i = 0; i < particleSystem.Length; i++)
{
particleInfo[i] = new ParticleInfo();
particleInfo[i].Path = assetPath;
particleInfo[i].RealPath = assetPath + "/" + ViewerConst.GetPath(particleSystem[i].transform);
particleInfo[i].MaxParticles = particleSystem[i].main.maxParticles;
particleInfo[i].Duration = particleSystem[i].main.duration;
particleInfo[i].PlayOnAwake = particleSystem[i].main.playOnAwake;
particleInfo[i].Looping = particleSystem[i].main.loop;
}
return(particleInfo);
}
public static TextureInfo CreateTextureInfo(string assetPath)
{
if (!EditorPath.IsTexture(assetPath))
{
return(null);
}
TextureInfo textureInfo = null;
if (!_dictTexInfo.TryGetValue(assetPath, out textureInfo))
{
textureInfo = new TextureInfo();
_dictTexInfo.Add(assetPath, textureInfo);
}
TextureImporter textureImport = AssetImporter.GetAtPath(assetPath) as TextureImporter;
Texture texture = AssetDatabase.LoadAssetAtPath <Texture>(assetPath);
if (textureImport == null || texture == null)
{
return(null);
}
textureInfo.Path = textureImport.assetPath;
textureInfo.ImportType = textureImport.textureType;
textureInfo.ImportShape = textureImport.textureShape;
textureInfo.ReadWriteEnable = textureImport.isReadable;
textureInfo.MipmapEnable = textureImport.mipmapEnabled;
textureInfo.WrapMode = textureImport.wrapMode;
textureInfo.FilterMode = textureImport.filterMode;
textureInfo.StandaloneFormat = EditorTool.GetPlatformTextureSettings(textureImport, EditorConst.PlatformStandalone);
textureInfo.AndroidFormat = EditorTool.GetPlatformTextureSettings(textureImport, EditorConst.PlatformAndroid);
textureInfo.IosFormat = EditorTool.GetPlatformTextureSettings(textureImport, EditorConst.PlatformIos);
textureInfo.StandaloneOverriden = EditorTool.IsTextureOverriden(textureImport, EditorConst.PlatformStandalone);
textureInfo.AndroidOverriden = EditorTool.IsTextureOverriden(textureImport, EditorConst.PlatformAndroid);
textureInfo.IosOverriden = EditorTool.IsTextureOverriden(textureImport, EditorConst.PlatformIos);
textureInfo.StandaloneSize = EditorTool.CalculateTextureSizeBytes(texture, textureInfo.StandaloneFormat);
textureInfo.AndroidSize = EditorTool.CalculateTextureSizeBytes(texture, textureInfo.AndroidFormat);
textureInfo.IosSize = EditorTool.CalculateTextureSizeBytes(texture, textureInfo.IosFormat);
textureInfo.MemSize = Mathf.Max(textureInfo.StandaloneSize, textureInfo.AndroidSize, textureInfo.IosSize);
textureInfo.Width = texture.width;
textureInfo.Height = texture.height;
if (Selection.activeObject != texture)
{
Resources.UnloadAsset(texture);
}
if (++_loadCount % 256 == 0)
{
Resources.UnloadUnusedAssets();
}
return(textureInfo);
}
private static void ProcessSpecialResource(string path)
{
if (m_specialCache.ContainsKey(path))
{
return;
}
m_specialCache.Add(path, path);
if (EditorPath.IsShader(path))
{
if (!BundleDataManager.CheckPathInBundle(path))
{
BundleData shader = BundleDataManager.GetBundleData(BundleName.BN_SHADER);
if (shader != null && shader.children.Count > 0)
{
BundleDataManager.AddPathToBundle(path, shader.children[0], 1024);
}
}
}
else if (EditorPath.IsMaterial(path))
{
BundleData shaderBundle = BundleDataManager.GetBundleData(BundleName.BN_SHADER);
if (shaderBundle == null)
{
return;
}
UnityEngine.Object[] assetAtPath = AssetDatabase.LoadAllAssetsAtPath(path);
foreach (var obj in assetAtPath)
{
if (obj != null && obj.GetType() == typeof(Material))
{
Material mat = obj as Material;
if (mat != null && mat.shader != null && !string.IsNullOrEmpty(mat.shader.name))
{
if (!shaderBundle.includs.Contains(mat.shader.name))
{
shaderBundle.includs.Add(mat.shader.name);
}
}
}
if ((!(obj is GameObject)) && (!(obj is Component)))
{
Resources.UnloadAsset(obj);
}
}
ProcessClear();
}
else if (EditorPath.IsScript(path))
{
BundleData script = BundleDataManager.GetBundleData(BundleName.BN_SCRIPT);
if (script != null && script.children.Count > 0)
{
BundleDataManager.AddPathToBundle(path, script.children[0], 1024);
}
}
}
// Randomize chance of path
void setChanceAndPath()
{
chance = Random.Range(0f, 1f);
if (chance <= 0.5f)
{
PathToFollow = Paths[0];
}
else
{
PathToFollow = Paths[1];
}
}
private static void CopyDatabaseFile(string dbFolderPath, long dbLocalAddress, string entityName = null)
{
var sourceFilePath = PathUtility.UnifyToAltDirectorySeparatorChar(Path.Combine(TempFolderPath, $"db{dbLocalAddress}.box"));
var newFileName = dbLocalAddress > 1 ? $"{entityName}.db.bytes" : "MetadataEntityDBConfig.db.bytes";
var destFilePath = PathUtility.UnifyToAltDirectorySeparatorChar(Path.Combine(dbFolderPath, newFileName));
FileUtil.ReplaceFile(sourceFilePath, destFilePath);
EncryptFileRawData(destFilePath);
var assetFilePath = EditorPath.ConvertToAssetPath(destFilePath);
AssetDatabase.ImportAsset(assetFilePath);
}
void OnTriggerEnter(Collider other)
{
if (other.CompareTag("Rail") && !is_railed)
{
if (other.gameObject.transform.parent.GetComponent <EditorPath> ())
{
is_railed = true;
GetComponent <Rigidbody> ().isKinematic = true;
PathToFollow = other.gameObject.transform.parent.GetComponent <EditorPath> ();
assign_part_of_path();
}
}
}
private void BrowseButton4_Click(object sender, RoutedEventArgs e)
{
OpenFileDialog editorDialog = new OpenFileDialog();
editorDialog.Title = "Open UE4Editor Executable";
editorDialog.Filter = "Application|*.exe";
if (editorDialog.ShowDialog() == true)
{
editorExeFile = Path.GetFullPath(editorDialog.FileName);
Console.WriteLine("Value returned: " + editorDialog);
EditorPath.Clear();
EditorPath.AppendText(editorExeFile);
}
}
public static ModelInfo CreateModelInfo(string assetPath)
{
if (!EditorPath.IsModel(assetPath))
{
return(null);
}
ModelInfo tInfo = null;
if (!m_dictModelInfo.TryGetValue(assetPath, out tInfo))
{
tInfo = new ModelInfo();
m_dictModelInfo.Add(assetPath, tInfo);
}
ModelImporter tImport = AssetImporter.GetAtPath(assetPath) as ModelImporter;
Mesh mesh = AssetDatabase.LoadAssetAtPath <Mesh>(assetPath);
if (tImport == null || mesh == null)
{
return(null);
}
tInfo.Path = assetPath;
tInfo.ReadWriteEnable = tImport.isReadable;
tInfo.OptimizeMesh = tImport.optimizeMesh;
tInfo.ImportMaterials = tImport.importMaterials;
tInfo.ImportAnimation = tImport.importAnimation;
tInfo.MeshCompression = tImport.meshCompression;
tInfo.bHasUV = mesh.uv != null && mesh.uv.Length != 0;
tInfo.bHasUV2 = mesh.uv2 != null && mesh.uv2.Length != 0;
tInfo.bHasUV3 = mesh.uv3 != null && mesh.uv3.Length != 0;
tInfo.bHasUV4 = mesh.uv4 != null && mesh.uv4.Length != 0;
tInfo.bHasColor = mesh.colors != null && mesh.colors.Length != 0;
tInfo.bHasNormal = mesh.normals != null && mesh.normals.Length != 0;
tInfo.bHasTangent = mesh.tangents != null && mesh.tangents.Length != 0;
tInfo.vertexCount = mesh.vertexCount;
tInfo.triangleCount = mesh.triangles.Length / 3;
tInfo.MemSize = EditorTool.CalculateModelSizeBytes(assetPath);
if (m_loadCount % 256 == 0)
{
Resources.UnloadUnusedAssets();
}
return(tInfo);
}
internal static bool CreateMetadataDatabaseFiles()
{
var result = false;
var settings = MetadataAssetSettings.Load();
MetadataAssetSettings.CreateMetadataPersistentStoreFolder(settings);
DeleteTempDbFiles();
var dbFolderPath = EditorPath.ConvertToAbsolutePath(settings.MetadataPersistentStorePath);
ForEachExcelFile(settings.ExcelWorkbookFilesFolderPath, (table, fileName, index, length) =>
{
if (table == null)
{
return;
}
var entityClassName = fileName.ToTitleCase();
var info = $"Creating Database File for Entity {entityClassName}... {index + 1}/{length}";
var progress = (float)(index + 1) / length;
UnityEditorUtility.DisplayProgressBar("Hold on...", info, progress);
var rawInfoList = CreateMetadataEntityRawInfoList(settings, table);
var entityClassType = GetEntityClassType(settings, entityClassName);
if (entityClassType != null)
{
var entityDataList = CreateEntityDataList(settings, table, entityClassType, rawInfoList);
typeof(MetadataAssetUtility).InvokeGenericStaticMethod("InsertEntityData", new[] { entityClassType }, new object[] { dbFolderPath, entityClassName, rawInfoList, entityDataList, index });
result = true;
}
else
{
UnityDebug.LogErrorFormat(null, "Can not find the entity class: {0}.cs!", entityClassName);
result = false;
}
});
// Copy MetadataEntityDBConfig database file.
if (result)
{
CopyDatabaseFile(dbFolderPath, MetadataEntityDBConfig.DatabaseLocalAddress);
}
UnityEditorUtility.ClearProgressBar();
return(result);
}
private void RefreshList(List <string> list)
{
for (int i = 0; i < list.Count; ++i)
{
string path = EditorPath.FormatAssetPath(list[i]);
string name = System.IO.Path.GetFileName(path);
EditorUtility.DisplayProgressBar("获取AssetPath数据", name, (i * 1.0f) / list.Count);
if (EditorPath.IsMeta(path))
{
continue;
}
AssetPathInfo pathInfo = AssetPathInfo.CreatePathInfo(path);
m_pathInfoList.Add(pathInfo);
}
EditorUtility.ClearProgressBar();
RefreshDataWithSelect();
}
public static AudioInfo CreateAudioInfo(string assetPath)
{
if (!EditorPath.IsAudio(assetPath))
{
return(null);
}
AudioInfo audioInfo = null;
if (!_dictAudioInfo.TryGetValue(assetPath, out audioInfo))
{
audioInfo = new AudioInfo();
_dictAudioInfo.Add(assetPath, audioInfo);
}
AudioImporter audioImporter = AssetImporter.GetAtPath(assetPath) as AudioImporter;
AudioClip audioClip = AssetDatabase.LoadAssetAtPath <AudioClip>(assetPath);
if (audioImporter == null || audioClip == null)
{
Debug.LogError("audioImporter is empty");
return(null);
}
audioInfo.Path = assetPath;
audioInfo.ForceToMono = audioImporter.forceToMono;
audioInfo.LoadInBackground = audioImporter.loadInBackground;
audioInfo.Ambisonic = audioImporter.ambisonic;
audioInfo.MemSize = EditorTool.GetRuntimeMemorySize(audioClip);
audioInfo.ImportedSize = EditorTool.GetRuntimeMemorySize(audioClip);
audioInfo.StandAloneAudioClipLoadType = audioImporter.GetOverrideSampleSettings("Standalone").loadType;
audioInfo.AndroidAudioClipLoadType = audioImporter.GetOverrideSampleSettings("Android").loadType;
audioInfo.iOSAudioClipLoadType = audioImporter.GetOverrideSampleSettings("iOS").loadType;
audioInfo.StandAloneAudioCompressionFormat = audioImporter.GetOverrideSampleSettings("Standalone").compressionFormat;
audioInfo.AndroidAudioCompressionFormat = audioImporter.GetOverrideSampleSettings("Android").compressionFormat;
audioInfo.iOSAudioCompressionFormat = audioImporter.GetOverrideSampleSettings("iOS").compressionFormat;
audioInfo.OriginSize = ViewerConst.GetInternalValue <int>(audioImporter, "get_origSize", null);
audioInfo.CompressedSize = ViewerConst.GetInternalValue <int>(audioImporter, "get_compSize", null);
if (++_loadCount % 256 == 0)
{
Resources.UnloadUnusedAssets();
}
return(audioInfo);
}
public static List <ModelInfo> GetModelInfoByDirectory(string dir)
{
List <ModelInfo> modelInfoList = new List <ModelInfo>();
List <string> list = new List <string>();
EditorPath.ScanDirectoryFile(dir, true, list);
for (int i = 0; i < list.Count; ++i)
{
string assetPath = EditorPath.FormatAssetPath(list[i]);
ModelInfo modelInfo = CreateModelInfo(assetPath);
if (modelInfo != null)
{
modelInfoList.Add(modelInfo);
}
}
return(modelInfoList);
}
public static ShaderInfo CreateShaderInfo(string assetPath)
{
if (!EditorPath.IsShader(assetPath))
{
return(null);
}
ShaderInfo shaderInfo = null;
if (!_dictShaderInfo.TryGetValue(assetPath, out shaderInfo))
{
shaderInfo = new ShaderInfo();
_dictShaderInfo.Add(assetPath, shaderInfo);
}
Shader shader = AssetDatabase.LoadAssetAtPath <Shader>(assetPath);
string shaderText = File.ReadAllText(assetPath);
//ShaderUtil.OpenCompiledShader(shader, (int)ShaderPlatformModes.Custom, 1 << (int)ShaderUtil.ShaderCompilerPlatformType.D3D11, false);
typeof(ShaderUtil).GetMethod("OpenCompiledShader", BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, new object[] { shader, (int)ShaderPlatformModes.Custom, 1 << (int)ShaderCompilerPlatformType.D3D11, false });
try
{
CompiledShaderInfo compiledShaderInfo = CompiledShaderInfo.CreateCompiledShaderInfo(shaderText);
shaderInfo.Path = assetPath;
//shaderInfo.MaxLOD = ShaderUtil.GetLOD(shader);
//shaderInfo.Variant = ShaderUtil.GetVariantCount(shader, true);
shaderInfo.Property = ShaderUtil.GetPropertyCount(shader);
shaderInfo.RenderQueue = shader.renderQueue;
shaderInfo.Pass = compiledShaderInfo.GetPass();
shaderInfo.Instruction = compiledShaderInfo.GetInstruction();
shaderInfo.SubShader = compiledShaderInfo.GetSubShaderCount();
shaderInfo.Sample = compiledShaderInfo.GetSample();
shaderInfo.RenderType = compiledShaderInfo.GetRenderType();
shaderInfo.CompiledShaderInfoList.Add(compiledShaderInfo);
}
catch (Exception ex)
{
Debug.LogError(ex.Message);
return(null);
}
return(shaderInfo);
}
public static List <TextureInfo> GetTextureInfoByDirectory(string dir)
{
List <TextureInfo> texInfoList = new List <TextureInfo>();
List <string> list = new List <string>();
EditorPath.ScanDirectoryFile(dir, true, list);
for (int i = 0; i < list.Count; ++i)
{
string assetPath = EditorPath.FormatAssetPath(list[i]);
string name = System.IO.Path.GetFileName(assetPath);
EditorUtility.DisplayProgressBar("获取贴图数据", name, (i * 1.0f) / list.Count);
TextureInfo texInfo = CreateTextureInfo(assetPath);
if (texInfo != null)
{
texInfoList.Add(texInfo);
}
}
EditorUtility.ClearProgressBar();
return(texInfoList);
}
protected override void _RefreshList(List <string> list)
{
m_aniInfo = new List <AnimationInfo>();
for (int i = 0; i < list.Count; ++i)
{
string path = EditorPath.FormatAssetPath(list[i]);
string name = System.IO.Path.GetFileName(path);
EditorUtility.DisplayProgressBar("获取动作数据", name, (i * 1.0f) / list.Count);
if (!EditorPath.IsAnimation(path))
{
continue;
}
AnimationInfo aniInfo = AnimationInfo.CreateAnimationInfo(path);
if (aniInfo != null)
{
m_aniInfo.Add(aniInfo);
}
}
EditorUtility.ClearProgressBar();
RefreshDataWithSelect();
}
private void EditorPath_Init(object sender, EventArgs e)
{
var ini = new INIFile();
ini.Load(appconfig + "LauncherConfig.ini");
// Check if a key exists in an INI file
if (ini.HasSetting("ProjectConfiguration", "EditorExeFile"))
{
var editorExe = ini.GetValue("ProjectConfiguration", "EditorExeFile").ToString();
editorExeFile = editorExe;
EditorPath.AppendText(editorExe);
Console.WriteLine("Populated element: EditorPath");
}
else
{
Console.WriteLine("WARNING: No key defined in configuration file.");
}
}
void Start()
{
JellikZluta = Resources.Load("Units/JellikZluta") as GameObject;
JellikCerna = Resources.Load("Units/JellikCerna") as GameObject;
JellikBila = Resources.Load("Units/JellikBila") as GameObject;
golem = Resources.Load("Units/Golem") as GameObject;
FinalGolem = Resources.Load("Units/FinalGolem") as GameObject;
PathLeft1 = Resources.Load("Paths/PathLeft1") as GameObject;
PathLeft1Editor = PathLeft1.GetComponent <EditorPath>();
PathLeft2 = Resources.Load("Paths/PathLeft2") as GameObject;
PathLeft2Editor = PathLeft2.GetComponent <EditorPath>();
PathRight2 = Resources.Load("Paths/PathRight2") as GameObject;
PathRight2Editor = PathRight2.GetComponent <EditorPath>();
PathRight1 = Resources.Load("Paths/PathRight1") as GameObject;
PathRight1Editor = PathRight1.GetComponent <EditorPath>();
arrayPoints = GetComponentsInChildren <Transform>();
WaveNummber = 1;
foreach (Transform path_obj in arrayPoints)
{
if (path_obj != this.transform)
{
checkpoints.Add(path_obj);
if (checkpoints.Count == arrayPoints.Length - 1)
{
AddCollider(path_obj.gameObject);
}
}
}
}
protected override void _RefreshList(List <string> list)
{
m_texInfoList = new List <TextureInfo>();
for (int i = 0; i < list.Count; ++i)
{
string path = EditorPath.FormatAssetPath(list[i]);
string name = System.IO.Path.GetFileName(path);
EditorUtility.DisplayProgressBar("获取贴图数据", name, (i * 1.0f) / list.Count);
if (!EditorPath.IsTexture(path))
{
continue;
}
TextureInfo texInfo = TextureInfo.CreateTextureInfo(path);
if (texInfo != null)
{
m_texInfoList.Add(texInfo);
}
}
EditorUtility.ClearProgressBar();
RefreshDataWithSelect();
}
private static bool GenerateMetadataEntityScript(MetadataAssetSettings settings, string entityScriptName, List <MetadataEntityRawInfo> rawInfoList)
{
try
{
entityScriptName = entityScriptName.ToTitleCase();
var scriptTextContent = ScriptTemplate.LoadScriptTemplateFile("NewMetadataEntityScriptTemplate.txt", UnityPackageName);
scriptTextContent = scriptTextContent.Replace(ScriptTemplate.Placeholders.Namespace, settings.EntityScriptNamespace);
scriptTextContent = scriptTextContent.Replace(ScriptTemplate.Placeholders.ScriptName, entityScriptName);
scriptTextContent = scriptTextContent.Replace(ScriptTemplate.Placeholders.EnumInsideOfClass, GenerateEntityScriptEnumString(rawInfoList));
scriptTextContent = scriptTextContent.Replace(ScriptTemplate.Placeholders.Properties, GenerateEntityScriptPropertiesString(rawInfoList));
var scriptStorePath = EditorPath.ConvertToAbsolutePath(settings.EntityScriptsStorePath, $"{entityScriptName}.cs");
var assetPath = EditorPath.ConvertToAssetPath(scriptStorePath);
File.WriteAllText(scriptStorePath, scriptTextContent, new UTF8Encoding(true));
AssetDatabase.ImportAsset(assetPath);
return(true);
}
catch (Exception ex)
{
UnityDebug.LogError(ex.ToString());
return(false);
}
}
public BundleImportData GetPathImportData(string path)
{
path = EditorPath.FormatAssetPath(path);
path = EditorPath.NormalizePathSplash(path);
AssetPathInfo pathInfo = AssetPathInfo.CreatePathInfo(path);
if (pathInfo == null)
{
return(null);
}
if (pathInfo.Index >= 0 && pathInfo.Index < m_dataList.Count)
{
return(m_dataList[pathInfo.Index]);
}
for (int i = m_dataList.Count - 1; i >= 0; --i)
{
if (m_dataList[i].IsMatch(path))
{
return(m_dataList[i]);
}
}
return(null);
}
public override bool IsMatch(string path)
{
if (AlwaysMatch)
{
return(true);
}
bool pathMatch = EditorPath.IsTexture(path) && base.IsMatch(path);
if (!pathMatch || ForceSet)
{
return(pathMatch);
}
TextureImporter texureImporter = AssetImporter.GetAtPath(path) as TextureImporter;
#pragma warning disable 0618
if (TexType == TextureImporterType.Cubemap)
{
#pragma warning restore 0618
if (texureImporter.textureShape != TextureImporterShape.TextureCube)
{
return(false);
}
else
{
return(true);
}
}
else
{
if (texureImporter.textureShape == TextureImporterShape.TextureCube)
{
return(false);
}
}
return(texureImporter.textureType == TexType);
}
void Start()
{
//userSkipped = false;//TESTING
//isVRMode = true;
userSkipped = GameObject.Find("PersistentData").GetComponent <PersistentManagaer>().skip;
isVRMode = GameObject.Find("PersistentData").GetComponent <PersistentManagaer>().vr;
if (!isVRMode)
{
GvrCardboardHelpers.Recenter();
}
errorHud = GameObject.Find("errorHUD").GetComponent <ErrorHUDManager>();
thePlayer = GameObject.Find("Player");//Main camera is a child
pathToFollow = GameObject.Find("PathForCamera").GetComponent <EditorPath>();
theLights = GameObject.FindGameObjectsWithTag("aLight");
eyeVideoScreen = GameObject.Find("videoScreen");
eyeVideoScreen.SetActive(false);
footVideoScreen = GameObject.Find("videoScreenFeet");
footVideoMat = footVideoScreen.GetComponent <Renderer>().material;
footVideoMat.color = new Color(1, 1, 1, 0);
footVideoScreen.SetActive(false);
audioManager = GetComponent <AudioManager>();
hallProbe = GameObject.Find("hallProbe").GetComponent <ReflectionProbe>();
roomProbe = GameObject.Find("roomProbe").GetComponent <ReflectionProbe>();
blurCanvas = GameObject.Find("blurImage");
blurMat = blurCanvas.GetComponent <Image>().material;
blurCanvasPhone = GameObject.Find("blurImagePhone");
blurMatPhone = blurCanvasPhone.GetComponent <Image>().material;
arrowManager = GameObject.Find("arrows").GetComponent <ArrowManager>();
gridObjectsManager = GameObject.Find("gridObjects").GetComponent <GridObjectsManager>();
luxMeterManager = GameObject.Find("LUXMeter").GetComponent <LuxMeterManager>();
mainCamera = Camera.main.GetComponent <Transform>();
inTheRoom = false;
hallProbe.RenderProbe();//probe set to scripted update
roomProbe.RenderProbe();
//starCanvas
theStars = GameObject.Find("theStars");//for setActive
theStars.GetComponent <CanvasGroup>().alpha = 0;
theStars.SetActive(false);
theStarsPhone = GameObject.Find("theStarsPhone");//for setActive
theStarsPhone.GetComponent <CanvasGroup>().alpha = 0;
theStarsPhone.SetActive(false);
coverLeft = GameObject.Find("coverLeft");
coverRight = GameObject.Find("coverRight");
coverLeftPhone = GameObject.Find("coverLeftPhone");
coverRightPhone = GameObject.Find("coverRightPhone");
coverLeft.GetComponent <CanvasGroup>().alpha = 0;
coverRight.GetComponent <CanvasGroup>().alpha = 0;
coverLeftPhone.GetComponent <CanvasGroup>().alpha = 0;
coverRightPhone.GetComponent <CanvasGroup>().alpha = 0;
coverLeft.SetActive(false);
coverRight.SetActive(false);
coverLeftPhone.SetActive(false);
coverRightPhone.SetActive(false);
luxMeterManager.hideMeter(true);
errorHud.hideHUD(true);
blurCanvas.SetActive(false);
blurCanvasPhone.SetActive(false);
LeanTween.delayedCall(2f, openIntroDoor);
normalLightLevel();
//did user skip to lux level chapter
if (userSkipped)
{
inTheRoom = true;
//User skipped to LUX levels - only play lux info
currentPathNodeIndex = 6;
//last node will give us time of flight to the next node
lastNodeData = pathToFollow.pathNodes[currentPathNodeIndex - 1].GetComponent <NodeData>();
//data from the node the camera will move TO
nextNodeData = pathToFollow.pathNodes[currentPathNodeIndex].GetComponent <NodeData>();
thePlayer.transform.position = pathToFollow.pathNodes[currentPathNodeIndex - 1].transform.position;
LeanTween.delayedCall(1f, gridObjectsManager.showItAll);
upTheArrow();
LeanTween.delayedCall(1.2f, arrowManager.showArrows10);
// LeanTween.delayedCall(4.2f, upTheArrow);
LeanTween.delayedCall(1.5f, playAud15);
}
else
{
currentPathNodeIndex = 1;
//last node will give us time of flight to the next node
lastNodeData = pathToFollow.pathNodes[currentPathNodeIndex - 1].GetComponent <NodeData>();
//data from the node the camera will move TO
nextNodeData = pathToFollow.pathNodes[currentPathNodeIndex].GetComponent <NodeData>();
moveToNextNode();
}
}
public override bool IsMatch(string path)
{
return(EditorPath.IsAnimation(path) && base.IsMatch(path));
}
public static long CalcAssetSize(string assetPath, BundleType type)
{
assetPath = EditorPath.FormatAssetPath(assetPath);
assetPath = EditorPath.NormalizePathSplash(assetPath);
long ret = 0;
if (m_pathFileSize.TryGetValue(assetPath, out ret))
{
return(ret);
}
BundleImportData assetImportData = BundleDataControl.Instance.GetPathImportData(assetPath);
UnityEngine.Object[] assets = null;
switch (type)
{
case BundleType.Texture:
assets = AssetDatabase.LoadAllAssetsAtPath(assetPath);
for (int i = 0; i < assets.Length; ++i)
{
if (assets[i] is Texture)
{
ret += EditorTool.GetRuntimeMemorySize(assets[i]);
}
}
break;
case BundleType.Material:
string[] deps = AssetDepot.GetDependenciesCache(assetPath);
for (int i = 0; i < deps.Length; ++i)
{
if (EditorPath.IsTexture(deps[i]))
{
BundleImportData data = BundleDataControl.Instance.GetPathImportData(deps[i]);
if (assetImportData == null || data == null || assetImportData.Index < data.Index || data.SkipData)
{
ret += EditorTool.CalculateTextureSizeBytes(deps[i]);
}
}
}
ret += 512;
break;
case BundleType.FBX:
case BundleType.Controller:
case BundleType.Animation:
assets = AssetDatabase.LoadAllAssetsAtPath(assetPath);
List <UnityEngine.Object> list = AssetFilter.FilterObjectByType(assets, type, assetPath);
for (int i = 0; i < list.Count; ++i)
{
ret += EditorTool.GetRuntimeMemorySize(list[i]);
}
break;
default:
FileInfo fileInfo = new FileInfo(assetPath);
ret = fileInfo.Length;
break;
}
for (int i = 0; assets != null && i < assets.Length; ++i)
{
if ((!(assets[i] is GameObject)) && (!(assets[i] is Component)))
{
Resources.UnloadAsset(assets[i]);
}
}
m_pathFileSize.Add(assetPath, ret);
return(ret);
}
public virtual void RefreshDataByRootPath(string path)
{
List <string> list = EditorPath.GetAssetPathList(FormatConfig.ResourceRootPath + "/" + path);
_RefreshList(list);
}
public static void ExportBundleDictToOutput()
{
EditorTool.CreateDirectory(BuildConfig.InterpretedOutputPath);
BundleDataControl dataControl = BundleDataControl.Instance;
BundleMainfest bundleMainfest = new BundleMainfest();
BundleData[] bundleData = BundleDataAccessor.Datas.ToArray();
Dictionary <string, string> dict = new Dictionary <string, string>();
for (int i = 0; i < bundleData.Length; ++i)
{
for (int j = 0; j < bundleData[i].includs.Count; ++j)
{
string path = bundleData[i].includs[j];
if (string.IsNullOrEmpty(path))
{
continue;
}
if (!dict.ContainsKey(path))
{
dict.Add(path, bundleData[i].name);
}
else
{
Debug.LogWarningFormat("[BundleExport] Path to bundle name have same path {0} : {1} _ {2}", path, bundleData[i].name, dict[path]);
}
BundleImportData data = dataControl.GetPathImportData(path);
if (data == null || !data.Publish || !path.StartsWith("Assets", StringComparison.OrdinalIgnoreCase))
{
continue;
}
string bundlePath = path; // format path to load path!!!
bundleMainfest.AddPathToBundle(bundlePath, bundleData[i].name);
}
}
for (int i = 0; i < bundleData.Length; ++i)
{
for (int j = 0; j < bundleData[i].includs.Count; ++j)
{
string[] dep = AssetDepot.GetDependenciesCache(bundleData[i].includs[j]);
for (int k = 0; k < dep.Length; ++k)
{
if (EditorPath.IsScript(dep[k]) || EditorPath.IsShader(dep[k]))
{
continue;
}
string bundleName = null;
dict.TryGetValue(EditorPath.NormalizePathSplash(dep[k]), out bundleName);
if (string.IsNullOrEmpty(bundleName) || bundleName == bundleData[i].name)
{
continue;
}
BundleState childBuildState = BundleDataManager.GetBundleState(bundleName);
if (childBuildState.loadState == BundleLoadState.Preload || childBuildState.size == -1)
{
continue;
}
bundleMainfest.AddBundleDepend(bundleData[i].name, bundleName);
}
}
}
List <BundleState> stateList = new List <BundleState>(BundleDataAccessor.States);
bundleMainfest.AddBundleState(stateList);
bundleMainfest.SaveBytes(BuildConfig.BundleMainfestOutputPath);
AssetDatabase.ImportAsset(BuildConfig.BundleMainfestOutputPath, ImportAssetOptions.ForceSynchronousImport);
}
public void RefreshBaseData()
{
List <string> list = EditorPath.GetAssetPathList(BuildConfig.ResourceRootPath);
RefreshList(list);
}
public void RefreshDataByRootPath(string path)
{
List <string> list = EditorPath.GetAssetPathList(BuildConfig.ResourceRootPath + "/" + path);
RefreshList(list);
}
