// Use this for initialization
void Awake()
{
player = GameObject.FindGameObjectWithTag ("Player").transform;
playerOrgin = player.position;
path2 = new []{ new Vector3(10.0f,20.0f,40f), new Vector3(10f,10f,20f),
playerOrgin, new Vector3(0f,10f,-10f), new Vector3( 0f, -5f, -20f), new Vector3(10f,-10f,5f),
new Vector3(5f,5f,15f), new Vector3(0f,20f,20f)};
path3 = new []{ new Vector3(30.0f,6.0f,60f), new Vector3(9f,40f,40f),
new Vector3(15.2f,2f,20f), new Vector3(0f,0f,5f), new Vector3( 4f, 7f, -30f), new Vector3(16f,4f, 5f)};
path4 = new []{ new Vector3(20.0f,30.0f,60f), new Vector3(5f,70f,40f),
new Vector3(28.2f,21f,20f), new Vector3(0f,0f,5f), new Vector3( 4f, 7f, -30f), new Vector3(16f,4f, 5f)};
path5 = new []{ new Vector3(20.0f,30.0f,60f), new Vector3(5f,-70f,30f),
new Vector3(11.2f,16f,20f), new Vector3(0f,0f,5f), new Vector3( 4f, -17f, -30f), new Vector3(16f,4f, 5f)};
aiShip = FindObjectOfType <Rigidbody> ();
launcher = GetComponent<MLauncher> ();
path = path2;
target = path[0];
bound = new Bounds (path[0], new Vector3(1f,1f,1f));
}
public void checkPlayerObjectCollision(Bounds playerBounds)
{
if (tileMapData != null)
{
currentNodeIndex = tileMapData.checkObjectCollision(playerBounds) + 1;
if (currentNodeIndex > 0)
{
currentNode = (ZoneTreeNode)zoneTree.getNodeCheckingRootBranchList(currentNodeIndex);
if (currentNode != null)
{
//Enter battles automatically
if (currentNode.content.nodeType == ZoneNodeType.Battle)
{
ZoneNodeButtonClick();
}
panelText.text = currentNode.content.nodeName + " " + currentNode.content.description;
panelButton.enabled = true;
}
else
{
panelText.text = "";
panelButton.enabled = false;
}
}
else
{
panelText.text = "";
panelButton.enabled = false;
}
}
}
private List<Vector3> DynamicSetupList(float minX, float maxX, float minZ, float maxZ, Bounds bR, Bounds bM)
{
List<Vector3> checkList = new List<Vector3>();
float Tilesize = Pathfinder.Instance.Tilesize;
for (float i = minZ; i < maxZ; i += Tilesize / 2)
{
for (float j = minX; j < maxX; j += Tilesize / 2)
{
for (float k = bR.min.y; k < bR.max.y; k += Tilesize)
{
if (k > lowestY)
{
Vector3 local = transform.InverseTransformPoint(new Vector3(j, k, i));
if (bM.Contains(local))
{
checkList.Add(new Vector3(j, k, i));
}
}
}
}
}
return checkList;
}
// IN: Object (single element array)
// OUT: Location
public Vector3 BEHIND(object[] args)
{
Vector3 outValue = Vector3.zero;
if (args [0] is GameObject) { // behind an object
GameObject obj = ((GameObject)args [0]);
Bounds bounds = new Bounds ();
bounds = Helper.GetObjectWorldSize (obj);
GameObject camera = GameObject.Find ("Main Camera");
float povDir = cameraRelativeDirections ? camera.transform.eulerAngles.y : 0.0f;
Vector3 rayStart = new Vector3 (0.0f, 0.0f,
Mathf.Abs(bounds.size.z));
rayStart = Quaternion.Euler (0.0f, povDir, 0.0f) * rayStart;
rayStart += obj.transform.position;
outValue = Helper.RayIntersectionPoint (rayStart, obj);
Debug.Log ("behind: " + Helper.VectorToParsable (outValue));
}
else if (args [0] is Vector3) { // behind a location
outValue = (Vector3)args[0];
}
return outValue;
}
// Update is called once per frame
void Update()
{
// I.E We've moved somewhere.
if (HasShipMoved(20)) {
Bounds generateDistance = new Bounds (Ship.transform.position, Vector3.one * VIEW_DISTANCE);
foreach (ChunkObject c in StreamSource.GetObjects(generateDistance))
{
if (!LiveObjects.Exists(i => i.transform.position == c.Position))
{
GameObject GO = PhotonNetwork.InstantiateSceneObject(c.ChunkObjectType, c.Position, c.Rotation,0, null);
GO.transform.localScale = new Vector3(400,400,400);
LiveObjects.Add(GO);
GO.transform.parent = this.transform;
}
}
for (var i = LiveObjects.Count() - 1; i >= 0; i--) {
//Replace your Where(...)
var go = LiveObjects[i];
if (!generateDistance.Intersects(new Bounds(go.transform.position,new Vector3(3,3,3))))
continue;
Debug.Log ("Deleting" + LiveObjects[i].transform.position.ToString ());
GameObject reference = LiveObjects[i];
LiveObjects.RemoveAt(i);
PhotonNetwork.Destroy (reference);
//body of foreach loop goes here
}
oldShipPosition = Ship.transform.position;
}
}
/// <summary>
/// Calculate the combined bounds of all widgets attached to the specified game object or its children (in world space).
/// </summary>
public static Bounds CalculateAbsoluteWidgetBounds(Transform trans)
{
UIWidget[] widgets = trans.GetComponentsInChildren<UIWidget>() as UIWidget[];
Bounds b = new Bounds(trans.transform.position, Vector3.zero);
bool first = true;
foreach (UIWidget w in widgets)
{
Vector2 size = w.relativeSize;
Vector2 offset = w.pivotOffset;
float x = (offset.x + 0.5f) * size.x;
float y = (offset.y - 0.5f) * size.y;
size *= 0.5f;
Transform wt = w.cachedTransform;
Vector3 v0 = wt.TransformPoint(new Vector3(x - size.x, y - size.y, 0f));
// 'Bounds' can never start off with nothing, apparently, and including the origin point is wrong.
if (first)
{
first = false;
b = new Bounds(v0, Vector3.zero);
}
else
{
b.Encapsulate(v0);
}
b.Encapsulate(wt.TransformPoint(new Vector3(x - size.x, y + size.y, 0f)));
b.Encapsulate(wt.TransformPoint(new Vector3(x + size.x, y - size.y, 0f)));
b.Encapsulate(wt.TransformPoint(new Vector3(x + size.x, y + size.y, 0f)));
}
return b;
}
public static Bounds GetBounds(Renderer r)
{
if (r is SkinnedMeshRenderer) {
SkinnedMeshRenderer smr = r as SkinnedMeshRenderer;
Mesh mesh = smr.sharedMesh;
Vector3[] vertices = mesh.vertices;
if (vertices.Length <= 0) {
return r.bounds;
}
int idx = 0;
Vector3 min, max;
min = max = r.transform.TransformPoint (vertices [idx++]);
for (int i = idx; i < vertices.Length; i++) {
Vector3 v = vertices [i];
Vector3 V = r.transform.TransformPoint (v);
for (int n = 0; n < 3; n++) {
if (V [n] > max [n])
max [n] = V [n];
if (V [n] < min [n])
min [n] = V [n];
}
}
Bounds b = new Bounds ();;
b.SetMinMax (min, max);
return b;
} else {
return r.bounds;
}
}
/// <summary>
/// - Debugs an axis-aligned bounding box.
/// </summary>
/// <param name='bounds'>
/// - The bounds to debug.
/// </param>
/// <param name='color'>
/// - The color of the bounds.
/// </param>
/// <param name='duration'>
/// - How long to draw the bounds.
/// </param>
/// <param name='depthTest'>
/// - Whether or not the bounds should be faded when behind other objects.
/// </param>
public static void DebugBounds(Bounds bounds, Color color, float duration, bool depthTest)
{
Vector3 center = bounds.center;
float x = bounds.extents.x;
float y = bounds.extents.y;
float z = bounds.extents.z;
Vector3 ruf = center+new Vector3(x,y,z);
Vector3 rub = center+new Vector3(x,y,-z);
Vector3 luf = center+new Vector3(-x,y,z);
Vector3 lub = center+new Vector3(-x,y,-z);
Vector3 rdf = center+new Vector3(x,-y,z);
Vector3 rdb = center+new Vector3(x,-y,-z);
Vector3 lfd = center+new Vector3(-x,-y,z);
Vector3 lbd = center+new Vector3(-x,-y,-z);
Debug.DrawLine(ruf, luf, color, duration, depthTest);
Debug.DrawLine(ruf, rub, color, duration, depthTest);
Debug.DrawLine(luf, lub, color, duration, depthTest);
Debug.DrawLine(rub, lub, color, duration, depthTest);
Debug.DrawLine(ruf, rdf, color, duration, depthTest);
Debug.DrawLine(rub, rdb, color, duration, depthTest);
Debug.DrawLine(luf, lfd, color, duration, depthTest);
Debug.DrawLine(lub, lbd, color, duration, depthTest);
Debug.DrawLine(rdf, lfd, color, duration, depthTest);
Debug.DrawLine(rdf, rdb, color, duration, depthTest);
Debug.DrawLine(lfd, lbd, color, duration, depthTest);
Debug.DrawLine(lbd, rdb, color, duration, depthTest);
}
private Camera viewCamera; // Gets the main camera for worldspacetoscreenspace calculations.
#endregion Fields
#region Methods
// Gets the mesh origin and farthest extents as a Rect
public Rect BoundsToScreenRect(Bounds bounds)
{
Vector3 origin = Camera.main.WorldToScreenPoint(new Vector3(bounds.min.x, bounds.max.y, 0f));
Vector3 extent = Camera.main.WorldToScreenPoint(new Vector3(bounds.max.x, bounds.min.y, 0f));
return new Rect(origin.x, Screen.height - origin.y, extent.x - origin.x, origin.y - extent.y);
}
public static void DebugDrawCube(Vector3 center, Vector3 size, Color c)
{
/*
* 4-----5
* /| /|
* y 7-----6 |
* | | 0---|-1
* | |/ |/
* | 3-----2
* | z
* |/_______x
*/
Bounds bounds = new Bounds(center, size);
Vector3 p3 = bounds.min;
Vector3 p5 = bounds.max;
Vector3 p0 = new Vector3(p3.x, p3.y, p5.z);
Vector3 p1 = new Vector3(p5.x, p3.y, p5.z);
Vector3 p2 = new Vector3(p5.x, p3.y, p3.z);
Vector3 p4 = new Vector3(p3.x, p5.y, p5.z);
Vector3 p6 = new Vector3(p5.x, p5.y, p3.z);
Vector3 p7 = new Vector3(p3.x, p5.y, p3.z);
Debug.DrawLine(p0, p1, c);
Debug.DrawLine(p1, p2, c);
Debug.DrawLine(p2, p3, c);
Debug.DrawLine(p3, p0, c);
Debug.DrawLine(p4, p5, c);
Debug.DrawLine(p5, p6, c);
Debug.DrawLine(p6, p7, c);
Debug.DrawLine(p7, p4, c);
Debug.DrawLine(p0, p4, c);
Debug.DrawLine(p1, p5, c);
Debug.DrawLine(p2, p6, c);
Debug.DrawLine(p3, p7, c);
}
public void CalculateBounds()
{
if (connectedBody == null)
{
_bodyBounds = new Bounds();
return;
}
AABB aabb_full = new AABB();
bool combine = false;
for (int i = 0; i < connectedBody.FixtureList.Count; i++)
{
for (int j = 0; j < connectedBody.FixtureList[i].Shape.ChildCount; j++)
{
AABB aabb;
connectedBody.FixtureList[i].Shape.ComputeAABB(out aabb, ref connectedBody.Xf, j);
if (!combine)
{
combine = true;
aabb_full = aabb;
}
else
{
aabb_full.Combine(ref aabb);
}
}
}
_bodyBounds = Bounds.FromAABB(ref aabb_full, to2dMode, GetSize());
}
public void CalculateBounds()
{
selectionBounds = new Bounds(transform.position, Vector3.zero);
foreach(Renderer r in GetComponentsInChildren< Renderer >()) {
selectionBounds.Encapsulate(r.bounds);
}
}
void CheckOffscreen()
{
//if bounds are still tehir default value
if (bounds.size == Vector3.zero)
{
//then set them
bounds = Utils.CombineBoundsOfChildren(this.gameObject);
//Also find the diff between bounds.center & transform.position
boundsCenterOffset = bounds.center - transform.position;
}
//every time, update teh bounds to the ucrrent positon
bounds.center = transform.position + boundsCenterOffset;
//check to see wehether the bounds are completely offscreen
Vector3 off = Utils.ScreenBoundsCheck(bounds, BoundsTest.offScreen);
if (off != Vector3.zero)
{
//if this enemy has gone off the bottom edge of the screen
if (off.y < 0)
{
//then destroy it
Destroy(this.gameObject);
}
}
}
//for moving object based on gaze coordinates from tracker
//based on resolution of window
//receives object, renderer, bounds script, and data script
//returns vector3 position in world coordinates
public Vector3 positionObjectWithRendererBoundsData(GameObject theObject, Renderer theRenderer, Bounds theBounds, GazeDataManager theData) {
//verify the gaze data
if (theData.gazeCoords != null) {
//convert gaze coords to screen coords
Point2D screenCoords = DataUtilities.gazePointToWindowPoint(theData.gazeCoords);
//convert window coords to viewport coords
Point2D viewCoords = DataUtilities.windowPointToViewPoint(screenCoords);
Vector3 viewVector = new Vector3((float)viewCoords.X, (float)(viewCoords.Y), 0);
//check bounds
//use the object with the outermost bounds and a renderer to make the check
Vector3 boundsVector = theBounds.checkBoundsForRenderer(theRenderer, viewVector);
//convert viewport vector to world position vector
Vector3 worldPos = Camera.main.ViewportToWorldPoint(boundsVector);
worldPos.z = theObject.transform.position.z; //maintain z position for object
//return new world position
return worldPos;
}
//error
else {
//Debug.Log("[GazeMove] Null gaze data, " + theObject.name + " cannot be positioned");
return Vector3.zero;
}
} //end function
public override object ReadJson( Type objectType, Dictionary<string,object> values)
{
Bounds b = new Bounds();
b.center = new Vector3( CastFloat(values["cx"]),CastFloat(values["cy"]),CastFloat(values["cz"]));
b.extents = new Vector3(CastFloat(values["ex"]),CastFloat(values["ey"]),CastFloat(values["ez"]));
return b;
}
void CreateGrid() {
GameObject floorTiles = new GameObject("Floor Tiles"); // An object to store the tiles in the Hiearchy. Just for tidyness ;).
floorTiles.AddComponent<LevelInfo>(); // This should be done manually for the designed floors.
Bounds levelBounds = new Bounds();
int nrTiles = this.transform.childCount;
for (int i = 0; i < nrTiles; i++) {
Transform child = transform.GetChild(i);
if (child.GetComponent<Renderer>())
levelBounds.Encapsulate(child.GetComponent<Renderer>().bounds);
//TODO fixa så att det även funkar med cubeworld utan en tom box i dem
// else if (child.GetComponentInChildren<Renderer>())
// levelBounds.Encapsulate(child.GetComponent<Renderer>().bounds);
}
Vector3 size = levelBounds.size;
_gridManager.CreateGrid((int)size.x + 1, (int)size.z + 1);
for (int i = 0; i < nrTiles; i++) {
BaseTile tile = transform.GetChild(i).GetComponent<BaseTile>();
tile.Init(_gridManager);
_gridManager.AddTile(tile);
}
Object[] allUnits = Object.FindObjectsOfType<BaseUnit>();
for (int i = 0; i < allUnits.Length; i++) {
BaseUnit bu = allUnits[i] as BaseUnit;
bu.Init(_gridManager);
BaseTile tile = _gridManager.GetTile(bu.transform.position);
DebugAux.Assert(tile != null, "Can't have a unit placed on a non-tile " + bu);
BaseTile.TeleportTo(bu, null, tile);
}
}
public void Update()
{
var newBounds = Bounds.Translate(Velocity);
if (Playfield.Bounds.Contains(newBounds))
Bounds = newBounds;
}
public static Vector3 GetPointInBounds(Bounds bounds)
{
float x = Random.Range(bounds.center.x, bounds.center.x + bounds.extents.x);
float y = Random.Range(bounds.center.y, bounds.center.y + bounds.extents.y);
float z = Random.Range(bounds.center.z, bounds.center.z + bounds.extents.z);
return new Vector3(x, y, z);
}
public void Start () {
// Capture the bounds of the collider while it is closed
bounds = GetComponent<Collider>().bounds;
// Initially open the door
SetState(open);
}
public void Query(Vector3 pos, float radius, UKList<IUKSpatialObject> result)
{
var b = new Bounds(pos, Vector3.one * radius * 2f);
int minx = Mathf.FloorToInt(b.min.x / CELL_SIZE);
int miny = Mathf.FloorToInt(b.min.y / CELL_SIZE);
int minz = Mathf.FloorToInt(b.min.z / CELL_SIZE);
int maxx = Mathf.FloorToInt(b.max.x / CELL_SIZE);
int maxy = Mathf.FloorToInt(b.max.y / CELL_SIZE);
int maxz = Mathf.FloorToInt(b.max.z / CELL_SIZE);
for (int z = minz; z <= maxz; ++z) {
for (int y = miny; y <= maxy; ++y) {
for (int x = minx; x <= maxx; ++x) {
var h = CalculateHash(x,y,z);
if (spatialHashTable.ContainsKey(h)) {
var l = spatialHashTable[h];
foreach(var p in l) {
result.Add(p.Key);
}
}
}
}
}
}
public static Bounds calculateWorldBounds(GameObject go)
{
if (null == go) { return new Bounds(Vector3.zero, Vector3.zero); }
Vector2 min = new Vector2(float.MaxValue, float.MaxValue);
Vector2 max = new Vector2(float.MinValue, float.MinValue);
Vector3 v;
RectTransform[] rts = go.GetComponentsInChildren<RectTransform>();
if (rts.Length == 0) return new Bounds(go.transform.position, Vector3.zero);
for (int i = 0, imax = rts.Length; i < imax; ++i)
{
RectTransform t = rts[i];
if (!t.gameObject.activeSelf) { continue; }
Vector3[] corners = new Vector3[4];
t.GetWorldCorners(corners);
for (int j = 0; j < 4; ++j)
{
v = corners[j];
if (v.x > max.x) max.x = v.x;
if (v.y > max.y) max.y = v.y;
if (v.x < min.x) min.x = v.x;
if (v.y < min.y) min.y = v.y;
}
}
Bounds b = new Bounds(min, Vector3.zero);
b.Encapsulate(max);
return b;
}
public void DoUpdateGraphs()
{
if (col == null) { return; }
isWaitingForUpdate = false;
Bounds newBounds = col.bounds;
//if (!simple) {
Bounds merged = newBounds;
merged.Encapsulate (prevBounds);
if (BoundsVolume (merged) < BoundsVolume (newBounds)+BoundsVolume(prevBounds)) {
AstarPath.active.UpdateGraphs (merged);
} else {
AstarPath.active.UpdateGraphs (prevBounds);
AstarPath.active.UpdateGraphs (newBounds);
}
/*} else {
GraphUpdateObject guo = new GraphUpdateObject (prevBounds);
guo.updatePhysics = false;
guo.modifyWalkability = true;
guo.setWalkability = true;
AstarPath.active.UpdateGraphs (guo);
}*/
prevBounds = newBounds;
}
private void Start()
{
if (this.template != null)
{
int num = 0;
Bounds bounds = new Bounds();
for (int i = 0; i < this.maxRows; i++)
{
for (int j = 0; j < this.maxColumns; j++)
{
GameObject obj2 = NGUITools.AddChild(base.gameObject, this.template);
obj2.transform.localPosition = new Vector3(this.padding + ((j + 0.5f) * this.spacing), -this.padding - ((i + 0.5f) * this.spacing), 0f);
UIStorageSlot component = obj2.GetComponent<UIStorageSlot>();
if (component != null)
{
component.storage = this;
component.slot = num;
}
bounds.Encapsulate(new Vector3((this.padding * 2f) + ((j + 1) * this.spacing), (-this.padding * 2f) - ((i + 1) * this.spacing), 0f));
if (++num >= this.maxItemCount)
{
if (this.background != null)
{
this.background.transform.localScale = bounds.size;
}
return;
}
}
}
if (this.background != null)
{
this.background.transform.localScale = bounds.size;
}
}
}
public static char CollisionDectection(Bounds moi, Bounds toi)
{
char sides;
Vector3 moiMax = moi.max;
Vector3 moiMin = moi.min;
Vector3 toiMax = toi.max;
Vector3 toiMin = toi.min;
//toiMax
Vector3 maxMinusMin = new Vector3(Mathf.Abs(moiMax.x - toiMin.x),Mathf.Abs(moiMax.y - toiMin.y),Mathf.Abs(moiMax.z - toiMin.z));
Vector3 minMinusMax = new Vector3(Mathf.Abs(moiMin.x - toiMax.x),Mathf.Abs(moiMin.y - toiMax.y),Mathf.Abs(moiMin.z - toiMax.z));
if(maxMinusMin.x <= maxMinusMin.y &&
maxMinusMin.x <= minMinusMax.y)
return 'r';
if(minMinusMax.x <= minMinusMax.y &&
minMinusMax.x <= maxMinusMin.y)
return 'l';
if(maxMinusMin.y <= minMinusMax.x &&
maxMinusMin.y <= maxMinusMin.x)
return 'u';
if(minMinusMax.y <= minMinusMax.x &&
minMinusMax.y <= maxMinusMin.x)
return 'd';
return 'n';
}
static void FitToChildren()
{
foreach (GameObject rootGameObject in Selection.gameObjects)
{
if (!(rootGameObject.GetComponent<Collider>() is BoxCollider))
continue;
bool hasBounds = false;
Bounds bounds = new Bounds(Vector3.zero, Vector3.zero);
for (int i = 0; i < rootGameObject.transform.childCount; ++i)
{
Renderer childRenderer = rootGameObject.transform.GetChild(i).GetComponent<Renderer>();
if (childRenderer != null)
{
if (hasBounds)
{
bounds.Encapsulate(childRenderer.bounds);
}
else
{
bounds = childRenderer.bounds;
hasBounds = true;
}
}
}
BoxCollider collider = (BoxCollider)rootGameObject.GetComponent<Collider>();
collider.center = bounds.center - rootGameObject.transform.position;
collider.size = bounds.size;
}
}
static bool GetBoundWithChildren( Transform parent, ref Bounds pBound, ref bool initBound )
{
Bounds bound = new Bounds();
bool didOne = false;
if( parent.gameObject.renderer != null )
{
bound = parent.gameObject.renderer.bounds;
if( initBound )
{
pBound.Encapsulate( bound.min );
pBound.Encapsulate( bound.max );
}
else
{
pBound.min = new Vector3( bound.min.x, bound.min.y, bound.min.z );
pBound.max = new Vector3( bound.max.x, bound.max.y, bound.max.z );
initBound = true;
}
didOne = true;
}
foreach( Transform child in parent )
{
if( GetBoundWithChildren( child, ref pBound, ref initBound ))
didOne = true;
}
return didOne;
}
// Use this for initialization
public void Start()
{
renderer = this.GetComponent<SpriteRenderer>();
rigidbody = this.GetComponent<Rigidbody2D>();
bounds = limitsUniverse.GetComponent<Renderer>().bounds;
animator = this.GetComponent<Animator>();
}
// sets up the inventory with as many items
// as maxItemSlot. the background can be seen
// if it contains a UISprite.
void InitializeInventory()
{
int count = 0;
Bounds bound = new Bounds();
BackgroundSettings();
for(int y = 0; y < m_MaxRows; ++y)
{
for(int x = 0; x < m_MaxColumns; ++x)
{
GameObject go = NGUITools.AddChild(gameObject, m_Template);
UISprite sprite = go.GetComponent<UISprite> () as UISprite;
int width = sprite.width;
int height = sprite.height;
go.transform.localPosition = new Vector3 ( width * (x + 0.5f) * m_Spacing,
-(height * ( y + 0.5f ) * m_Padding),
0f);
InventoryItem slot = go.GetComponent<InventoryItem>();
if(slot != null)
{
slot.Slot = count;
}
InventoryData.AddSlot(go);
++count;
}
}
}
private float m_ZoomAmountMultiplier = 2; // a multiplier for the FOV amount. The default of 2 makes the field of view twice as wide as required to fit the target.
#endregion Fields
#region Methods
public static float MaxBoundsExtent(Transform obj, bool includeEffects)
{
// get the maximum bounds extent of object, including all child renderers,
// but excluding particles and trails, for FOV zooming effect.
var renderers = obj.GetComponentsInChildren<Renderer>();
Bounds bounds = new Bounds();
bool initBounds = false;
foreach (Renderer r in renderers)
{
if (!((r is TrailRenderer) || (r is ParticleRenderer) || (r is ParticleSystemRenderer)))
{
if (!initBounds)
{
initBounds = true;
bounds = r.bounds;
}
else
{
bounds.Encapsulate(r.bounds);
}
}
}
float max = Mathf.Max(bounds.extents.x, bounds.extents.y, bounds.extents.z);
return max;
}
public static Bounds CombineBoundsOfChildren(GameObject go)
{
// Create an empty Bounds b
Bounds b = new Bounds(Vector3.zero, Vector3.zero);
// If this GameObject has a Renderer Component...
if (go.GetComponent<Renderer>() != null)
{
// Expand b to contain the Renderer's Bounds
b = BoundsUnion(b, go.GetComponent<Renderer>().bounds);
}
// If this GameObject has a Collider Component...
if (go.GetComponent<Collider>() != null)
{
// Expand b to contain the Collider's Bounds
b = BoundsUnion(b, go.GetComponent<Collider>().bounds);
}
// Iterate through each child of this gameObject.transform
foreach (Transform t in go.transform)
{
// Expand b to contain their Bounds as well
b = BoundsUnion(b, CombineBoundsOfChildren(t.gameObject));
}
return (b);
}
private void showGameObjectPreview()
{
if (toShowInstance == null)
{
return;
}
//all comonents
List <Component> toShow_components = new List <Component>(toShowInstance.GetComponentsInChildren <Component>());
//removes all components but meshes
foreach (Component comp in toShow_components)
{
//Debug.Log(comp.GetType());
//if comp is not a mesh or a transform component or interactive component
if (!comp.GetType().Equals(typeof(Mesh)) &&
!comp.GetType().Equals(typeof(Renderer)) &&
!comp.GetType().Equals(typeof(MeshRenderer)) &&
!comp.GetType().Equals(typeof(TextMesh)) &&
!comp.GetType().Equals(typeof(MeshFilter)) &&
!comp.GetType().Equals(typeof(Transform)) &&
!comp.GetType().Equals(typeof(Vector3InteractiveTheme)) &&
!comp.GetType().Equals(typeof(ColorInteractiveTheme)) &&
!comp.GetType().Equals(typeof(StringInteractiveTheme)) &&
!comp.GetType().Equals(typeof(TextureInteractiveTheme)) &&
!comp.GetType().Equals(typeof(ButtonFocusShowHideWidget)) &&
!comp.GetType().Equals(typeof(ButtonThemeWidget)) &&
!comp.GetType().Equals(typeof(ButtonThemeWidgetLabel)) &&
!comp.GetType().Equals(typeof(ButtonThemeWidgetOutline)) &&
!comp.GetType().Equals(typeof(ElementSelectedActiveWidget)) &&
!comp.GetType().Equals(typeof(LabelTheme)) &&
!comp.GetType().Equals(typeof(LoadingAnimation)) &&
!comp.GetType().Equals(typeof(SliderGestureControl)) &&
!comp.GetType().Equals(typeof(RectTransform)) &&//canvas
!comp.GetType().Equals(typeof(Canvas)) &&
!comp.GetType().Equals(typeof(CanvasScaler)) &&
!comp.GetType().Equals(typeof(GraphicRaycaster)) &&
!comp.GetType().Equals(typeof(Text)) &&
!comp.GetType().Equals(typeof(CanvasRenderer)))
{
if (Application.isPlaying) //Application.isPlaying
{ //if called from inspector, use destroyimmediate
Destroy(comp);
try
{
//MonoBehaviour b = (MonoBehaviour)comp;
//b.enabled = false;
//Destroy(b);
}
catch { }
}
else
{
DestroyImmediate(comp);
}
}
}
//bounds of original obj
Bounds toShow_Instance_Bounds = BoundsUtils.getBounds(toShowInstance);
Vector3 newScale = toShowInstance.transform.localScale;
//use the smallest resize
if (targetSizeHeight / toShow_Instance_Bounds.size.y < targetSizeLenght / toShow_Instance_Bounds.size.x)
{
//calc a new scale based on targetSizeHeight
newScale.y = targetSizeHeight * newScale.y / toShow_Instance_Bounds.size.y;
newScale.x = targetSizeHeight * newScale.x / toShow_Instance_Bounds.size.y;
newScale.z = targetSizeHeight * newScale.z / toShow_Instance_Bounds.size.y;
}
else
{
//calc a new scale based on targetSizeLenght
newScale.y = targetSizeLenght * newScale.y / toShow_Instance_Bounds.size.x;
newScale.x = targetSizeLenght * newScale.x / toShow_Instance_Bounds.size.x;
newScale.z = targetSizeLenght * newScale.z / toShow_Instance_Bounds.size.x;
}
//set new scale
toShowInstance.transform.localScale = newScale;
//applies the scale resize to the go
// toShow_Instance.transform.localScale = toShow_Instance.transform.lossyScale / scaleFactor;
//apply the offset
toShowInstance.transform.localPosition = offset;
toShowInstance.transform.localEulerAngles = Vector3.zero;
}
protected override void UpdateOverride()
{
base.UpdateOverride();
if (Editor.Tools.IsViewing)
{
SelectedAxis = RuntimeHandleAxis.None;
return;
}
if (!IsWindowActive || !Window.IsPointerOver)
{
return;
}
IRTE editor = Editor;
if (IsDragging)
{
if (SnapToGround && SelectedAxis != RuntimeHandleAxis.Y)
{
SnapActiveTargetsToGround(ActiveTargets, Window.Camera, true);
transform.position = Targets[0].position;
}
}
if (HightlightOnHover && !IsDragging && !IsPointerDown)
{
SelectedAxis = Hit();
}
if (IsInVertexSnappingMode || Editor.Tools.IsSnapping)
{
Vector2 mousePosition;
if (Window.Pointer.XY(HandlePosition, out mousePosition))
{
if (editor.Tools.SnappingMode == SnappingMode.BoundingBox)
{
if (IsDragging)
{
SelectedAxis = RuntimeHandleAxis.Snap;
if (m_prevMousePosition != mousePosition)
{
m_prevMousePosition = mousePosition;
float minDistance = float.MaxValue;
Vector3 minPoint = Vector3.zero;
bool minPointFound = false;
for (int i = 0; i < m_allExposedToEditor.Length; ++i)
{
ExposeToEditor exposeToEditor = m_allExposedToEditor[i];
Bounds bounds = exposeToEditor.Bounds;
m_boundingBoxCorners[0] = bounds.center + new Vector3(bounds.extents.x, bounds.extents.y, bounds.extents.z);
m_boundingBoxCorners[1] = bounds.center + new Vector3(bounds.extents.x, bounds.extents.y, -bounds.extents.z);
m_boundingBoxCorners[2] = bounds.center + new Vector3(bounds.extents.x, -bounds.extents.y, bounds.extents.z);
m_boundingBoxCorners[3] = bounds.center + new Vector3(bounds.extents.x, -bounds.extents.y, -bounds.extents.z);
m_boundingBoxCorners[4] = bounds.center + new Vector3(-bounds.extents.x, bounds.extents.y, bounds.extents.z);
m_boundingBoxCorners[5] = bounds.center + new Vector3(-bounds.extents.x, bounds.extents.y, -bounds.extents.z);
m_boundingBoxCorners[6] = bounds.center + new Vector3(-bounds.extents.x, -bounds.extents.y, bounds.extents.z);
m_boundingBoxCorners[7] = bounds.center + new Vector3(-bounds.extents.x, -bounds.extents.y, -bounds.extents.z);
GetMinPoint(ref minDistance, ref minPoint, ref minPointFound, exposeToEditor.BoundsObject.transform);
}
if (minPointFound)
{
HandlePosition = minPoint;
}
}
}
else
{
SelectedAxis = RuntimeHandleAxis.None;
if (m_prevMousePosition != mousePosition)
{
m_prevMousePosition = mousePosition;
float minDistance = float.MaxValue;
Vector3 minPoint = Vector3.zero;
bool minPointFound = false;
for (int i = 0; i < m_snapTargets.Length; ++i)
{
Transform snapTarget = m_snapTargets[i];
Bounds bounds = m_snapTargetsBounds[i];
m_boundingBoxCorners[0] = bounds.center + new Vector3(bounds.extents.x, bounds.extents.y, bounds.extents.z);
m_boundingBoxCorners[1] = bounds.center + new Vector3(bounds.extents.x, bounds.extents.y, -bounds.extents.z);
m_boundingBoxCorners[2] = bounds.center + new Vector3(bounds.extents.x, -bounds.extents.y, bounds.extents.z);
m_boundingBoxCorners[3] = bounds.center + new Vector3(bounds.extents.x, -bounds.extents.y, -bounds.extents.z);
m_boundingBoxCorners[4] = bounds.center + new Vector3(-bounds.extents.x, bounds.extents.y, bounds.extents.z);
m_boundingBoxCorners[5] = bounds.center + new Vector3(-bounds.extents.x, bounds.extents.y, -bounds.extents.z);
m_boundingBoxCorners[6] = bounds.center + new Vector3(-bounds.extents.x, -bounds.extents.y, bounds.extents.z);
m_boundingBoxCorners[7] = bounds.center + new Vector3(-bounds.extents.x, -bounds.extents.y, -bounds.extents.z);
if (Targets[i] != null)
{
GetMinPoint(ref minDistance, ref minPoint, ref minPointFound, snapTarget);
}
}
if (minPointFound)
{
m_handleOffset = minPoint - transform.position;
}
}
}
}
else
{
if (IsDragging)
{
SelectedAxis = RuntimeHandleAxis.Snap;
if (m_prevMousePosition != mousePosition)
{
m_prevMousePosition = mousePosition;
Ray ray = Window.Pointer;
RaycastHit hitInfo;
LayerMask layerMask = (1 << Physics.IgnoreRaycastLayer);
layerMask = ~layerMask;
for (int i = 0; i < m_snapTargets.Length; ++i)
{
m_targetLayers[i] = m_snapTargets[i].gameObject.layer;
m_snapTargets[i].gameObject.layer = Physics.IgnoreRaycastLayer;
}
GameObject closestObject = null;
if (Physics.Raycast(ray, out hitInfo, float.PositiveInfinity, layerMask))
{
closestObject = hitInfo.collider.gameObject;
}
else
{
float minDistance = float.MaxValue;
for (int i = 0; i < m_allExposedToEditor.Length; ++i)
{
ExposeToEditor exposedToEditor = m_allExposedToEditor[i];
Bounds bounds = exposedToEditor.Bounds;
m_boundingBoxCorners[0] = bounds.center + new Vector3(bounds.extents.x, bounds.extents.y, bounds.extents.z);
m_boundingBoxCorners[1] = bounds.center + new Vector3(bounds.extents.x, bounds.extents.y, -bounds.extents.z);
m_boundingBoxCorners[2] = bounds.center + new Vector3(bounds.extents.x, -bounds.extents.y, bounds.extents.z);
m_boundingBoxCorners[3] = bounds.center + new Vector3(bounds.extents.x, -bounds.extents.y, -bounds.extents.z);
m_boundingBoxCorners[4] = bounds.center + new Vector3(-bounds.extents.x, bounds.extents.y, bounds.extents.z);
m_boundingBoxCorners[5] = bounds.center + new Vector3(-bounds.extents.x, bounds.extents.y, -bounds.extents.z);
m_boundingBoxCorners[6] = bounds.center + new Vector3(-bounds.extents.x, -bounds.extents.y, bounds.extents.z);
m_boundingBoxCorners[7] = bounds.center + new Vector3(-bounds.extents.x, -bounds.extents.y, -bounds.extents.z);
for (int j = 0; j < m_boundingBoxCorners.Length; ++j)
{
Vector2 screenPoint;
if (Window.Pointer.WorldToScreenPoint(HandlePosition, exposedToEditor.BoundsObject.transform.TransformPoint(m_boundingBoxCorners[j]), out screenPoint))
{
float distance = (screenPoint - mousePosition).magnitude;
if (distance < minDistance)
{
closestObject = exposedToEditor.gameObject;
minDistance = distance;
}
}
}
}
}
if (closestObject != null)
{
float minDistance = float.MaxValue;
Vector3 minPoint = Vector3.zero;
bool minPointFound = false;
Transform meshTransform;
Mesh mesh = GetMesh(closestObject, out meshTransform);
GetMinPoint(meshTransform, ref minDistance, ref minPoint, ref minPointFound, mesh);
if (minPointFound)
{
HandlePosition = minPoint;
}
}
for (int i = 0; i < m_snapTargets.Length; ++i)
{
m_snapTargets[i].gameObject.layer = m_targetLayers[i];
}
}
}
else
{
SelectedAxis = RuntimeHandleAxis.None;
if (m_prevMousePosition != mousePosition)
{
m_prevMousePosition = mousePosition;
float minDistance = float.MaxValue;
Vector3 minPoint = Vector3.zero;
bool minPointFound = false;
for (int i = 0; i < RealTargets.Length; ++i)
{
Transform snapTarget = RealTargets[i];
Transform meshTranform;
Mesh mesh = GetMesh(snapTarget.gameObject, out meshTranform);
GetMinPoint(meshTranform, ref minDistance, ref minPoint, ref minPointFound, mesh);
}
if (minPointFound)
{
m_handleOffset = minPoint - transform.position;
}
}
}
}
}
}
}
private void OnGUI()
{
b = EditorGUILayout.BoundsField("", b);
}
/// <summary>Returns true if the layout is a simple rectangle, i.e. not rotated</summary>
protected bool IsOrthogonal()
{
return(Vertices[0].ApproxEqual(Bounds.Location) && Vertices[1].ApproxEqual(Bounds.TopRight()));
// Not sure if it's actually necessary to check more than one point
}
public BoxConstraint(Point point, Bounds bounds) :
base()
{
this.bounds = bounds;
this.point = point;
}
void Start()
{
shipBounds = ContentBounds.Box(this.gameObject).Value;
gameController = GameObject.FindWithTag("GameController")
.GetComponent <GameControllerScript>();
}
public void Apply()
{
if (AstarPath.active == null)
{
Debug.LogError("There is no AstarPath object in the scene");
return;
}
GraphUpdateObject graphUpdateObject;
if (this.points == null || this.points.Length == 0)
{
Collider component = base.GetComponent <Collider>();
Renderer component2 = base.GetComponent <Renderer>();
Bounds bounds;
if (component != null)
{
bounds = component.bounds;
}
else
{
if (!(component2 != null))
{
Debug.LogWarning("Cannot apply GraphUpdateScene, no points defined and no renderer or collider attached");
return;
}
bounds = component2.bounds;
}
if (bounds.size.y < this.minBoundsHeight)
{
bounds.size = new Vector3(bounds.size.x, this.minBoundsHeight, bounds.size.z);
}
graphUpdateObject = new GraphUpdateObject(bounds);
}
else
{
GraphUpdateShape graphUpdateShape = new GraphUpdateShape();
graphUpdateShape.convex = this.convex;
Vector3[] array = this.points;
if (!this.useWorldSpace)
{
array = new Vector3[this.points.Length];
Matrix4x4 localToWorldMatrix = base.transform.localToWorldMatrix;
for (int i = 0; i < array.Length; i++)
{
array[i] = localToWorldMatrix.MultiplyPoint3x4(this.points[i]);
}
}
graphUpdateShape.points = array;
Bounds bounds2 = graphUpdateShape.GetBounds();
if (bounds2.size.y < this.minBoundsHeight)
{
bounds2.size = new Vector3(bounds2.size.x, this.minBoundsHeight, bounds2.size.z);
}
graphUpdateObject = new GraphUpdateObject(bounds2);
graphUpdateObject.shape = graphUpdateShape;
}
this.firstApplied = true;
graphUpdateObject.modifyWalkability = this.modifyWalkability;
graphUpdateObject.setWalkability = this.setWalkability;
graphUpdateObject.addPenalty = this.penaltyDelta;
graphUpdateObject.updatePhysics = this.updatePhysics;
graphUpdateObject.updateErosion = this.updateErosion;
graphUpdateObject.resetPenaltyOnPhysics = this.resetPenaltyOnPhysics;
graphUpdateObject.modifyTag = this.modifyTag;
graphUpdateObject.setTag = this.setTag;
AstarPath.active.UpdateGraphs(graphUpdateObject);
}
private void BeginSnap()
{
if (Window.Camera == null)
{
return;
}
if (Model != null && Model is PositionHandleModel)
{
((PositionHandleModel)Model).IsVertexSnapping = true;
}
HashSet <Transform> snapTargetsHS = new HashSet <Transform>();
List <Transform> snapTargets = new List <Transform>();
List <Bounds> snapTargetBounds = new List <Bounds>();
if (Target != null)
{
for (int i = 0; i < RealTargets.Length; ++i)
{
Transform target = RealTargets[i];
if (target != null)
{
snapTargets.Add(target);
snapTargetsHS.Add(target);
ExposeToEditor exposeToEditor = target.GetComponent <ExposeToEditor>();
if (exposeToEditor != null)
{
snapTargetBounds.Add(exposeToEditor.Bounds);
}
else
{
MeshFilter filter = target.GetComponent <MeshFilter>();
if (filter != null && filter.sharedMesh != null)
{
snapTargetBounds.Add(filter.sharedMesh.bounds);
}
else
{
SkinnedMeshRenderer smr = target.GetComponent <SkinnedMeshRenderer>();
if (smr != null && smr.sharedMesh != null)
{
snapTargetBounds.Add(smr.sharedMesh.bounds);
}
else
{
Bounds b = new Bounds(Vector3.zero, Vector3.zero);
snapTargetBounds.Add(b);
}
}
}
}
}
}
m_snapTargets = snapTargets.ToArray();
m_targetLayers = new int[m_snapTargets.Length];
m_snapTargetsBounds = snapTargetBounds.ToArray();
Plane[] frustumPlanes = GeometryUtility.CalculateFrustumPlanes(Window.Camera);
ExposeToEditor[] exposeToEditorObjects = FindObjectsOfType <ExposeToEditor>();
List <ExposeToEditor> insideOfFrustum = new List <ExposeToEditor>();
for (int i = 0; i < exposeToEditorObjects.Length; ++i)
{
ExposeToEditor exposeToEditor = exposeToEditorObjects[i];
if (exposeToEditor.CanSnap)
{
if (GeometryUtility.TestPlanesAABB(frustumPlanes, new Bounds(exposeToEditor.transform.TransformPoint(exposeToEditor.Bounds.center), Vector3.zero)))
{
if (!snapTargetsHS.Contains(exposeToEditor.transform))
{
insideOfFrustum.Add(exposeToEditor);
}
}
}
}
m_allExposedToEditor = insideOfFrustum.ToArray();
}
// Tests to see whether lilB is inside bigB
public static Vector3 BoundsInBoundsCheck(Bounds bigB, Bounds lilB, BoundsTest test = BoundsTest.onScreen)
{
// Get the center of lilB
Vector3 pos = lilB.center;
// Initialize the offset at [0,0,0]
Vector3 off = Vector3.zero;
switch (test)
{
// The center test determines what off (offset) would have to be applied to lilB to move its center back inside bigB
case BoundsTest.center:
// if the center is contained, return Vector3.zero
if (bigB.Contains(pos))
{
return(Vector3.zero);
}
// if not contained, find the offset
if (pos.x > bigB.max.x)
{
off.x = pos.x - bigB.max.x;
}
else if (pos.x < bigB.min.x)
{
off.x = pos.x - bigB.min.x;
}
if (pos.y > bigB.max.y)
{
off.y = pos.y - bigB.max.y;
}
else if (pos.y < bigB.min.y)
{
off.y = pos.y - bigB.min.y;
}
if (pos.z > bigB.max.z)
{
off.z = pos.z - bigB.max.z;
}
else if (pos.z < bigB.min.z)
{
off.z = pos.z - bigB.min.z;
}
return(off);
// The onScreen test determines what off would have to be applied to keep all of lilB inside bigB
case BoundsTest.onScreen:
// find whether bigB contains all of lilB
if (bigB.Contains(lilB.min) && bigB.Contains(lilB.max))
{
return(Vector3.zero);
}
// if not, find the offset
if (lilB.max.x > bigB.max.x)
{
off.x = lilB.max.x - bigB.max.x;
}
else if (lilB.min.x < bigB.min.x)
{
off.x = lilB.min.x - bigB.min.x;
}
if (lilB.max.y > bigB.max.y)
{
off.y = lilB.max.y - bigB.max.y;
}
else if (lilB.min.y < bigB.min.y)
{
off.y = lilB.min.y - bigB.min.y;
}
if (lilB.max.z > bigB.max.z)
{
off.z = lilB.max.z - bigB.max.z;
}
else if (lilB.min.z < bigB.min.z)
{
off.z = lilB.min.z - bigB.min.z;
}
return(off);
// The offScreen test determines what off would need to be applied to move any tiny part of lilB inside of bigB
case BoundsTest.offScreen:
// find whether bigB contains any of lilB
bool cMin = bigB.Contains(lilB.min);
bool cMax = bigB.Contains(lilB.max);
if (cMin || cMax)
{
return(Vector3.zero);
}
// if not, find the offset
if (lilB.min.x > bigB.max.x)
{
off.x = lilB.min.x - bigB.max.x;
}
else if (lilB.max.x < bigB.min.x)
{
off.x = lilB.max.x - bigB.min.x;
}
if (lilB.min.y > bigB.max.y)
{
off.y = lilB.min.y - bigB.max.y;
}
else if (lilB.max.y < bigB.min.y)
{
off.y = lilB.max.y - bigB.min.y;
}
if (lilB.min.z > bigB.max.z)
{
off.z = lilB.min.z - bigB.max.z;
}
else if (lilB.max.z < bigB.min.z)
{
off.z = lilB.max.z - bigB.min.z;
}
return(off);
}
return(Vector3.zero);
}
public IEnumerator Scale(Transform thisTransform, float byThatMuch, float value, ScaleObject.ScaleType moveType)
{
_bounds = GameObjectBounds(thisTransform.gameObject);
yield return(Scale(thisTransform, thisTransform.localScale, thisTransform.localScale * byThatMuch, value, moveType));
}
protected virtual void Awake()
{
selectionBounds = ResourceManager.InvalidBounds;
CalculateBounds();
}
// Test to see whether Bounds are on screen.
public static Vector3 ScreenBoundsCheck(Bounds bnd, BoundsTest test = BoundsTest.center)
{
// Call the more generic BoundsInBoundsCheck with camBounds as bigB
return(BoundsInBoundsCheck(camBounds, bnd, test));
}
/// <summary>
/// Constrain the specified target to be within the panel's bounds.
/// </summary>
public bool ConstrainTargetToBounds (Transform target, bool immediate)
{
Bounds bounds = NGUIMath.CalculateRelativeWidgetBounds(cachedTransform, target);
return ConstrainTargetToBounds(target, ref bounds, immediate);
}
public abstract void SetBounds(Bounds newBounds);
public override void OnUpdate(ref ChiselBoxDefinition definition, Bounds bounds)
{
definition.settings.bounds = new ChiselAABB {
Min = bounds.min, Max = bounds.max
};
}
public override void OnPaint(IChiselHandleRenderer renderer, Bounds bounds)
{
renderer.RenderBox(bounds);
renderer.RenderBoxMeasurements(bounds);
}
private Bounds TransformBounds(Bounds oldBounds, Matrix4x4 matrix)
{
Bounds bounds = new Bounds();
Vector3 center, extents;
center = oldBounds.center; //matrix.MultiplyPoint3x4(m.bounds.center);
extents = oldBounds.extents; //matrix.MultiplyVector(m.bounds.size);
/*size.x = Math.Abs(size.x);
* size.y = Math.Abs(size.y);
* size.z = Math.Abs(size.z);*/
Vector3 boundPt;
boundPt = center + extents;
boundPt = matrix.MultiplyPoint3x4(boundPt);
bounds.Encapsulate(boundPt);
boundPt = center - extents;
boundPt = matrix.MultiplyPoint3x4(boundPt);
bounds.Encapsulate(boundPt);
boundPt = center;
boundPt.x += extents.x;
boundPt.y += extents.y;
boundPt.z -= extents.z;
boundPt = matrix.MultiplyPoint3x4(boundPt);
bounds.Encapsulate(boundPt);
boundPt = center;
boundPt.x += extents.x;
boundPt.y -= extents.y;
boundPt.z += extents.z;
boundPt = matrix.MultiplyPoint3x4(boundPt);
bounds.Encapsulate(boundPt);
boundPt = center;
boundPt.x -= extents.x;
boundPt.y += extents.y;
boundPt.z += extents.z;
boundPt = matrix.MultiplyPoint3x4(boundPt);
bounds.Encapsulate(boundPt);
boundPt = center;
boundPt.x -= extents.x;
boundPt.y -= extents.y;
boundPt.z += extents.z;
boundPt = matrix.MultiplyPoint3x4(boundPt);
bounds.Encapsulate(boundPt);
boundPt = center;
boundPt.x -= extents.x;
boundPt.y += extents.y;
boundPt.z -= extents.z;
boundPt = matrix.MultiplyPoint3x4(boundPt);
bounds.Encapsulate(boundPt);
boundPt = center;
boundPt.x += extents.x;
boundPt.y -= extents.y;
boundPt.z -= extents.z;
boundPt = matrix.MultiplyPoint3x4(boundPt);
bounds.Encapsulate(boundPt);
return(bounds);
}
private static Vector3 Transform(Vector3 vert, Bounds bounds)
{
return(bounds.center + Vector3.Scale(vert, bounds.size));
}
public void Voxelize(Bounds bounds)
{
Voxelize(mesh, bounds);
}
/// <summary>
/// Display the drop-down list when the game object gets clicked on.
/// </summary>
void OnClick()
{
if (enabled && NGUITools.GetActive(gameObject) && mChild == null && atlas != null && font != null && items.Count > 0)
{
mLabelList.Clear();
// Disable the navigation script
handleEvents = true;
// Automatically locate the panel responsible for this object
if (mPanel == null)
{
mPanel = UIPanel.Find(transform, true);
}
// Calculate the dimensions of the object triggering the popup list so we can position it below it
Transform myTrans = transform;
Bounds bounds = NGUIMath.CalculateRelativeWidgetBounds(myTrans.parent, myTrans);
// Create the root object for the list
mChild = new GameObject("Drop-down List");
mChild.layer = gameObject.layer;
UIPanel droplistPanel = mChild.AddComponent <UIPanel>();
if (droplistPanel != null)
{
droplistPanel.depth = 700;
}
Transform t = mChild.transform;
t.parent = myTrans.parent;
t.localPosition = bounds.min;
t.localRotation = Quaternion.identity;
t.localScale = Vector3.one;
// Add a sprite for the background
mBackground = NGUITools.AddSprite(mChild, atlas, backgroundSprite);
mBackground.pivot = UIWidget.Pivot.TopLeft;
mBackground.depth = NGUITools.CalculateNextDepth(mPanel.gameObject);
mBackground.color = backgroundColor;
// We need to know the size of the background sprite for padding purposes
Vector4 bgPadding = mBackground.border;
mBgBorder = bgPadding.y;
mBackground.cachedTransform.localPosition = new Vector3(0f, bgPadding.y, 0f);
// Add a sprite used for the selection
mHighlight = NGUITools.AddSprite(mChild, atlas, highlightSprite);
mHighlight.pivot = UIWidget.Pivot.TopLeft;
mHighlight.color = highlightColor;
UISpriteData hlsp = mHighlight.GetAtlasSprite();
if (hlsp == null)
{
return;
}
float hlspHeight = hlsp.borderTop;
float labelHeight = font.size * font.pixelSize * textScale;
float x = 0f, y = -padding.y;
List <UILabel> labels = new List <UILabel>();
// 加个补丁，如果国际化过程导致无法选中默认值，则设置一个默认值。
UILabel labelFirst = null;
bool bFocusLabel = false;
// Run through all items and create labels for each one
for (int i = 0, imax = items.Count; i < imax; ++i)
{
string s = items[i];
string curDicID = "0";
if (useDicTable)
{
int id = 0;
if (int.TryParse(s, out id))
{
string val = Utils.GetDicByID(id);
s = val;
curDicID = id.ToString();
}
}
UILabel lbl = NGUITools.AddWidget <UILabel>(mChild);
lbl.pivot = UIWidget.Pivot.TopLeft;
lbl.font = font;
lbl.text = (isLocalized && Localization.instance != null) ? Localization.instance.Get(s) : s;
lbl.color = textColor;
lbl.cachedTransform.localPosition = new Vector3(bgPadding.x + padding.x, y, -1f);
lbl.overflowMethod = UILabel.Overflow.ResizeFreely;
Transform lblTrans = lbl.gameObject.transform;
lblTrans.localPosition = new Vector3(lblTrans.localPosition.x, lblTrans.localPosition.y, 0);
lbl.MakePixelPerfect();
if (textScale != 1f)
{
lbl.cachedTransform.localScale = Vector3.one * textScale;
}
labels.Add(lbl);
y -= labelHeight;
y -= padding.y;
x = Mathf.Max(x, labelHeight);
// Add an event listener
UIEventListener listener = UIEventListener.Get(lbl.gameObject);
listener.onHover = OnItemHover;
listener.onPress = OnItemPress;
listener.parameter = s;
// Move the selection here if this is the right label
if (mSelectedItem == s || mSelectedItem == curDicID)
{
Highlight(lbl, true);
bFocusLabel = true;
}
if (null == labelFirst)
{
labelFirst = lbl;
}
// Add this label to the list
mLabelList.Add(lbl);
}
if (!bFocusLabel && null != labelFirst)
{
Highlight(labelFirst, true);
}
// The triggering widget's width should be the minimum allowed width
x = Mathf.Max(x, bounds.size.x - (bgPadding.x + padding.x) * 2f);
Vector3 bcCenter = new Vector3(x * 0.5f, -labelHeight * 0.5f, 0f);
Vector3 bcSize = new Vector3(x, (labelHeight + padding.y), 1f);
// Run through all labels and add colliders
for (int i = 0, imax = labels.Count; i < imax; ++i)
{
UILabel lbl = labels[i];
BoxCollider bc = NGUITools.AddWidgetCollider(lbl.gameObject);
bcCenter.z = bc.center.z;
bc.center = bcCenter;
bc.size = bcSize;
}
x += (bgPadding.x + padding.x) * 2f;
y -= bgPadding.y;
// Scale the background sprite to envelop the entire set of items
mBackground.width = Mathf.RoundToInt(x);
mBackground.height = Mathf.RoundToInt(-y + bgPadding.y);
// Scale the highlight sprite to envelop a single item
float scaleFactor = 2f * atlas.pixelSize;
float w = x - (bgPadding.x + padding.x) * 2f + hlsp.borderLeft * scaleFactor;
float h = labelHeight + hlspHeight * scaleFactor;
mHighlight.width = Mathf.RoundToInt(w);
mHighlight.height = Mathf.RoundToInt(h);
bool placeAbove = (position == Position.Above);
if (position == Position.Auto)
{
UICamera cam = UICamera.FindCameraForLayer(gameObject.layer);
if (cam != null)
{
Vector3 viewPos = cam.cachedCamera.WorldToViewportPoint(myTrans.position);
placeAbove = (viewPos.y < 0.5f);
}
}
// If the list should be animated, let's animate it by expanding it
if (isAnimated)
{
float bottom = y + labelHeight;
Animate(mHighlight, placeAbove, bottom);
for (int i = 0, imax = labels.Count; i < imax; ++i)
{
Animate(labels[i], placeAbove, bottom);
}
AnimateColor(mBackground);
AnimateScale(mBackground, placeAbove, bottom);
}
// If we need to place the popup list above the item, we need to reposition everything by the size of the list
if (placeAbove)
{
t.localPosition = new Vector3(bounds.min.x, bounds.max.y - y - bgPadding.y, bounds.min.z);
}
}
else
{
OnSelect(false);
}
}
public BoundsKun(Bounds bounds)
{
this.m_center = new Vector3Kun(bounds.center);
this.m_size = new Vector3Kun(bounds.size);
}
/// <summary>Returns a unique hash representing this resolution.</summary>
/// <returns>A System.Int32 that may serve as a hash code for this resolution.</returns>
public override int GetHashCode()
{
return(Bounds.GetHashCode() ^ bits_per_pixel ^ refresh_rate.GetHashCode());
}
void Update()
{
if (Input.GetMouseButtonDown(0))
{
Ray mouseToWorldRay = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hitInfo;
//Shoots a ray into the 3D world starting at our mouseposition
if (Physics.Raycast(mouseToWorldRay, out hitInfo))
{
//We check if we clicked on an object with a Selectable component
Selectable s = hitInfo.collider.GetComponent <Selectable>();
if (s != null)
{
//While holding the copyKey, we can add and remove objects from our selection
if (Input.GetKey(copyKey))
{
//Toggle the selection
UpdateSelection(s, !s.isSelected);
}
else
{
//If the copyKey was not held, we clear our current selection and select only this unit
ClearSelected();
UpdateSelection(s, true);
}
//If we clicked on a Selectable, we don't want to enable our SelectionBox
return;
}
}
if (selectionBox == null)
{
return;
}
//Storing these variables for the selectionBox
startScreenPos = Input.mousePosition;
isSelecting = true;
}
//If we never set the selectionBox variable in the inspector, we are simply not able to drag the selectionBox to easily select multiple objects. 'Regular' selection should still work
if (selectionBox == null)
{
return;
}
//We finished our selection box when the key is released
if (Input.GetMouseButtonUp(0))
{
isSelecting = false;
}
selectionBox.gameObject.SetActive(isSelecting);
if (isSelecting)
{
Bounds b = new Bounds();
//The center of the bounds is inbetween startpos and current pos
b.center = Vector3.Lerp(startScreenPos, Input.mousePosition, 0.5f);
//We make the size absolute (negative bounds don't contain anything)
b.size = new Vector3(Mathf.Abs(startScreenPos.x - Input.mousePosition.x),
Mathf.Abs(startScreenPos.y - Input.mousePosition.y),
0);
//To display our selectionbox image in the same place as our bounds
rt.position = b.center;
rt.sizeDelta = canvas.transform.InverseTransformVector(b.size);
//Looping through all the selectables in our world (automatically added/removed through the Selectable OnEnable/OnDisable)
foreach (Selectable selectable in selectables)
{
//If the screenPosition of the worldobject is within our selection bounds, we can add it to our selection
Vector3 screenPos = Camera.main.WorldToScreenPoint(selectable.transform.position);
screenPos.z = 0;
UpdateSelection(selectable, (b.Contains(screenPos)));
}
}
}
public static Mesh GetCorrectedMeshPloppableAsph(Mesh originalMesh, Mesh correctedInstance, out Bounds realBounds)
{
if (correctedInstance == null)
{
correctedInstance = originalMesh.InstantiateMesh();
}
Bounds b = new Bounds();
Vector3 noZFightingSurplus = new Vector3(0, 0.01f, 0);
var vertices = new List <Vector3>();
for (int i = 0; i < correctedInstance.vertices.Length; i++)
{
var vertex = originalMesh.vertices[i].PloppableAsphaltPosition() + noZFightingSurplus;
vertices.Add(vertex);
if (i == 0)
{
b = new Bounds(vertex, Vector3.zero);
}
b.Encapsulate(vertex);
}
correctedInstance.SetVertices(vertices);
realBounds = b;
return(correctedInstance);
}
public static Vector3 GetAlignedPosition(this Bounds bounds,
BoundsAlign xAlign,
BoundsAlign yAlign,
BoundsAlign zAlign)
{
Vector3 vector3;
switch (xAlign)
{
case BoundsAlign.Min:
vector3.x = bounds.min.x;
break;
case BoundsAlign.Center:
vector3.x = bounds.center.x;
break;
case BoundsAlign.Max:
vector3.x = bounds.max.x;
break;
default:
throw new ArgumentOutOfRangeException(nameof(xAlign), xAlign, null);
}
switch (yAlign)
{
case BoundsAlign.Min:
vector3.y = bounds.min.y;
break;
case BoundsAlign.Center:
vector3.y = bounds.center.y;
break;
case BoundsAlign.Max:
vector3.y = bounds.max.y;
break;
default:
throw new ArgumentOutOfRangeException(nameof(yAlign), yAlign, null);
}
switch (zAlign)
{
case BoundsAlign.Min:
vector3.z = bounds.min.z;
break;
case BoundsAlign.Center:
vector3.z = bounds.center.z;
break;
case BoundsAlign.Max:
vector3.z = bounds.max.z;
break;
default:
throw new ArgumentOutOfRangeException(nameof(zAlign), zAlign, null);
}
return(vector3);
}
bool AvoideVessel(VesselWrapper vsl, Vector3d dir, float dist, Vector3d dV,
float r2, Bounds exhaust2, Transform refT2,
out Vector3d maneuver, float threshold = -1)
{
maneuver = Vector3d.zero;
//filter vessels on non-collision courses
var dVn = dV.normalized;
var cosA = Mathf.Clamp(Vector3.Dot(dir, dVn), -1, 1);
var collision_dist = threshold.Equals(0)?
2 * dist - vsl.Geometry.DistToBounds(vsl.Physics.wCoM + dir * dist) -
Mathf.Sqrt(exhaust2.SqrDistance(refT2.InverseTransformPoint(vsl.Physics.wCoM))) :
Mathf.Max(vsl.Geometry.R, dist - vsl.Geometry.DistToBounds(vsl.Physics.wCoM + dir * dist)) +
Mathf.Max(r2, dist - Mathf.Sqrt(exhaust2.SqrDistance(refT2.InverseTransformPoint(vsl.Physics.wCoM))));
// vsl.Log("R {}, R2 {}; r {}, r2 {}", vsl.Geometry.R, r2,
// dist-vsl.DistToBounds(vsl.wCoM+dir*dist),
// dist-Mathf.Sqrt(exhaust2.SqrDistance(refT2.InverseTransformPoint(vsl.wCoM))));//debug
// Utils.Log("{}: cosA: {}, threshold {}", vsl.vessel.vesselName, cosA, threshold);//debug
if (cosA <= 0)
{
goto check_distance;
}
if (threshold < 0)
{
threshold = C.MinDistance;
}
var sinA = Mathf.Sqrt(1 - cosA * cosA);
var min_separation = dist * sinA;
var sep_threshold = collision_dist + threshold;
// Utils.Log("{}: min_sep > sep_thresh: {} > {}, threshold {}",
// vsl.vessel.vesselName, min_separation, sep_threshold, threshold);//debug
if (min_separation > sep_threshold)
{
goto check_distance;
}
//calculate time to collision
var vDist = 0f;
var alpha = Mathf.Acos(cosA);
var dVm = dV.magnitude;
if (sinA <= 0)
{
vDist = dist - sep_threshold;
}
else if (dist > sep_threshold)
{
vDist = sep_threshold * Mathf.Sin(Mathf.Asin(min_separation / sep_threshold) - alpha) / sinA;
}
var vTime = Utils.ClampL(vDist, 0.1f) / dVm;
// Utils.Log("{}: vTime > SafeTime: {} > {}",
// vsl.vessel.vesselName, vTime, CPS.SafeTime/Utils.Clamp(Mathf.Abs(Vector3.Dot(vsl.wMaxAngularA, dVn)), 0.01f, 1f));//debug
if (vTime > SafeTime(vsl, dVn))
{
goto check_distance;
}
//calculate maneuver
Vector3d side;
if (cosA < 0.9)
{
side = (dVn * cosA - dir).normalized;
}
else if (Math.Abs(Vector3d.Dot(dVn, vsl.Physics.Up)) < 0.9)
{
side = Vector3d.Cross(dVn, vsl.Physics.Up).normalized;
}
else
{
side = Vector3d.Cross(dVn, vsl.OnPlanetParams.Fwd).normalized;
}
// if(dist > sep_threshold)
// {
// var beta = Mathf.Asin(sep_threshold/dist)-alpha;
// maneuver = (Mathf.Sin(beta)*side + dVn*(Mathf.Cos(beta)-1)).normalized;
// }
// else
maneuver = side;
maneuver += vsl.Physics.Up * Mathf.Sign(Vector3.Dot(dir, vsl.Physics.Up)) * (min_separation / sep_threshold - 1);
maneuver *= (sep_threshold - min_separation) / Math.Sqrt(vTime);
// maneuver = (-vsl.Up*Mathf.Sign(Vector3.Dot(dir, vsl.Up))*(1-min_separation/sep_threshold) +
// (dVn*cosA-dir).normalized).normalized * (sep_threshold-min_separation) / vTime;
// vsl.Log("\ndist {}\ndV {}\nmaneuver: {}\n" +
// "vTime {}, vDist {}, min sep {}, sep_thresh {}",
// dir*dist, dV, maneuver, vTime, vDist, min_separation, sep_threshold);//debug
#if DEBUG
Collided |= dist < collision_dist;
#endif
//if distance is not safe, correct course anyway
check_distance:
var collision = !maneuver.IsZero();
dist -= collision_dist;
if (dist < threshold)
{
var dist_to_safe = Utils.ClampH(dist - threshold, -0.01f);
var dc = dir * dist_to_safe;
if (vsl.HorizontalSpeed.NeededVector.sqrMagnitude > C.LatAvoidMinVelSqr)
{
var lat_avoid = Vector3d.Cross(vsl.Physics.Up, vsl.HorizontalSpeed.NeededVector.normalized);
dc = Vector3d.Dot(dc, lat_avoid) >= 0?
lat_avoid * dist_to_safe :
lat_avoid * -dist_to_safe;
}
if (dc.sqrMagnitude > 0.25)
{
maneuver += dc / C.SafeTime * 2;
}
// vsl.Log("adding safe distance correction: {}", dc/CPS.SafeTime*2);//debug
}
// #if DEBUG
// Dir = dir*dist;
// DeltaV = dV;
// Maneuver = maneuver;
// #endif
return(collision);
}
private IEnumerator AnalyzeGeometry(GameObject avatarObject, IEnumerable <Renderer> renderers, AvatarPerformanceStats perfStats)
{
List <Renderer> lodGroupRendererIgnoreBuffer = new List <Renderer>(16);
List <LODGroup> lodBuffer = new List <LODGroup>(16);
ulong polyCount = 0;
Bounds bounds = new Bounds(avatarObject.transform.position, Vector3.zero);
yield return(ScanAvatarForComponentsOfType(avatarObject, lodBuffer));
try
{
foreach (LODGroup lodGroup in lodBuffer)
{
LOD[] lodLevels = lodGroup.GetLODs();
ulong highestLodPolyCount = 0;
foreach (LOD lod in lodLevels)
{
uint thisLodPolyCount = 0;
foreach (Renderer renderer in lod.renderers)
{
lodGroupRendererIgnoreBuffer.Add(renderer);
checked
{
thisLodPolyCount += CalculateRendererPolyCount(renderer);
}
}
if (thisLodPolyCount > highestLodPolyCount)
{
highestLodPolyCount = thisLodPolyCount;
}
}
checked
{
polyCount += highestLodPolyCount;
}
}
}
catch (OverflowException e)
{
VRC.Core.Logger.Log("Overflow exception while analyzing geometry, assuming max value:" + e.ToString(), VRC.Core.DebugLevel.All);
polyCount = uint.MaxValue;
}
Profiler.BeginSample("Calculate Total Polygon Count and Bounds");
foreach (Renderer renderer in renderers)
{
Profiler.BeginSample("Single Renderer");
if (renderer is MeshRenderer || renderer is SkinnedMeshRenderer)
{
if (!RendererHasMesh(renderer))
{
Profiler.EndSample();
continue;
}
bounds.Encapsulate(renderer.bounds);
}
if (lodGroupRendererIgnoreBuffer.Contains(renderer))
{
Profiler.EndSample();
continue;
}
polyCount += CalculateRendererPolyCount(renderer);
Profiler.EndSample();
}
Profiler.EndSample();
bounds.center -= avatarObject.transform.position;
lodGroupRendererIgnoreBuffer.Clear();
lodBuffer.Clear();
perfStats.polyCount = polyCount > int.MaxValue ? int.MaxValue : (int)polyCount;
perfStats.aabb = bounds;
}
public virtual void Show()
{
if (base.enabled && NGUITools.GetActive(base.gameObject) && UIPopupList.mChild == null && this.atlas != null && this.isValid && this.items.Count > 0)
{
this.mLabelList.Clear();
base.StopCoroutine("CloseIfUnselected");
UICamera.selectedObject = (UICamera.hoveredObject ?? base.gameObject);
this.mSelection = UICamera.selectedObject;
this.source = UICamera.selectedObject;
if (this.source == null)
{
Debug.LogError("Popup list needs a source object...");
return;
}
this.mOpenFrame = Time.frameCount;
if (this.mPanel == null)
{
this.mPanel = UIPanel.Find(base.transform);
if (this.mPanel == null)
{
return;
}
}
UIPopupList.mChild = new GameObject("Drop-down List");
UIPopupList.mChild.layer = base.gameObject.layer;
UIPopupList.current = this;
Transform transform = UIPopupList.mChild.transform;
transform.parent = this.mPanel.cachedTransform;
Vector3 localPosition;
Vector3 vector;
Vector3 v;
if (this.openOn == UIPopupList.OpenOn.Manual && this.mSelection != base.gameObject)
{
localPosition = UICamera.lastEventPosition;
vector = this.mPanel.cachedTransform.InverseTransformPoint(this.mPanel.anchorCamera.ScreenToWorldPoint(localPosition));
v = vector;
transform.localPosition = vector;
localPosition = transform.position;
}
else
{
Bounds bounds = NGUIMath.CalculateRelativeWidgetBounds(this.mPanel.cachedTransform, base.transform, false, false);
vector = bounds.min;
v = bounds.max;
transform.localPosition = vector;
localPosition = transform.position;
}
base.StartCoroutine("CloseIfUnselected");
transform.localRotation = Quaternion.identity;
transform.localScale = Vector3.one;
this.mBackground = NGUITools.AddSprite(UIPopupList.mChild, this.atlas, this.backgroundSprite);
this.mBackground.pivot = UIWidget.Pivot.TopLeft;
this.mBackground.depth = NGUITools.CalculateNextDepth(this.mPanel.gameObject);
this.mBackground.color = this.backgroundColor;
Vector4 border = this.mBackground.border;
this.mBgBorder = border.y;
this.mBackground.cachedTransform.localPosition = new Vector3(0f, border.y, 0f);
this.mHighlight = NGUITools.AddSprite(UIPopupList.mChild, this.atlas, this.highlightSprite);
this.mHighlight.pivot = UIWidget.Pivot.TopLeft;
this.mHighlight.color = this.highlightColor;
UISpriteData atlasSprite = this.mHighlight.GetAtlasSprite();
if (atlasSprite == null)
{
return;
}
float num = (float)atlasSprite.borderTop;
float num2 = (float)this.activeFontSize;
float activeFontScale = this.activeFontScale;
float num3 = num2 * activeFontScale;
float num4 = 0f;
float num5 = -this.padding.y;
List <UILabel> list = new List <UILabel>();
if (!this.items.Contains(this.mSelectedItem))
{
this.mSelectedItem = null;
}
int i = 0;
int count = this.items.Count;
while (i < count)
{
string text = this.items[i];
UILabel uilabel = NGUITools.AddWidget <UILabel>(UIPopupList.mChild);
uilabel.name = i.ToString();
uilabel.pivot = UIWidget.Pivot.TopLeft;
uilabel.bitmapFont = this.bitmapFont;
uilabel.trueTypeFont = this.trueTypeFont;
uilabel.fontSize = this.fontSize;
uilabel.fontStyle = this.fontStyle;
string text2 = (!this.isLocalized) ? text : Localization.Get(text);
if (this.toUpper)
{
text2 = text2.ToUpper();
}
uilabel.text = text2;
uilabel.color = this.textColor;
uilabel.cachedTransform.localPosition = new Vector3(border.x + this.padding.x - uilabel.pivotOffset.x, num5, -1f);
uilabel.overflowMethod = UILabel.Overflow.ResizeFreely;
uilabel.alignment = this.alignment;
list.Add(uilabel);
num5 -= num3;
num5 -= this.padding.y;
num4 = Mathf.Max(num4, uilabel.printedSize.x);
UIEventListener uieventListener = UIEventListener.Get(uilabel.gameObject);
uieventListener.onHover = new UIEventListener.BoolDelegate(this.OnItemHover);
uieventListener.onPress = new UIEventListener.BoolDelegate(this.OnItemPress);
uieventListener.parameter = text;
if (this.mSelectedItem == text || (i == 0 && string.IsNullOrEmpty(this.mSelectedItem)))
{
this.Highlight(uilabel, true);
}
this.mLabelList.Add(uilabel);
i++;
}
num4 = Mathf.Max(num4, v.x - vector.x - (border.x + this.padding.x) * 2f);
float num6 = num4;
Vector3 vector2 = new Vector3(num6 * 0.5f, -num3 * 0.5f, 0f);
Vector3 vector3 = new Vector3(num6, num3 + this.padding.y, 1f);
int j = 0;
int count2 = list.Count;
while (j < count2)
{
UILabel uilabel2 = list[j];
NGUITools.AddWidgetCollider(uilabel2.gameObject);
uilabel2.autoResizeBoxCollider = false;
BoxCollider component = uilabel2.GetComponent <BoxCollider>();
if (component != null)
{
vector2.z = component.center.z;
component.center = vector2;
component.size = vector3;
}
else
{
BoxCollider2D component2 = uilabel2.GetComponent <BoxCollider2D>();
component2.offset = vector2;
component2.size = vector3;
}
j++;
}
int width = Mathf.RoundToInt(num4);
num4 += (border.x + this.padding.x) * 2f;
num5 -= border.y;
this.mBackground.width = Mathf.RoundToInt(num4);
this.mBackground.height = Mathf.RoundToInt(-num5 + border.y);
int k = 0;
int count3 = list.Count;
while (k < count3)
{
UILabel uilabel3 = list[k];
uilabel3.overflowMethod = UILabel.Overflow.ShrinkContent;
uilabel3.width = width;
k++;
}
float num7 = 2f * this.atlas.pixelSize;
float f = num4 - (border.x + this.padding.x) * 2f + (float)atlasSprite.borderLeft * num7;
float f2 = num3 + num * num7;
this.mHighlight.width = Mathf.RoundToInt(f);
this.mHighlight.height = Mathf.RoundToInt(f2);
bool flag = this.position == UIPopupList.Position.Above;
if (this.position == UIPopupList.Position.Auto)
{
UICamera uicamera = UICamera.FindCameraForLayer(this.mSelection.layer);
if (uicamera != null)
{
flag = (uicamera.cachedCamera.WorldToViewportPoint(localPosition).y < 0.5f);
}
}
if (this.isAnimated)
{
this.AnimateColor(this.mBackground);
if (Time.timeScale == 0f || Time.timeScale >= 0.1f)
{
float bottom = num5 + num3;
this.Animate(this.mHighlight, flag, bottom);
int l = 0;
int count4 = list.Count;
while (l < count4)
{
this.Animate(list[l], flag, bottom);
l++;
}
this.AnimateScale(this.mBackground, flag, bottom);
}
}
if (flag)
{
vector.y = v.y - border.y;
v.y = vector.y + (float)this.mBackground.height;
v.x = vector.x + (float)this.mBackground.width;
transform.localPosition = new Vector3(vector.x, v.y - border.y, vector.z);
}
else
{
v.y = vector.y + border.y;
vector.y = v.y - (float)this.mBackground.height;
v.x = vector.x + (float)this.mBackground.width;
}
Transform parent = this.mPanel.cachedTransform.parent;
if (parent != null)
{
vector = this.mPanel.cachedTransform.TransformPoint(vector);
v = this.mPanel.cachedTransform.TransformPoint(v);
vector = parent.InverseTransformPoint(vector);
v = parent.InverseTransformPoint(v);
}
Vector3 b = (!this.mPanel.hasClipping) ? this.mPanel.CalculateConstrainOffset(vector, v) : Vector3.zero;
localPosition = transform.localPosition + b;
localPosition.x = Mathf.Round(localPosition.x);
localPosition.y = Mathf.Round(localPosition.y);
transform.localPosition = localPosition;
}
else
{
this.OnSelect(false);
}
}
protected override void DrawWireframe()
{
if (this.radius <= 0f)
{
base.DrawWireframe();
return;
}
var cameraPos = default(float3);
var cameraFwd = new float3 {
z = 1f
};
var cameraOrtho = true;
if (Camera.current != null)
{
cameraPos = Camera.current.transform.position;
cameraFwd = Camera.current.transform.forward;
cameraOrtho = Camera.current.orthographic;
}
var size = new float3(this.radius * 2f, this.radius * 2f, height);
var radius = this.radius;
var origin = (float3)this.center;
var bounds = new Bounds(this.center, size);
// Since the geometry is transformed by Handles.matrix during rendering, we transform the camera position
// by the inverse matrix so that the two-shaded wireframe will have the proper orientation.
var invMatrix = Handles.inverseMatrix;
var cameraCenter = (float3)invMatrix.MultiplyPoint(cameraPos);
var cameraForward = (float3)invMatrix.MultiplyVector(cameraFwd);
bool isCameraInsideBox = Camera.current != null &&
bounds.Contains(invMatrix.MultiplyPoint(cameraPos));
PhysicsBoundsHandleUtility.DrawFace(origin, size * new float3(1f, 1f, 1f), radius, 0, axes, isCameraInsideBox);
PhysicsBoundsHandleUtility.DrawFace(origin, size * new float3(-1f, 1f, 1f), radius, 0, axes, isCameraInsideBox);
PhysicsBoundsHandleUtility.DrawFace(origin, size * new float3(1f, 1f, 1f), radius, 1, axes, isCameraInsideBox);
PhysicsBoundsHandleUtility.DrawFace(origin, size * new float3(1f, -1f, 1f), radius, 1, axes, isCameraInsideBox);
PhysicsBoundsHandleUtility.DrawFace(origin, size * new float3(1f, 1f, 1f), radius, 2, axes, isCameraInsideBox);
PhysicsBoundsHandleUtility.DrawFace(origin, size * new float3(1f, 1f, -1f), radius, 2, axes, isCameraInsideBox);
var corner = 0.5f * size - new float3(1f) * radius;
var axisx = new float3(1f, 0f, 0f);
var axisy = new float3(0f, 1f, 0f);
var axisz = new float3(0f, 0f, 1f);
PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(-1f, 1f, -1f), quaternion.LookRotation(-axisz, axisy), cameraCenter, cameraForward, cameraOrtho, radius, out s_Corners[0]);
PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(-1f, 1f, 1f), quaternion.LookRotation(-axisx, axisy), cameraCenter, cameraForward, cameraOrtho, radius, out s_Corners[1]);
PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(1f, 1f, 1f), quaternion.LookRotation(axisz, axisy), cameraCenter, cameraForward, cameraOrtho, radius, out s_Corners[2]);
PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(1f, 1f, -1f), quaternion.LookRotation(axisx, axisy), cameraCenter, cameraForward, cameraOrtho, radius, out s_Corners[3]);
PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(-1f, -1f, -1f), quaternion.LookRotation(-axisx, -axisy), cameraCenter, cameraForward, cameraOrtho, radius, out s_Corners[4]);
PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(-1f, -1f, 1f), quaternion.LookRotation(axisz, -axisy), cameraCenter, cameraForward, cameraOrtho, radius, out s_Corners[5]);
PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(1f, -1f, 1f), quaternion.LookRotation(axisx, -axisy), cameraCenter, cameraForward, cameraOrtho, radius, out s_Corners[6]);
PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(1f, -1f, -1f), quaternion.LookRotation(-axisz, -axisy), cameraCenter, cameraForward, cameraOrtho, radius, out s_Corners[7]);
PhysicsBoundsHandleUtility.DrawCorner(s_Corners[0], new bool3(false, true, true));
PhysicsBoundsHandleUtility.DrawCorner(s_Corners[3], new bool3(true, false, true));
PhysicsBoundsHandleUtility.DrawCorner(s_Corners[4], new bool3(true, false, true));
PhysicsBoundsHandleUtility.DrawCorner(s_Corners[7], new bool3(false, true, true));
PhysicsBoundsHandleUtility.DrawCorner(s_Corners[1], new bool3(true, false, true));
PhysicsBoundsHandleUtility.DrawCorner(s_Corners[2], new bool3(false, true, true));
PhysicsBoundsHandleUtility.DrawCorner(s_Corners[5], new bool3(false, true, true));
PhysicsBoundsHandleUtility.DrawCorner(s_Corners[6], new bool3(true, false, true));
// Draw the horizon edges between the corners
for (int upA = 3, upB = 0; upB < 4; upA = upB, upB++)
{
int dnA = upA + 4;
int dnB = upB + 4;
if (s_Corners[upA].splitAxis[0].z && s_Corners[upB].splitAxis[1].x)
{
Handles.DrawLine(s_Corners[upA].points[0], s_Corners[upB].points[1]);
}
if (s_Corners[upA].splitAxis[1].z && s_Corners[upB].splitAxis[0].x)
{
Handles.DrawLine(s_Corners[upA].points[1], s_Corners[upB].points[0]);
}
if (s_Corners[dnA].splitAxis[0].x && s_Corners[dnB].splitAxis[1].z)
{
Handles.DrawLine(s_Corners[dnA].points[0], s_Corners[dnB].points[1]);
}
if (s_Corners[dnA].splitAxis[1].x && s_Corners[dnB].splitAxis[0].z)
{
Handles.DrawLine(s_Corners[dnA].points[1], s_Corners[dnB].points[0]);
}
if (s_Corners[dnA].splitAxis[0].y && s_Corners[upA].splitAxis[1].y)
{
Handles.DrawLine(s_Corners[dnA].points[0], s_Corners[upA].points[1]);
}
if (s_Corners[dnA].splitAxis[1].y && s_Corners[upA].splitAxis[0].y)
{
Handles.DrawLine(s_Corners[dnA].points[1], s_Corners[upA].points[0]);
}
}
}
/// <summary>
/// Update the values of the associated scroll bars.
/// </summary>
public void UpdateScrollbars(bool recalculateBounds)
{
if (mPanel == null)
{
return;
}
if (horizontalScrollBar != null || verticalScrollBar != null)
{
if (recalculateBounds)
{
mCalculatedBounds = false;
mShouldMove = shouldMove;
}
Bounds b = bounds;
Vector2 bmin = b.min;
Vector2 bmax = b.max;
if (mPanel.clipping == UIDrawCall.Clipping.SoftClip)
{
Vector2 soft = mPanel.clipSoftness;
bmin -= soft;
bmax += soft;
}
if (horizontalScrollBar != null && bmax.x > bmin.x)
{
Vector4 clip = mPanel.clipRange;
float extents = clip.z * 0.5f;
float min = clip.x - extents - b.min.x;
float max = b.max.x - extents - clip.x;
float width = bmax.x - bmin.x;
min = Mathf.Clamp01(min / width);
max = Mathf.Clamp01(max / width);
float sum = min + max;
mIgnoreCallbacks = true;
horizontalScrollBar.barSize = 1f - sum;
horizontalScrollBar.scrollValue = (sum > 0.001f) ? min / sum : 0f;
mIgnoreCallbacks = false;
}
if (verticalScrollBar != null && bmax.y > bmin.y)
{
Vector4 clip = mPanel.clipRange;
float extents = clip.w * 0.5f;
float min = clip.y - extents - bmin.y;
float max = bmax.y - extents - clip.y;
float height = bmax.y - bmin.y;
min = Mathf.Clamp01(min / height);
max = Mathf.Clamp01(max / height);
float sum = min + max;
mIgnoreCallbacks = true;
verticalScrollBar.barSize = 1f - sum;
verticalScrollBar.scrollValue = (sum > 0.001f) ? 1f - min / sum : 0f;
mIgnoreCallbacks = false;
}
}
else if (recalculateBounds)
{
mCalculatedBounds = false;
}
}
