// Update is called once per frame void Update() { //Movement Input //Look Input Ray ray = viewCamera.ScreenPointToRay(Input.mousePosition); Plane groundPlane = new Plane(Vector3.up, Vector3.zero); float rayDistance; if (groundPlane.Raycast(ray, out rayDistance)) { Vector3 point = ray.GetPoint(rayDistance); //Debug.DrawLine(ray.origin, point, Color.red); } if (hasMoveTarget) { StartCoroutine(UpdatePath()); } //Movement if (Input.GetMouseButtonDown(1)) { hasMoveTarget = true; moveTarget = new Vector3(Input.mousePosition.x, Input.mousePosition.y); Debug.Log("Right-Click: " + moveTarget); } }
int findLeaf(Vector3 position) { if (position == null) { throw new ArgumentException(); } int index = 0; while (index >= 0) { //Debug.Log(index); BSPFileParser.BSPTreeNode node = _nodes[index]; UnityEngine.Plane plane = planes[node.plane]; float distance = plane.GetDistanceToPoint(position); if (distance >= 0) { index = node.children[0]; } else { index = node.children[1]; } } // When index < 0, meaning this is a BSP Leaf Index // convert into correct leaf index: -index-1 return(-index - 1); }
void Update() { if (navMeshAgent.remainingDistance < 0.5f) { if (idle != null && anim != null) anim.CrossFade(idle.name); } else { if (run != null && anim != null) anim.CrossFade(run.name); } // Moves the Player if the Left Mouse Button was clicked: if (Input.GetMouseButtonDown((int) mouseButton) && GUIUtility.hotControl == 0) { Plane playerPlane = new Plane(Vector3.up, myTransform.position); Ray ray = UnityEngine.Camera.main.ScreenPointToRay(Input.mousePosition); float hitdist = 0.0f; if (playerPlane.Raycast(ray, out hitdist)) { navMeshAgent.SetDestination(ray.GetPoint(hitdist)); } } // Moves the player if the mouse button is held down: else if (Input.GetMouseButton((int) mouseButton) && GUIUtility.hotControl == 0) { Plane playerPlane = new Plane(Vector3.up, myTransform.position); Ray ray = UnityEngine.Camera.main.ScreenPointToRay(Input.mousePosition); float hitdist = 0.0f; if (playerPlane.Raycast(ray, out hitdist)) { navMeshAgent.SetDestination(ray.GetPoint(hitdist)); } } }
/// <summary> /// Initialises the component. /// </summary> public void Start() { this.planeZ = new Plane(Vector3.back, Vector3.zero); // Get a refernce to the terrain's touchable component this.terrainTouchable = GameObject.Find("Terrain").GetComponent<TouchableComponent>(); }
private void AdjustEdgeHandleColor(Vector3 handlePos, Vector3 slideDir1, Vector3 slideDir2, Matrix4x4 transform, float alphaFactor) { bool flag; Vector3 inPoint = transform.MultiplyPoint(handlePos); Vector3 normalized = transform.MultiplyVector(slideDir1).normalized; Vector3 rhs = transform.MultiplyVector(slideDir2).normalized; if (Camera.current.isOrthoGraphic) { flag = (Vector3.Dot(-Camera.current.transform.forward, normalized) < 0f) && (Vector3.Dot(-Camera.current.transform.forward, rhs) < 0f); } else { Plane plane = new Plane(normalized, inPoint); Plane plane2 = new Plane(rhs, inPoint); flag = !plane.GetSide(Camera.current.transform.position) && !plane2.GetSide(Camera.current.transform.position); } if (flag) { alphaFactor *= 0.2f; } if (alphaFactor < 1f) { Handles.color = new Color(Handles.color.r, Handles.color.g, Handles.color.b, Handles.color.a * alphaFactor); } }
// Update is called once per frame public override void OnUpdate() { var vrcam = SteamVR_Render.Top(); GameObject go = Fsm.GetOwnerDefaultTarget(gazeObject); Ray r = new Ray(vrcam.transform.position, vrcam.transform.forward); Plane p = new Plane(vrcam.transform.forward, go.transform.position); float enter = 0.0f; if (p.Raycast(r, out enter)) { Vector3 intersect = vrcam.transform.position + vrcam.transform.forward * enter; float dist = Vector3.Distance(intersect, go.transform.position); //Debug.Log("Gaze dist = " + dist); if (dist < gazeInCutoff.Value && !isInGaze.Value) { isInGaze.Value = true; GazeEventArgsPlaymaker e; e.distance = dist; OnGazeOn(e); } else if (dist >= gazeOutCutoff.Value && isInGaze.Value) { isInGaze.Value = false; GazeEventArgsPlaymaker e; e.distance = dist; OnGazeOff(e); } } }
void Update () { Plane playerPlane = new Plane(Vector3.up, transform.position + new Vector3(0, 0, 0)); switch (state) { case State.Walking: Walking(); break; case State.Attacking: Attacking(); break; } if(state != nextState){ state = nextState; switch(state){ case State.Walking: WalkStart(); break; case State.Attacking: AttackStart(); break; case State.Died: Died(); break; } } }
/// <summary> /// Same functionality as GeometryUtility.CalculateFrustumPlanes, but doesn't allocate memory. /// </summary> public static void ExtractFrustumPlanes(Plane[] planes, Camera camera) { Matrix4x4 viewProjMatrix = camera.projectionMatrix * camera.worldToCameraMatrix; Vector3 normal = new Vector3(viewProjMatrix[3, 0] + viewProjMatrix[0, 0], viewProjMatrix[3, 1] + viewProjMatrix[0, 1], viewProjMatrix[3, 2] + viewProjMatrix[0, 2]); float length = normal.magnitude; planes[0].normal = normal.normalized; planes[0].distance = (viewProjMatrix[3, 3] + viewProjMatrix[0, 3]) / length; normal = new Vector3(viewProjMatrix[3, 0] - viewProjMatrix[0, 0], viewProjMatrix[3, 1] - viewProjMatrix[0, 1], viewProjMatrix[3, 2] - viewProjMatrix[0, 2]); length = normal.magnitude; planes[1].normal = normal.normalized; planes[1].distance = (viewProjMatrix[3, 3] - viewProjMatrix[0, 3]) / length; normal = new Vector3(viewProjMatrix[3, 0] + viewProjMatrix[1, 0], viewProjMatrix[3, 1] + viewProjMatrix[1, 1], viewProjMatrix[3, 2] + viewProjMatrix[1, 2]); length = normal.magnitude; planes[2].normal = normal.normalized; planes[2].distance = (viewProjMatrix[3, 3] + viewProjMatrix[1, 3]) / length; normal = new Vector3(viewProjMatrix[3, 0] - viewProjMatrix[1, 0], viewProjMatrix[3, 1] - viewProjMatrix[1, 1], viewProjMatrix[3, 2] - viewProjMatrix[1, 2]); length = normal.magnitude; planes[3].normal = normal.normalized; planes[3].distance = (viewProjMatrix[3, 3] - viewProjMatrix[1, 3]) / length; normal = new Vector3(viewProjMatrix[3, 0] + viewProjMatrix[2, 0], viewProjMatrix[3, 1] + viewProjMatrix[2, 1], viewProjMatrix[3, 2] + viewProjMatrix[2, 2]); length = normal.magnitude; planes[4].normal = normal.normalized; planes[4].distance = (viewProjMatrix[3, 3] + viewProjMatrix[2, 3]) / length; normal = new Vector3(viewProjMatrix[3, 0] - viewProjMatrix[2, 0], viewProjMatrix[3, 1] - viewProjMatrix[2, 1], viewProjMatrix[3, 2] - viewProjMatrix[2, 2]); length = normal.magnitude; planes[5].normal = normal.normalized; planes[5].distance = (viewProjMatrix[3, 3] - viewProjMatrix[2, 3]) / length; }
public RaycastScreenPointFromCamera(Camera targetCamera, Vector2 screenPosition) { this._targetCamera = targetCamera; this._screenPosition = screenPosition; _plane = new Plane(Vector3.down, Vector3.zero); Invalidate(); }
/// <summary> /// Projects a screen point to a plane. /// </summary> /// <param name="position">Screen point.</param> /// <param name="camera">The camera.</param> /// <param name="projectionPlane">The projection plane.</param> /// <returns></returns> public static Vector3 CameraToPlaneProjection(Vector2 position, Camera camera, Plane projectionPlane) { var ray = camera.ScreenPointToRay(position); var relativeIntersection = 0f; projectionPlane.Raycast(ray, out relativeIntersection); return ray.origin + ray.direction*relativeIntersection; }
public Vector3 PositionUnderMouseLine(out bool fail) { fail = false; if (!Camera.main) { return(transform.position); } Ray r = Camera.main.ScreenPointToRay(new Vector3(Input.mousePosition.x, Input.mousePosition.y, 0)); Vector3 n = WorldNormal(); n = Vector3.Cross(n, Vector3.Cross(r.direction, n)); if (n == Vector3.zero) { fail = true; return(n); } n = n.normalized; Plane p = new Plane(n, atom.transform.position); p.Raycast(r, out var d); Vector3 hitGlobal = r.GetPoint(d); Vector3 hitLocal = moleculeSpace.transform.InverseTransformPoint(hitGlobal); Vector3 currentLocal = atom.transform.localPosition; currentLocal[axis] = hitLocal[axis]; return(moleculeSpace.transform.TransformPoint(currentLocal)); }
public void OnBeginDrag(int modelIndex) { if (_isTracking) { /* If we're tracking, instantiate a new model prefab based on the button index and */ GameObject modelPrefab = Models[modelIndex]; Transform model = Instantiate(modelPrefab).transform; _activeModels.Add(model.gameObject); /* Set model position at touch position */ var cameraRay = Camera.main.ScreenPointToRay(Input.mousePosition); Plane p = new Plane(Vector3.up, Vector3.zero); float enter; if (p.Raycast(cameraRay, out enter)) { model.position = cameraRay.GetPoint(enter); } /* Set model orientation to face toward the camera */ Quaternion modelRotation = Quaternion.LookRotation(Vector3.ProjectOnPlane(-Camera.main.transform.forward, Vector3.up), Vector3.up); model.rotation = modelRotation; /* Assign the new model to the move controller, so that it can be further dragged after it leaves the button area. */ _moveController.SetMoveObject(model); } }
public static bool RaycastSmoke(Ray ray) { if(!CMDropper.smokePool) { return false; } for(int i = 0; i < CMDropper.smokePool.size; i++) { Transform smokeTf = CMDropper.smokePool.GetPooledObject(i).transform; if(smokeTf.gameObject.activeInHierarchy) { Plane smokePlane = new Plane((ray.origin-smokeTf.position).normalized, smokeTf.position); float enter; if(smokePlane.Raycast(ray, out enter)) { float dist = (ray.GetPoint(enter)-smokeTf.position).magnitude; if(dist < 16) { return true; } } } } return false; }
// Update is called once per frame void Update() { if (Input.GetMouseButtonDown(0) && isTracking && !EventSystem.current.IsPointerOverGameObject()) { var cameraRay = Camera.main.ScreenPointToRay(Input.mousePosition); UnityEngine.Plane groundPlane = new UnityEngine.Plane(Vector3.up, Vector3.zero); float touchPos; if (groundPlane.Raycast(cameraRay, out touchPos)) { Vector3 position = cameraRay.GetPoint(touchPos); GameObject pizza = Instantiate(PizzaPrefab, position, Quaternion.identity); } } if (trackerState == InstantTrackingState.Initializing) { if (Tracker.CanStartTracking()) { grid.TargetColor = Color.green; } else { grid.TargetColor = GridRenderer.DefaultTargetColor; } } else { grid.TargetColor = GridRenderer.DefaultTargetColor; } }
void GizmosDrawABrushOfLeaf(int brushIndex) { Color tc = Gizmos.color; // Draw Brush Gizmos.color = Color.white; BSPFileParser.Brush bsh = _brushes[brushIndex]; for (int k = bsh.brushside; k < bsh.brushside + bsh.n_brushsides; k++) { BSPFileParser.Brushside bsd = _brushsides[k]; UnityEngine.Plane plane = planes[bsd.plane]; GizmosDrawPlane(GetOnePointOnPlane(plane), plane.normal, 5000.0f); } // Draw Leaf which hold the brushIndex Gizmos.color = Color.red; for (int i = 0; i < _leafs.Length; i++) { BSPFileParser.BSPTreeLeaf lf = _leafs[i]; for (int j = lf.leafbrush; j < lf.leafbrush + lf.n_leafbrushes; j++) { if (_leafbrushes[j] == brushIndex) { Bounds temp = new Bounds(); temp.SetMinMax(new Vector3(lf.mins[0], lf.mins[1], lf.mins[2]), new Vector3(lf.maxs[0], lf.maxs[1], lf.maxs[2])); temp = Right2Left(temp); Gizmos.DrawWireCube(temp.center, temp.size); } } } Gizmos.color = tc; }
private void Draw() { mesh.Clear(); plane = new UnityEngine.Plane(new Vector3(1, 0, 0), new Vector3(0, 1, 0), new Vector3(0, 0, 1)); }
static public int constructor(IntPtr l) { LuaDLL.lua_remove(l,1); UnityEngine.Plane o; if(matchType(l,1,typeof(UnityEngine.Vector3),typeof(UnityEngine.Vector3))){ UnityEngine.Vector3 a1; checkType(l,1,out a1); UnityEngine.Vector3 a2; checkType(l,2,out a2); o=new UnityEngine.Plane(a1,a2); pushObject(l,o); return 1; } else if(matchType(l,1,typeof(UnityEngine.Vector3),typeof(float))){ UnityEngine.Vector3 a1; checkType(l,1,out a1); System.Single a2; checkType(l,2,out a2); o=new UnityEngine.Plane(a1,a2); pushObject(l,o); return 1; } else if(matchType(l,1,typeof(UnityEngine.Vector3),typeof(UnityEngine.Vector3),typeof(UnityEngine.Vector3))){ UnityEngine.Vector3 a1; checkType(l,1,out a1); UnityEngine.Vector3 a2; checkType(l,2,out a2); UnityEngine.Vector3 a3; checkType(l,3,out a3); o=new UnityEngine.Plane(a1,a2,a3); pushObject(l,o); return 1; } LuaDLL.luaL_error(l,"New object failed."); return 0; }
// Handle map in the leaf level, so no care face level //ArrayList findVisibleFaces(ArrayList visibleLeafs) { // if (visibleLeafs == null) { // throw new ArgumentException(); // } // bool[] alreadyVisibleFaces = new bool[_faces.Length]; // ArrayList visibleFaces = new ArrayList(); // foreach(int i in visibleLeafs) { // BSPTreeLeaf lf = _leafs[i]; // for(int j=lf.leafface; j<lf.leafface+lf.n_leaffaces; j++) { // int faceIndex = _leaffaces[j]; // if(!alreadyVisibleFaces[faceIndex]) { // alreadyVisibleFaces[faceIndex] = true; // visibleFaces.Add(faceIndex); // } // } // } // return visibleFaces; //} // Handle map in the leaf level, so no care face level //ArrayList backfaceCulling(Camera cam, ArrayList visibleFaces) { // ArrayList visible = new ArrayList (); // foreach (int i in visibleFaces) { // BSPFileParser.Face f = _faces[i]; // Vector3 normal = Right2Left(new Vector3(f.normal[0], f.normal[1], f.normal[2])); // if(Vector3.Dot(cam.transform.forward, normal) < BACKCULLINGFACTOR) { // visible.Add(i); // } // } // return visible; //} int findLeafIndex(Vector3 position) { if (position == null) { throw new ArgumentException(); } int index = 0; while (index >= 0) { BSPFileParser.BSPTreeNode node = _nodes[index]; UnityEngine.Plane plane = planes[node.plane]; if (plane.GetSide(position)) { index = node.children[0]; } else { index = node.children[1]; } } // When index < 0, meaning this is a BSP Leaf Index // convert into correct leaf index: -index-1 return(-index - 1); }
internal static bool RaycastGUIPointToWorldHit(Vector2 guiPoint, Plane plane, out Vector3 hit) { Ray ray = HandleUtility.GUIPointToWorldRay(guiPoint); float distance = 0f; bool flag = plane.Raycast(ray, out distance); hit = ((!flag) ? Vector3.zero : ray.GetPoint(distance)); return flag; }
internal static bool RaycastGUIPointToWorldHit(Vector2 guiPoint, Plane plane, out Vector3 hit) { Ray worldRay = HandleUtility.GUIPointToWorldRay(guiPoint); float enter = 0.0f; bool flag = plane.Raycast(worldRay, out enter); hit = !flag ? Vector3.zero : worldRay.GetPoint(enter); return flag; }
static public int set_normal(IntPtr l) { UnityEngine.Plane o = (UnityEngine.Plane)checkSelf(l); UnityEngine.Vector3 v; checkType(l,2,out v); o.normal=v; setBack(l,o); return 0; }
public static Vector3 ScreenPointToWorldPointOnPlane(Vector3 screenPoint , Plane plane , Camera camera ) { // Set up a ray corresponding to the screen position Ray ray = camera.ScreenPointToRay(screenPoint); // Find out where the ray intersects with the plane return PlaneRayIntersection(plane, ray); }
static public int set_distance(IntPtr l) { UnityEngine.Plane o = (UnityEngine.Plane)checkSelf(l); float v; checkType(l,2,out v); o.distance=v; setBack(l,o); return 0; }
// Convert BSP coordinate into Unity3D coordinate // BSP File data based coordinate system(Right-hand): // x-axis points East, y-axis points South, and z-axis points vertically downward // Unity3D based coordinate system(Left-hand): // x-axis points East, y-axis points vertically upward, and z-axis points North // You must convert BSP's vertex, normal, plane, bounding box into Unity3D coordinate UnityEngine.Plane Right2Left(UnityEngine.Plane plane) { plane.normal = Right2Left(plane.normal); // Notice: While Right hand coordinate convert into left coordinate, // you must negative plane.distance. plane.distance = -plane.distance; return(plane); }
/// <summary> /// Projects a screen point to a plane using parallel projection. /// </summary> /// <param name="position">Screen point.</param> /// <param name="projectionPlane">Projection plane.</param> /// <returns>Projected point on the plane in World coordinates.</returns> public static Vector3 ScreenToPlaneProjection(Vector2 position, Plane projectionPlane) { var distance = 0f; var ray = new Ray(position, Vector3.forward); var result = projectionPlane.Raycast(ray, out distance); if (!result && distance == 0f) return -projectionPlane.normal * projectionPlane.distance; // perpendicular to the screen return ray.origin + new Vector3(0, 0, distance); }
/// <summary> /// Projects a screen point to a plane from a camera's point of view. /// </summary> /// <param name="position">Screen point.</param> /// <param name="camera">The camera.</param> /// <param name="projectionPlane">Projection plane.</param> /// <returns>Projected point on the plane in World coordinates.</returns> public static Vector3 CameraToPlaneProjection(Vector2 position, Camera camera, Plane projectionPlane) { var distance = 0f; var ray = camera.ScreenPointToRay(position); var result = projectionPlane.Raycast(ray, out distance); if (!result && Mathf.Approximately(distance, 0f)) return -projectionPlane.normal * projectionPlane.GetDistanceToPoint(Vector3.zero); // perpendicular to the screen return ray.origin + ray.direction * distance; }
/// <summary> /// Projects a screen point to a plane using parallel projection. /// </summary> /// <param name="position">Screen point.</param> /// <param name="projectionPlane">Projection plane.</param> /// <returns>Projected point on the plane in World coordinates.</returns> public static Vector3 ScreenToPlaneProjection(Vector2 position, Plane projectionPlane) { var distance = 0f; var ray = new Ray(position, Vector3.forward); var result = projectionPlane.Raycast(ray, out distance); if (!result && Mathf.Approximately(distance, 0f)) return -projectionPlane.normal * projectionPlane.GetDistanceToPoint(Vector3.zero); // perpendicular to the screen return ray.origin + new Vector3(0, 0, distance); }
public Vector3 GetWorldPositionOnPlane(Vector3 screenPosition, float y) { Ray ray = Camera.main.ScreenPointToRay(screenPosition); UnityEngine.Plane xy = new UnityEngine.Plane(Vector3.up, new Vector3(0, y, 0)); float distance; xy.Raycast(ray, out distance); return(ray.GetPoint(distance)); }
/** * If the ray intersects with a plane, return the intersect point. */ public static bool MousePositionOnPlane(Ray ray, Plane plane, ref Vector3 pos) { float dist; if( !plane.Raycast(ray, out dist ) ) return false; pos = ray.GetPoint(dist); return true; }
internal static Vector3 GetPlanePoint (Vector3 aPoint, Plane aPlane) { Plane p = aPlane; Ray r = SceneView.lastActiveSceneView == null ? new Ray(Vector3.up,-Vector3.up) : new Ray (SceneView.lastActiveSceneView.camera.transform.position, aPoint - SceneView.lastActiveSceneView.camera.transform.position); float d = 0; if (p.Raycast(r, out d)) { Vector3 result = r.GetPoint(d); return result; } return aPoint; }
protected void init(){ for (int i=0; i<normals.Count; i++) { avgNormal+=normals[i]; } avgNormal /= normals.Count; plane = new Plane (); plane.Set3Points (positions[0],positions[1],positions[2]); bounds = MeshUtils.createBounds (positions/*, avgNormal, centerPos, true*/); extendedBounds = new Bounds (bounds.center, bounds.size + MeshUtils.MAX_ROUND_ERROR); }
public static void DrawLineBetweenWorldPositions(Vector3 worldPosA, Vector3 worldPosB, float width, Color color) { Camera cam = GetMainCamera(); GUI.matrix = Matrix4x4.identity; bool aBehind = false; Plane clipPlane = new Plane(cam.transform.forward, cam.transform.position + cam.transform.forward * 0.05f); if(Vector3.Dot(cam.transform.forward, worldPosA-cam.transform.position) < 0) { Ray ray = new Ray(worldPosB, worldPosA - worldPosB); float dist; if(clipPlane.Raycast(ray, out dist)) { worldPosA = ray.GetPoint(dist); } aBehind = true; } if(Vector3.Dot(cam.transform.forward, worldPosB-cam.transform.position) < 0) { if(aBehind) return; Ray ray = new Ray(worldPosA, worldPosB - worldPosA); float dist; if(clipPlane.Raycast(ray, out dist)) { worldPosB = ray.GetPoint(dist); } } Vector3 screenPosA = cam.WorldToViewportPoint(worldPosA); screenPosA.x = screenPosA.x*Screen.width; screenPosA.y = (1-screenPosA.y)*Screen.height; Vector3 screenPosB = cam.WorldToViewportPoint(worldPosB); screenPosB.x = screenPosB.x*Screen.width; screenPosB.y = (1-screenPosB.y)*Screen.height; screenPosA.z = screenPosB.z = 0; float angle = Vector2.Angle(Vector3.up, screenPosB - screenPosA); if(screenPosB.x < screenPosA.x) { angle = -angle; } Vector2 vector = screenPosB - screenPosA; float length = vector.magnitude; Rect upRect = new Rect(screenPosA.x - (width / 2), screenPosA.y-length, width, length); GUIUtility.RotateAroundPivot(-angle+180, screenPosA); DrawRectangle(upRect, color); GUI.matrix = Matrix4x4.identity; }
/// <summary> /// Returns the normalized interpolant between point1 and point2 where the edge they represent intersects with the /// supplied plane. /// </summary> public static float IntersectsPlane(UnityEngine.Plane plane, Vector3 point1, Vector3 point2) { // TODO: The plane might need flipping here float interpolant = (-plane.normal.x * point1.x - plane.normal.y * point1.y - plane.normal.z * point1.z - plane.distance) / (-plane.normal.x * (point1.x - point2.x) - plane.normal.y * (point1.y - point2.y) - plane.normal.z * (point1.z - point2.z)); // DISABLED: Should find a way of making this work with the new Assert support in Unity // DebugHelper.Assert((interpolant >= 0 && interpolant <= 1), "Edge Interpolant outside (0,1) range"); return(interpolant); }
void LateUpdate() { float v = scale * Settings.marker_scale; if (Settings.marker_autoscale) { var cam = EditorCamera.Instance; var plane = new Plane (cam.transform.forward, cam.transform.position); float dist = plane.GetDistanceToPoint (transform.position); v *= Mathf.Clamp (dist_c * dist, 0f, 1f); } transform.localScale = Vector3.one * v; }
Vector3 GetOnePointOnPlane(UnityEngine.Plane plane) { Ray r = new Ray(Vector3.zero, plane.normal); //Debug.Log(plane.GetDistanceToPoint(r.GetPoint(-plane.distance))); return(r.GetPoint(-plane.distance)); // or //float distance = 0.0f; //plane.Raycast (r, out distance); //return r.GetPoint (distance); }
void LoadCollider(GameObject gmObject) { for (int i = 0; i < _leafs.Length; i++) { for (int j = _leafs[i].leafbrush; j < _leafs[i].leafbrush + _leafs[i].n_leafbrushes; j++) { int brushIndex = _leafbrushes[j]; BSPFileParser.Brush bsh = _brushes[brushIndex]; if (bsh.n_brushsides == 6) { // Generate Box Collider directly by the 6 bounding planes UnityEngine.Plane[] ps = new UnityEngine.Plane[bsh.n_brushsides]; for (int k = bsh.brushside; k < bsh.brushside + bsh.n_brushsides; k++) { UnityEngine.Plane plane = planes[_brushsides[k].plane]; ps[k - bsh.brushside] = new UnityEngine.Plane(plane.normal, plane.distance); } Bounds b = GenerateBoxFromPlanes(ps); GameObject obj = new GameObject(); obj.name = "BoxCollider"; obj.AddComponent <BoxCollider>(); obj.GetComponent <BoxCollider>().center = b.center; obj.GetComponent <BoxCollider>().size = b.size; obj.transform.SetParent(gmObject.transform); } else { // Generate Box Collider by leaf bounding box which brush in it for (int m = 0; m < _leafs.Length; m++) { BSPFileParser.BSPTreeLeaf lf = _leafs[m]; for (int n = lf.leafbrush; n < lf.leafbrush + lf.n_leafbrushes; n++) { if (_leafbrushes[n] == brushIndex) { Bounds b = new Bounds(); b.SetMinMax(new Vector3(lf.mins[0], lf.mins[1], lf.mins[2]), new Vector3(lf.maxs[0], lf.maxs[1], lf.maxs[2])); b = Right2Left(b); GameObject obj = new GameObject(); obj.name = "BoxCollider"; obj.AddComponent <BoxCollider>(); obj.GetComponent <BoxCollider>().center = b.center; obj.GetComponent <BoxCollider>().size = b.size; obj.transform.SetParent(gmObject.transform); } } } } } } }
/// <summary> /// Builds the bounded plane to match the obb defined by xform /// </summary> public BoundedPlane(Transform xform) { Plane = new Plane(xform.forward, xform.position); Bounds = new OrientedBoundingBox() { Center = xform.position, Extents = xform.localScale / 2, Rotation = xform.rotation }; Area = Bounds.Extents.x * Bounds.Extents.y; }
void drawDebugPlane(Plane plane) { Quaternion rotation = Quaternion.LookRotation (plane.normal) * Quaternion.Euler(90f, 0f, 0f); GameObject newGo = Instantiate(m_planePrefab, -plane.normal * plane.distance, rotation); newGo.GetComponent <MeshRenderer>().material.color = new Color(1f, 1f, 1f, 0.05f); newGo.transform.SetParent(gameObject.transform); }
void LookRotation() { Ray ray = mainCamera.ScreenPointToRay(Input.mousePosition); Plane ground = new Plane(Vector3.up,Vector3.zero); float rayDistance; if (ground.Raycast(ray, out rayDistance)) { Vector3 lookPoint = ray.GetPoint(rayDistance); controller.LookTo(lookPoint); } }
public void setup(Transform tran, Camera cam, Plane sky) { this.transform.SetParent (tran); float x = Random.Range (0.0f, Screen.width); float y = Random.Range (0.0f, Screen.height); Ray ray = cam.ScreenPointToRay (new Vector3 (x, y, 0)); float dist = 0; sky.Raycast (ray, out dist); Vector3 p = ray.GetPoint (dist); this.transform.position = p; this.gameObject.SetActive (true); }
private void Awake() { // Debug.Log ("!!!!!????"); sky_ = new Plane(Vector3.forward, _z); Ray ray1 = _camera.ScreenPointToRay (new Vector3 (0, 0, 0)); Ray ray2 = _camera.ScreenPointToRay (new Vector3 (0, Screen.height, 0)); float dist1 = 0; sky_.Raycast (ray1, out dist1); float dist2 = 0; sky_.Raycast (ray2, out dist2); y_ = (ray2.GetPoint (dist2) - ray1.GetPoint (dist1)).y; }
// Update is called once per frame void Update() { // Get pressed world position bool mouseDown = Input.GetMouseButtonDown(0); bool touchUp = Input.touchCount > 0 && Input.GetTouch(0).phase == TouchPhase.Ended; if (mouseDown || touchUp) { Ray ray = Camera.main.ScreenPointToRay(mouseDown ? Input.mousePosition : new Vector3( Input.GetTouch(0).position.x, Input.GetTouch(0).position.y) ); Plane hPlane = new Plane(Vector3.forward, Vector3.zero); float distance = 0; if (hPlane.Raycast(ray, out distance)) { // get the hit point: m_pathFindingBehaviour.TargetPos = ray.GetPoint(distance); } } Vector3 vTarget = m_pathFindingBehaviour.TargetPos; vTarget.z = transform.position.z; // stop when target position has been reached Vector3 vDist = (vTarget - transform.position); //Debug.DrawLine(vTarget, transform.position); //TODO: the target is the touch position, not the target tile center. Fix this to go to target position once in the target tile m_pathFindingBehaviour.enabled = vDist.magnitude > MinDistToReachTarget; if (!m_pathFindingBehaviour.enabled) { m_moving.Veloc = Vector3.zero; } //+++avoid obstacles Vector3 vTurnVel = Vector3.zero; if (0 != (m_phyChar.CollFlags & PhysicCharBehaviour.eCollFlags.RIGHT)) { vTurnVel.x = -m_moving.MaxSpeed; } else if (0 != (m_phyChar.CollFlags & PhysicCharBehaviour.eCollFlags.LEFT)) { vTurnVel.x = m_moving.MaxSpeed; } if (0 != (m_phyChar.CollFlags & PhysicCharBehaviour.eCollFlags.DOWN)) { vTurnVel.y = m_moving.MaxSpeed; } else if (0 != (m_phyChar.CollFlags & PhysicCharBehaviour.eCollFlags.UP)) { vTurnVel.y = -m_moving.MaxSpeed; } if (vTurnVel != Vector3.zero) { m_moving.ApplyForce(vTurnVel - m_moving.Veloc); } //--- UpdateAnimDir(); }
static Vector3 GetSpawnPos() { Plane plane = new Plane(new Vector3(0, 0, -1), 0); float dist = 0; Vector3 result = new Vector3(0, 0, 0); Ray ray = SceneView.lastActiveSceneView.camera.ViewportPointToRay(new Vector3(0.5f, 0.5f, 1.0f)); if (plane.Raycast(ray, out dist)) { result = ray.GetPoint(dist); } return new Vector3(result.x, result.y, 0); }
// Update is called once per frame void Update() { Ray ray = mainCam.ScreenPointToRay(Input.mousePosition); Plane virtualGround = new Plane(Vector3.up, Vector3.zero); float rayDistance; if (virtualGround.Raycast(ray, out rayDistance)) { MousePosition = ray.GetPoint(rayDistance); Debug.DrawLine(ray.origin, MousePosition, Color.red); } }
static public int constructor(IntPtr l) { try { int argc = LuaDLL.lua_gettop(l); UnityEngine.Plane o; if (argc == 5) { UnityEngine.Vector3 a1; checkType(l, 3, out a1); UnityEngine.Vector3 a2; checkType(l, 4, out a2); UnityEngine.Vector3 a3; checkType(l, 5, out a3); o = new UnityEngine.Plane(a1, a2, a3); pushValue(l, true); pushValue(l, o); return(2); } else if (matchType(l, "ctor__Vector3__Vector3", argc, 2, typeof(UnityEngine.Vector3), typeof(UnityEngine.Vector3))) { UnityEngine.Vector3 a1; checkType(l, 3, out a1); UnityEngine.Vector3 a2; checkType(l, 4, out a2); o = new UnityEngine.Plane(a1, a2); pushValue(l, true); pushValue(l, o); return(2); } else if (matchType(l, "ctor__Vector3__Single", argc, 2, typeof(UnityEngine.Vector3), typeof(float))) { UnityEngine.Vector3 a1; checkType(l, 3, out a1); System.Single a2; checkType(l, 4, out a2); o = new UnityEngine.Plane(a1, a2); pushValue(l, true); pushValue(l, o); return(2); } else if (argc <= 2) { o = new UnityEngine.Plane(); pushValue(l, true); pushValue(l, o); return(2); } return(error(l, "New object failed.")); } catch (Exception e) { return(error(l, e)); } }
public static Plane Normalize(ref Plane value) { Plane result = new Plane(); float factor; result.normal = Vector3.Normalize(value.normal); factor = (float)Math.Sqrt(result.normal.x * result.normal.x + result.normal.y * result.normal.y + result.normal.z * result.normal.z) / (float)Math.Sqrt(value.normal.x * value.normal.x + value.normal.y * value.normal.y + value.normal.z * value.normal.z); result.distance = value.distance * factor; return result; }
static public int ctor_s(IntPtr l) { try { UnityEngine.Plane o; o = new UnityEngine.Plane(); pushValue(l, true); pushValue(l, o); return(2); } catch (Exception e) { return(error(l, e)); } }
static bool Plane_GetSide__Vector3(JSVCall vc, int argc) { int len = argc; if (len == 1) { UnityEngine.Vector3 arg0 = (UnityEngine.Vector3)JSApi.getVector3S((int)JSApi.GetType.Arg); UnityEngine.Plane argThis = (UnityEngine.Plane)vc.csObj; JSApi.setBooleanS((int)JSApi.SetType.Rval, (System.Boolean)(argThis.GetSide(arg0))); JSMgr.changeJSObj(vc.jsObjID, argThis); } return(true); }
void Update() { Plane plane = new Plane(transform.up, transform.position); for (int i = 0; i < LockedObjects.Length; i++) { float currentDistance = plane.GetDistanceToPoint(LockedObjects[i].position); Vector3 currentoffset = transform.up * currentDistance; Vector3 offset = transform.up * MaxDistance; Debug.DrawLine(LockedObjects[i].position, LockedObjects[i].position - offset); LockedObjects[i].position = LockedObjects[i].position - currentoffset + offset; Vector3 centerOffset = LockedObjects[i].position - transform.position; centerOffset = Vector3.ClampMagnitude(centerOffset, MaxRadialDistance); LockedObjects[i].position = transform.position + centerOffset; } }
public Vector2 GetSeaPosition() { touch = Input.GetTouch(0); Ray touchRay; touchRay = mainCamera.ScreenPointToRay(touch.position); Plane ground = new Plane(Vector3.up, new Vector3(0, 0, 0)); float distance; ground.Raycast(touchRay, out distance); return(Coordinates.ConvertWorldToVector2(touchRay.GetPoint(distance))); }
private Vector3 GetGroundPosition(Vector2 touchPosition) { var groundPlane = new Plane(Vector3.up, Vector3.zero); var touchRay = _mainCamera.ScreenPointToRay(touchPosition); float enter; if (groundPlane.Raycast(touchRay, out enter)) { return(touchRay.GetPoint(enter)); } return(Vector3.zero); }
public Vector3 PositionUnderMouseLineAndSphere(out bool fail) { fail = false; UpdateSliceNormal(); Ray r = Camera.main.ScreenPointToRay(new Vector3(Input.mousePosition.x, Input.mousePosition.y, 0)); Vector3 fatherPos = atom.molecularParent.transform.position; Plane p = new Plane(sliceNormal, fatherPos); p.Raycast(r, out var d); Vector3 hitGlobal = r.GetPoint(d); return(ProjectOnSphere(hitGlobal)); }
static bool Plane_SetNormalAndPosition__Vector3__Vector3(JSVCall vc, int argc) { int len = argc; if (len == 2) { UnityEngine.Vector3 arg0 = (UnityEngine.Vector3)JSApi.getVector3S((int)JSApi.GetType.Arg); UnityEngine.Vector3 arg1 = (UnityEngine.Vector3)JSApi.getVector3S((int)JSApi.GetType.Arg); UnityEngine.Plane argThis = (UnityEngine.Plane)vc.csObj; argThis.SetNormalAndPosition(arg0, arg1); JSMgr.changeJSObj(vc.jsObjID, argThis); } return(true); }
void GizmosDrawCameraInsideLeaf(Camera cam) { Color tc = Gizmos.color; Color[] cs = new Color[] { Color.gray, Color.yellow, Color.magenta, Color.red }; // from light to dark int colorIndex = 0; Vector3 position = cam.transform.position; // Camera Gizmos.DrawCube(position, new Vector3(200, 200, 200)); int index = 0; while (index >= 0) { Gizmos.color = cs[colorIndex++ % cs.Length]; BSPFileParser.BSPTreeNode node = _nodes[index]; UnityEngine.Plane plane = planes[node.plane]; Bounds b = new Bounds(); b.SetMinMax(new Vector3(node.mins[0], node.mins[1], node.mins[2]), new Vector3(node.maxs[0], node.maxs[1], node.maxs[2])); b = Right2Left(b); // Draw Sub-Space(BSP Tree Node bounding box) Gizmos.DrawWireCube(b.center, b.size); // Draw Split-Plane GizmosDrawPlane(GetOnePointOnPlane(plane), plane.normal, 5000.0f); if (plane.GetSide(position)) { index = node.children[0]; //Debug.Log("Front"); } else { index = node.children[1]; //Debug.Log("Back"); } } // Draw BSP Tree Leaf bounding box BSPFileParser.BSPTreeLeaf lf = _leafs[-index - 1]; Bounds temp = new Bounds(); temp.SetMinMax(new Vector3(lf.mins[0], lf.mins[1], lf.mins[2]), new Vector3(lf.maxs[0], lf.maxs[1], lf.maxs[2])); temp = Right2Left(temp); Gizmos.color = Color.white; Gizmos.DrawWireCube(temp.center, temp.size); Gizmos.color = tc; }
void OnTriggerEnter(Collider other) { Debug.Log("Slashy triggered"); if (other.tag == "dorito") { UnityEngine.Plane plane = new UnityEngine.Plane(swordPoint.position, swordHilt.position, lastPoint); GameObject[] sliceyBoys = other.gameObject.SliceInstantiate(lastPoint, plane.normal); Debug.Log(sliceyBoys); for (int i = 0; i < sliceyBoys.Length; i++) { sliceyBoys[i].AddComponent <SlicesScript>(); } } }
static public int GetSide(IntPtr l) { try{ UnityEngine.Plane self=(UnityEngine.Plane)checkSelf(l); UnityEngine.Vector3 a1; checkType(l,2,out a1); System.Boolean ret=self.GetSide(a1); pushValue(l,ret); return 1; } catch(Exception e) { LuaDLL.luaL_error(l, e.ToString()); return 0; } }
public void Execute() { Plane plane = new Plane(Vector3.up, Vector3.zero); Vector3 mousePosition = Input.mousePosition; Ray ray = _camera.ScreenPointToRay(mousePosition); if (plane.Raycast(ray, out float enter)) { foreach (var entity in _group) { Vector3 lookDirection = ray.GetPoint(enter) - entity.position.Position; entity.ReplaceRotation(Quaternion.LookRotation(lookDirection)); } } }
static public int GetDistanceToPoint(IntPtr l) { try{ UnityEngine.Plane self = (UnityEngine.Plane)checkSelf(l); UnityEngine.Vector3 a1; checkType(l, 2, out a1); System.Single ret = self.GetDistanceToPoint(a1); pushValue(l, ret); return(1); } catch (Exception e) { LuaDLL.luaL_error(l, e.ToString()); return(0); } }
void LoadPlanes() { if (planes == null) { int len = _planes.Length; planes = new UnityEngine.Plane[len]; for (int i = 0; i < len; i++) { BSPFileParser.Plane p = _planes[i]; // Notice: Convert Plane from right hand coordinate into left coordinate UnityEngine.Plane plane = new UnityEngine.Plane(new Vector3(p.normal[0], p.normal[1], p.normal[2]), p.dist); planes[i] = Right2Left(plane); } } }
protected Plane GetSelectedPlane() { const float distEpsilon = 0.2f; bool isFound; bool loopOnceIfPlaneNotFound = true; do { for (int idPlane = 0; idPlane < m_listPlane.Count; idPlane++) { isFound = true; Plane globalPlane = new Plane(transform.TransformPoint(m_listPlane[idPlane].normal), m_listPlane[idPlane].distance); foreach (var faceGO in m_selectedSlice) { if (Mathf.Abs(globalPlane.GetDistanceToPoint(faceGO.transform.position)) > distEpsilon) { isFound = false; break; } } if (isFound) { #if UNITY_EDITOR if (m_drawSelectedPlane) { drawDebugPlane(globalPlane); } #endif currentPlaneSelectedID = idPlane; return(globalPlane); } } loopOnceIfPlaneNotFound = false; RefreachPrescisionCube(); RefreachPrecisionPlane(); Debug.LogWarning("Cube or plane corruption"); } while (loopOnceIfPlaneNotFound); Debug.LogError("Cube still corrupted after plane and cube refreach"); Restart(); return(new Plane()); }