void addCommonCameraComponents(GameObject camGO)
{
Camera cam = camGO.GetComponent <Camera>();
if (!cam)
{
cam = Undo.AddComponent <Camera>(camGO);
}
GUILayer guiLayer = camGO.GetComponent <GUILayer>();
if (!guiLayer)
{
guiLayer = Undo.AddComponent <GUILayer>(camGO);
}
FlareLayer flareLayer = camGO.GetComponent <FlareLayer>();
if (!flareLayer)
{
flareLayer = Undo.AddComponent <FlareLayer>(camGO);
}
AudioListener al = camGO.GetComponent <AudioListener>();
if (!al)
{
al = Undo.AddComponent <AudioListener>(camGO);
}
}
// Use this for initialization
void Start()
{
//renderer = GetComponent<MeshRenderer>();
GetComponent <Renderer>().material.SetTextureOffset("_MainTex", uvOffset);
speedGUIText = speedGUI.GetComponent <GUIText>();
guiLayer = Camera.main.GetComponent <GUILayer>();
}
GUIElement FindGUIElement(Camera camera, Vector3 mousePosition)
{
// JCsProfilerMethod pm = JCsProfiler.Instance.StartCallStopWatch(gameObject.name, gameObject.name, "FindGUIElement");
// Is the mouse inside the cameras viewport?
Rect rect = camera.pixelRect;
if (!rect.Contains(mousePosition))
{
return(null);
}
// Did we hit any gui elements?
GUILayer layer = (GUILayer)camera.GetComponent(typeof(GUILayer));
if (!layer)
{
return(null);
}
GUIElement res = layer.HitTest(mousePosition);
// pm.CallIsFinished();
return(res);
}
public IPropertyEditingContext CreatePropertyContext(GUILayer.IGetAndSetProperties getAndSet)
{
var ps = new GUILayer.BasicPropertySource(
getAndSet,
GetPropertyDescriptors("gap:ErosionSettings"));
return new XLEBridgeUtils.PropertyBridge(ps);
}
public IPropertyEditingContext CreatePropertyContext(GUILayer.RawMaterial material)
{
var ps = new GUILayer.BasicPropertySource(
new XLEBridgeUtils.RawMaterialShaderConstants_GetAndSet(material),
GetPropertyDescriptors("gap:RawMaterial"));
return new XLEBridgeUtils.PropertyBridge(ps);
}
public void BuildAssetList(GUILayer.PendingSaveList pendingAssetList)
{
// some clients cannot construct "GUILayer.DivergentAssetList"
// (because that requires adding a reference to the Aga.Controls library)
// So this is provided for convenience to avoid that extra dependancy
AssetList = new GUILayer.DivergentAssetList(
GUILayer.EngineDevice.GetInstance(), pendingAssetList);
}
public void Expand()
{
Transform transform = base.transform.parent;
if (transform == null)
{
transform = new GameObject(base.name + " (origin)").transform;
transform.localPosition = base.transform.localPosition;
transform.localRotation = base.transform.localRotation;
transform.localScale = base.transform.localScale;
}
if (this.head == null)
{
this._head = new GameObject(base.name + " (head)", new Type[]
{
typeof(SteamVR_TrackedObject)
}).transform;
this.head.parent = transform;
this.head.position = base.transform.position;
this.head.rotation = base.transform.rotation;
this.head.localScale = Vector3.one;
this.head.tag = base.tag;
}
if (base.transform.parent != this.head)
{
base.transform.parent = this.head;
base.transform.localPosition = Vector3.zero;
base.transform.localRotation = Quaternion.identity;
base.transform.localScale = Vector3.one;
while (base.transform.childCount > 0)
{
base.transform.GetChild(0).parent = this.head;
}
GUILayer component = base.GetComponent <GUILayer>();
if (component != null)
{
UnityEngine.Object.DestroyImmediate(component);
this.head.gameObject.AddComponent <GUILayer>();
}
AudioListener component2 = base.GetComponent <AudioListener>();
if (component2 != null)
{
UnityEngine.Object.DestroyImmediate(component2);
this._ears = new GameObject(base.name + " (ears)", new Type[]
{
typeof(SteamVR_Ears)
}).transform;
this.ears.parent = this._head;
this.ears.localPosition = Vector3.zero;
this.ears.localRotation = Quaternion.identity;
this.ears.localScale = Vector3.one;
}
}
if (!base.name.EndsWith(" (eye)"))
{
base.name += " (eye)";
}
}
public static void DrawPivot(GUILayer.SimpleRenderingContext context, Matrix4F xform, Color c)
{
GameEngine.DrawPrimitive(context, PrimitiveType.LineStrip,
s_pivotVerts,
0,
s_pivotVertexCount,
c,
xform);
}
public static void DrawCircle(GUILayer.SimpleRenderingContext context, Matrix4F xform, Color color)
{
GameEngine.DrawPrimitive(context, PrimitiveType.LineStrip,
s_circleVerts,
0,
s_circleVertexCount,
color,
xform);
}
public static void DrawUnitSquare(GUILayer.SimpleRenderingContext context, Matrix4F xform, Color color)
{
GameEngine.DrawPrimitive(context, PrimitiveType.LineList,
s_linesVertId,
s_unitSquareStartVertex,
s_unitSquareVertexCount,
color,
xform);
}
public Erosion(GUILayer.ErosionIterativeSystem system)
{
_system = system;
_previewWindow.Underlying.AddSystem(_system._overlay);
_previewSettings.SelectedObject = _system._settings;
_schemaLoader = new ErosionSettingsSchemaLoader();
_systemSettings.Bind(
_schemaLoader.CreatePropertyContext(_system._getAndSetProperties));
}
// Use this for initialization
void Start()
{
stones = new GameObject[transform.childCount];
for (int i = 0; i < transform.childCount; i++)
{
stones [i] = transform.GetChild(i).gameObject; //get each stone
}
stoneIndex = transform.childCount - 1;
gui = Camera.main.GetComponent(typeof(GUILayer)) as GUILayer;
}
static int HitTest(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 2);
GUILayer obj = (GUILayer)LuaScriptMgr.GetUnityObjectSelf(L, 1, "GUILayer");
Vector3 arg0 = LuaScriptMgr.GetVector3(L, 2);
GUIElement o = obj.HitTest(arg0);
LuaScriptMgr.Push(L, o);
return(1);
}
void Awake()
{
GUILayer guiLayer = GetComponent <GUILayer> ();
if (guiLayer != null)
{
RealClickListener.HitTestMaskGUILayer = guiLayer;
}
Destroy(this);
}
// Use this for initialization
void Start()
{
rate = 0.03f;
maxCap = 3.0f;
x = end.transform.position.x;
y = end.transform.position.y;
endInitialPosition = end.transform.position;
guiLayer = Camera.main.GetComponent <GUILayer>();
}
public static void DrawSphere(GUILayer.SimpleRenderingContext context, Sphere3F sphere, Color c)
{
// create matrix from AABB
T1.Set(sphere.Center);
float scale = 2*sphere.Radius;
T1.M11 = scale;
T1.M22 = scale;
T1.M33 = scale;
DrawSphere(context, T1, c);
}
// Use this for initialization
void Start () {
guiLayer = Camera.main.GetComponent<GUILayer>();
n0 = GameObject.Find("00");
n1 = GameObject.Find("01");
n2 = GameObject.Find("02");
n3 = GameObject.Find("03");
n4 = GameObject.Find("04");
n5 = GameObject.Find("05");
n6 = GameObject.Find("06");
n7 = GameObject.Find("07");
n8 = GameObject.Find("08");
n9 = GameObject.Find("09");
n10 = GameObject.Find("10");
n11 = GameObject.Find("11");
n12 = GameObject.Find("12");
n13 = GameObject.Find("13");
n14 = GameObject.Find("14");
n15 = GameObject.Find("15");
n16 = GameObject.Find("16");
n17 = GameObject.Find("17");
n18 = GameObject.Find("18");
n19 = GameObject.Find("19");
n0.renderer.enabled = false;
n1.renderer.enabled = false;
n2.renderer.enabled = false;
n3.renderer.enabled = false;
n4.renderer.enabled = false;
n5.renderer.enabled = false;
n6.renderer.enabled = false;
n7.renderer.enabled = false;
n8.renderer.enabled = false;
n9.renderer.enabled = false;
n10.renderer.enabled = false;
n11.renderer.enabled = false;
n12.renderer.enabled = false;
n13.renderer.enabled = false;
n14.renderer.enabled = false;
n15.renderer.enabled = false;
n16.renderer.enabled = false;
n17.renderer.enabled = false;
n18.renderer.enabled = false;
n19.renderer.enabled = false;
timer = 60;
}
void InitGUI()
{
var guiObj = new GameObject("GUI Layer");
guiObj.transform.parent = Camera.main.transform;
gui = guiObj.AddComponent <GUILayer>();
gui.Scale = Scale;
gui.Font = font;
gui.transform.position = new Vector3(0f, 0f, -8f);
overlay = new Overlay(TileSize, Scale);
}
public RefCFD(GUILayer.IterativeSystem system, String settingsName)
{
_hasOldMouse = false;
_system = system;
_previewWindow.Underlying.AddSystem(_system.Overlay);
_previewSettings.SelectedObject = _system.PreviewSettings;
_schemaLoader = new CFDSettingsSchemaLoader(settingsName);
_systemSettings.Bind(
_schemaLoader.CreatePropertyContext(_system.SimulationSettings));
// _previewWindow.MouseDown += _previewWindow_MouseDown;
_previewWindow.MouseMove += _previewWindow_MouseMove;
_previewWindow.MouseEnter += _previewWindow_MouseEnter;
}
void Start()
{
guiHit = Camera.main.GetComponent <GUILayer>();
Debug.Log("Building dictionary for presses.");
_buttons.Add("A", false);
_buttons.Add("B", false);
_buttons.Add("SR", false);
_buttons.Add("SE", false);
_buttons.Add("UP", false);
_buttons.Add("DN", false);
_buttons.Add("LT", false);
_buttons.Add("RT", false);
_buttons.Add("ROMPress", false);
_buttons.Add("GAMEPress", false);
}
public static string TouchedGUITexture(int id)
{
Vector2 pos = Vector2.zero;
GUILayer test = Camera.main.GetComponent <GUILayer>();
if (TouchManager.GetTouchPos(id, out pos))
{
if (test.HitTest(pos))
{
return(test.HitTest(pos).name);
}
}
return(null);
}
public void Collapse()
{
base.transform.parent = null;
while (this.head.childCount > 0)
{
this.head.GetChild(0).parent = base.transform;
}
GUILayer component = this.head.GetComponent <GUILayer>();
if (component != null)
{
UnityEngine.Object.DestroyImmediate(component);
base.gameObject.AddComponent <GUILayer>();
}
if (this.ears != null)
{
while (this.ears.childCount > 0)
{
this.ears.GetChild(0).parent = base.transform;
}
UnityEngine.Object.DestroyImmediate(this.ears.gameObject);
this._ears = null;
base.gameObject.AddComponent(typeof(AudioListener));
}
if (this.origin != null)
{
if (this.origin.name.EndsWith(" (origin)"))
{
Transform origin = this.origin;
while (origin.childCount > 0)
{
origin.GetChild(0).parent = origin.parent;
}
UnityEngine.Object.DestroyImmediate(origin.gameObject);
}
else
{
base.transform.parent = this.origin;
}
}
UnityEngine.Object.DestroyImmediate(this.head.gameObject);
this._head = null;
if (base.name.EndsWith(" (eye)"))
{
base.name = base.name.Substring(0, base.name.Length - " (eye)".Length);
}
}
static int _CreateGUILayer(IntPtr L)
{
int count = LuaDLL.lua_gettop(L);
if (count == 0)
{
GUILayer obj = new GUILayer();
LuaScriptMgr.Push(L, obj);
return 1;
}
else
{
LuaDLL.luaL_error(L, "invalid arguments to method: GUILayer.New");
}
return 0;
}
static int _CreateGUILayer(IntPtr L)
{
int count = LuaDLL.lua_gettop(L);
if (count == 0)
{
GUILayer obj = new GUILayer();
LuaScriptMgr.Push(L, obj);
return(1);
}
else
{
LuaDLL.luaL_error(L, "invalid arguments to method: GUILayer.New");
}
return(0);
}
public NativeDesignControl(DesignView designView, GUILayer.EditorSceneManager sceneManager, GUILayer.ObjectSet selection)
: base(designView, sceneManager, selection)
{
if (s_marqueePen == null)
{
s_marqueePen = new Pen(Color.FromArgb(30, 30, 30), 2);
s_marqueePen.DashPattern = new float[] { 3, 3 };
}
m_renderState = new RenderState();
m_renderState.RenderFlag = GlobalRenderFlags.Solid | GlobalRenderFlags.Textured | GlobalRenderFlags.Lit | GlobalRenderFlags.Shadows;
m_renderState.WireFrameColor = Color.DarkBlue;
m_renderState.SelectionColor = Color.FromArgb(66, 255, 161);
BackColor = SystemColors.ControlDark;
m_renderState.OnChanged += (sender, e) => Invalidate();
base.AddRenderCallback(RenderExtras);
}
public void SetActiveContext(GUILayer.ActiveManipulatorContext context)
{
if (_context != null)
{
_context.OnActiveManipulatorChange -= OnActiveManipulatorChange;
_context.OnManipulatorSetChange -= OnManipulatorSetChange;
}
manipulatorProperties.Bind(null);
_context = context;
if (_context != null)
{
_context.OnActiveManipulatorChange += OnActiveManipulatorChange;
_context.OnManipulatorSetChange += OnManipulatorSetChange;
}
OnManipulatorSetChange(null, null);
}
List <GestureHit> innerCastGUI(Vector3 screenPos, Camera castOn, GUILayer gui)
{
List <GestureHit> hitBehaviours = new List <GestureHit>();
GUIElement g = gui.HitTest(screenPos);
if (g == null)
{
return(null);
}
GestureHit h = new GestureHit();
h.HitHandlers = GetComponentsByInterfaceType <IGestureHandler>(g.transform);
h.Hit = new RaycastHit();
hitBehaviours.Add(h);
return(hitBehaviours);
}
public static void DrawAABB(GUILayer.SimpleRenderingContext context, AABB bound)
{
// create matrix from AABB
Vec3F trans = bound.Center;
Vec3F diag = bound.Max - bound.Min;
T1.Set(trans);
T1.M11 = diag.X;
T1.M22 = diag.Y;
T1.M33 = diag.Z;
GameEngine.DrawIndexedPrimitive(context, PrimitiveType.LineList,
s_boxVertsId,
s_boxIndicesId,
0,
s_boxIndicesCount,
0,
Color.White,
T1);
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
// Create a new SpriteBox.
Global.spriteBox = new SpriteBox();
cursor = Content.Load <Texture2D>("MouseCursor");
SoundEffect se = Content.Load <SoundEffect>("Town-of-Forgotten-Souls");
// Create layers.
FileStream fs = (FileStream)TitleContainer.OpenStream("Content/Tilemaps/tilemap1.tm");
GameObjectLayer GOLayer = new GameObjectLayer("GameObjectLayer");
GUILayer guiLayer = new GUILayer("GUILayer");
Tilemap tm = new Tilemap("tilemap1", fs);
EffectLayer bottomEffectLayer = new EffectLayer("BottomEffectLayer", true);
EffectLayer topEffectLayer = new EffectLayer("TopEffectLayer");
// Add layers to world. The order is important.
Global.world.AddLayers(tm, GOLayer, bottomEffectLayer, guiLayer, topEffectLayer);
GOLayer.elements.Add(Player.GetPlayer(100, 100));
GOLayer.elements.Add(new Boundary(300, 300));
GOLayer.elements.Add(new Lantern(200, 200));
List <Enemy> enemyFrontList = new List <Enemy>();
List <Enemy> enemyBehindList = new List <Enemy>();
enemyFrontList.Add(new Goul());
GOLayer.elements.Add(new EnemySoul(400, 400, new Combat(enemyFrontList, enemyBehindList)));
Global.soulBox = new SoulBox();
Hero1 hero = new Hero1(FighterState.Front);
Hero2 hero2 = new Hero2(FighterState.Front);
Ring1 ring1 = new Ring1();
Global.world.GetPlayer().AddHero(hero);
Global.world.GetPlayer().AddHero(hero2);
Global.world.GetPlayer().AddItem(ring1);
ChangeState(new ExploreState());
}
private void Start()
{
inited = true;
#region EditorChecks
#if UNITY_EDITOR
Camera[] cameras = Camera.allCameras;
int len = cameras.Length;
float highestCameraDeph = float.MinValue;
float highestSuitableCameraDeph = float.MinValue;
for (int i = 0; i < len; i++)
{
Camera cam = cameras[i];
if (cam.depth > highestCameraDeph)
{
highestCameraDeph = cam.depth;
}
GUILayer guiLayer = cameras[i].GetComponent <GUILayer>();
if (guiLayer != null && guiLayer.enabled)
{
// checking if AFPSCounter's layer in the camera's culling mask
if ((cam.cullingMask & (1 << gameObject.layer)) != 0)
{
if (cam.depth > highestSuitableCameraDeph)
{
highestSuitableCameraDeph = cam.depth;
}
}
}
}
if (len == 0 || Math.Abs(highestCameraDeph - highestSuitableCameraDeph) > 0.0001f)
{
Debug.LogWarning("Please check you have camera and your top-most (highest depth) camera\nhas enabled GUILayer and has layer " + LayerMask.LayerToName(gameObject.layer) + " in the camera's culling mask!");
}
#endif
#endregion
}
private void Start()
{
Camera[] cameras = Camera.allCameras;
int len = Camera.allCamerasCount;
bool willRender = false;
for (int i = 0; i < len; i++)
{
Camera cam = cameras[i];
GUILayer guiLayer = cam.GetComponent <GUILayer>();
if (guiLayer != null && guiLayer.enabled)
{
// checking if AFPSCounter's layer in the camera's culling mask
if ((cam.cullingMask & (1 << gameObject.layer)) != 0)
{
willRender = true;
break;
}
}
}
if (!willRender)
{
Debug.LogWarning("Please check you have at least one camera with enabled GUILayer and layer \"" + LayerMask.LayerToName(gameObject.layer) + "\" in the culling mask!");
}
if (transform.position != Vector3.zero)
{
Debug.LogWarning("AFPSCounter should be placed on Game Object with zero position!", gameObject);
}
if (transform.rotation != Quaternion.identity)
{
Debug.LogWarning("AFPSCounter should be placed on Game Object with zero rotation!", gameObject);
}
if (transform.localScale != Vector3.one)
{
Debug.LogWarning("AFPSCounter should be placed on Game Object with 1,1,1 scale!", gameObject);
}
}
void Start()
{
if (!isLocalPlayer)
{
AudioListener listener = GetComponentInChildren <AudioListener>();
GUILayer gui = GetComponentInChildren <GUILayer>();
FlareLayer flare = GetComponentInChildren <FlareLayer>();
listener.enabled = false;
gui.enabled = false;
flare.enabled = false;
return;
}
if (Camera.main)
{
Camera.main.gameObject.SetActive(false);
}
playerCamera = GetComponentInChildren <Camera>();
playerCamera.enabled = true;
}
// Use this for initialization
void Start () {
stopOk = false;
guiLayer = Camera.main.GetComponent<GUILayer>();
GameObject go = GameObject.Find("POP");
GameObject go2 = GameObject.Find("go");
GameObject go3 = GameObject.Find("ready");
pop1 = (GUITexture)go.GetComponent(typeof(GUITexture));
pop2 = (GUITexture)go2.GetComponent(typeof(GUITexture));
pop3 = (GUITexture)go3.GetComponent(typeof(GUITexture));
pop1.guiTexture.enabled = false;
pop2.guiTexture.enabled = false;
pop3.guiTexture.enabled = false;
}
public void Start()
{
gridScript = GameObject.Find("UGrid").GetComponent <UGrid>();
groupM = GameObject.Find("Faction Manager").GetComponent <GroupManager>();
placement = gameObject.GetComponent <BuildingPlacement>();
if (placement)
{
placement.SetGroup(group);
}
GUIManager manager = gameObject.GetComponent <GUIManager>();
if (manager)
{
manager.group = groupM.groupList[group].GetComponent <Group>();
}
guiManager = gameObject.GetComponent <GUIManager>();
GameObject obj = GameObject.Find("MiniMap");
if (obj)
{
map = obj.GetComponent <MiniMap>();
}
test = Camera.main.GetComponent <GUILayer>();
}
public PendingExport(string targetFile, GUILayer.EditorSceneManager.PendingExport pendingExport)
{
TargetFile = targetFile;
Export = pendingExport;
}
public void Render(GUILayer.SimpleRenderingContext context, Camera cam)
{
GameEngine.SetRendererFlag(context, BasicRendererFlags.WireFrame);
IGrid grid = this.As<IGrid>();
if (grid.Visible == false)
return;
float s = grid.Size;
Matrix4F scale = new Matrix4F();
scale.Scale(new Vec3F(s, s, s));
Matrix4F gridXform = new Matrix4F();
if (cam.Frustum.IsOrtho)
{
float dist = cam.ViewMatrix.Translation.Z;
ViewTypes vt = cam.ViewType;
if (vt == ViewTypes.Top)
{
gridXform.Translation
= new Vec3F(0, dist, 0);
}
else if (vt == ViewTypes.Bottom)
{
gridXform.Translation
= new Vec3F(0, -dist, 0);
}
else if (vt == ViewTypes.Right)
{
gridXform.RotZ(MathHelper.PiOver2);
gridXform.Translation
= new Vec3F(dist, 0, 0);
}
else if (vt == ViewTypes.Left)
{
gridXform.RotZ(MathHelper.PiOver2);
gridXform.Translation
= new Vec3F(-dist, 0, 0);
}
else if (vt == ViewTypes.Front)
{
gridXform.RotX(MathHelper.PiOver2);
gridXform.Translation
= new Vec3F(0, 0, dist);
}
else if (vt == ViewTypes.Back)
{
gridXform.RotX(MathHelper.PiOver2);
gridXform.Translation
= new Vec3F(0, 0, -dist);
}
gridXform.Mul(scale, gridXform);
}
else
{
Matrix4F trans = new Matrix4F();
trans.Translation = new Vec3F(0, grid.Height, 0);
gridXform = Matrix4F.Multiply(scale, trans);
}
GameEngine.DrawPrimitive(context, PrimitiveType.LineList, m_gridVBId, 0, m_gridVertexCount, Color.LightGray,
Matrix4F.Multiply(gridXform, cam.AxisSystem));
GameEngine.DrawPrimitive(context, PrimitiveType.LineList, m_basisAxesVBId, 0, m_basisAxesVertexCount, Color.White,
gridXform);
}
private static Object ReadAsset(AssetStream stream, AssetInfo assetInfo, long offset, int size)
{
Object asset = null;
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.MeshFilter:
asset = new MeshFilter(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 PhysicMaterial(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.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.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.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);
}
private bool CalculateTerrainIntersection(ViewControl vc, Ray3F ray, GUILayer.IntersectionTestSceneWrapper testScene, out Vec3F result)
{
var nativeVC = vc as NativeDesignControl;
if (nativeVC == null) { result = Vec3F.ZeroVector; return false; }
var pick = XLEBridgeUtils.Picking.RayPick(nativeVC.Adapter, ray, XLEBridgeUtils.Picking.Flags.Terrain);
if (pick != null && pick.Length > 0)
{
result = pick[0].hitPt;
return true;
}
result = Vec3F.ZeroVector;
return false;
}
// Use this for initialization
void Start()
{
loadText.SetActive(false);
loadProgressBar.SetActive(false);
layer = Camera.main.GetComponent<GUILayer>();
}
private void setupCameras()
{
Transform lcam = transform.Find("leftCam");
if (lcam != null)
{
_leftCamera = lcam.gameObject;
_leftCamera.camera.CopyFrom(camera);
}
else
{
_leftCamera = new GameObject("leftCam", typeof(Camera));
_leftCamera.AddComponent <GUILayer>();
_leftCamera.camera.CopyFrom(camera);
_leftCamera.transform.parent = transform;
}
Transform rcam = transform.Find("rightCam");
if (rcam != null)
{
_rightCamera = rcam.gameObject;
_rightCamera.camera.CopyFrom(camera);
}
else
{
_rightCamera = new GameObject("rightCam", typeof(Camera));
_rightCamera.AddComponent <GUILayer>();
_rightCamera.camera.CopyFrom(camera);
_rightCamera.transform.parent = transform;
}
Transform gcam = transform.Find("guiCam");
if (gcam != null)
{
GuiCamera = gcam.gameObject;
}
else
{
GuiCamera = new GameObject("guiCam", typeof(Camera));
GuiCamera.AddComponent <GUILayer>();
GuiCamera.camera.CopyFrom(camera);
GuiCamera.transform.parent = transform;
}
GUILayer guiComponent = GetComponent <GUILayer>();
guiComponent.enabled = false;
// rendering order (back to front): centerCam/maskCam/leftCam1/rightCam1/leftCam2/rightCam2/ etc
camera.depth = -2;
_leftCamera.camera.depth = camera.depth + (RenderOrderDepth * 2) + 2;
_rightCamera.camera.depth = camera.depth + ((RenderOrderDepth * 2) + 1) + 3;
_leftCamera.camera.cullingMask = camera.cullingMask;
_rightCamera.camera.cullingMask = camera.cullingMask;
GuiCamera.camera.depth = _rightCamera.camera.depth + 1;
GuiCamera.camera.cullingMask = 1 << guiOnlyLayer;
GuiCamera.camera.clearFlags = CameraClearFlags.Depth;
#if !UNITY_EDITOR
if (!UseStereoShader)
{
camera.enabled = false;
}
#endif
}
// Use this for initialization
void Start()
{
layer = Camera.main.GetComponent<GUILayer>();
ballScript = gameBall.GetComponent<Ball>();
batScript = batObj.GetComponent<Bat>();
//Debug.Log("Screen Resolution " + Screen.width + " " + Screen.height);
}
private static void DoSendMouseEvents(int skipRTCameras)
{
Vector3 mousePosition = Input.mousePosition;
int allCamerasCount = Camera.allCamerasCount;
if (m_Cameras == null || m_Cameras.Length != allCamerasCount)
{
m_Cameras = new Camera[allCamerasCount];
}
Camera.GetAllCameras(m_Cameras);
for (int i = 0; i < m_CurrentHit.Length; i++)
{
m_CurrentHit[i] = default(HitInfo);
}
if (!s_MouseUsed)
{
Camera[] cameras = m_Cameras;
foreach (Camera camera in cameras)
{
if (camera == null || (skipRTCameras != 0 && camera.targetTexture != null) || !camera.pixelRect.Contains(mousePosition))
{
continue;
}
GUILayer component = camera.GetComponent <GUILayer>();
if ((bool)component)
{
GUIElement gUIElement = component.HitTest(mousePosition);
if ((bool)gUIElement)
{
m_CurrentHit[0].target = gUIElement.gameObject;
m_CurrentHit[0].camera = camera;
}
else
{
m_CurrentHit[0].target = null;
m_CurrentHit[0].camera = null;
}
}
if (camera.eventMask != 0)
{
Ray ray = camera.ScreenPointToRay(mousePosition);
Vector3 direction = ray.direction;
float z = direction.z;
float distance = (!Mathf.Approximately(0f, z)) ? Mathf.Abs((camera.farClipPlane - camera.nearClipPlane) / z) : float.PositiveInfinity;
GameObject gameObject = camera.RaycastTry(ray, distance, camera.cullingMask & camera.eventMask);
if (gameObject != null)
{
m_CurrentHit[1].target = gameObject;
m_CurrentHit[1].camera = camera;
}
else if (camera.clearFlags == CameraClearFlags.Skybox || camera.clearFlags == CameraClearFlags.Color)
{
m_CurrentHit[1].target = null;
m_CurrentHit[1].camera = null;
}
GameObject gameObject2 = camera.RaycastTry2D(ray, distance, camera.cullingMask & camera.eventMask);
if (gameObject2 != null)
{
m_CurrentHit[2].target = gameObject2;
m_CurrentHit[2].camera = camera;
}
else if (camera.clearFlags == CameraClearFlags.Skybox || camera.clearFlags == CameraClearFlags.Color)
{
m_CurrentHit[2].target = null;
m_CurrentHit[2].camera = null;
}
}
}
}
for (int k = 0; k < m_CurrentHit.Length; k++)
{
SendEvents(k, m_CurrentHit[k]);
}
s_MouseUsed = false;
}
private static GUIElement INTERNAL_CALL_HitTest(GUILayer self, ref Vector3 screenPosition){}
// Use this for initialization
void Start()
{
//cache some things..
//our (the drag source's) GUITexture
texture=GetComponent<GUITexture>();
//the GameObject and GUITexture of the GhostButton object
//ghostButtonObj=GameObject.Find("GhostButton");
ghostButtonTex=ghostButtonObj.GetComponent<GUITexture>();
//and calculate the screen position of our guitexture
screenPos=Camera.main.ViewportToScreenPoint(transform.position);
layer=Camera.main.GetComponent<GUILayer>();
}
private bool CalculateTerrainIntersection(ViewControl vc, Ray3F ray, GUILayer.IntersectionTestSceneWrapper testScene, out Vec3F result)
{
var pick = XLEBridgeUtils.Picking.RayPick(vc, ray, XLEBridgeUtils.Picking.Flags.Terrain);
if (pick != null && pick.Length > 0)
{
result = pick[0].hitPt;
return true;
}
result = new Vec3F(0.0f, 0.0f, 0.0f);
return false;
}
// Update is called once per frame
void Update()
{
if (Input.GetMouseButtonDown(0))
{
moveDelta = new Vector2(0f, 0f);
isMoving = true;
}
else if (Input.GetMouseButtonUp(0))
{
isMoving = false;
if (Mathf.Abs(moveDelta.x) < threshold && Mathf.Abs(moveDelta.y) < threshold)
{
GUILayer l = (GUILayer)Camera.main.GetComponent <GUILayer> ();
GUIElement gl = l.HitTest(Input.mousePosition);
if (gl != null)
{
return;
}
// check if there's anything under the mouse button
Vector3 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
RaycastHit2D[] hits = Physics2D.RaycastAll(mousePos, Vector2.zero);
foreach (RaycastHit2D hit in hits)
{
if (hit.collider != null)
{
Clickable c = hit.collider.gameObject.GetComponent <Clickable>();
if (c == null)
{
continue;
}
if (target != null)
{
if (target.handleClick(hit.collider.gameObject, mousePos))
{
return;
}
else
{
target.loseClickFocus();
}
}
target = c;
target.clicked();
return;
}
}
// three were no clickable items clicked on
if (target != null)
{
target.handleClick(null, mousePos);
}
}
}
else if (isMoving)
{
float xMove = Input.GetAxis("Mouse X");
float yMove = Input.GetAxis("Mouse Y");
moveDelta = new Vector2(moveDelta.x + xMove, moveDelta.y + yMove);
if (xMove != 0 || yMove != 0)
{
CameraController.AdjustCameraPosition(xMove, yMove);
}
}
}
// Use this for initialization
void Start()
{
guiHit = Camera.main.GetComponent<GUILayer>();
}
void InitGUI()
{
var guiObj = new GameObject("GUI Layer");
guiObj.transform.parent = Camera.main.transform;
gui = guiObj.AddComponent<GUILayer>();
gui.Scale = Scale;
gui.Font = font;
overlay = new Overlay(TileSize, Scale);
}
public void Start()
{
gridScript = GameObject.Find("UGrid").GetComponent<UGrid>();
groupM = GameObject.Find("Faction Manager").GetComponent<GroupManager>();
placement = gameObject.GetComponent<BuildingPlacement>();
if(placement)
placement.SetGroup(group);
GUIManager manager = gameObject.GetComponent<GUIManager>();
if(manager)
manager.group = groupM.groupList[group].GetComponent<Group>();
guiManager = gameObject.GetComponent<GUIManager>();
GameObject obj = GameObject.Find("MiniMap");
if(obj)
map = obj.GetComponent<MiniMap>();
test = Camera.main.GetComponent<GUILayer>();
}
private void Awake()
{
//Debug.Log("AFPSCounter Awake, instance = " + instance);
if (instance != null)
{
Debug.LogWarning("Only one Advanced FPS Counter instance allowed!");
Destroy(this);
return;
}
if (!IsPlacedCorrectly())
{
Debug.LogWarning("Advanced FPS Counter is placed in scene incorrectly and will be auto-destroyed! Please, use \"GameObject->Create Other->Code Stage->Advanced FPS Counter\" menu to correct this!");
Destroy(this);
return;
}
#if UNITY_EDITOR
Camera[] cameras = Camera.allCameras;
int len = cameras.Length;
float highestCameraDeph = float.MinValue;
float highestSuitableCameraDeph = float.MinValue;
for (int i = 0; i < len; i++)
{
Camera cam = cameras[i];
if (cam.depth > highestCameraDeph)
{
highestCameraDeph = cam.depth;
}
GUILayer guiLayer = cameras[i].GetComponent <GUILayer>();
if (guiLayer != null && guiLayer.enabled)
{
if (cam.depth > highestSuitableCameraDeph)
{
highestSuitableCameraDeph = cam.depth;
}
}
}
if (highestCameraDeph != highestSuitableCameraDeph)
{
Debug.LogWarning("Advanced FPS Counter needs top-most (highest depth) camera with enabled GUILayer to be visible!");
}
#endif
instance = this;
DontDestroyOnLoad(gameObject);
anchorsCount = Enum.GetNames(typeof(LabelAnchor)).Length;
labels = new DrawableLabel[anchorsCount];
for (int i = 0; i < anchorsCount; i++)
{
labels[i] = new DrawableLabel((LabelAnchor)i, anchorsOffset, labelsFont, fontSize, lineSpacing);
}
RefreshHotKey();
}
public void RegisterToLayer( GUILayer layer )
{
layer.Register( this );
}
public bool AddTouch(Touch t, Camera castOn, LayerMask hitLayers, bool DoRayCastAll, GUILayer gui)
{
Ray toCast = getRay(castOn, t);
List <GestureHit> lh = null;
// First see if we hit a GUI element
if (gui != null)
{
lh = innerCastGUI(t.position, castOn, gui);
}
if (lh == null || lh.Count == 0)
{
// Raycast the touch, see what we hit
if (DoRayCastAll)
{
lh = innerCastAll(toCast, hitLayers);
}
else
{
lh = innerCast(toCast, hitLayers);
}
}
// Update the touch link with the found handlers
MonoBehaviour[] allHanders = lh.SelectMany(m => m.HitHandlers).ToArray();
if (allHanders.Length == 0)
{
return(false);
}
touchLinks[t.fingerId] = allHanders;
// Notify all handlers
foreach (GestureHit gh in lh)
{
foreach (MonoBehaviour mb in gh.HitHandlers)
{
((IGestureHandler)mb).AddTouch(t, gh.Hit, castOn);
}
}
return(true);
}
public virtual void SetupCameras()
{
Transform lcam = transform.Find("leftCam"); // check if we've already created a leftCam
if (lcam)
{
leftCam = lcam.gameObject;
leftCam.GetComponent <Camera>().CopyFrom(GetComponent <Camera>());
}
else
{
leftCam = new GameObject("leftCam", new System.Type[] { typeof(Camera) });
leftCam.AddComponent(typeof(GUILayer));
leftCam.GetComponent <Camera>().CopyFrom(GetComponent <Camera>());
leftCam.transform.parent = transform;
}
Transform rcam = transform.Find("rightCam"); // check if we've already created a rightCam
if (rcam)
{
rightCam = rcam.gameObject;
rightCam.GetComponent <Camera>().CopyFrom(GetComponent <Camera>());
}
else
{
rightCam = new GameObject("rightCam", new System.Type[] { typeof(Camera) });
rightCam.AddComponent(typeof(GUILayer));
rightCam.GetComponent <Camera>().CopyFrom(GetComponent <Camera>());
rightCam.transform.parent = transform;
}
Transform mcam = transform.Find("maskCam"); // check if we've already created a maskCam
if (mcam)
{
maskCam = mcam.gameObject;
}
else
{
maskCam = new GameObject("maskCam", new System.Type[] { typeof(Camera) });
maskCam.AddComponent(typeof(GUILayer));
maskCam.GetComponent <Camera>().CopyFrom(GetComponent <Camera>());
maskCam.transform.parent = transform;
}
Transform gcam = transform.Find("guiCam"); // check if we've already created a maskCam
if (gcam)
{
guiCam = gcam.gameObject;
}
else
{
guiCam = new GameObject("guiCam", new System.Type[] { typeof(Camera) });
guiCam.AddComponent(typeof(GUILayer));
guiCam.GetComponent <Camera>().CopyFrom(GetComponent <Camera>());
guiCam.transform.parent = transform;
}
GUILayer guiC = (GUILayer)GetComponent(typeof(GUILayer));
guiC.enabled = false;
GetComponent <Camera>().depth = -2; // rendering order (back to front): centerCam/maskCam/leftCam1/rightCam1/leftCam2/rightCam2/ etc
horizontalFOV = (2 * Mathf.Atan(Mathf.Tan((GetComponent <Camera>().fieldOfView *Mathf.Deg2Rad) / 2) * GetComponent <Camera>().aspect)) * Mathf.Rad2Deg;
verticalFOV = GetComponent <Camera>().fieldOfView;
leftCam.GetComponent <Camera>().depth = (GetComponent <Camera>().depth + (renderOrderDepth * 2)) + 2;
rightCam.GetComponent <Camera>().depth = (GetComponent <Camera>().depth + ((renderOrderDepth * 2) + 1)) + 3;
if (useLeftRightOnlyLayers)
{
if (useCustomStereoLayer)
{
leftCam.GetComponent <Camera>().cullingMask = (1 << stereoLayer) | (1 << leftOnlyLayer); // show stereo + left only
rightCam.GetComponent <Camera>().cullingMask = (1 << stereoLayer) | (1 << rightOnlyLayer); // show stereo + right only
}
else
{
leftCam.GetComponent <Camera>().cullingMask = ~((1 << rightOnlyLayer) | (1 << guiOnlyLayer)); // show everything but right only layer & mask only layer
rightCam.GetComponent <Camera>().cullingMask = ~((1 << leftOnlyLayer) | (1 << guiOnlyLayer)); // show everything but left only layer & mask only layer
}
}
else
{
if (useCustomStereoLayer)
{
leftCam.GetComponent <Camera>().cullingMask = 1 << stereoLayer; // show stereo layer only
rightCam.GetComponent <Camera>().cullingMask = 1 << stereoLayer; // show stereo layer only
}
}
maskCam.GetComponent <Camera>().depth = leftCam.GetComponent <Camera>().depth - 1;
guiCam.GetComponent <Camera>().depth = rightCam.GetComponent <Camera>().depth + 1;
maskCam.GetComponent <Camera>().cullingMask = 0;
guiCam.GetComponent <Camera>().cullingMask = 1 << guiOnlyLayer; // only show what's in the guiOnly layer
maskCam.GetComponent <Camera>().clearFlags = CameraClearFlags.SolidColor;
guiCam.GetComponent <Camera>().clearFlags = CameraClearFlags.Depth;
maskCam.GetComponent <Camera>().backgroundColor = Color.black;
}
// Use this for initialization
void Start()
{
layer = Camera.main.GetComponent<GUILayer>();
inpt = alley.GetComponent<InputHandler>();
//Debug.Log("Screen Resolution " + Screen.width + " " + Screen.height);
}
public void Expand()
{
Transform transform = base.transform.parent;
if (transform == null)
{
transform = new GameObject(base.name + " (origin)").transform;
transform.localPosition = base.transform.localPosition;
transform.localRotation = base.transform.localRotation;
transform.localScale = base.transform.localScale;
}
if (this.head == null)
{
if (SteamVR_Camera.useHeadTracking)
{
this._head = new GameObject(base.name + " (head)", new Type[]
{
typeof(SteamVR_GameView),
typeof(SteamVR_TrackedObject)
}).transform;
}
else
{
this._head = new GameObject(base.name + " (head)", new Type[]
{
typeof(SteamVR_GameView)
}).transform;
this.head.position = base.transform.position;
this.head.rotation = base.transform.rotation;
this.head.localScale = Vector3.one;
this.head.tag = base.tag;
}
this.head.parent = transform;
Camera component = this.head.GetComponent <Camera>();
component.clearFlags = CameraClearFlags.Nothing;
component.cullingMask = 0;
component.eventMask = 0;
component.orthographic = true;
component.orthographicSize = 1f;
component.nearClipPlane = 0f;
component.farClipPlane = 1f;
component.useOcclusionCulling = false;
}
if (transform.parent != this.head)
{
transform.parent = this.head;
transform.localPosition = Vector3.zero;
transform.localRotation = Quaternion.identity;
transform.localScale = Vector3.one;
while (base.transform.childCount > 0)
{
base.transform.GetChild(0).parent = this.head;
}
GUILayer component2 = base.GetComponent <GUILayer>();
if (component2 != null)
{
UnityEngine.Object.DestroyImmediate(component2);
this.head.gameObject.AddComponent <GUILayer>();
}
AudioListener component3 = base.GetComponent <AudioListener>();
if (component3 != null)
{
UnityEngine.Object.DestroyImmediate(component3);
this._ears = new GameObject(base.name + " (ears)", new Type[]
{
typeof(SteamVR_Ears)
}).transform;
this.ears.parent = this._head;
this.ears.localPosition = Vector3.zero;
this.ears.localRotation = Quaternion.identity;
this.ears.localScale = Vector3.one;
}
}
if (!base.name.EndsWith(" (eye)"))
{
base.name += " (eye)";
}
}
public GUILayer BuildLayer( GUIStratas level, string layerName = "" )
{
if( lastUsedDepth + depthIncrement > maxLayerDepth )
throw new Exception( "Le layer '" + System.Enum.GetName( level.GetType(), level ) + "' ne peux plus contenir d'élements" );
lastUsedDepth += depthIncrement;
GUILayer l = new GUILayer( lastUsedDepth, layerName );
layerList.Add( lastUsedDepth, l );
return l;
}
// Use this for initialization
void Start()
{
guiHit = Camera.main.GetComponent <GUILayer>();
}
// Use this for initialization
void Start ()
{
UILayer = GetComponentInParent<GUILayer>();
spCode = GetComponentInParent<SphereParentCode>();
}
