Exemplo n.º 1
0
    protected override void OnUpdate()
    {
        if (flag)
        {
            return;
        }

        flag = true;

        ComponentGroup planetGroup = GetComponentGroup(typeof(Planet), typeof(PlanetNoise));
        ComponentGroup dataGroup   = GetComponentGroup(typeof(PlanetSharedData));

        ComponentDataArray <Planet>                 planetArray = planetGroup.GetComponentDataArray <Planet>();
        ComponentDataArray <PlanetNoise>            noiseArray  = planetGroup.GetComponentDataArray <PlanetNoise>();
        SharedComponentDataArray <PlanetSharedData> dataArray   = dataGroup.GetSharedComponentDataArray <PlanetSharedData>();

        GameObject prefab = dataArray[0].nodePrefab;

        for (int i = 0; i < planetArray.Length; ++i)
        {
            Planet        planet = planetArray[i];
            PlanetNoise   noise  = noiseArray[i];
            HyperDistance r      = planet.radius;

            for (int n = 0; n < 20; ++n)
            {
                Entity      nodeEntity = EntityManager.Instantiate(prefab);
                TerrainNode node       = EntityManager.GetComponentData <TerrainNode>(nodeEntity);
                node.level        = 0;
                node.planetData   = planet;
                node.noiseData    = noise;
                node.built        = 0;
                node.divided      = 0;
                node.hyperDistant = 1;

                int idx = n * 3;
                node.corner1 = icoVerts[idx];
                node.corner2 = icoVerts[idx + 1];
                node.corner3 = icoVerts[idx + 2];
                EntityManager.SetComponentData(nodeEntity, node);

                HyperPosition pos = math.normalize(node.corner1 + node.corner2 + node.corner3) * r;

                PrecisePosition prspos = new PrecisePosition {
                    pos = pos.prs
                };
                EntityManager.SetComponentData(nodeEntity, prspos);

                OctantPosition octpos = new OctantPosition {
                    pos = pos.oct
                };
                EntityManager.SetComponentData(nodeEntity, octpos);
            }
        }
    }
Exemplo n.º 2
0
    private void Subdivide(Entity e, TerrainNode t, HPMeshInstanceRenderer r, PlanetSharedData d,
                           float parentPrcSubdivideDist, int parentOctSubdivideDist, float3 parentPrcCenter, int3 parentOctCenter)
    {
        Entity[]      entities = new Entity[4];
        TerrainNode[] nodes    = new TerrainNode[4];

        float3 corner0 = t.corner1;
        float3 corner1 = t.corner2;
        float3 corner2 = t.corner3;

        for (int i = 0; i < 4; ++i)
        {
            entities[i]            = EntityManager.Instantiate(d.nodePrefab);
            nodes[i]               = EntityManager.GetComponentData <TerrainNode>(entities[i]);
            nodes[i].level         = t.level + 1;
            nodes[i].planetData    = t.planetData;
            nodes[i].noiseData     = t.noiseData;
            nodes[i].built         = 0;
            nodes[i].divided       = 0;
            nodes[i].childrenBuilt = 0;
            nodes[i].parentEntity  = e;

            nodes[i].parentPreciseCenter        = parentPrcCenter;
            nodes[i].parentOctantCenter         = parentOctCenter;
            nodes[i].parentPreciseSubdivideDist = parentPrcSubdivideDist;
            nodes[i].parentOctantSubdivideDist  = parentOctSubdivideDist;
        }

        float3 mid01 = corner1 - corner0;

        mid01 = corner0 + math.normalize(mid01) * (math.length(mid01) / 2f);
        float3 mid02 = corner2 - corner0;

        mid02 = corner0 + math.normalize(mid02) * (math.length(mid02) / 2f);
        float3 mid12 = corner2 - corner1;

        mid12 = corner1 + math.normalize(mid12) * (math.length(mid12) / 2f);

        nodes[0].corner1 = corner0;
        nodes[0].corner2 = mid01;
        nodes[0].corner3 = mid02;

        nodes[1].corner1 = mid01;
        nodes[1].corner2 = corner1;
        nodes[1].corner3 = mid12;

        nodes[2].corner1 = mid02;
        nodes[2].corner2 = mid12;
        nodes[2].corner3 = corner2;

        nodes[3].corner1 = mid02;
        nodes[3].corner2 = mid01;
        nodes[3].corner3 = mid12;

        for (int i = 0; i < 4; ++i)
        {
            EntityManager.SetComponentData(entities[i], nodes[i]);

            HyperPosition pos = math.normalize(nodes[i].corner1 + nodes[i].corner2 + nodes[i].corner3) * t.planetData.radius;

            PrecisePosition prspos = new PrecisePosition {
                pos = pos.prs
            };
            EntityManager.SetComponentData(entities[i], prspos);

            OctantPosition octpos = new OctantPosition {
                pos = pos.oct
            };
            EntityManager.SetComponentData(entities[i], octpos);
        }

        t.divided = 1;
        t.built   = 0;

        EntityManager.SetComponentData(e, t);
    }
Exemplo n.º 3
0
    protected override void OnUpdate()
    {
        for (int i = meshCreationSets.Count - 1; i >= 0; --i)
        {
            if (meshCreationSets[i].jobHandle.IsCompleted)
            {
                meshCreationSets[i].jobHandle.Complete();

                if (EntityManager.Exists(meshCreationSets[i].entity))
                {
                    Mesh mesh = new Mesh();

                    mesh.vertices  = meshCreationSets[i].verts.ToArray();
                    mesh.triangles = meshCreationSets[i].tris.ToArray();
                    mesh.RecalculateNormals();

                    HPMeshInstanceRenderer r = EntityManager.GetSharedComponentData <HPMeshInstanceRenderer>(meshCreationSets[i].entity);

                    r.mesh = mesh;

                    EntityManager.SetSharedComponentData(meshCreationSets[i].entity, r);

                    TerrainNode node = EntityManager.GetComponentData <TerrainNode>(meshCreationSets[i].entity);

                    if (node.level != 0 && EntityManager.Exists(node.parentEntity))
                    {
                        TerrainNode parentNode = EntityManager.GetComponentData <TerrainNode>(node.parentEntity);

                        if (parentNode.divided == 1)
                        {
                            ++parentNode.childrenBuilt;
                            if (parentNode.childrenBuilt == 4)
                            {
                                HPMeshInstanceRenderer parentR = EntityManager.GetSharedComponentData <HPMeshInstanceRenderer>(node.parentEntity);
                                parentR.mesh = null;
                                EntityManager.SetSharedComponentData(node.parentEntity, parentR);
                            }

                            EntityManager.SetComponentData(node.parentEntity, parentNode);
                        }
                    }
                }

                meshCreationSets[i].verts.Dispose();
                meshCreationSets[i].tris.Dispose();

                meshCreationSets.RemoveAt(i);
            }
        }



        ComponentGroup nodeGroup = GetComponentGroup(typeof(TerrainNode), typeof(HPMeshInstanceRenderer), typeof(PrecisePosition), typeof(OctantPosition));
        ComponentGroup camGroup  = GetComponentGroup(typeof(Flycam), typeof(PrecisePosition), typeof(Rotation), typeof(OctantPosition));
        ComponentGroup dataGroup = GetComponentGroup(typeof(PlanetSharedData));

        SharedComponentDataArray <PlanetSharedData> planetDataArray = dataGroup.GetSharedComponentDataArray <PlanetSharedData>();

        PlanetSharedData[] dataArray = new PlanetSharedData[planetDataArray.Length];
        for (int i = 0; i < dataArray.Length; ++i)
        {
            dataArray[i] = planetDataArray[i];
        }

        EntityArray entityTempArray = nodeGroup.GetEntityArray();

        Entity[] entityArray = new Entity[entityTempArray.Length];
        for (int i = 0; i < entityArray.Length; ++i)
        {
            entityArray[i] = entityTempArray[i];
        }

        SharedComponentDataArray <HPMeshInstanceRenderer> meshCDArray = nodeGroup.GetSharedComponentDataArray <HPMeshInstanceRenderer>();

        HPMeshInstanceRenderer[] meshArray = new HPMeshInstanceRenderer[meshCDArray.Length];
        for (int i = 0; i < meshArray.Length; ++i)
        {
            meshArray[i] = meshCDArray[i];
        }

        ComponentDataArray <TerrainNode> nodeCDArray = nodeGroup.GetComponentDataArray <TerrainNode>();

        TerrainNode[] nodeArray = new TerrainNode[nodeCDArray.Length];
        for (int i = 0; i < nodeCDArray.Length; ++i)
        {
            nodeArray[i] = nodeCDArray[i];
        }

        ComponentDataArray <PrecisePosition> nodePosArray = nodeGroup.GetComponentDataArray <PrecisePosition>();

        PrecisePosition[] posArray = new PrecisePosition[nodePosArray.Length];
        for (int i = 0; i < nodePosArray.Length; ++i)
        {
            posArray[i] = nodePosArray[i];
        }

        ComponentDataArray <OctantPosition> nodeOctArray = nodeGroup.GetComponentDataArray <OctantPosition>();

        OctantPosition[] octArray = new OctantPosition[nodePosArray.Length];
        for (int i = 0; i < nodeOctArray.Length; ++i)
        {
            octArray[i] = nodeOctArray[i];
        }

        ComponentDataArray <PrecisePosition> camPosArray = camGroup.GetComponentDataArray <PrecisePosition>();
        float3 camPos = camPosArray[0].pos;
        ComponentDataArray <OctantPosition> camOctArray = camGroup.GetComponentDataArray <OctantPosition>();
        int3 camOct = camOctArray[0].pos;

        float octantSize = HyperposStaticReferences.OctantSize;


        for (int i = 0; i < meshArray.Length; ++i)
        {
            if (nodeArray[i].built == 1 && nodeArray[i].divided == 0)
            {
                if (nodeArray[i].level < nodeArray[i].planetData.maxNodeLevels)
                {
                    float3        corner0      = nodeArray[i].corner1;
                    float3        corner1      = nodeArray[i].corner2;
                    float3        corner2      = nodeArray[i].corner3;
                    HyperDistance sphereRadius = nodeArray[i].planetData.radius;

                    HyperPosition corner0Pos = corner0 * sphereRadius;
                    HyperPosition corner1Pos = corner1 * sphereRadius;

                    HyperDistance distToSubdivide = MathUtils.Distance(corner0Pos, corner1Pos)
                                                    * (PERCENT_DIST_TO_SUBDIVIDE_AT / 100f);

                    HyperPosition centerPos = GetNodeCenter(nodeArray[i]);

                    //if (UnityEngine.Random.Range(0, 20) == 2)
                    //    Debug.Log(MathUtils.ToString(distToSubdivide) + "\n" + MathUtils.ToString(centerPos));
                    if (InSubdivideDist(camOct, camPos, centerPos.oct, centerPos.prs, distToSubdivide.oct, distToSubdivide.prs))
                    {
                        //Debug.Log(MathUtils.ToString(distToSubdivide) + "\n" + MathUtils.ToString(centerPos)
                        //    + "\n" + camOct + " " + camPos);
                        Subdivide(entityArray[i], nodeArray[i], meshArray[i], dataArray[0],
                                  distToSubdivide.prs, distToSubdivide.oct, centerPos.prs, centerPos.oct);
                    }
                }
                if (nodeArray[i].level > 0 && EntityManager.Exists(nodeArray[i].parentEntity))
                {
                    HPMeshInstanceRenderer parentR
                        = EntityManager.GetSharedComponentData <HPMeshInstanceRenderer>(nodeArray[i].parentEntity);
                    //float dist = math.distance(camPos, nodeArray[i].parentCenter);
                    //HyperDistance dist = MathUtils.Distance(camOct, camPos,
                    //    nodeArray[i].parentOctantCenter, nodeArray[i].parentPreciseCenter);

                    //if (parentR.mesh != null
                    //    && (dist.octantDist < nodeArray[i].parentOctantSubdivideDist
                    //        || (dist.octantDist == nodeArray[i].parentOctantSubdivideDist && dist.preciseDist < nodeArray[i].parentPreciseSubdivideDist)))
                    if (!InSubdivideDist(camOct, camPos, nodeArray[i].parentOctantCenter, nodeArray[i].parentPreciseCenter,
                                         nodeArray[i].parentOctantSubdivideDist, nodeArray[i].parentPreciseSubdivideDist))
                    {
                        EntityManager.DestroyEntity(entityArray[i]);
                    }
                }
            }
            else if (nodeArray[i].built == 0 && nodeArray[i].divided == 1)
            {
                float3        corner0      = nodeArray[i].corner1;
                float3        corner1      = nodeArray[i].corner2;
                float3        corner2      = nodeArray[i].corner3;
                HyperDistance sphereRadius = nodeArray[i].planetData.radius;

                HyperPosition corner0Pos = corner0 * sphereRadius;
                HyperPosition corner1Pos = corner1 * sphereRadius;

                HyperDistance distToSubdivide = MathUtils.Distance(corner0Pos, corner1Pos) * (PERCENT_DIST_TO_SUBDIVIDE_AT / 100f);
                HyperPosition centerPos       = GetNodeCenter(nodeArray[i]);

                if (!InSubdivideDist(camOct, camPos, centerPos.oct, centerPos.prs, distToSubdivide.oct, distToSubdivide.prs))
                {
                    nodeArray[i].divided       = 0;
                    nodeArray[i].childrenBuilt = 0;
                    EntityManager.SetComponentData(entityArray[i], nodeArray[i]);
                }
            }
            else if (nodeArray[i].built == 0 && nodeArray[i].divided == 0)
            {
                nodeArray[i].built = 1;

                Planet planetData = nodeArray[i].planetData;

                // rez is the number of vertices on one side of the mesh/triangle
                // the part in parentheses is called the "Mersenne Number"
                int rez = 2 + ((int)Mathf.Pow(2, planetData.meshSubdivisions) - 1);
                // nTris is the number of tris in the mesh
                int t     = rez - 2;
                int nTris = (t * (t + 1)) + (rez - 1);
                // nVerts is the number of vertices in the mesh
                // it is the formula for the "Triangle Sequence" of numbers
                int nVerts = (rez * (rez + 1)) / 2;

                NativeArray <Vector3> verts = new NativeArray <Vector3>(nVerts, Allocator.Persistent);
                NativeArray <int>     tris  = new NativeArray <int>(nTris * 3, Allocator.Persistent);

                HyperPosition centerPos = GetNodeCenter(nodeArray[i]);
                HyperPosition camHyp    = new HyperPosition {
                    prs = camPos, oct = camOct
                };
                HyperDistance dist = MathUtils.Distance(centerPos, camHyp);

                //if (dist > planetData.hyperdistanceThreshold)
                //{
                //    nodeArray[i].hyperDistant = 1;
                //    if(!EntityManager.HasComponent<HyperdistantMarker>(entityArray[i]))
                //        EntityManager.AddComponent(entityArray[i], typeof(HyperdistantMarker));
                //}
                //else
                //{
                //    nodeArray[i].hyperDistant = 0;
                //    if (EntityManager.HasComponent<HyperdistantMarker>(entityArray[i]))
                //        EntityManager.RemoveComponent(entityArray[i], typeof(HyperdistantMarker));
                //}

                MeshBuildJob job = new MeshBuildJob();
                job.node    = nodeArray[i];
                job.corner0 = nodeArray[i].corner3;
                job.corner1 = nodeArray[i].corner2;
                job.corner2 = nodeArray[i].corner1;
                job.rez     = rez;
                job.nTris   = nTris;
                job.nVerts  = nVerts;
                job.verts   = verts;
                job.tris    = tris;

                JobHandle handle = job.Schedule();
                JobHandle.ScheduleBatchedJobs();

                MeshCreationSet mcs = new MeshCreationSet();
                mcs.entity    = entityArray[i];
                mcs.jobHandle = handle;
                mcs.verts     = verts;
                mcs.tris      = tris;
                meshCreationSets.Add(mcs);

                EntityManager.SetComponentData(entityArray[i], nodeArray[i]);
            }
        }
    }
    protected override void OnUpdate()
    {
        ComponentGroup nodeGroup = GetComponentGroup(typeof(Flycam), typeof(PrecisePosition), typeof(OctantPosition), typeof(Rotation));

        EntityArray tempEntityArray = nodeGroup.GetEntityArray();

        Entity[] entityArray = new Entity[tempEntityArray.Length];
        for (int i = 0; i < entityArray.Length; ++i)
        {
            entityArray[i] = tempEntityArray[i];
        }

        ComponentDataArray <Flycam> tempFlycamArray = nodeGroup.GetComponentDataArray <Flycam>();

        Flycam[] flycamArray = new Flycam[tempFlycamArray.Length];
        for (int i = 0; i < flycamArray.Length; ++i)
        {
            flycamArray[i] = tempFlycamArray[i];
        }

        ComponentDataArray <PrecisePosition> tempPosArray = nodeGroup.GetComponentDataArray <PrecisePosition>();

        PrecisePosition[] posArray = new PrecisePosition[tempPosArray.Length];
        for (int i = 0; i < tempPosArray.Length; ++i)
        {
            posArray[i] = tempPosArray[i];
        }

        ComponentDataArray <OctantPosition> tempOPosArray = nodeGroup.GetComponentDataArray <OctantPosition>();

        OctantPosition[] oposArray = new OctantPosition[tempOPosArray.Length];
        for (int i = 0; i < tempOPosArray.Length; ++i)
        {
            oposArray[i] = tempOPosArray[i];
        }

        ComponentDataArray <Rotation> tempRotArray = nodeGroup.GetComponentDataArray <Rotation>();

        Rotation[] rotArray = new Rotation[tempRotArray.Length];
        for (int i = 0; i < tempRotArray.Length; ++i)
        {
            rotArray[i] = tempRotArray[i];
        }



        //Position[] nodeArray = new Position[posArray.Length];
        //for (int i = 0; i < posArray.Length; ++i)
        //    nodeArray[i] = posArray[i];

        quaternion pitchChange = quaternion.RotateX(Input.GetAxis("Mouse Y") * -flycamArray[0].mouseSensitivity);
        quaternion yawChange   = quaternion.RotateY(Input.GetAxis("Mouse X") * flycamArray[0].mouseSensitivity);
        quaternion rollChange  = quaternion.RotateZ(Input.GetAxis("Roll") * -flycamArray[0].rollSensitivity);

        quaternion rotChange = math.mul(pitchChange, yawChange);

        rotChange = math.mul(rollChange, rotChange);

        rotArray[0] = new Rotation {
            Value = math.mul(rotArray[0].Value, rotChange)
        };



        Flycam flyCam          = flycamArray[0];
        float  axisScrollWheel = Input.GetAxis("Mouse ScrollWheel");
        float  octantSize      = HyperposStaticReferences.OctantSize;

        float ospeed       = flyCam.octMoveSpeed;
        float ospeedChange = flyCam.octMoveSpeed * flycamArray[0].moveSpeedChangeMultiplier * axisScrollWheel;

        ospeed += ospeedChange;
        float pspeedChange = ospeed % 1f;

        ospeed       -= pspeedChange;
        pspeedChange *= octantSize;
        pspeedChange += flyCam.moveSpeed * flycamArray[0].moveSpeedChangeMultiplier * axisScrollWheel;

        flyCam.moveSpeed += pspeedChange;
        int overSpeed = (int)(flyCam.moveSpeed / octantSize);

        flyCam.moveSpeed   -= overSpeed * octantSize;
        flyCam.octMoveSpeed = (int)ospeed + overSpeed;

        EntityManager.SetComponentData(entityArray[0], flyCam);

        SystemStaticReferences.SpeedText.text = flyCam.moveSpeed.ToString() + " m/s  "
                                                + flyCam.octMoveSpeed.ToString() + " oct/s";



        float3 forward = math.forward(rotArray[0].Value);
        float3 right   = MathUtils.right(rotArray[0].Value);
        float3 up      = MathUtils.up(rotArray[0].Value);

        float dt = Time.deltaTime;

        float axisForeBack   = Input.GetAxis("ForeBack");
        float axisHorizontal = Input.GetAxis("Horizontal");
        float axisVertical   = Input.GetAxis("Vertical");

        float3 octChangeInitial = forward * axisForeBack * dt * flyCam.octMoveSpeed
                                  + right * axisHorizontal * dt * flyCam.octMoveSpeed
                                  + up * axisVertical * dt * flyCam.octMoveSpeed;

        float3 posChange = octChangeInitial % 1f;

        int3 octChange = (int3)(octChangeInitial - posChange);

        posChange *= octantSize;
        posChange += forward * axisForeBack * dt * flyCam.moveSpeed
                     + right * axisHorizontal * dt * flyCam.moveSpeed
                     + up * axisVertical * dt * flyCam.moveSpeed;

        int3 overPos = (int3)(posChange / octantSize);

        posChange -= (float3)overPos * octantSize;
        octChange += overPos;

        //float3 posChange = forward * Input.GetAxis("ForeBack") * dt * flyCam.moveSpeed
        //                 + right * Input.GetAxis("Horizontal") * dt * flyCam.moveSpeed
        //                 + up * Input.GetAxis("Vertical") * dt * flyCam.moveSpeed;

        posArray[0] = new PrecisePosition()
        {
            pos = posArray[0].pos + posChange
        };
        oposArray[0] = new OctantPosition()
        {
            pos = oposArray[0].pos + octChange
        };

        EntityManager.SetComponentData(entityArray[0], posArray[0]);
        EntityManager.SetComponentData(entityArray[0], rotArray[0]);
        EntityManager.SetComponentData(entityArray[0], oposArray[0]);
    }
Exemplo n.º 5
0
    protected override void OnUpdate()
    {
        float octantSize = HyperposStaticReferences.OctantSize;



        ComponentGroup camGroup = GetComponentGroup(typeof(Flycam), typeof(PrecisePosition), typeof(OctantPosition));

        EntityArray entityArray = camGroup.GetEntityArray();
        Entity      camEntity   = entityArray[0];

        ComponentDataArray <PrecisePosition> tempcposArray = camGroup.GetComponentDataArray <PrecisePosition>();
        PrecisePosition camPos = tempcposArray[0];
        ComponentDataArray <OctantPosition> coctposArray = camGroup.GetComponentDataArray <OctantPosition>();

        float3         coverPosF = math.floor(camPos.pos / octantSize);
        int3           coverPos  = (int3)coverPosF;
        OctantPosition coctpos   = coctposArray[0];

        //Debug.Log("POS:" + camPos.pos + " OCTPOS:" + coctpos.pos);

        if (coverPos.x != 0 || coverPos.y != 0 || coverPos.z != 0)
        {
            coctpos.pos += coverPos;
            float3 offsetAmt = coverPosF * octantSize;
            camPos = new PrecisePosition {
                pos = camPos.pos - offsetAmt
            };

            EntityManager.SetComponentData(camEntity, coctpos);
            EntityManager.SetComponentData(camEntity, camPos);
        }

        localOctant = coctpos.pos;



        ComponentGroup preciseGroup    = GetComponentGroup(typeof(PrecisePosition), typeof(Position), typeof(OctantPosition));
        EntityArray    pposEntityArray = preciseGroup.GetEntityArray();
        ComponentDataArray <PrecisePosition> pposArray = preciseGroup.GetComponentDataArray <PrecisePosition>();
        ComponentDataArray <OctantPosition>  oposArray = preciseGroup.GetComponentDataArray <OctantPosition>();
        ComponentDataArray <Position>        posArray  = preciseGroup.GetComponentDataArray <Position>();

        for (int i = 0; i < pposArray.Length; ++i)
        {
            PrecisePosition ppos     = pposArray[i];
            OctantPosition  octpos   = oposArray[i];
            float3          overPosF = math.floor(ppos.pos / octantSize);
            int3            overPos  = (int3)overPosF;

            Entity entity = pposEntityArray[i];

            if (overPos.x != 0 || overPos.y != 0 || overPos.z != 0)
            {
                octpos.pos += overPos;
                float3 offsetAmt = overPosF * octantSize;
                ppos = new PrecisePosition {
                    pos = ppos.pos - offsetAmt
                };

                EntityManager.SetComponentData(entity, octpos);
                EntityManager.SetComponentData(entity, ppos);
            }

            if (EntityManager.HasComponent <HyperdistantMarker>(entity))
            {
                float3 octOffset = octpos.pos - localOctant;

                posArray[i] = new Position {
                    Value = camPos.pos + octOffset + (ppos.pos - camPos.pos) / octantSize
                };
            }
            else
            {
                float3 octOffset = octpos.pos - localOctant;

                posArray[i] = new Position {
                    Value = ppos.pos + octOffset * octantSize
                };
            }
        }

        //ComponentGroup camGroup = GetComponentGroup(typeof(Position), typeof(Flycam));
        //
        //EntityArray entityArray = camGroup.GetEntityArray();
        //Entity camEntity = entityArray[0];
        //
        //ComponentDataArray<Position> cposArray = camGroup.GetComponentDataArray<Position>();
        //Position camPos = cposArray[0];
        //
        //float3 overPosF = math.floor(camPos.Value / octantSize);
        //int3 overPos = (int3)overPosF;
        //
        //if(overPos.x != 0 || overPos.y != 0 || overPos.z != 0)
        //{
        //    OctantPosition octpos;
        //
        //    if (EntityManager.HasComponent<OctantPosition>(camEntity))
        //    {
        //       octpos = EntityManager.GetComponentData<OctantPosition>(camEntity);
        //    }
        //    else
        //    {
        //        octpos = new OctantPosition();
        //        EntityManager.AddComponentData(camEntity, octpos);
        //    }
        //
        //    octpos.pos += overPos;
        //    float3 offsetAmt = overPosF * octantSize;
        //    camPos = new Position { Value = camPos.Value - offsetAmt };
        //
        //    EntityManager.SetComponentData(camEntity, octpos);
        //    EntityManager.SetComponentData(camEntity, camPos);
        //
        //    Debug.Log("POS:" + camPos.Value + " OCTPOS:" + octpos.pos);
        //
        //
        //
        //    ComponentGroup hyperposGroup = GetComponentGroup(typeof(Position), typeof(PrecisePosition));
        //    ComponentDataArray<Position> posArray = hyperposGroup.GetComponentDataArray<Position>();
        //
        //    for(int i = 0; i < posArray.Length; ++i)
        //    {
        //        posArray[i] = new Position { Value = posArray[i].Value - offsetAmt };
        //    }
        //}
        //
        //
        //
        //ComponentGroup hyperdistGroup = GetComponentGroup(typeof(Position), typeof(HyperdistantMarker));
        //ComponentDataArray<Position> hdposArray = hyperdistGroup.GetComponentDataArray<Position>();
        //ComponentDataArray<HyperdistantMarker> hyperdistArray = hyperdistGroup.GetComponentDataArray<HyperdistantMarker>();
        //
        //for(int i = 0; i < hdposArray.Length; ++i)
        //{
        //    hdposArray[i] = new Position { Value = camPos.Value + (hyperdistArray[i].precisePos - camPos.Value) / octantSize };
        //}
    }