private void OnSceneGUI()
{
this.m_Object.Update();
OcclusionArea occlusionArea = (OcclusionArea)this.target;
Color color = Handles.color;
Handles.color = new Color(145f, 244f, 139f, 255f) / 255f;
Vector3 p = occlusionArea.transform.TransformPoint(this.m_Center.vector3Value);
Vector3 vector = this.m_Size.vector3Value * 0.5f;
Vector3 a = this.m_Size.vector3Value * 0.5f;
Vector3 lossyScale = occlusionArea.transform.lossyScale;
Vector3 b = new Vector3(1f / lossyScale.x, 1f / lossyScale.y, 1f / lossyScale.z);
vector = Vector3.Scale(vector, lossyScale);
a = Vector3.Scale(a, lossyScale);
bool changed = GUI.changed;
vector.x = this.SizeSlider(p, -Vector3.right, vector.x);
vector.y = this.SizeSlider(p, -Vector3.up, vector.y);
vector.z = this.SizeSlider(p, -Vector3.forward, vector.z);
a.x = this.SizeSlider(p, Vector3.right, a.x);
a.y = this.SizeSlider(p, Vector3.up, a.y);
a.z = this.SizeSlider(p, Vector3.forward, a.z);
if (GUI.changed)
{
this.m_Center.vector3Value = this.m_Center.vector3Value + Vector3.Scale(Quaternion.Inverse(occlusionArea.transform.rotation) * (a - vector) * 0.5f, b);
vector = Vector3.Scale(vector, b);
a = Vector3.Scale(a, b);
this.m_Size.vector3Value = a + vector;
base.serializedObject.ApplyModifiedProperties();
}
GUI.changed |= changed;
Handles.color = color;
}
private void OnSceneGUI()
{
this.m_Object.Update();
OcclusionArea target = (OcclusionArea)this.target;
Color color = Handles.color;
Handles.color = new Color(145f, 244f, 139f, (float)byte.MaxValue) / (float)byte.MaxValue;
Vector3 p = target.transform.TransformPoint(this.m_Center.vector3Value);
Vector3 a1 = this.m_Size.vector3Value * 0.5f;
Vector3 a2 = this.m_Size.vector3Value * 0.5f;
Vector3 lossyScale = target.transform.lossyScale;
Vector3 b = new Vector3(1f / lossyScale.x, 1f / lossyScale.y, 1f / lossyScale.z);
Vector3 a3 = Vector3.Scale(a1, lossyScale);
Vector3 a4 = Vector3.Scale(a2, lossyScale);
bool changed = GUI.changed;
a3.x = this.SizeSlider(p, -Vector3.right, a3.x);
a3.y = this.SizeSlider(p, -Vector3.up, a3.y);
a3.z = this.SizeSlider(p, -Vector3.forward, a3.z);
a4.x = this.SizeSlider(p, Vector3.right, a4.x);
a4.y = this.SizeSlider(p, Vector3.up, a4.y);
a4.z = this.SizeSlider(p, Vector3.forward, a4.z);
if (GUI.changed)
{
this.m_Center.vector3Value = this.m_Center.vector3Value + Vector3.Scale(Quaternion.Inverse(target.transform.rotation) * (a4 - a3) * 0.5f, b);
Vector3 vector3 = Vector3.Scale(a3, b);
this.m_Size.vector3Value = Vector3.Scale(a4, b) + vector3;
this.serializedObject.ApplyModifiedProperties();
}
GUI.changed |= changed;
Handles.color = color;
}
private OcclusionArea CreateNewArea()
{
GameObject obj2 = new GameObject("Occlusion Area");
OcclusionArea area = obj2.AddComponent <OcclusionArea>();
Selection.activeGameObject = obj2;
return(area);
}
OcclusionArea CreateNewArea()
{
GameObject go = new GameObject("Occlusion Area");
OcclusionArea oa = go.AddComponent <OcclusionArea>();
Selection.activeGameObject = go;
return(oa);
}
private OcclusionArea CreateNewArea()
{
GameObject gameObject = new GameObject("Occlusion Area");
OcclusionArea occlusionArea = gameObject.AddComponent <OcclusionArea>();
Selection.activeGameObject = gameObject;
return(occlusionArea);
}
// Use this for initialization
void Start()
{
occlusion = gameObject.AddComponent <OcclusionArea> ();
flagText = GameObject.Find("FlagText").GetComponent <Text> ();
timerText = GameObject.Find("TimerText").GetComponent <Text> ();
gameOverText = GameObject.Find("GameOverText").GetComponent <Text> ();
Reset();
}
private void Awake()
{
this.area = this.GetComponent <OcclusionArea>();
var box = this.gameObject.AddComponent <BoxCollider>();
box.size = this.Size;
box.isTrigger = true;
box.hideFlags = HideFlags.HideInInspector;
}
void OnSceneGUI()
{
if (!target)
{
return;
}
m_Object.Update();
OcclusionArea area = (OcclusionArea)target;
Color tempColor = Handles.color;
Handles.color = new Color(145f, 244f, 139f, 255f) / 255;
Vector3 offset = area.transform.TransformPoint(m_Center.vector3Value);
// Get min and max extends from center and size
Vector3 min = m_Size.vector3Value * 0.5f;
Vector3 max = m_Size.vector3Value * 0.5f;
// Yes, it's weird to use lossyScale here, but that's what the occlusion volumes do
Vector3 scale = area.transform.lossyScale;
Vector3 inverseScale = new Vector3(1 / scale.x, 1 / scale.y, 1 / scale.z);
min = Vector3.Scale(min, scale);
max = Vector3.Scale(max, scale);
// Handles
bool temp = GUI.changed;
min.x = SizeSlider(offset, -Vector3.right, min.x);
min.y = SizeSlider(offset, -Vector3.up, min.y);
min.z = SizeSlider(offset, -Vector3.forward, min.z);
max.x = SizeSlider(offset, Vector3.right, max.x);
max.y = SizeSlider(offset, Vector3.up, max.y);
max.z = SizeSlider(offset, Vector3.forward, max.z);
// Apply cahnges if there were any
if (GUI.changed)
{
// Occlusion volumes can't be rotated but the center is still affected by rotation, so
// we need to rotate the offset (and apply the inverse lossyScale AFTER that)
m_Center.vector3Value = m_Center.vector3Value + Vector3.Scale(Quaternion.Inverse(area.transform.rotation) * (max - min) * 0.5f, inverseScale);
min = Vector3.Scale(min, inverseScale);
max = Vector3.Scale(max, inverseScale);
m_Size.vector3Value = (max + min);
serializedObject.ApplyModifiedProperties();
}
GUI.changed |= temp;
Handles.color = tempColor;
}
static int _CreateOcclusionArea(IntPtr L)
{
int count = LuaDLL.lua_gettop(L);
if (count == 0)
{
OcclusionArea obj = new OcclusionArea();
LuaScriptMgr.Push(L, obj);
return(1);
}
else
{
LuaDLL.luaL_error(L, "invalid arguments to method: OcclusionArea.New");
}
return(0);
}
public static int get_size(IntPtr l)
{
int result;
try
{
OcclusionArea occlusionArea = (OcclusionArea)LuaObject.checkSelf(l);
LuaObject.pushValue(l, true);
LuaObject.pushValue(l, occlusionArea.size);
result = 2;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
public static int set_size(IntPtr l)
{
int result;
try
{
OcclusionArea occlusionArea = (OcclusionArea)LuaObject.checkSelf(l);
Vector3 size;
LuaObject.checkType(l, 2, out size);
occlusionArea.size = size;
LuaObject.pushValue(l, true);
result = 1;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
static int get_size(IntPtr L)
{
object o = LuaScriptMgr.GetLuaObject(L, 1);
if (o == null)
{
LuaTypes types = LuaDLL.lua_type(L, 1);
if (types == LuaTypes.LUA_TTABLE)
{
LuaDLL.luaL_error(L, "unknown member name size");
}
else
{
LuaDLL.luaL_error(L, "attempt to index size on a nil value");
}
}
OcclusionArea obj = (OcclusionArea)o;
LuaScriptMgr.PushValue(L, obj.size);
return(1);
}
static int set_center(IntPtr L)
{
object o = LuaScriptMgr.GetLuaObject(L, 1);
if (o == null)
{
LuaTypes types = LuaDLL.lua_type(L, 1);
if (types == LuaTypes.LUA_TTABLE)
{
LuaDLL.luaL_error(L, "unknown member name center");
}
else
{
LuaDLL.luaL_error(L, "attempt to index center on a nil value");
}
}
OcclusionArea obj = (OcclusionArea)o;
obj.center = LuaScriptMgr.GetNetObject <Vector3>(L, 3);
return(0);
}
private static Object ReadAsset(AssetStream stream, AssetInfo assetInfo, long offset, int size)
{
Object asset;
switch (assetInfo.ClassID)
{
case ClassIDType.GameObject:
asset = new GameObject(assetInfo);
break;
case ClassIDType.Transform:
asset = new Transform(assetInfo);
break;
case ClassIDType.Camera:
asset = new Camera(assetInfo);
break;
case ClassIDType.Material:
asset = new Material(assetInfo);
break;
case ClassIDType.MeshRenderer:
asset = new MeshRenderer(assetInfo);
break;
case ClassIDType.Texture2D:
asset = new Texture2D(assetInfo);
break;
case ClassIDType.SceneSettings:
asset = new OcclusionCullingSettings(assetInfo);
break;
case ClassIDType.MeshFilter:
asset = new MeshFilter(assetInfo);
break;
case ClassIDType.OcclusionPortal:
asset = new OcclusionPortal(assetInfo);
break;
case ClassIDType.Mesh:
asset = new Mesh(assetInfo);
break;
case ClassIDType.Shader:
asset = new Shader(assetInfo);
break;
case ClassIDType.TextAsset:
asset = new TextAsset(assetInfo);
break;
case ClassIDType.Rigidbody2D:
asset = new Rigidbody2D(assetInfo);
break;
case ClassIDType.Rigidbody:
asset = new Rigidbody(assetInfo);
break;
case ClassIDType.CircleCollider2D:
asset = new CircleCollider2D(assetInfo);
break;
case ClassIDType.PolygonCollider2D:
asset = new PolygonCollider2D(assetInfo);
break;
case ClassIDType.BoxCollider2D:
asset = new BoxCollider2D(assetInfo);
break;
case ClassIDType.PhysicsMaterial2D:
asset = new PhysicsMaterial2D(assetInfo);
break;
case ClassIDType.MeshCollider:
asset = new MeshCollider(assetInfo);
break;
case ClassIDType.BoxCollider:
asset = new BoxCollider(assetInfo);
break;
case ClassIDType.SpriteCollider2D:
asset = new CompositeCollider2D(assetInfo);
break;
case ClassIDType.EdgeCollider2D:
asset = new EdgeCollider2D(assetInfo);
break;
case ClassIDType.CapsuleCollider2D:
asset = new CapsuleCollider2D(assetInfo);
break;
case ClassIDType.AnimationClip:
asset = new AnimationClip(assetInfo);
break;
case ClassIDType.AudioListener:
asset = new AudioListener(assetInfo);
break;
case ClassIDType.AudioSource:
asset = new AudioSource(assetInfo);
break;
case ClassIDType.AudioClip:
asset = new AudioClip(assetInfo);
break;
case ClassIDType.RenderTexture:
asset = new RenderTexture(assetInfo);
break;
case ClassIDType.Cubemap:
asset = new Cubemap(assetInfo);
break;
case ClassIDType.Avatar:
asset = new Avatar(assetInfo);
break;
case ClassIDType.AnimatorController:
asset = new AnimatorController(assetInfo);
break;
case ClassIDType.GUILayer:
asset = new GUILayer(assetInfo);
break;
case ClassIDType.Animator:
asset = new Animator(assetInfo);
break;
case ClassIDType.RenderSettings:
asset = new RenderSettings(assetInfo);
break;
case ClassIDType.Light:
asset = new Light(assetInfo);
break;
case ClassIDType.Animation:
asset = new Animation(assetInfo);
break;
case ClassIDType.MonoScript:
asset = new MonoScript(assetInfo);
break;
case ClassIDType.NewAnimationTrack:
asset = new NewAnimationTrack(assetInfo);
break;
case ClassIDType.FlareLayer:
asset = new FlareLayer(assetInfo);
break;
case ClassIDType.Font:
asset = new Font(assetInfo);
break;
case ClassIDType.PhysicMaterial:
asset = new PhysicMaterial(assetInfo);
break;
case ClassIDType.SphereCollider:
asset = new SphereCollider(assetInfo);
break;
case ClassIDType.CapsuleCollider:
asset = new CapsuleCollider(assetInfo);
break;
case ClassIDType.SkinnedMeshRenderer:
asset = new SkinnedMeshRenderer(assetInfo);
break;
case ClassIDType.BuildSettings:
asset = new BuildSettings(assetInfo);
break;
case ClassIDType.AssetBundle:
asset = new AssetBundle(assetInfo);
break;
case ClassIDType.WheelCollider:
asset = new WheelCollider(assetInfo);
break;
case ClassIDType.MovieTexture:
asset = new MovieTexture(assetInfo);
break;
case ClassIDType.TerrainCollider:
asset = new TerrainCollider(assetInfo);
break;
case ClassIDType.TerrainData:
asset = new TerrainData(assetInfo);
break;
case ClassIDType.LightmapSettings:
asset = new LightmapSettings(assetInfo);
break;
case ClassIDType.OcclusionArea:
asset = new OcclusionArea(assetInfo);
break;
case ClassIDType.NavMeshSettings:
asset = new NavMeshSettings(assetInfo);
break;
case ClassIDType.ParticleSystem:
asset = new ParticleSystem(assetInfo);
break;
case ClassIDType.ParticleSystemRenderer:
asset = new ParticleSystemRenderer(assetInfo);
break;
case ClassIDType.SpriteRenderer:
asset = new SpriteRenderer(assetInfo);
break;
case ClassIDType.Sprite:
asset = new Sprite(assetInfo);
break;
case ClassIDType.Terrain:
asset = new Terrain(assetInfo);
break;
case ClassIDType.AnimatorOverrideController:
asset = new AnimatorOverrideController(assetInfo);
break;
case ClassIDType.CanvasRenderer:
asset = new CanvasRenderer(assetInfo);
break;
case ClassIDType.Canvas:
asset = new Canvas(assetInfo);
break;
case ClassIDType.RectTransform:
asset = new RectTransform(assetInfo);
break;
case ClassIDType.NavMeshData:
asset = new NavMeshData(assetInfo);
break;
case ClassIDType.OcclusionCullingData:
asset = new OcclusionCullingData(assetInfo);
break;
case ClassIDType.SceneAsset:
asset = new SceneAsset(assetInfo);
break;
case ClassIDType.LightmapParameters:
asset = new LightmapParameters(assetInfo);
break;
case ClassIDType.SpriteAtlas:
asset = new SpriteAtlas(assetInfo);
break;
default:
return(null);
}
stream.BaseStream.Position = offset;
if (Config.IsGenerateGUIDByContent)
{
byte[] data = stream.ReadBytes(size);
asset.Read(data);
using (MD5 md5 = MD5.Create())
{
byte[] md5Hash = md5.ComputeHash(data);
assetInfo.GUID = new UtinyGUID(md5Hash);
}
}
else
{
stream.AlignPosition = offset;
asset.Read(stream);
long read = stream.BaseStream.Position - offset;
if (read != size)
{
throw new Exception($"Read {read} but expected {size} for object {asset.GetType().Name}");
}
}
return(asset);
}
// Use this for initialization
void Start()
{
Random.InitState(randomSeed);
parentGen = GameObject.Find("Main").GetComponent <LevelGen>();
iStats = parentGen.islandStats[iStatsIndex];
SetBaseHeight(iStats.baseLayerHeight);
islandUpdater = GetComponent <IslandUpdater>();
transform.position = Random.onUnitSphere;
farHolder = transform.Find("Far");
closeHolder = transform.Find("Close");
cloudHolder = transform.Find("CloudHolder");
cloudHolder.localScale = Vector3.one * radius / 2;
cloudCover = cloudHolder.GetComponentInChildren <ParticleSystem>();
cloudHolder.gameObject.SetActive(false); //TODO Re enable if this ever works well enough
ParticleSystem.MainModule cloudCoverMain = cloudCover.main;
cloudCoverMain.startSizeMultiplier *= radius;
spin = Random.Range(0.0f, 360.0f);
spinSpeed = Random.Range(-maxSpinSpeed, maxSpinSpeed);
timeRecalc = Random.Range(0, parentGen.islandMoveIntervals);
foreach (PerlinLayer layer in iStats.layerStats)
{
layer.Set(); //TODO maybe save seperatley incase we need to reaccess this (it will get overwritten by the next island)
}
GenerateLowQuality();
tiles = new HexType[iStats.layerStats.Count + iStats.cityLayerStats.Count, size, size];
GenerateBaseHexes();
//TODO put in a loop
if (iStats.cityLayerStats.Count != 0)
{
for (int index = 0; index < iStats.cityLayerStats.Count; index++)
{
iStats.cityLayerStats[index].GenerateHuts(iStats.layerStats.Count + index, tiles);
iStats.cityLayerStats[index].GenerateConnections(iStats.layerStats.Count + index, tiles);
iStats.cityLayerStats[index].RemoveSingleHuts(iStats.layerStats.Count + index, tiles);
iStats.cityLayerStats[index].FillHoles(iStats.layerStats.Count + index, tiles);
iStats.cityLayerStats[index].RemoveIfNoBottom(iStats.layerStats.Count + index, tiles);
if (index != 0)
{
iStats.cityLayerStats[index - 1].GenerateStairs(iStats.layerStats.Count + index - 1, tiles);
}
//iStats.cityLayerStats [index].RemoveSingleHuts (iStats.layerStats.Count + index, tiles);
}
}
DrawBaseHexes();
if (iStats.cityLayerStats.Count != 0)
{
DrawCityHexes();
}
CapsuleCollider cTemp = gameObject.GetComponent <CapsuleCollider>();
cTemp.radius = radius + 5;
cTemp.height = cTemp.radius * 2f;
OcclusionArea oTemp = gameObject.GetComponent <OcclusionArea>();
oTemp.size = Vector3.one * (radius + 1) * 2;
islandUpdater.SetExpectedNumOfWeapons();
//TODO Fix to allow more or less islands added.
if (!isServer)
{
parentGen.islandStats[iStatsIndex].islands.Add(this);
parentGen.AddOneIsland(this);
}
SetFar(true);
Random.InitState((int)System.DateTime.Now.Ticks);
if (isServer)
{
UpdateToSpherePosition(true);
}
}
//StaticOcclusionCulling SOC;
private void Awake()
{
OA = OA.GetComponent <OcclusionArea>();
BakeArea();
}
public static Tween TweenCenter(this OcclusionArea area, Vector3 to, float duration) =>
Tweening.To(getter: () => area.center,
setter: center => area.center = center,
to, duration).SetTarget(area);
public static Tween TweenSize(this OcclusionArea area, Vector3 to, float duration) =>
Tweening.To(getter: () => area.size,
setter: size => area.size = size,
to, duration).SetTarget(area);
public void calculateBounds()
{
this.cullMagnitude = 64f * this.bias;
this.sqrCullMagnitude = this.cullMagnitude * this.cullMagnitude;
if (this.lod == EObjectLOD.MESH)
{
ObjectsLOD.meshes.Clear();
base.GetComponentsInChildren <MeshFilter>(true, ObjectsLOD.meshes);
if (ObjectsLOD.meshes.Count == 0)
{
base.enabled = false;
return;
}
Bounds item = default(Bounds);
for (int i = 0; i < ObjectsLOD.meshes.Count; i++)
{
Mesh sharedMesh = ObjectsLOD.meshes[i].sharedMesh;
if (!(sharedMesh == null))
{
Bounds bounds = sharedMesh.bounds;
item.Encapsulate(bounds.min);
item.Encapsulate(bounds.max);
}
}
item.Expand(-1f);
item.center += this.center;
item.size += this.size;
if (item.size.x < 1f || item.size.y < 1f || item.size.z < 1f)
{
base.enabled = false;
return;
}
this.bounds = new List <Bounds>();
this.bounds.Add(item);
}
else if (this.lod == EObjectLOD.AREA)
{
ObjectsLOD.areas.Clear();
base.GetComponentsInChildren <OcclusionArea>(true, ObjectsLOD.areas);
if (ObjectsLOD.areas.Count == 0)
{
base.enabled = false;
return;
}
this.bounds = new List <Bounds>();
for (int j = 0; j < ObjectsLOD.areas.Count; j++)
{
OcclusionArea occlusionArea = ObjectsLOD.areas[j];
Bounds item2;
item2..ctor(occlusionArea.transform.localPosition + occlusionArea.center, new Vector3(occlusionArea.size.x, occlusionArea.size.z, occlusionArea.size.y));
this.bounds.Add(item2);
}
}
this.objects = new List <LevelObject>();
for (int k = 0; k < this.bounds.Count; k++)
{
Bounds bounds2 = this.bounds[k];
this.cullCenter += bounds2.center;
}
this.cullCenter /= (float)this.bounds.Count;
this.cullCenter = base.transform.TransformPoint(this.cullCenter);
byte b;
byte b2;
Regions.tryGetCoordinate(this.cullCenter, out b, out b2);
for (int l = (int)(b - 1); l <= (int)(b + 1); l++)
{
for (int m = (int)(b2 - 1); m <= (int)(b2 + 1); m++)
{
for (int n = 0; n < LevelObjects.objects[l, m].Count; n++)
{
LevelObject levelObject = LevelObjects.objects[l, m][n];
if (levelObject.asset != null && !(levelObject.transform == null) && levelObject.asset.type != EObjectType.LARGE)
{
if (!levelObject.isSpeciallyCulled)
{
Vector3 vector = base.transform.InverseTransformPoint(levelObject.transform.position);
bool flag = false;
for (int num = 0; num < this.bounds.Count; num++)
{
if (this.bounds[num].Contains(vector))
{
flag = true;
break;
}
}
if (flag)
{
levelObject.isSpeciallyCulled = true;
this.objects.Add(levelObject);
}
}
}
}
}
}
if (this.objects.Count == 0)
{
base.enabled = false;
return;
}
}
