// Pass in the render texture camera
        public ClipPlaneManager(Camera cam)
        {
            //Debug.Log("Cam name = " + cam.name);

            pos     = cam.transform.position;
            up      = cam.transform.up;
            forward = cam.transform.forward;
            right   = cam.transform.right;

            deg         = cam.fieldOfView / 2;
            dis         = cam.farClipPlane;
            hypotenuse  = dis / Mathf.Cos(Mathf.Deg2Rad * deg);
            opposite    = Mathf.Sin(Mathf.Deg2Rad * deg) * hypotenuse;
            nearClipDis = cam.nearClipPlane;
            aspect      = cam.aspect;

            //Debug.Log("Right vector is " + right);
            //Debug.Log("Up vector is " + up);
            //Debug.Log("Opposite is " + opposite);
            //Debug.Log("Degree is " + deg);
            //Debug.Log("Distance is " + dis);
            //Debug.Log("Hypotenuse is " + hypotenuse);

            //Debug.Log("ClipPlane Corner00 = " + calc00());
            //Debug.Log("ClipPlane Corner01 = " + calc01());
            //Debug.Log("ClipPlane Corner10 = " + calc10());
            //Debug.Log("ClipPlane Corner11 = " + calc11());

            clipPlane = new PlaneRect(calc00(), calc11(), -forward, false);
        }
        public void UpdateInfo(Camera cam)
        {
            pos     = cam.transform.position;
            up      = cam.transform.up;
            forward = cam.transform.forward;
            right   = cam.transform.right;

            deg         = cam.fieldOfView / 2;
            dis         = cam.farClipPlane;
            hypotenuse  = dis / Mathf.Cos(Mathf.Deg2Rad * deg);
            opposite    = Mathf.Sin(Mathf.Deg2Rad * deg) * hypotenuse;
            nearClipDis = cam.nearClipPlane;
            aspect      = cam.aspect;

            //Debug.Log("Right vector is " + right);
            //Debug.Log("Up vector is " + up);
            //Debug.Log("Opposite is " + opposite);
            //Debug.Log("Degree is " + deg);
            //Debug.Log("Distance is " + dis);
            //Debug.Log("Hypotenuse is " + hypotenuse);

            clipPlane = new PlaneRect(calc00(), calc11(), -forward, false);
            //Debug.Log("deg = " + deg);
            //Debug.Log("New planeRect 00 = " + calc00());
            //Debug.Log("New planeRect 11 = " + calc11());
            //Debug.Log("opp = " + opposite);
        }
Exemplo n.º 3
0
 public PlaneRect(PlaneRect pr)
 {
     this.p00 = pr.p00;
     this.p01 = pr.p01;
     this.p10 = pr.p10;
     this.p11 = pr.p11;
 }
Exemplo n.º 4
0
 public void CopyTo(PlaneRect pr)
 {
     pr.p00 = this.p00;
     pr.p01 = this.p01;
     pr.p11 = this.p11;
     pr.p10 = this.p10;
 }
        /// <summary>
        /// Generates a new plane from a given plane by shrinking the corners in
        /// to each other. This assumes a flat, level plane.
        /// </summary>
        /// <param name="plane"></param>
        /// <returns></returns>
        public PlaneRect ShrinkPlaneRect(PlaneRect plane, float shrinkFactor)
        {
            // Generate diagonal vectors for shrinking points
            Vector3 ULtoLR = plane.Corner10 - plane.Corner01;
            Vector3 LRtoUL = -ULtoLR;
            Vector3 LLtoUR = plane.Corner11 - plane.Corner00;
            Vector3 URtoLL = -LLtoUR;

            // Adjust the points that will make the new plane
            Vector3 newLL = plane.Corner00 + LLtoUR * shrinkFactor;
            Vector3 newUL = plane.Corner01 + ULtoLR * shrinkFactor;
            Vector3 newUR = plane.Corner11 + URtoLL * shrinkFactor;
            Vector3 newLR = plane.Corner10 + LRtoUL * shrinkFactor;

            // Make the new plane
            PlaneRect newPlane = new PlaneRect(newLL, newUL, newUR, newLR);

            Debug.Log("Shrunken plane LL = " + newLL);
            Debug.Log("Original plane LL = " + plane.Corner00);
            Debug.Log("Shrunken plane UL = " + newUL);
            Debug.Log("Original plane UL = " + plane.Corner01);
            Debug.Log("Shrunken plane UR = " + newUR);
            Debug.Log("Original plane UR = " + plane.Corner11);
            Debug.Log("Shrunken plane LR = " + newLR);
            Debug.Log("Original plane LR = " + plane.Corner10);

            return(newPlane);
        }
Exemplo n.º 6
0
        public static Vector2 UV(PlaneRect canvas, Vector3 pointOnCanvas)
        {
            Vector3 rightComp = pointOnCanvas - canvas.Corner00;
            float   dot       = Vector3.Dot(rightComp, canvas.Right);
            float   u         = dot / canvas.width;
            Vector3 upComp    = pointOnCanvas - canvas.Corner00;

            dot = Vector3.Dot(upComp, canvas.Up);
            float v = dot / canvas.height;

            return(new Vector2(u, v));
        }
        public void Init()
        {
            //Debug.Log("Viewing cam clip plane corner01 = " + viewingCamManager.ViewingCameras[0].GetComponent<ClipPlaneManager>().ClipRect.Corner01);
            //Debug.Log("Clip planes array corner10 = " + viewingCamManager.ClipPlanes[0].clipPlane.Corner10);

            PlaneRect  pr = GenerateAggregatePlaneRect();
            GameObject go = GenerateAggregateClipPlaneObject(pr);

            go.transform.parent = gameObject.transform;
            InvokeRepeating("RefreshShaderInfo", 1.0f, 2.0f);
            //Invoke("RefreshShaderInfo", 2.0f);
        }
        public Mesh GeneratePlaneMesh(PlaneRect plane)
        {
            if (plane != null)
            {
                Mesh planeMesh = new Mesh();

                // Set mesh vertices
                List <Vector3> meshVertices = new List <Vector3>();
                meshVertices.Add(plane.Corner00); // lower left
                meshVertices.Add(plane.Corner01); // upper left
                meshVertices.Add(plane.Corner11); // upper right
                meshVertices.Add(plane.Corner10); // lower right

                //Debug.Log("Plane corner 00 = " + plane.Corner00);
                //Debug.Log("Plane corner 01 = " + plane.Corner01);
                //Debug.Log("Plane corner 11 = " + plane.Corner11);
                //Debug.Log("Plane corner 10 = " + plane.Corner10);

                // Set mesh triangles
                int[] meshTriangles = new int[6];
                meshTriangles[0] = 0;
                meshTriangles[1] = 1;
                meshTriangles[2] = 2;
                meshTriangles[3] = 0;
                meshTriangles[4] = 2;
                meshTriangles[5] = 3;

                planeMesh.SetVertices(meshVertices);
                planeMesh.SetTriangles(meshTriangles, 0);

                // Set the uv values
                List <Vector2> uvs = new List <Vector2>();
                uvs.Add(new Vector2(0, 0));
                uvs.Add(new Vector2(0, 1));
                uvs.Add(new Vector2(1, 1));
                uvs.Add(new Vector2(1, 0));
                //planeMesh.uv = uvs.ToArray();
                planeMesh.SetUVs(0, uvs);
                planeMesh.SetUVs(1, uvs);

                planeMesh.name = "PlaneMesh";

                return(planeMesh);
            }
            else
            {
                Debug.LogError("Plane not created properly. Cannot construct plane mesh.");
                return(cubeMesh);
            }
        }
        /// <summary>
        /// Impossible to fix with current implementation without tearing down the project and starting over. It seems that the representative plane constructed in teh viewing camera's uvcalc script is causing UV calculations to go awry. If we pushed the representative plane to be back as far as the main camera's interpolated plane, this should calculate correctly. However, I don't know what else this will mess up in my project's logic.
        /// </summary>
        public void AdjustViewingCams()
        {
            int numChildren = AggregateClipPlane.transform.childCount;

            if (numChildren.Equals(1) &&
                AggregateClipPlane.transform.GetChild(0).gameObject.name.Equals(AggregateClipPlane.GetComponent <AggregateClipPlane>().PlaneName))
            {
                for (int i = 0; i < viewingCamManager.ViewingCameras.Length; i++)
                {
                    GameObject viewingCam = viewingCamManager.ViewingCameras[i];
                    Camera     mainCam    = MainCamera.GetComponent <Camera>();

                    //float mainCamPointOnPlane = (mainCam.transform.position + mainCam.transform.forward * mainCam.farClipPlane).x;
                    PlaneRect viewingClipPlane = viewingCam.GetComponent <ClipPlaneManager>().ClipRect;
                    //float oppositeOrig = Mathf.Abs(viewingClipPlane.Corner00.x - viewingClipPlane.center.x);
                    float oppositeOrig = oppositeOrigs[i];

                    Ray ray = new Ray(viewingCam.transform.position, viewingCam.transform.forward);

                    GameObject     interpolatedPlane = AggregateClipPlane.transform.GetChild(0).gameObject;
                    DebugPlaneRect dpr = interpolatedPlane.GetComponent <DebugPlaneRect>();

                    RaycastHit hit         = dpr.Intersect(ray, viewingCam.transform.position);
                    float      adjacentNew = Mathf.Abs((hit.point - viewingCam.transform.position).magnitude);

                    float theta = (Mathf.Tan(oppositeOrig / adjacentNew) * Mathf.Rad2Deg) * 2;

                    if (theta != viewingCam.GetComponent <Camera>().fieldOfView)
                    {
                        //Debug.Log("Original opposite = " + oppositeOrig);
                        //Debug.Log("Intersect hits at " + hit.point);
                        Debug.Log("New adjacent value = " + adjacentNew);
                        //Debug.Log("orig theta = " + viewingCam.GetComponent<Camera>().fieldOfView);
                        Debug.Log("new theta = " + theta);

                        //Debug.Log("Updating camera for " + viewingCam.name);
                    }
                    viewingCam.GetComponent <Camera>().fieldOfView = theta;
                    viewingCam.GetComponent <ClipPlaneManager>().UpdateInfo(viewingCam.GetComponent <Camera>());
                }
            }
        }
Exemplo n.º 10
0
        int IComparer <ClipPlaneManager> .Compare(ClipPlaneManager x, ClipPlaneManager y)
        {
            PlaneRect xRect = x.clipPlane;
            PlaneRect yRect = y.clipPlane;

            if (xRect.Corner00.x < yRect.Corner00.x)
            {
                return(-1);
            }
            else if (xRect.Corner00.x == yRect.Corner00.x)
            {
                if (xRect.center.x < yRect.Corner00.x)
                {
                    return(-1);
                }
                else if (xRect.center.x == yRect.Corner00.x)
                {
                    return(0);
                }
                else
                {
                    return(1);
                }
            }
            else
            {
                return(1);
            }

            //if(xRect.center.x > yRect.center.x)
            //{
            //    return 1;
            //}
            //else if(xRect.center.x < yRect.center.x)
            //{
            //    return 1;
            //}
            //else
            //{
            //    return 0;
            //}
        }
        public void Init()
        {
            SetMinMax();

            GameObject mainCam = AggregateClipPlane.GetComponent <AggregateClipPlane>().MainCamera;

            origCamPos = new Vector3(mainCam.transform.position.x, mainCam.transform.position.y, mainCam.transform.position.z);

            PosX.value = origCamPos.x;
            PosY.value = origCamPos.y;
            PosZ.value = origCamPos.z;
            //Rotation.value = 0;



            int numChildren = AggregateClipPlane.transform.childCount;

            if (numChildren.Equals(1) &&
                AggregateClipPlane.transform.GetChild(0).gameObject.name.Equals(AggregateClipPlane.GetComponent <AggregateClipPlane>().PlaneName))
            {
                GameObject     interpolatedPlane = AggregateClipPlane.transform.GetChild(0).gameObject;
                DebugPlaneRect dpr       = interpolatedPlane.GetComponent <DebugPlaneRect>();
                Vector3        planeCent = dpr.Center;

                origCent = new Vector3(
                    planeCent.x,
                    planeCent.y,
                    planeCent.z);

                Debug.Log("origCent = " + origCent);


                origViewingCamDistanceRatios = new List <Vector3>();
                for (int i = 0; i < viewingCamManager.ViewingCameras.Length; i++)
                {
                    Vector3    simOrigCamPos = origCamPos - new Vector3(0, 0, -10);
                    GameObject viewingCam    = viewingCamManager.ViewingCameras[i];
                    Ray        r             = new Ray(simOrigCamPos, viewingCam.transform.position - simOrigCamPos);
                    Vector3    pos           = viewingCam.GetComponent <UVCalc>().IntersectRepresentativePlane(r, simOrigCamPos).point;
                    Ray        camRay        = new Ray(simOrigCamPos, mainCam.transform.forward);
                    Vector3    camPos        = interpolatedPlane.GetComponent <UVCalc>().IntersectRepresentativePlane(camRay, simOrigCamPos).point;
                    float      ratioX        = (viewingCam.transform.position.x - camPos.x) / (pos.x - camPos.x);
                    float      ratioY        = (viewingCam.transform.position.y - camPos.y) / (pos.y - camPos.y);
                    origViewingCamDistanceRatios.Add(new Vector3(ratioX, ratioY, 0));
                }
            }
            else
            {
                origCent = new Vector3(
                    origCamPos.x,
                    origCamPos.y,
                    mainCam.GetComponent <Camera>().farClipPlane);

                Debug.Log("origCent = " + origCent);
            }

            origObjScales = new List <Vector3>();
            for (int i = 0; i < WorldObjectParent.transform.childCount; i++)
            {
                origObjScales.Add(WorldObjectParent.transform.GetChild(i).transform.localScale);
            }

            origCamPosList = new List <Vector3>();
            for (int i = 0; i < viewingCamManager.ViewingCameras.Length; i++)
            {
                origCamPosList.Add(viewingCamManager.ViewingCameras[i].transform.position);
            }

            oppositeOrigs = new List <float>();
            for (int i = 0; i < viewingCamManager.ViewingCameras.Length; i++)
            {
                PlaneRect viewingClipPlane = viewingCamManager.ViewingCameras[i].GetComponent <ClipPlaneManager>().ClipRect;
                Camera    viewingCamCam    = viewingCamManager.ViewingCameras[i].GetComponent <Camera>();
                float     oppositeOrig     = Mathf.Abs(viewingClipPlane.Corner00.x - viewingClipPlane.center.x);
                oppositeOrigs.Add(oppositeOrig / viewingCamCam.aspect);

                Debug.Log("Corner00x = " + viewingClipPlane.Corner00.x);
                Debug.Log("centerx = " + viewingClipPlane.center.x);
            }


            //int numChildren = AggregateClipPlane.transform.childCount;
            //if(numChildren.Equals(1)
            //    && AggregateClipPlane.transform.GetChild(0).gameObject.name.Equals(AggregateClipPlane.GetComponent<AggregateClipPlane>().PlaneName))
            //{

            //}
            //else
            //{
            //}

            XField.text = PosX.value.ToString();
            YField.text = PosY.value.ToString();
            ZField.text = PosZ.value.ToString();
            //RotField.text = Rotation.value.ToString();

            initialized = true;
        }
Exemplo n.º 12
0
        public Vector2[] GenerateUV(int camIndex)
        {
            // Assumes LL, UL, UR, LR
            Vector2[]  UVs        = new Vector2[4];
            GameObject viewingCam = viewingCamManager.ViewingCameras[camIndex];
            UVCalc     uvCalc     = viewingCam.GetComponent <UVCalc>();
            //ClipPlaneManager viewingCamClipPlane = viewingCamManager.ClipPlanes[camIndex];
            //Vector3 origin = MainCamera.transform.position;
            Vector3 origin = viewingCam.transform.position;

            //PlaneRect aggregatePlane = aggregateClipPlane.GetComponent<AggregateClipPlane>().GenerateAggregatePlaneRect(viewingCamManager.ClipPlanes);
            Vector3[] aggregatePlaneVertices;
            bool      interpolatedPlaneInitialized =
                aggregateClipPlane.transform.childCount == 1 &&
                aggregateClipPlane.transform.GetChild(0).name.Equals(aggregateClipPlane.GetComponent <AggregateClipPlane>().PlaneName);

            if (interpolatedPlaneInitialized)
            {
                GameObject     interpolatedPlane = aggregateClipPlane.transform.GetChild(0).gameObject;
                DebugPlaneRect dpr = interpolatedPlane.GetComponent <DebugPlaneRect>();
                aggregatePlaneVertices = new Vector3[4]
                {
                    dpr.LowerLeft,
                    dpr.UpperLeft,
                    dpr.UpperRight,
                    dpr.LowerRight
                };

                //Debug.Log("Taking UV values from Interpolated plane debug plane rectangle.");
            }
            else
            {
                PlaneRect aggregatePlane = aggregateClipPlane.GetComponent <AggregateClipPlane>().GenerateAggregatePlaneRect();
                aggregatePlaneVertices = new Vector3[4]
                {
                    aggregatePlane.Corner00,
                    aggregatePlane.Corner01,
                    aggregatePlane.Corner11,
                    aggregatePlane.Corner10
                };

                Debug.Log("Taking UV values from uninitialized plane calculations.");
            }

            //Debug.Log("aggregatePlaneVertices[0] = " + aggregatePlaneVertices[0]);
            //Debug.Log("aggregatePlaneVertices[1] = " + aggregatePlaneVertices[1]);
            //Debug.Log("aggregatePlaneVertices[2] = " + aggregatePlaneVertices[2]);
            //Debug.Log("aggregatePlaneVertices[3] = " + aggregatePlaneVertices[3]);

            // Calculate the UV values of the aggregate plane in terms of the
            // UV for the clip plane of the given viewing camera clip plane.
            // This makes it so that the four corners of the aggregate plane
            // can be passed in as UV values and compared to each of the
            // textures in the texture array to determine easily if a given uv
            // value for the aggregate plane corresponds to a point on any of
            // the independent texture planes
            //Vector2 LL = uvCalc.UVOffCanvas(origin, viewingCamClipPlane.clipPlane.Corner00);
            //Vector2 UL = uvCalc.UVOffCanvas(origin, viewingCamClipPlane.clipPlane.Corner01);
            //Vector2 UR = uvCalc.UVOffCanvas(origin, viewingCamClipPlane.clipPlane.Corner11);
            //Vector2 LR = uvCalc.UVOffCanvas(origin, viewingCamClipPlane.clipPlane.Corner10);
            Vector2 LL = uvCalc.UVOffCanvas(origin, aggregatePlaneVertices[0]); // lower left
            Vector2 UL = uvCalc.UVOffCanvas(origin, aggregatePlaneVertices[1]); // upper left
            Vector2 UR = uvCalc.UVOffCanvas(origin, aggregatePlaneVertices[2]); // upper right
            Vector2 LR = uvCalc.UVOffCanvas(origin, aggregatePlaneVertices[3]); // lower right

            UVs[0] = LL;
            UVs[1] = UL;
            UVs[2] = UR;
            UVs[3] = LR;

            // update values shown on uvCalc script of viewing camera
            uvCalc.LowerLeft  = LL;
            uvCalc.UpperLeft  = UL;
            uvCalc.UpperRight = UR;
            uvCalc.LowerRight = LR;

            return(UVs);
        }
 public void AssociatePlaneRect(PlaneRect pr)
 {
     this.planeRect = pr;
     Debug.Log("Plane Rect associated! Center = " + Center);
 }
        // NOTE: If generating dynamic aggregate clip plane as originally intended, InterpolationManager's GenerateUV needs to call this instead of GenerateAggregatePlaneRect
        public PlaneRect GenerateAggregatePlaneRect(ClipPlaneManager[] clipPlanes)//, out Vector3 pos, out Vector3 forward)
        {
            // NOTE: If generating dynamic aggregate clip plane as originally intended, InterpolationManager's GenerateUV needs to call this instead of GenerateAggregatePlaneRect

            // Adjust all clipPlanes and viewing cameras to be in their starting position
            // ERROR TESTING
            // This is a bit of a hack to circumvent an issue encountered in ViewingCamManager in InitViewingCameras
            for (int i = 0; i < viewingCamManager.ViewingCameras.Length; i++)
            {
                GameObject       viewingCam = viewingCamManager.ViewingCameras[i];
                ClipPlaneManager clipPlane  = viewingCam.GetComponent <ClipPlaneManager>();
                // ERROR TESTING - this fix doesn't work either...
                //viewingCam.transform.Translate(viewingCamManager.CamStartingPositions[i]);
                //clipPlane.transform.Translate(viewingCamManager.CamStartingPositions[i]);
            }

            if (clipPlanes != null &&
                clipPlanes.Length > 0)
            {
                List <ClipPlaneManager> clipPlaneList    = ClipPlaneManager.SortClipPlanes(clipPlanes);
                ClipPlaneManager[]      sortedClipPlanes = clipPlaneList.ToArray();

                // Assumes all planes exist in the same plane and that they
                // are all horizontally aligned
                float leftX   = sortedClipPlanes[0].clipPlane.Corner00.x;
                float rightX  = sortedClipPlanes[0].clipPlane.Corner01.x;
                float bottomY = sortedClipPlanes[0].clipPlane.Corner00.y;
                float topY    = sortedClipPlanes[0].clipPlane.Corner10.y;
                float z       = sortedClipPlanes[0].clipPlane.Corner00.z;

                //Debug.Log("Sorted clip planes length = " + sortedClipPlanes.Length);
                //Debug.Log("Sorted clip planes:");
                //Debug.Log("Sorted clip planes[0] corner00 = " + sortedClipPlanes[0].clipPlane.Corner00);
                //Debug.Log("Sorted clip planes[0] corner01 = " + sortedClipPlanes[0].clipPlane.Corner01);
                //Debug.Log("Sorted clip planes[0] corner11 = " + sortedClipPlanes[0].clipPlane.Corner11);
                //Debug.Log("Sorted clip planes[0] corner10 = " + sortedClipPlanes[0].clipPlane.Corner10);

                //Debug.Log("Unsorted clip planes[0] corner00 = " + clipPlanes[0].clipPlane.Corner00);
                //Debug.Log("Unsorted clip planes[0] corner01 = " + clipPlanes[0].clipPlane.Corner01);
                //Debug.Log("Unsorted clip planes[0] corner11 = " + clipPlanes[0].clipPlane.Corner11);
                //Debug.Log("Unsorted clip planes[0] corner10 = " + clipPlanes[0].clipPlane.Corner10);

                for (int i = 0; i < sortedClipPlanes.Length; i++)
                {
                    Vector3[] corners = new Vector3[4] {
                        sortedClipPlanes[i].clipPlane.Corner00,
                        sortedClipPlanes[i].clipPlane.Corner01,
                        sortedClipPlanes[i].clipPlane.Corner11,
                        sortedClipPlanes[i].clipPlane.Corner10
                    };

                    foreach (Vector3 corner in corners)
                    {
                        if (corner.x < leftX)
                        {
                            leftX = corner.x;
                            //Debug.Log(sortedClipPlanes[i].gameObject.name + "replaced leftX with: " + corner.x + " (" + corner + ")");
                        }
                        if (corner.x > rightX)
                        {
                            rightX = corner.x;
                            //Debug.Log(sortedClipPlanes[i].gameObject.name + "replaced rightX with: " + corner.x + " (" + corner + ")");
                        }
                        if (corner.y < bottomY)
                        {
                            bottomY = corner.y;
                            //Debug.Log(sortedClipPlanes[i].gameObject.name + "replaced bottomY with: " + corner.y + " (" + corner + ")");
                        }
                        if (corner.y > topY)
                        {
                            topY = corner.y;
                            //Debug.Log(sortedClipPlanes[i].gameObject.name + "replaced topY with: " + corner.y + " (" + corner + ")");
                        }
                    }
                }

                PlaneRect newPlane = new PlaneRect(
                    new Vector3(leftX, bottomY, z), // lower left
                    new Vector3(leftX, topY, z),    // upper left
                    new Vector3(rightX, topY, z),   // upper right
                    new Vector3(rightX, bottomY, z) // lower right
                    );

                //int farRightIndex = sortedClipPlanes.Length - 1;
                //int farLeftIndex = 0;
                //ClipPlaneManager farLeft = sortedClipPlanes[farLeftIndex];
                //ClipPlaneManager farRight = sortedClipPlanes[farRightIndex];
                //PlaneRect newPlane = new PlaneRect(
                //    farLeft.ClipRect.Corner00, // lower left
                //    farLeft.ClipRect.Corner01, // upper left
                //    farRight.ClipRect.Corner11, // upper right
                //    farRight.ClipRect.Corner10  // lower right
                //    );

                //Debug.Log("Far Left C00 = " + farLeft.ClipRect.Corner00);
                //Debug.Log("Far Left C01 = " + farLeft.ClipRect.Corner01);
                //Debug.Log("Far Right C11 = " + farRight.ClipRect.Corner11);
                //Debug.Log("Far Right C10 = " + farRight.ClipRect.Corner10);

                //Debug.Log("New Plane Corner00 = " + newPlane.Corner00);
                //Debug.Log("New Plane Corner01 = " + newPlane.Corner01);
                //Debug.Log("New Plane Corner11 = " + newPlane.Corner11);
                //Debug.Log("New Plane Corner10 = " + newPlane.Corner10);

                // Generate a slightly shrunken plane for our purposes
                PlaneRect shrunkenPlane = ShrinkPlaneRect(newPlane, PlaneShrinkFactor);

                //// Form anchor for new plane (as if the image was projected from
                //// a camera at this point)
                //pos = farLeft.pos + ((farRight.pos - farLeft.pos) / 2.0f);
                //// ERROR TESTING - THIS NEEDS TO BE ADJUSTED TO ACCOUNT FOR STATES WHERE THE FORWARD DIRECTIONS ARE NOT THE SAME.
                //forward = farLeft.forward;

                return(shrunkenPlane);
            }
            else
            {
                //pos = Vector3.zero;
                //forward = new Vector3(0, 0, 1);
                return(null);
            }
        }
        public GameObject GenerateAggregateClipPlaneObject(PlaneRect planeRect)
        {
            GameObject interpolatedPlane = new GameObject();

            // Generate the plane rectangle
            Vector3 pos;
            Vector3 forward;
            //PlaneRect planeRect = GenerateAggregatePlaneRect(clipPlanes, out pos, out forward);
            //PlaneRect planeRect = GenerateAggregatePlaneRect(clipPlanes);
            DebugPlaneRect dpr = interpolatedPlane.AddComponent <DebugPlaneRect>(); // Allows for easy access to see where the

            dpr.SetCorners(planeRect.Corner00, planeRect.Corner01, planeRect.Corner11, planeRect.Corner10);
            dpr.AssociatePlaneRect(planeRect);

            // Add UVCalc script for easier UI control access and intersection calculation later
            var uvCalc = interpolatedPlane.AddComponent <UVCalc>();

            uvCalc.SetRepresentativePlane(MainCamera.GetComponent <Camera>());

            // Generate the mesh and object for the plane
            Mesh planeMesh = GeneratePlaneMesh(planeRect);
            var  mf        = interpolatedPlane.AddComponent <MeshFilter>();

            mf.mesh = planeMesh;
            var mr = interpolatedPlane.AddComponent <MeshRenderer>();

            // Set material
            Material planeMat = GeneratePlaneMaterial();

            mr.material = planeMat;

            // Assign meta attributes
            interpolatedPlane.name  = PlaneName;
            interpolatedPlane.layer = LayerManager.GetLayerMask(CloakLayers.TableView);

            // Adjust position and orientation of generated plane object
            // (Make it face the user (the forward used is the forward
            // of the other clip plane cameras to the clip planes.
            // The forward for this object has to be from the plane to
            // the "camera" it is associated with))
            //aggregateClipPlane.transform.forward = -forward;
            //aggregateClipPlane.transform.position = pos + forward.normalized * FarClipDistance;
            interpolatedPlane.transform.position += -interpolatedPlane.transform.forward.normalized * PlanePullDistance; // -forward.normalized * 3.0f

            //Debug.Log("Aggregate calculated pos = " + aggregateClipPlane.transform.position);

            // set initialization flag appropriately
            if (planeRect != null &&
                planeMesh != null &&
                planeMat != null)
            {
                Debug.Log("Aggregate Clip Plane initialized");
                initialized = true;
            }
            else
            {
                GameObject.Destroy(interpolatedPlane);
            }

            return(interpolatedPlane);
        }