コード例 #1
0
        private void Start()
        {
            sidesForPyramids = new List <AbstractPolygon>();
            myPyramids       = new List <DependentPyramid>();

            myPrism = GeoObjConstruction.iPrism(GeoObjConstruction.rPoly(nSides, apothem, Vector3.ProjectOnPlane(this.transform.position, Vector3.up) + Vector3.up * height1), Vector3.ProjectOnPlane(this.transform.position, Vector3.up) + Vector3.up * height2);
            myPrism.LeapInteraction = false;
            foreach (AbstractLineSegment mgo in myPrism.allEdges)
            {
                mgo.LeapInteraction = false;
            }
            foreach (AbstractPolygon mgo in myPrism.allfaces)
            {
                mgo.LeapInteraction = false;
                foreach (AbstractPoint mgol2 in mgo.pointList)
                {
                    mgol2.LeapInteraction = false;
                }
            }
            foreach (AbstractPolygon side in myPrism.sides)
            {
                sidesForPyramids.Add(side);
            }
            sidesForPyramids.Add(myPrism.bases[0]);

            myApex = GeoObjConstruction.iPoint(Vector3.ProjectOnPlane(this.transform.position, Vector3.up) + Vector3.up * height2);

            //restrict the movement of myApex.
            flatface1 = flatlandSurface.Constructor();
            flatface1.GetComponent <MeshRenderer>().materials[0].color = Color.clear;
            flatface1.attachedObjs.Add(myApex);

            foreach (AbstractPolygon side in sidesForPyramids)
            {
                myPyramids.Add(GeoObjConstruction.dPyramid(side, myApex));
            }

            for (int i = 0; i < myPyramids.Count; i++)
            {
                foreach (AbstractPolygon face in myPyramids[i].allfaces)
                {
                    face.figColor        = mgoColor[i];
                    face.LeapInteraction = false;
                }
                foreach (AbstractLineSegment line in myPyramids[i].allEdges)
                {
                    line.LeapInteraction = false;
                }
                foreach (AbstractPoint point in myPyramids[i].basePolygon.pointList)
                {
                    point.LeapInteraction = false;
                }
            }
            foreach (DependentPyramid pyramid in myPyramids)
            {
                pyramid.GetComponent <InteractionBehaviour>().OnHoverBegin += updateGlow;
                pyramid.GetComponent <InteractionBehaviour>().OnHoverEnd   += updateGlow;
            }
        }
コード例 #2
0
        private void Start()
        {
            myPrism = GeoObjConstruction.iPrism(GeoObjConstruction.rPoly(nSides, Mathf.Abs(height1 - height2) / 2f, Vector3.ProjectOnPlane(this.transform.position, Vector3.up) + Vector3.up * height1), Vector3.ProjectOnPlane(this.transform.position, Vector3.up) + Vector3.up * height2);
            myPrism.LeapInteraction = false;
            foreach (AbstractLineSegment mgo in myPrism.allEdges)
            {
                mgo.LeapInteraction = false;
            }
            foreach (AbstractPolygon mgo in myPrism.bases)
            {
                mgo.LeapInteraction = false;
                foreach (AbstractPoint mgol2 in mgo.pointList)
                {
                    mgol2.LeapInteraction = false;
                }
            }

            foreach (AbstractPolygon face in myPrism.allfaces)
            {
                face.figColor = mgoColor;
            }

            //pyramid 1 - base ABC - apex D
            myPyramids.Add(GeoObjConstruction.dPyramid(myPrism.bases[0], myPrism.bases[1].pointList[0]));

            //pyramid 2 - base DEF - apex C
            myPyramids.Add(GeoObjConstruction.dPyramid(myPrism.bases[1], myPrism.bases[0].pointList[2]));

            //pyramid 3 - base CBD - apex E
            myPyramids.Add(GeoObjConstruction.dPyramid(myPyramids[0].sides[1], myPrism.bases[1].pointList[1]));

            foreach (DependentPyramid pyramid in myPyramids)
            {
                pyramid.GetComponent <InteractionBehaviour>().OnHoverBegin += updateGlow;
                pyramid.GetComponent <InteractionBehaviour>().OnHoverEnd   += updateGlow;
            }
        }
コード例 #3
0
ファイル: XMLManager.cs プロジェクト: maine-imre/handwaver
        //[ContextMenu("Load from Save")] for debugging make public and uncomment
        private void xmlToMGO()
        {
            Dictionary <string, AbstractGeoObj> spawnedObjects = new Dictionary <string, AbstractGeoObj>();

            foreach (GeoObj geo in GeoObjDB.list)
            {
                switch (geo.type)
                {
                case GeoObjType.point:
                    AbstractGeoObj spawnedPoint = null;                            //initialzed as null so that cases that do not spawn still have it initialized but still fails a null check.
                    switch (geo.definition)
                    {
                    case GeoObjDef.Abstract:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    case GeoObjDef.Dependent:
                        spawnedPoint = GeoObjConstruction.dPoint(geo.position);
                        break;

                    case GeoObjDef.Interactable:
                        spawnedPoint = GeoObjConstruction.iPoint(geo.position);
                        break;

                    case GeoObjDef.Static:
                        spawnedPoint = GeoObjConstruction.sPoint(geo.position);
                        break;

                    case GeoObjDef.none:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    default:
                        break;
                    }
                    if (spawnedPoint != null)
                    {
                        if (!String.IsNullOrEmpty(geo.label))
                        {
                            GeoObjConstruction.label(spawnedPoint, geo.label);
                        }
                        spawnedObjects.Add(geo.figName, spawnedPoint);
                    }
                    break;

                case GeoObjType.line:
                    AbstractGeoObj spawnedLine = null;                            //initialzed as null so that cases that do not spawn still have it initialized but still fails a null check.
                    switch (geo.definition)
                    {
                    case GeoObjDef.Abstract:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    case GeoObjDef.Dependent:
                        spawnedLine = GeoObjConstruction.dLineSegment(spawnedObjects[geo.dependencies[0]] as AbstractPoint, spawnedObjects[geo.dependencies[1]] as AbstractPoint);
                        break;

                    case GeoObjDef.Interactable:
                        spawnedLine = GeoObjConstruction.iLineSegment(spawnedObjects[geo.dependencies[0]] as AbstractPoint, spawnedObjects[geo.dependencies[1]] as AbstractPoint);
                        break;

                    case GeoObjDef.Static:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    case GeoObjDef.none:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    default:
                        break;
                    }
                    if (spawnedLine != null)
                    {
                        if (!String.IsNullOrEmpty(geo.label))
                        {
                            GeoObjConstruction.label(spawnedLine, geo.label);
                        }
                        spawnedObjects.Add(geo.figName, spawnedLine);
                    }
                    break;

                case GeoObjType.polygon:
                    AbstractGeoObj             spawnedPoly = null;                //initialzed as null so that cases that do not spawn still have it initialized but still fails a null check.
                    List <AbstractLineSegment> lineList;
                    List <AbstractPoint>       pointList;
                    switch (geo.definition)
                    {
                    case GeoObjDef.Abstract:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    case GeoObjDef.Dependent:
                        lineList = new List <AbstractLineSegment>();
                        geo.dependencies.Where(d => spawnedObjects[d].figType == GeoObjType.line).ToList().ForEach(l => lineList.Add(spawnedObjects[l] as AbstractLineSegment));
                        pointList = new List <AbstractPoint>();
                        geo.dependencies.Where(d => spawnedObjects[d].figType == GeoObjType.point).ToList().ForEach(p => pointList.Add(spawnedObjects[p] as AbstractPoint));
                        spawnedPoly = GeoObjConstruction.dPolygon(lineList, pointList);
                        break;

                    case GeoObjDef.Interactable:
                        lineList = new List <AbstractLineSegment>();
                        geo.dependencies.Where(d => spawnedObjects[d].figType == GeoObjType.line).ToList().ForEach(l => lineList.Add(spawnedObjects[l] as AbstractLineSegment));
                        pointList = new List <AbstractPoint>();
                        geo.dependencies.Where(d => spawnedObjects[d].figType == GeoObjType.point).ToList().ForEach(p => pointList.Add(spawnedObjects[p] as AbstractPoint));
                        spawnedPoly = GeoObjConstruction.iPolygon(lineList, pointList);
                        break;

                    case GeoObjDef.Static:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    case GeoObjDef.none:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    default:
                        break;
                    }
                    if (spawnedPoly != null)
                    {
                        if (!String.IsNullOrEmpty(geo.label))
                        {
                            GeoObjConstruction.label(spawnedPoly, geo.label);
                        }
                        spawnedObjects.Add(geo.figName, spawnedPoly);
                    }
                    break;

                case GeoObjType.prism:
                    AbstractGeoObj spawnedPrism = null;                            //initialzed as null so that cases that do not spawn still have it initialized but still fails a null check.
                    switch (geo.definition)
                    {
                    case GeoObjDef.Abstract:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    case GeoObjDef.Dependent:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    case GeoObjDef.Interactable:
                        if (!(geo.prismData.bases.Count < 2 || geo.prismData.sides.Count < spawnedObjects[geo.prismData.bases[0]].GetComponent <AbstractPolygon>().pointList.Count))
                        {
                            List <AbstractPolygon> bases = new List <AbstractPolygon>();
                            List <AbstractPolygon> sides = new List <AbstractPolygon>();
                            geo.prismData.bases.ForEach(b => bases.Add(spawnedObjects[b] as AbstractPolygon));
                            geo.prismData.sides.ForEach(s => sides.Add(spawnedObjects[s] as AbstractPolygon));
                            spawnedPrism = GeoObjConstruction.iPrism(bases, sides);
                        }
                        else
                        {
                            List <AbstractLineSegment> edges = new List <AbstractLineSegment>();
                            geo.prismData.edges.ForEach(e => edges.Add(spawnedObjects[e] as AbstractLineSegment));
                            spawnedPrism = GeoObjConstruction.iPrism(edges);
                        }
                        break;

                    case GeoObjDef.Static:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    case GeoObjDef.none:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    default:
                        break;
                    }
                    if (spawnedPrism != null)
                    {
                        if (!String.IsNullOrEmpty(geo.label))
                        {
                            GeoObjConstruction.label(spawnedPrism, geo.label);
                        }
                        spawnedObjects.Add(geo.figName, spawnedPrism);
                    }
                    break;

                case GeoObjType.pyramid:
                    AbstractGeoObj spawnedPyramid = null;                            //initialzed as null so that cases that do not spawn still have it initialized but still fails a null check.

                    switch (geo.definition)
                    {
                    case GeoObjDef.Abstract:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    case GeoObjDef.Dependent:
                        spawnedPyramid = GeoObjConstruction.dPyramid(spawnedObjects[geo.dependencies[0]] as AbstractPolygon, spawnedObjects[geo.pyramidData.apexName] as AbstractPoint);
                        break;

                    case GeoObjDef.Interactable:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    case GeoObjDef.Static:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    case GeoObjDef.none:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    default:
                        break;
                    }
                    if (spawnedPyramid != null)
                    {
                        if (!String.IsNullOrEmpty(geo.label))
                        {
                            GeoObjConstruction.label(spawnedPyramid, geo.label);
                        }
                        spawnedObjects.Add(geo.figName, spawnedPyramid);
                    }
                    break;

                case GeoObjType.circle:
                    AbstractGeoObj spawnedCircle = null;                                    //initialzed as null so that cases that do not spawn still have it initialized but still fails a null check.
                    switch (geo.definition)
                    {
                    case GeoObjDef.Abstract:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    case GeoObjDef.Dependent:
                        spawnedCircle = GeoObjConstruction.dCircle(spawnedObjects[geo.dependencies[0]] as AbstractPoint, spawnedObjects[geo.dependencies[1]] as AbstractPoint, geo.circleData.normDir);
                        break;

                    case GeoObjDef.Interactable:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    case GeoObjDef.Static:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    case GeoObjDef.none:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    default:
                        break;
                    }
                    if (spawnedCircle != null)
                    {
                        if (!String.IsNullOrEmpty(geo.label))
                        {
                            GeoObjConstruction.label(spawnedCircle, geo.label);
                        }
                        spawnedObjects.Add(geo.figName, spawnedCircle);
                    }
                    break;

                case GeoObjType.sphere:
                    AbstractGeoObj spawnedSphere = null;                            //initialzed as null so that cases that do not spawn still have it initialized but still fails a null check.
                    switch (geo.definition)
                    {
                    case GeoObjDef.Abstract:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    case GeoObjDef.Dependent:
                        spawnedSphere = GeoObjConstruction.dSphere(spawnedObjects[geo.dependencies[0]] as AbstractPoint, spawnedObjects[geo.dependencies[1]] as AbstractPoint);
                        break;

                    case GeoObjDef.Interactable:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    case GeoObjDef.Static:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    case GeoObjDef.none:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    default:
                        break;
                    }
                    if (spawnedSphere != null)
                    {
                        if (!String.IsNullOrEmpty(geo.label))
                        {
                            GeoObjConstruction.label(spawnedSphere, geo.label);
                        }
                        spawnedObjects.Add(geo.figName, spawnedSphere);
                    }
                    break;

                case GeoObjType.revolvedsurface:
                    AbstractGeoObj spawnedrevSurf = null;                            //initialzed as null so that cases that do not spawn still have it initialized but still fails a null check.
                    switch (geo.definition)
                    {
                    case GeoObjDef.Abstract:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    case GeoObjDef.Dependent:
                        spawnedrevSurf = GeoObjConstruction.dRevSurface(spawnedObjects[geo.dependencies[0]] as AbstractPoint, spawnedObjects[geo.dependencies[1]] as AbstractLineSegment, geo.revSurfData.normDir);
                        spawnedrevSurf.transform.position = geo.position;
                        spawnedrevSurf.transform.rotation = geo.rotation;
                        break;

                    case GeoObjDef.Interactable:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    case GeoObjDef.Static:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    case GeoObjDef.none:
                        Debug.Log(geo.figName + " was attempted to spawn but is not supported yet within XMLManager script! Add construction function in place of this log.");
                        break;

                    default:
                        break;
                    }
                    if (spawnedrevSurf != null)
                    {
                        if (!String.IsNullOrEmpty(geo.label))
                        {
                            GeoObjConstruction.label(spawnedrevSurf, geo.label);
                        }
                        spawnedObjects.Add(geo.figName, spawnedrevSurf);
                    }
                    break;

                case GeoObjType.torus:
                    break;

                case GeoObjType.flatface:
                    Transform flatface = flatfaceBehave.Constructor().transform;
                    flatface.transform.position = geo.position;
                    flatface.transform.rotation = geo.rotation;
                    if (!String.IsNullOrEmpty(geo.label))
                    {
                        GeoObjConstruction.label(flatface.GetComponent <flatfaceBehave>(), geo.label);
                    }
                    spawnedObjects.Add(geo.figName, flatface.GetComponent <AbstractGeoObj>());
                    break;

                case GeoObjType.straightedge:
                    Transform straightEdge = straightEdgeBehave.Constructor().transform;
                    straightEdge.transform.position = geo.position;
                    straightEdge.transform.rotation = geo.rotation;
                    if (!String.IsNullOrEmpty(geo.label))
                    {
                        GeoObjConstruction.label(straightEdge.GetComponent <straightEdgeBehave>(), geo.label);
                    }
                    spawnedObjects.Add(geo.figName, straightEdge.GetComponent <AbstractGeoObj>());
                    break;

                default:
                    break;
                }
            }
        }
コード例 #4
0
        internal void Start()
        {
            shearingLabManager labMan = FindObjectOfType <shearingLabManager>();

            labMan.measurementDisplays.Add(surfaceAreaModel.transform);
            labMan.measurementDisplays.Add(volumeModel.transform);
            //labMan.measurementDisplays.Add(crossSectionModel.transform);
            labMan.disableDisplays();

            surfaceAreaModel.GetComponent <MeshRenderer>().materials[0].color  = mgoColor;
            volumeModel.GetComponent <MeshRenderer>().materials[0].color       = mgoColor;
            crossSectionModel.GetComponent <MeshRenderer>().materials[0].color = mgoColor;
            //copy into base scene on Load.
            //this.transform.parent = SceneManager.GetSceneByName("HandWaverBase").GetRootGameObjects()[0].transform.parent;

            //construct parallel planes

            flatface1 = flatlandSurface.Constructor();
            flatface2 = flatlandSurface.Constructor();

            flatface1.otherFlatlandSurface = flatface2;
            flatface2.otherFlatlandSurface = flatface1;

            flatface1.transform.localScale = new Vector3(3f, .0001f, 3f);
            flatface2.transform.localScale = new Vector3(3f, .0001f, 3f);

            AbstractPoint   apexPoint = GeoObjConstruction.iPoint(Vector3.ProjectOnPlane(this.transform.position, Vector3.up) + Vector3.up * height2);
            AbstractPolygon basePoly  = GeoObjConstruction.rPoly(nSides, .3f, Vector3.ProjectOnPlane(this.transform.position, Vector3.up) + Vector3.up * height1);

            myPyramid = GeoObjConstruction.dPyramid(basePoly, apexPoint);

            foreach (AbstractLineSegment line in myPyramid.allEdges)
            {
                line.LeapInteraction = false;
            }
            foreach (AbstractPoint point in basePoly.pointList)
            {
                point.LeapInteraction = false;
                flatface1.attachedObjs.Add(point);
            }
            foreach (AbstractPolygon face in myPyramid.allfaces)
            {
                face.LeapInteraction = false;
            }
            flatface2.attachedObjs.Add(apexPoint);
            flatface2.attachedObjs.Add(basePoly);

            myPyramid.GetComponent <InteractionBehaviour>().enabled = false;

            mf.transform.position   = Vector3.zero;
            mf.transform.localScale = Vector3.one;
            mf.transform.rotation   = Quaternion.identity;

            palmDetectors = GetComponentsInChildren <PalmDirectionDetector>();

            //NATHAN HELP ME HERE
            for (int i = 0; i < palmDetectors.Length; i++)
            {
                PalmDirectionDetector palm = palmDetectors[i];

                palm.OnActivate.AddListener(startUpdateMesh);
                palm.OnDeactivate.AddListener(endUpdateMesh);

                ExtendedFingerDetector finger = palm.GetComponent <ExtendedFingerDetector>();

                finger.OnDeactivate.AddListener(endUpdateMesh);
                //the extended finger detectors are set to enable/disable the respective PalmDirectionDetectors.

                switch (i)
                {
                case 0:
                    palm.HandModel   = leapHandDataLogger.ins.currHands.Lhand_rigged;
                    finger.HandModel = leapHandDataLogger.ins.currHands.Lhand_rigged;
                    break;

                case 1:
                    palm.HandModel   = leapHandDataLogger.ins.currHands.RHand_rigged;
                    finger.HandModel = leapHandDataLogger.ins.currHands.RHand_rigged;
                    break;

                default:
                    break;
                }
            }

            updateMesh = updateMeshRoutine();
            if (overrideHandInput)
            {
                startUpdateMesh();
            }

            foreach (AbstractPolygon face in myPyramid.allfaces)
            {
                face.figColor = mgoColor;
            }

            myPyramid.apex.GetComponent <InteractionBehaviour>().OnGraspEnd += constantVelOutOfRange;
            labMan.addApexToList(myPyramid.apex);
        }