private static void ResourcesOfUI()
{
ResBase.Suffixs.Clear();
ResBase.Suffixs.Add(FileSystem.key_suffix_prefab);
ResBase.RootPath = PathSystem.GetReservedPrefabRoot(PathType.absPath);
ResourceMap2File.Add2AllResources(ResBase.GetNamesOfPath(false, "*", false, string.Empty));
ResBase.Suffixs.Clear();
ResBase.Suffixs.Add(FileSystem.key_suffix_prefab);
ResBase.RootPath = PathSystem.GetUIPrefabRoot(PathType.absPath);
ResourceMap2File.Add2AllResources(ResBase.GetNamesOfPath(false, "*", false, string.Empty));
ResBase.Suffixs.Clear();
ResBase.Suffixs.Add(FileSystem.key_suffix_prefab);
ResBase.RootPath = PathSystem.GetUI3DPrefabRoot(PathType.absPath);
ResourceMap2File.Add2AllResources(ResBase.GetNamesOfPath(false, "*", false, string.Empty));
ResBase.Suffixs.Clear();
ResBase.Suffixs.Add(FileSystem.key_suffix_prefab);
ResBase.RootPath = PathSystem.GetReservedPrefabRoot(PathType.absPath);
ResourceMap2File.Add2AllResources(ResBase.GetNamesOfPath(false, "*", false, string.Empty));
ResBase.Suffixs.Clear();
ResBase.Suffixs.Add(FileSystem.key_suffix_material);
ResBase.RootPath = PathSystem.GetUI3DPrefabRoot(PathType.absPath);
ResourceMap2File.Add2AllResources(ResBase.GetNamesOfPath(true, "*", false, string.Empty));
ResBase.Suffixs.Clear();
ResBase.Suffixs.Add(FileSystem.key_suffix_controller);
ResBase.RootPath = PathSystem.GetUIAnimRoot(PathType.absPath);
ResourceMap2File.Add2AllResources(ResBase.GetNamesOfPath(false, "*", false, string.Empty));
ResBase.Suffixs.Clear();
ResBase.Suffixs.Add(FileSystem.key_suffix_prefab);
ResBase.RootPath = PathSystem.GetSpineRoot(PathType.absPath);
ResourceMap2File.Add2AllResources(ResBase.GetNamesOfPath(true, "*", false, FileSystem.key_suffix_spine));
}
private static void ResourcesOfAnimatorController()
{
ResBase.Suffixs.Clear();
ResBase.Suffixs.Add(".controller");
ResBase.RootPath = PathSystem.GetActorAnimationRoot(PathType.absPath);
ResourceMap2File.Add2AllResources(ResBase.GetNamesOfPath(false, "*", false, string.Empty));
}
private static void ResourcesOffxs()
{
ResBase.Suffixs.Clear();
ResBase.Suffixs.Add(".prefab");
ResBase.RootPath = PathSystem.GetGameEffectPrefabRoot(PathType.absPath);
ResourceMap2File.Add2AllResources(ResBase.GetNamesOfPath(false, "*", false, string.Empty));
}
private static void ResourcesOfSceneLightmaps()
{
ResBase.Suffixs.Clear();
ResBase.Suffixs.Add(".prefab");
ResBase.RootPath = PathSystem.GetSceneRoot(PathType.absPath);
ResourceMap2File.Add2AllResources(ResBase.GetNamesOfPath(false, "s*", false, string.Empty));
}
private static void ResourcesOfShaders()
{
ResBase.Suffixs.Clear();
ResBase.Suffixs.Add(".prefab");
ResBase.RootPath = PathSystem.GetShaderPrefabRoot(PathType.absPath);
ResourceMap2File.Add2AllResources(ResBase.GetNamesOfPath(true, "*", false, ".shader"));
}
private void ProcessInVesselPointerOver()
{
foreach (GameObject go in _InVesselPointerOver)
{
if (Input.GetKeyDown(KeyCode.Mouse0))
{
GameObjectManager.setGameObjectLayer(go, 11); // Now macrophage is considered as an immunity cell
MoveToward move = go.GetComponent <MoveToward>();
Playable playable = go.GetComponent <Playable>();
if (playable)
{
//Global.data.trackedEntities.
foreach (PairEStatTrackedEntityInt trackedEntity in Global.data.trackedEntities)
{
if (trackedEntity.a == playable.trackedEntity)
{
trackedEntity.b++;
break;
}
}
}
GameObject target = PathSystem.GetClosestWaypoint(go, _Waypoints);
GameObjectManager.addComponent(go, typeof(PathFollower), new
{
destination = PathSystem.ComputeDestination(target.transform.position, _EndWaypoints)
}); // Compute destination (the closest one from start waypoint)
move.target = target.transform.position; // Move cell to closest waypoint
}
}
}
private void Init()
{
PathSystem.Init();
if (Application.get_isPlaying() && Application.get_isEditor())
{
string text = Application.get_dataPath() + "/StreamingAssets/resources2json.txt";
}
Object.DontDestroyOnLoad(base.get_gameObject());
FileSystem.Init();
PreloadUIBaseSystem.Init();
GamePackets.Register();
base.InvokeRepeating("Tick", 0f, 0.03f);
Loom.Current.Init();
this.InitBugly();
base.get_gameObject().AddComponent <RemoteLogSender>();
if (GameManager.IsDebug)
{
return;
}
CamerasMgr.CameraUI.set_enabled(false);
this.OpenPreloadingUI();
PreloadingUIView.SetProgressName("正在初始化环境...");
Screen.set_sleepTimeout(-1);
Debug.Log("SystemInfo.deviceModel = " + SystemInfoTools.GetDeviceModel());
this.CurrentUpdateManager = new UpdateManager();
this.CurrentUpdateManager.Init();
this.CheckUpdate();
}
private static void ResourcesOfAudios()
{
ResBase.Suffixs.Clear();
ResBase.Suffixs.Add(".wav");
ResBase.Suffixs.Add(".mp3");
ResBase.RootPath = PathSystem.GetAudioRoot(PathType.absPath);
ResourceMap2File.Add2AllResources(ResBase.GetNamesOfPath(false, "*", false, string.Empty));
}
public static string GetPath(PathType type, string u3dPathOfnoasset)
{
switch (type)
{
case PathType.absPath:
return(Application.get_dataPath() + u3dPathOfnoasset);
case PathType.u3dPath_no_assets:
return(u3dPathOfnoasset);
case PathType.u3dPath_has_asset:
{
string path = PathSystem.GetPath(PathType.absPath, u3dPathOfnoasset);
return(path.Substring(path.IndexOf("Assets")));
}
case PathType.resourcesPath:
if (u3dPathOfnoasset.Contains("/Resources/"))
{
return(u3dPathOfnoasset.Substring("/Resources/".get_Length()));
}
PathSystem.ShowError();
return(string.Empty);
case PathType.SubPackageInfo:
return(Path.Combine(Environment.get_CurrentDirectory(), string.Format("SubPackageInfo/{0}", u3dPathOfnoasset)));
case PathType.ApkPath:
return(PathUtil.Combine(new string[]
{
PathSystem.ApkDir,
u3dPathOfnoasset
}));
case PathType.ApkPatchPath:
return(PathUtil.Combine(new string[]
{
PathSystem.ApkPatchDir,
u3dPathOfnoasset
}));
case PathType.ResPatch:
return(PathUtil.Combine(new string[]
{
PathSystem.PersistentDataPath,
"resPatch",
u3dPathOfnoasset
}));
default:
return(string.Empty);
}
}
private static void ResourcesOfTPAtlas()
{
ResBase.Suffixs.Clear();
ResBase.Suffixs.Add(".png");
ResBase.Suffixs.Add(".jpg");
ResBase.Suffixs.Add(".PNG");
ResBase.Suffixs.Add(".JPG");
ResBase.RootPath = PathSystem.GetSrcSpriteRoot(PathType.absPath);
ResourceMap2File.Add2AllResources(ResBase.GetNamesOfFolder(true, true));
ResBase.Suffixs.Clear();
ResBase.Suffixs.Add(".png");
ResBase.Suffixs.Add(".jpg");
ResBase.Suffixs.Add(".PNG");
ResBase.Suffixs.Add(".JPG");
ResBase.RootPath = PathSystem.GetSrcSpriteRGBRoot(PathType.absPath);
ResourceMap2File.Add2AllResources(ResBase.GetNamesOfFolder(true, true));
ResBase.Suffixs.Clear();
ResBase.Suffixs.Add(".prefab");
ResBase.RootPath = PathSystem.GetTPAtlasRoot(PathType.absPath);
Hashtable namesOfPath = ResBase.GetNamesOfPath(true, "*", true, string.Empty);
ResourceMap2File.Add2AllResources(namesOfPath);
string text = string.Empty;
IEnumerator enumerator = namesOfPath.get_Keys().GetEnumerator();
try
{
while (enumerator.MoveNext())
{
object current = enumerator.get_Current();
string text2 = current.ToString();
text2 = text2.Substring(0, text2.get_Length() - "_pb".get_Length());
text = text + text2 + ';';
}
}
finally
{
IDisposable disposable = enumerator as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
ResourceMap2File.AllResources.set_Item("UiAtlas_KEY", text);
ResBase.Suffixs.Clear();
ResBase.Suffixs.Add(".prefab");
ResBase.RootPath = PathSystem.GetReservedPrefabRoot(PathType.absPath);
namesOfPath = ResBase.GetNamesOfPath(true, "*", true, string.Empty);
ResourceMap2File.Add2AllResources(namesOfPath);
}
public static bool TryLoadText(PathSystem pathSystem, string path, string extension, out string text)
{
switch (pathSystem)
{
default:
case PathSystem.DirectPath:
return(TryLoadTextFromPatch(path + extension, out text));
case PathSystem.StreamingAssets:
return(TryLoadTextFromStreamingAssets(path + extension, out text));
case PathSystem.Resources:
return(TryLoadTextFromRessource(path, out text));
}
}
public static bool TrySaveText(PathSystem pathSystem, string path, string extension, string text)
{
switch (pathSystem)
{
default:
case PathSystem.DirectPath:
return(TrySaveTextToPatch(path + extension, text));
case PathSystem.StreamingAssets:
return(TrySaveTextToStreamingAssets(path + extension, text));
case PathSystem.Resources:
return(false);
}
}
private static void ResourcesOfTexture()
{
ResBase.Suffixs.Clear();
ResBase.Suffixs.Add(".png");
ResBase.Suffixs.Add(".jpg");
ResBase.Suffixs.Add(".tga");
ResBase.Suffixs.Add(".psd");
ResBase.RootPath = PathSystem.GetTextureRGBARoot(PathType.absPath);
ResourceMap2File.Add2AllResources(ResBase.GetNamesOfPath(true, "*", false, string.Empty));
ResBase.RootPath = PathSystem.GetTextureRGBRoot(PathType.absPath);
ResourceMap2File.Add2AllResources(ResBase.GetNamesOfPath(true, "*", false, string.Empty));
ResBase.RootPath = PathSystem.GetTextureShaderRoot(PathType.absPath);
ResourceMap2File.Add2AllResources(ResBase.GetNamesOfPath(true, "*", false, string.Empty));
ResBase.RootPath = PathSystem.GetReservedPrefabRoot(PathType.absPath);
ResourceMap2File.Add2AllResources(ResBase.GetNamesOfPath(true, "*", false, string.Empty));
}
// Update is called once per frame
void Update()
{
if (selectedItem != null)
{
Cursor.SetCursor(selectedItem.icon, Vector2.zero, CursorMode.Auto);
}
else
{
Cursor.SetCursor(basePointer, Vector2.zero, CursorMode.Auto);
}
//if we click the mouse
if (Input.GetMouseButtonDown(1) && !EventSystem.current.IsPointerOverGameObject())
{
//make a raycast from the camera to the world
Ray clickRay = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit clickHit; //this holds information about what we clicked on
//fire the raycast and retrieve the data
if (Physics.Raycast(clickRay, out clickHit))
{
//if we hit an interactable
if (clickHit.transform.GetComponent <Interactable>())
{
//interact
//Debug.Log("Interactable");
//pass our current action to the interactable and retrieve a response
//lastResponse = clickHit.transform.GetComponent<Interactable>().Interact(currentAction);
currentTarget = clickHit.transform.GetComponent <Interactable>(); //we're going to store the interactable as our target
}
else if (clickHit.transform.GetComponent <PathSystem>()) //If we've clicked on something with a path system (the backdrop)
{
//vector3 point
clickedPoint = clickHit.point; //we'll want this soon
PathSystem p = clickHit.transform.GetComponent <PathSystem>(); //Store a reference to the path system for convenience
//pass to avatar
Vector3 point = p.PathPoint(clickedPoint.x); //get the end point of the path from the path system by providing the click
avatar.SetPath(p.path, point); //pass the path to our avatar as well as the end point
}
}
UpdateUI();
}
}
public void Initialize(Action <string> loadFailed = null)
{
AssetLoader.useDynamicLoader = true;
this.LoadFailed = loadFailed;
if (Application.get_isEditor())
{
if (Directory.Exists(PathSystem.GetEditorDataDir()))
{
AppConst.ResourcePath = PathSystem.GetEditorDataDir();
}
this.InitPackageFileList();
}
if (this.m_assetName2abInfoMap == null)
{
this.m_assetName2abInfoMap = SerializeUtility.DeserializeXDictFromMemory <string, AssetBundleInfo>(XUtility.GetConfigTxt("abmap", ".txt"));
}
this.m_manifest = (AssetLoader.LoadAssetNow("AssetBundleManifest", typeof(AssetBundleManifest)) as AssetBundleManifest);
if (this.m_manifest == null)
{
Debug.LogError("manifest加载失败");
}
}
public void Start()
{
// TODO: This is a stupid hack because this system is half-assed
foreach (var og in FindObjectsOfType <OrbitGroup>())
{
og.Position();
}
// TODO: kind of a hacky way to set courses for all these predictive chasers
foreach (var chaser in FindObjectsOfType <PredictiveChaser>())
{
float tf = 3f;
float3 p0 = chaser.transform.position;
float3 v0 = InitialHeading * InitialSpeed;
float3 pf = FuturePosition(chaser.Target, tf);
float3 vf = FutureVelocity(chaser.Target, tf);
chaser.TimeElapsed = 0;
chaser.Trajectory = PathSystem.TrajectoryFrom(tf, p0, v0, pf, vf);
}
Emitters = FindObjectsOfType <Emitter>().ToList();
FreeBodies = FindObjectsOfType <FreeBody>().ToList();
Travelers = FindObjectsOfType <Traveler>().ToList();
Orbiters = FindObjectsOfType <Orbiter>().ToList();
Velocities = FindObjectsOfType <Velocity>().ToList();
DeathTimers = FindObjectsOfType <DeathTimer>().ToList();
Rotators = FindObjectsOfType <Rotator>();
Geosynchronouses = FindObjectsOfType <Geosynchronous>();
OrbitPredictors = FindObjectsOfType <OrbitPredictor>();
TargetReflectors = FindObjectsOfType <TargetReflector>();
LightSources = FindObjectsOfType <LightSource>();
NormalizedMasses = FindObjectsOfType <NormalizedMass>();
SkyHookRockets = FindObjectsOfType <SkyHookRocket>();
}
private void MakeDecision()
{
foreach (GameObject go in _Active)
{
Macrophage macrophage = go.GetComponent <Macrophage>();
MoveToward move = go.GetComponent <MoveToward>();
Triggered3D triggered = go.GetComponent <Triggered3D>();
bool shouldRecompute = false;
// Is the a pathogene nearby ?
if (triggered != null)
{
Eater eater = go.GetComponent <Eater>();
float minDistance = float.MaxValue;
GameObject targetedPosition = null;
// Compute closest eatable thing
foreach (GameObject target in triggered.Targets)
{
Eatable eatable = target.GetComponent <Eatable>();
if (eatable != null && (eatable.eatableMask & eater.eatingMask) > 0)
{
float distance = Vector3.Distance(go.transform.position, target.transform.position);
if (distance < minDistance)
{
minDistance = distance;
targetedPosition = target;
}
}
}
if (targetedPosition != null) // Found something to eat
{
// Move to it
move.target = targetedPosition.transform.position;
// Update last decision made
macrophage.lastDescision = DECISIONS.CHASE;
continue;
}
if (macrophage.lastDescision.Equals(DECISIONS.CHASE)) // Last decision was chase but nothing is eatable in our range
{
shouldRecompute = true; // We need to recompute a path to the closest EndNode.
}
}
if (macrophage.lastDescision.Equals(DECISIONS.CHASE) || shouldRecompute) // No pathogene to hunt in the area
{
// Recompute closest Waypoint
GameObject _target = PathSystem.GetClosestWaypoint(go, _Waypoints);
PathFollower follower = go.GetComponent <PathFollower>();
// Update destination
follower.destination = PathSystem.ComputeDestination(_target.transform.position, _EndWaypoints);
move.target = _target.transform.position;
// Update decision
macrophage.lastDescision = DECISIONS.FOLLOW_PATH;
}
}
}
private string GetResPatchPath(UpdateManager.ResPathDir type, string version)
{
return(PathSystem.GetPath(PathType.ResPatch, this.GetResPatchRelPath(type, version)));
}
private string GetResPatchConfigPath()
{
return(PathSystem.GetPath(PathType.ResPatch, this.GetResPatchRelPath(UpdateManager.ResPathDir.config, string.Empty)));
}
private string GetResPatchDir(UpdateManager.ResPathDir type)
{
return(PathSystem.GetPath(PathType.ResPatch, type.ToString()));
}
public static string GetGameDataCsRoot(PathType type)
{
return(PathSystem.GetPath(type, PathSystem.RootOfU3DNoAssets.GameDataCsRoot));
}
public static string GetActorAnimationRoot(PathType type)
{
return(PathSystem.GetPath(type, PathSystem.RootOfU3DNoAssets.RootOfActorAnimation));
}
public static string GetActorPrefabRoot(PathType type)
{
return(PathSystem.GetPath(type, PathSystem.RootOfU3DNoAssets.RootOfActorPrefab));
}
public void FixedUpdate()
{
float dt = Time.fixedDeltaTime;
foreach (var emitter in Emitters)
{
emitter.TimeTillEmission -= dt;
if (emitter.TimeTillEmission <= 0)
{
GameObject emittee = Instantiate(emitter.Emittee, emitter.transform.position, emitter.transform.rotation);
Register(emittee);
if (emittee.TryGetComponent <Velocity>(out Velocity v))
{
v.Value = emitter.transform.forward * emitter.EmissionSpeed;
}
// TODO: note... this is not totally correct as we could slightly overshoot...
// TODO: consider fixing this AND the initial position based on this slight overshoot to get perfect behavior
emitter.TimeTillEmission = emitter.EmissionPeriod;
}
}
// Update deathtimers: modifies component arrays
for (int i = 0; i < DeathTimers.Count; i++)
{
DeathTimer deathTimer = DeathTimers[i];
deathTimer.Value -= dt;
if (deathTimer.Value <= 0)
{
UnRegister(deathTimer.gameObject);
Destroy(deathTimer.gameObject);
i--;
}
}
// Update all free bodies
foreach (var freebody in FreeBodies)
{
Velocity v = freebody.GetComponent <Velocity>();
foreach (var normalizedMass in NormalizedMasses)
{
float3 delta = normalizedMass.transform.position - freebody.transform.position;
float3 direction = normalize(delta);
float d = length(delta);
v.Value += direction * dt * normalizedMass.Value * MassFactor * G / (d * d);
}
}
// There are several versions of this system that will offer better and better behavior
// The stupid chaser with fixed speed
// Constantly tries to move towards the CURRENT location of their target
foreach (var chaser in FindObjectsOfType <Chaser>())
{
float3 delta = chaser.Target.position - chaser.transform.position;
float3 direction = normalize(chaser.Target.position - chaser.transform.position);
float remainingDistance = min(length(delta), chaser.MaxSpeed * dt);
chaser.transform.position = chaser.transform.position + remainingDistance * (Vector3)direction;
Debug.DrawLine(chaser.transform.position, chaser.Target.position, Color.red);
}
// The predictive chaser
// Predicts the location of the target various times in the future
// Chooses the first time where the distance to the object is within its range for that given time based on its max speed
// Moves towards that future location at the required speed
var predictiveChasers = FindObjectsOfType <PredictiveChaser>();
foreach (var predictiveChaser in predictiveChasers)
{
predictiveChaser.TimeElapsed += dt;
predictiveChaser.transform.position = PathSystem.PositionFromTrajectoryAtTime(predictiveChaser.Trajectory, predictiveChaser.TimeElapsed);
}
foreach (var predictiveChaser in predictiveChasers)
{
if (predictiveChaser.TimeElapsed >= predictiveChaser.Trajectory.duration)
{
predictiveChaser.transform.SetParent(predictiveChaser.Target, true);
predictiveChaser.transform.localPosition = Vector3.zero;
Destroy(predictiveChaser);
}
}
foreach (var traveler in Travelers)
{
// every traveler needs to calculate the position of their target
}
// Set the required radius of all orbiters that are geosynchronous
foreach (var geosynchronous in Geosynchronouses)
{
if (geosynchronous.TryGetComponent <Orbiter>(out Orbiter orbiter))
{
const float MASS = 1;
orbiter.Radius = Orbiter.RequiredRadiusForPeriod(MASS, G, geosynchronous.Rotator.Period);
}
}
// Update all orbiters
foreach (var orbiter in Orbiters)
{
// TODO: This mass value is stubbed out here but probably should be taken from the body itself?
const float MASS = 1;
float period = Orbiter.Period(orbiter, MASS, G);
orbiter.Radians = (orbiter.Radians + (float)orbiter.Direction * TWO_PI / period * dt) % (TWO_PI);
orbiter.transform.localPosition = orbiter.Radius * UnitCircle(orbiter.Radians);
}
// Update all rotators
foreach (var rotator in Rotators)
{
rotator.Radians = (rotator.Radians + (float)rotator.Direction * TWO_PI / rotator.Period * dt) % (TWO_PI);
rotator.transform.localRotation = Quaternion.AngleAxis(-rotator.Radians * Mathf.Rad2Deg, Vector3.up);
}
// Update all target reflectors
foreach (var targetreflector in TargetReflectors)
{
float3 toSource = targetreflector.Source.transform.position - targetreflector.transform.position;
float3 toTarget = targetreflector.Target.transform.position - targetreflector.transform.position;
float3 halfway = normalize((normalize(toSource) + normalize(toTarget)) / 2);
targetreflector.transform.forward = halfway;
}
// Update Skyhook Rockets
foreach (var skyhookRocket in SkyHookRockets)
{
switch (skyhookRocket.CurrentPlan)
{
case SkyHookRocket.Plan.EnterOrbit:
skyhookRocket.TimeRemaining -= dt;
if (skyhookRocket.TimeRemaining <= 0)
{
Orbiter o = (Orbiter)skyhookRocket.gameObject.AddComponent(typeof(Orbiter));
o.Radians = 0;
o.Radius = skyhookRocket.orbitRadius;
o.Direction = Orbiter.RotationalDirection.CounterClockwise;
Orbiters.Add(o);
skyhookRocket.TimeRemaining = 0;
skyhookRocket.transform.SetParent(skyhookRocket.Origin, true);
skyhookRocket.CurrentPlan = SkyHookRocket.Plan.RideTheHook;
}
else
{
float3 currentPosition = skyhookRocket.transform.position;
float3 futurePosition = FuturePosition(skyhookRocket.Origin, skyhookRocket.TimeRemaining);
float fraction = skyhookRocket.TimeRemaining / skyhookRocket.TransitionTime;
Debug.DrawLine(currentPosition, futurePosition, Color.red);
skyhookRocket.TimeRemaining -= dt;
skyhookRocket.transform.position = lerp(futurePosition, currentPosition, fraction);
}
break;
case SkyHookRocket.Plan.RideTheHook:
// Check if we should release
if (Input.GetKeyDown(KeyCode.Space))
{
float3 trajectory = FutureVelocity(skyhookRocket.transform, 0);
Orbiter orbiter = skyhookRocket.GetComponent <Orbiter>();
Velocity velocity = (Velocity)skyhookRocket.gameObject.AddComponent(typeof(Velocity));
Orbiters.Remove(orbiter);
Velocities.Add(velocity);
Destroy(orbiter);
velocity.Value = trajectory;
skyhookRocket.transform.SetParent(null, true);
skyhookRocket.transform.forward = normalize(trajectory);
skyhookRocket.CurrentPlan = SkyHookRocket.Plan.Free;
}
break;
}
}
foreach (var velocity in Velocities)
{
velocity.transform.position += dt * (Vector3)velocity.Value;
}
foreach (var orbitPredictor in OrbitPredictors)
{
int count = orbitPredictor.LineRenderer.positionCount;
for (int i = 0; i < count; i++)
{
float time = (float)i / (float)(count - 1) * OrbitPredictorTimeInTheFuture;
float3 velocity = FutureVelocity(orbitPredictor.transform, 0);
float3 trajectory = normalize(velocity);
float3 toTarget = new float3(0, 0, 0) - (float3)orbitPredictor.transform.position;
float3 towardsTarget = normalize(toTarget);
float trajectoryDotTowardsTarget = dot(trajectory, towardsTarget);
orbitPredictor.LineRenderer.SetPosition(i, FuturePosition(orbitPredictor.transform, time));
}
}
// Raytracing for light sources
RaytracingSystem.LightSources = LightSources;
RaytracingSystem.LightSourceCount = RaytracingSystem.LightSources.Length;
RaytracingSystem.Schedule();
// Raytrace rendering
for (int i = 0; i < RaytracingSystem.Traces.Count; i++)
{
var trace = RaytracingSystem.Traces[i];
var lr = LineRenderers[i];
var logEnergy = pow(trace.Energy, ScalePower);
var width = EnergyToWidthCurve.Evaluate(logEnergy);
var intensity = EnergyToIntensityCurve.Evaluate(logEnergy);
var emissionColor = intensity * BeamColor;
lr.positionCount = 2;
lr.SetPosition(0, trace.From);
lr.SetPosition(1, trace.To);
lr.startWidth = width;
lr.endWidth = width;
lr.material.SetColor("Color", BeamColor);
lr.material.SetColor("_EmissionColor", emissionColor);
lr.gameObject.SetActive(true);
}
for (int i = RaytracingSystem.Traces.Count; i < LineRenderers.Length; i++)
{
LineRenderers[i].gameObject.SetActive(false);
}
// Render orbits
OrbitRenderingSystem.Orbiters = Orbiters;
OrbitRenderingSystem.Count = OrbitRenderingSystem.Orbiters.Count;
OrbitRenderingSystem.Schedule();
// Update the spacefield
SpaceField.NormalizedMasses = NormalizedMasses;
SpaceField.Count = SpaceField.NormalizedMasses.Length;
SpaceField.Schedule();
}
public static string GetSubPackageInfoPath(string fileName)
{
return(PathSystem.GetPath(PathType.SubPackageInfo, fileName));
}
public static string GetGameEffectPrefabRoot(PathType type)
{
return(PathSystem.GetPath(type, PathSystem.RootOfU3DNoAssets.GameEffectPrefabRoot));
}
private string GetNewPatchPath()
{
return(PathSystem.GetPath(PathType.ApkPatchPath, this.GetNewPatchName()));
}
// Use this for initialization
void Start()
{
Debug.Log("Runtime platform: " + PathSystem.GetPlatformStr());
}
private string GetPatchInfoPath()
{
return(PathSystem.GetPath(PathType.ApkPatchPath, PathSystem.ApkPatchInfoFileName));
}
public static string GetSceneRoot(PathType type)
{
return(PathSystem.GetPath(type, PathSystem.RootOfU3DNoAssets.RootOfScene));
}
