Java 类com.badlogic.gdx.math.collision.BoundingBox 实例源码

@Override
public void init(Graphics3D graphics) {
    view = new FlyView(30, 3.6f, 0);
    view.getAim().setAngleY(190);

    AWTGraphics3D g = (AWTGraphics3D) graphics;
    GL2 gl = g.getGL2(); // get the OpenGL graphics context

    gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // set background (clear) color
    gl.glClearDepth(1.0f);      // set clear depth value to farthest
    gl.glEnable(GL.GL_DEPTH_TEST); // enables depth testing
    gl.glDepthFunc(GL.GL_LEQUAL);  // the type of depth test to do
    gl.glHint(GL2.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST); // best perspective correction
    gl.glShadeModel(GL2.GL_SMOOTH); // blends colors nicely, and smoothes out lighting

    gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST);
    gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST);
    gl.glTexEnvi(GL2.GL_TEXTURE_ENV, GL2.GL_TEXTURE_ENV_MODE, GL2.GL_DECAL);

    xAxis = new BoundingBox(new Vector3(0, -axisWidth/2, -axisWidth/2), new Vector3(axisSize, axisWidth/2, axisWidth/2));
    yAxis = new BoundingBox(new Vector3(-axisWidth/2, 0, -axisWidth/2), new Vector3(axisWidth/2, axisSize, axisWidth/2));
    zAxis = new BoundingBox(new Vector3(-axisWidth/2, -axisWidth/2, 0), new Vector3(axisWidth/2, axisWidth/2, axisSize));
}

@Override
public void init(Graphics3D graphics) {
    view = new FlyView(30, 3.6f, 0);
    view.getAim().setAngleY(190);

    AWTGraphics3D g = (AWTGraphics3D) graphics;
    GL2 gl = g.getGL2(); // get the OpenGL graphics context

    gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // set background (clear) color
    gl.glClearDepth(1.0f);      // set clear depth value to farthest
    gl.glEnable(GL.GL_DEPTH_TEST); // enables depth testing
    gl.glDepthFunc(GL.GL_LEQUAL);  // the type of depth test to do
    gl.glHint(GL2.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST); // best perspective correction
    gl.glShadeModel(GL2.GL_SMOOTH); // blends colors nicely, and smoothes out lighting

    gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST);
    gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST);
    gl.glTexEnvi(GL2.GL_TEXTURE_ENV, GL2.GL_TEXTURE_ENV_MODE, GL2.GL_DECAL);

    vAxis = new BoundingBox(new Vector3(-axisSize/8, -axisWidth/2, -axisSize/8), new Vector3(axisSize/8, axisWidth/2, axisSize/8));
    hAxis = new BoundingBox(new Vector3(-axisSize/8, -axisSize/8, -axisWidth/2), new Vector3(axisSize/8, axisSize/8, axisWidth/2));

}

public GameObject(ScreenBase context, Model model, BoundingBox bounds) {
super(model);
this.context = context;
this.customBounds = bounds;

      this.bounds = this.customBounds != null ? this.customBounds : new BoundingBox();
      this.center = new Vector3();
      this.enabled = true;
      updateBox();

      this.animations = new AnimationController(this);
      this.blending = new BlendingAttribute(GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA);

      for(Material item : materials){
        item.set(new DepthTestAttribute(GL20.GL_LEQUAL, 0.01f, 25f, true));
    item.set(FloatAttribute.createAlphaTest(0.01f));
        item.set(blending);
      }
  }

public void setWorldBoundingBox(BoundingBox worldBoundingBox) {
    this.worldBoundingBox = new BoundingBox(worldBoundingBox);
    Vector3 min = new Vector3();
    Vector3 max = new Vector3();
    // Set height of bounding box to zero (y dimension)
    this.worldBoundingBox.getMax(max).y = 0;
    this.worldBoundingBox.getMin(min).y = 0;
    this.worldBoundingBox.set(min, max);

    ray.set(camera.targetPosition, camera.targetDirection);
    if (!Intersector.intersectRayBounds(ray, this.worldBoundingBox, worldGroundTarget)) {
        // TODO: What happens if the center of camera is not aimed at bounding box?
        // Probably move the camera until it is...
    }

}

/** Returns whether the given {@link BoundingBox} is in the frustum.
 * 
 * @param bounds The bounding box
 * @return Whether the bounding box is in the frustum */
public boolean boundsInFrustum (BoundingBox bounds) {
    Vector3[] corners = bounds.getCorners();
    int len = corners.length;

    for (int i = 0, len2 = planes.length; i < len2; i++) {
        int out = 0;

        for (int j = 0; j < len; j++)
            if (planes[i].testPoint(corners[j]) == PlaneSide.Back) out++;

        if (out == 8) return false;
    }

    return true;
}

/** Extends the bounding box with the bounds of this Node. This is a potential slow operation, it is advised to cache the
 * result. */
public BoundingBox extendBoundingBox (final BoundingBox out, boolean transform) {
    final int partCount = parts.size;
    for (int i = 0; i < partCount; i++) {
        final NodePart part = parts.get(i);
        if (part.enabled) {
            final MeshPart meshPart = part.meshPart;
            if (transform)
                meshPart.mesh.extendBoundingBox(out, meshPart.indexOffset, meshPart.numVertices, globalTransform);
            else
                meshPart.mesh.extendBoundingBox(out, meshPart.indexOffset, meshPart.numVertices);
        }
    }
    final int childCount = children.size;
    for (int i = 0; i < childCount; i++)
        children.get(i).extendBoundingBox(out);
    return out;
}

@Override
protected void addToWold(World world, float x, float y)
{
    BodyDef bodyDef = new BodyDef();
    bodyDef.type = BodyDef.BodyType.DynamicBody;
    bodyDef.position.set(x, y);
    body = world.createBody(bodyDef);
    body.setLinearDamping(0);
    bodyDef.angularDamping = 5f;
    body.setFixedRotation(false);
    body.setUserData(this);
    FixtureDef fixtureDef = new FixtureDef();
    fixtureDef.shape = shape;new BoundingBox(new Vector3(this.getX(), this.getY(), 0), new Vector3(this.getX() + this.getWidth(), this.getY() + this.getHeight(), 0));
    fixtureDef.restitution = 1;
    fixtureDef.density = 1;
    Fixture fixture = body.createFixture(fixtureDef);
    shape.dispose();
}

@Override
public void init(String name, boolean load) {
    visible = true;
    solid = true;

    this.name = name;

    transform.idt();

    terrainMap = new Grid[SIZE][SIZE][SIZE];
    boundingBox = new BoundingBox();
    gridArray = new Array<Grid>(Grid.class);
    gridCount = new WrappedInteger(0);
    isLoading = new WrappedBoolean(false);
    references = new WrappedInteger(1);

    if (load) {
        loadAll();
    }

    updateMatrix();
}

public void copyTo(TinyGrid tiny) {
    tiny.checkBounds = checkBounds;
    tiny.minX = minX;
    tiny.minY = minY;
    tiny.minZ = minZ;
    tiny.maxX = maxX;
    tiny.maxY = maxY;
    tiny.maxZ = maxZ;

    for (int i = 0; i < fullSides.length; i++)
        tiny.fullSides[i] = fullSides[i];

    tiny.boundingBox = new BoundingBox(boundingBox);
    for (int tx = 0; tx < Config.TINY_GRID_SIZE; tx++)
        for (int ty = 0; ty < Config.TINY_GRID_SIZE; ty++)
            for (int tz = 0; tz < Config.TINY_GRID_SIZE; tz++) {
                tiny.data[tx][ty][tz] = data[tx][ty][tz];
            }

    tiny.notUpToDate = true;
}

@Override
public void init(String name, boolean load) {
    visible = true;
    solid = true;

    this.name = name;

    transform.idt();

    boundingBox = new BoundingBox();
    gridCount = new WrappedInteger(0);
    isLoading = new WrappedBoolean(false);
    references = new WrappedInteger(1);

    if (load) {
        loadAll();
    }

    updateMatrix();
}

@Override
public void init(String name, boolean load) {
    visible = true;
    solid = true;

    this.name = name;

    transform.idt();

    terrainMap = new IntMap<IntMap<IntMap<Grid>>>();
    boundingBox = new BoundingBox();
    gridCount = new WrappedInteger(0);
    isLoading = new WrappedBoolean(false);
    references = new WrappedInteger(1);

    if (load) {
        loadAll();
    }

    updateMatrix();
}

private void setupMesh(Model model, MaterialTileMapping textures) {
    int numVertices = countModelVertices(model);
    vertices = new Vertices(
            numVertices,
            VertexAttribute.Position(),
            VertexAttribute.ColorUnpacked(),
            VertexAttribute.Normal(),
            VertexAttribute.TexCoords(0)
    );

    model.calculateBoundingBox(tmpModelBounds);
    if (scaleToSize != null) {
        MathHelpers.getScaleFactor(tmpModelBounds.getDimensions(), scaleToSize, tmpScaleFactor);
        bounds = new BoundingBox().set(Vector3.Zero, scaleToSize);
    } else {
        bounds = new BoundingBox().set(Vector3.Zero, tmpModelBounds.getDimensions());
        tmpScaleFactor.set(1.0f, 1.0f, 1.0f);
    }

    for (int i = 0; i < model.nodes.size; ++i)
        collectModelNodeVertices(model.nodes.get(i), vertices, textures, color, tmpScaleFactor, positionOffset);
}

public static float getSquaredDistanceFromPointToBox(Vector3 point, BoundingBox box) {
    float distanceSq = 0.0f;
    float v;

    v = point.x;
    if (v < box.min.x)
        distanceSq += (box.min.x - v) * (box.min.x - v);
    if (v > box.max.x)
        distanceSq += (v - box.max.x) * (v - box.max.x);

    v = point.y;
    if (v < box.min.y)
        distanceSq += (box.min.y - v) * (box.min.y - v);
    if (v > box.max.y)
        distanceSq += (v - box.max.y) * (v - box.max.y);

    v = point.z;
    if (v < box.min.z)
        distanceSq += (box.min.z - v) * (box.min.z - v);
    if (v > box.max.z)
        distanceSq += (v - box.max.z) * (v - box.max.z);

    return distanceSq;
}

public boolean boundsInFrustum(BoundingBox paramBoundingBox)
{
  Vector3[] arrayOfVector3 = paramBoundingBox.getCorners();
  int i = arrayOfVector3.length;
  int j = this.planes.length;
  for (int k = 0; k < j; k++)
  {
    int m = 0;
    int n = 0;
    while (m < i)
    {
      if (this.planes[k].testPoint(arrayOfVector3[m]) == Plane.PlaneSide.Back)
        n++;
      m++;
    }
    if (n == 8)
      return false;
  }
  return true;
}

public Entity(Matrix4 transform, int hp, int health, EnumSet<Types> types, EnumSet<Effects> effects, ModelInstance instance, btCollisionShape shape, btCollisionWorld world, IntMap<Entity> entities, Map<String, Sound> sounds){
    this.instance = instance;
    this.transform = transform;
    this.hp = hp;
    this.types = types;
    this.health = health;
    this.effects = effects;
    this.sounds = sounds;
    animation = new AnimationController(instance);
    this.instance.transform.set(transform);
    this.shape = shape;
    body = new btCollisionObject();
    body.setCollisionShape(shape);
    body.setWorldTransform(this.instance.transform);
    this.world = world;
    tempVector = new Vector3();
    tempVector2 = new Vector3();
    this.entities = entities;
    tempQuaternion = new Quaternion();
    quaternion = new Quaternion();
    if(this instanceof Enemy || this instanceof Projectile)
        body.setCollisionFlags(body.getCollisionFlags());
    int index = getNextIndex();
    entities.put(index, this);
    body.setUserValue(index);
    world.addCollisionObject(body);
    boundingBox = instance.calculateBoundingBox(new BoundingBox());
    //for(Node node: instance.nodes)
        //System.out.println();
}

public RaiderMap() {
    manager = ManagerAssets.getInstance();
    Model model = manager.getAssetsRaider().getModel(NameFiles.raiderMap);
    model.nodes.get(2).translation.set(-11,26.5f,-3f);
    instance = new ModelInstance(model);
    instance.transform.scl(1.5f);
    instance.transform.trn(50,50,5);
    instance.transform.rotate(1,0,0,55);
    box = new BoundingBox();
    position = new Vector3();
    dimension = new Vector3();
    instance.calculateBoundingBox(box).mul(instance.transform);
    box.getCenter(position);
    box.getDimensions(dimension);
}

@Override
public void write(Kryo kryo, Output output, BoundingBox boundingBox) {
    Vector3 min = boundingBox.min;
    output.writeFloat(min.x);
    output.writeFloat(min.y);
    output.writeFloat(min.z);
    Vector3 max = boundingBox.max;
    output.writeFloat(max.x);
    output.writeFloat(max.y);
    output.writeFloat(max.z);
}

@Override
public BoundingBox read(Kryo kryo, Input input, Class<BoundingBox> type) {
    Vector3 min = new Vector3();
    min.x = input.readFloat();
    min.y = input.readFloat();
    min.z = input.readFloat();
    Vector3 max = new Vector3();
    max.x = input.readFloat();
    max.y = input.readFloat();
    max.z = input.readFloat();
    return new BoundingBox(min, max);
}

public void testCollisionClasses (){
    Object[] objects = new Object[4];

    objects[0] = new BoundingBox(new Vector3(randFloat(), randFloat(), randFloat()), new Vector3(randFloat(), randFloat(), randFloat()));
    objects[1] = new Ray(new Vector3(randFloat(), randFloat(), randFloat()), new Vector3(randFloat(), randFloat(), randFloat()).nor());
    objects[2] = new Segment(randFloat(), randFloat(), randFloat(), randFloat(), randFloat(), randFloat());
    objects[3] = new Sphere(new Vector3(randFloat(), randFloat(), randFloat()), randFloat());

    simpleRoundTrip(objects);
}

public void updateBox(){
Vector3 position = transform.getTranslation(new Vector3());
      if(customBounds != null) bounds = new BoundingBox(customBounds);
      else calculateBoundingBox(bounds);
      bounds.getCenter(center);
      bounds.set(bounds.min.add(position.x,position.y, position.z), bounds.max.add(position.x, position.y, position.z));
  }

public VehicleBuilder buildChassis(float mass) {
    Vector3 chassisHalfExtents = chassisModel
            .calculateBoundingBox(new BoundingBox())
            .getDimensions(new Vector3())
            .scl(0.5f);

    btBoxShape boxShape = new btBoxShape(chassisHalfExtents);
    return buildChassis(boxShape, mass);
}

public VehicleBuilder buildWheel(Vector3 point, Vector3 direction, Vector3 axis, float friction,
                                 boolean frontWheel) {
    Vector3 wheelHalfExtents = wheelModel
            .calculateBoundingBox(new BoundingBox())
            .getDimensions(new Vector3())
            .scl(0.5f);

    return buildWheel(point, direction, axis, wheelHalfExtents.z, wheelHalfExtents.z * 0.3f,
            friction, frontWheel);
}

public void buildWithModel(ModelInstance m) {
    model = m;
    boundingBox = new BoundingBox();
    model.calculateBoundingBox(boundingBox);

    Vector3 dimensions = boundingBox.getDimensions(new Vector3());
    radius = dimensions.len() / 2f;

    state = ModelComponent.State.READY;

    if (m.animations.size > 0) {
        animationController = new AnimationController(model);
    }
}

private Entity loadParticle(OverlapScene scene, JsonValue value) {
    Entity entity = new Entity();

    logger.info("loading particle: " + value.getString("particleName") + " " + value.getString("itemIdentifier", ""));

    NodeComponent node = new NodeComponent();
    TransformComponent transform = new TransformComponent();
    ParticleComponent particle = new ParticleComponent();
    ZIndexComponent index = new ZIndexComponent();
    SizeComponent size = new SizeComponent();
    IDComponent id = new IDComponent();

    id.value = value.getInt("uniqueId");

    loadTransform(transform, value);
    index.layer = value.getString("layerName");

    String particleName = value.getString("particleName");

    ParticleEffect effect = new ParticleEffect();
    effect.load(
        Gdx.files.internal(PARTICLES_DIR + particleName),
        atlas
    );

    particle.effect = effect;
    BoundingBox box = particle.effect.getBoundingBox(); 
    size.width = (box.max.x - box.min.x) * parameters.units;
    size.height = (box.max.y - box.min.y) * parameters.units;

    entity.add(node);
    entity.add(size);
    entity.add(transform);
    entity.add(particle);
    entity.add(index);
    entity.add(id);

    return entity;
}

private void spawnSmoke(Entity entity) {
    Entity smoke = new Entity();

    ParticleComponent particle = new ParticleComponent();
    NodeComponent node = new NodeComponent();
    TransformComponent transform = new TransformComponent();
    ZIndexComponent index = new ZIndexComponent();
    SizeComponent size = new SizeComponent();

    AssetManager assetManager = Env.getGame().getAssetManager();
    TextureAtlas atlas = assetManager.get(Env.SCENES_TEXTURES_FOLDER + "pack.atlas", TextureAtlas.class);
    particle.effect = new ParticleEffect();
    particle.effect.load(Gdx.files.internal(Env.PARTICLES_FOLDER + "playerDie"), atlas);
    particle.effect.start();

    Entity parent = NodeUtils.getParent(entity);
    node.parent = parent;
    Mappers.node.get(parent).children.add(smoke);

    transform.position.set(Mappers.transform.get(entity).position);

    ZIndexComponent entityIndex = Mappers.index.get(entity);
    index.index = entityIndex.index - 1;
    index.layer = entityIndex.layer;

    BoundingBox box = particle.effect.getBoundingBox();
    size.width = box.max.x - box.min.x;
    size.height = box.max.y - box.min.y;

    smoke.add(particle);
    smoke.add(node);
    smoke.add(transform);
    smoke.add(index);
    smoke.add(size);

    engine.addEntity(smoke);
}

public GridChunk(Grid grid, int cx, int cy)
{
    _grid = grid;

    _cx = cx;
    _cy = cy;

    // отступ данного грида в тайлах
    _gx = _grid.getTc().x;
    _gy = _grid.getTc().y;

    _waterMesh = null;

    fillVertex();
    fillNormals();
    makeMesh();

    // определим нужна ли вода в этом чанке?
    // хоть одна вершина ниже уровня воды?
    if (_minHeight < WATER_LEVEL)
    {
        makeWater();
    }

    _boundingBox = new BoundingBox(
            new Vector3(_gx + _cx, _minHeight, _gy + _cy),
            new Vector3(_gx + _cx + CHUNK_SIZE, _maxHeight, _gy + _cy + CHUNK_SIZE));

}

/** Creates a btBoxShape with the same dimensions as the shape. */
public BulletConstructor (final Model model, final float mass) {
    final BoundingBox boundingBox = new BoundingBox();
    model.calculateBoundingBox(boundingBox);
    final Vector3 dimensions = boundingBox.getDimensions();
    create(model, mass, dimensions.x, dimensions.y, dimensions.z);
}

public int getBlockInFeet(IWorld world) {
    int x = MathUtils.floor(getPosition().getX());
    int y = MathUtils.floor(getPosition().getY());
    int z = MathUtils.floor(getPosition().getZ());
    IChunk chunk = world.getChunk(x, z);
    if (chunk != null && y < world.getHeight()) {
        int cx = x & (world.getChunkSize() - 1);
        int cz = z & (world.getChunkSize() - 1);
        try {
            int id = chunk.getBlockId(cx, y, cz);
            Block block = RadixAPI.instance.getBlock(id);
            if (block == null) return 0;
            BoundingBox blockBox = block.calculateBoundingBox(chunk, cx, y, cz);
            float halfWidth = width / 2f;
            Vector3 bottomBackLeft = getPosition().cpy().add(-halfWidth, 0, -halfWidth);
            Vector3 bottomBackRight = bottomBackLeft.cpy().add(width, 0, 0);
            Vector3 bottomFrontRight = bottomBackRight.cpy().add(0, 0, width);
            Vector3 bottomFrontLeft = bottomBackLeft.cpy().add(width, 0, 0);

            boolean inFeet = blockBox.contains(bottomBackLeft) || blockBox.contains(bottomBackRight) || blockBox.contains(bottomFrontLeft) || blockBox.contains(bottomFrontRight);

            return inFeet ? id : 0;
        } catch (BlockStorage.CoordinatesOutOfBoundsException ex) {
            ex.printStackTrace();
            return 0;
        }
    } else {
        return 0;
    }
}

public boolean checkDeltaCollision(LivingEntity e, float deltaX, float deltaY, float deltaZ) {
    BoundingBox curBB = e.calculateBoundingBox();
    BoundingBox newBB = new BoundingBox(curBB.min.cpy().add(deltaX, deltaY, deltaZ), curBB.max.cpy().add(deltaX, deltaY, deltaZ));

    boolean collideSuccess = false;

    int x = MathUtils.floor(e.getPosition().x);
    int y = MathUtils.floor(e.getPosition().y);
    int z = MathUtils.floor(e.getPosition().z);

    IChunk chunk = game.getWorld().getChunk(x, z);
    if (chunk == null)
        return true;

    int cx = x & (game.getWorld().getChunkSize() - 1);
    int cz = z & (game.getWorld().getChunkSize() - 1);
    try {
        Block block = chunk.getBlock(cx, y, cz);

        for (Vector3 corner : getCorners(newBB)) {
            collideSuccess = collideSuccess || checkCollision(corner);
        }

        return collideSuccess ||
                (block != null && block.isSolid()
                        && block.calculateBoundingBox(chunk, cx, y, cz).intersects(newBB));
    } catch(CoordinatesOutOfBoundsException ex) {
        ex.printStackTrace();
        return true;
    }
}

@Override
public BoundingBox calculateBoundingBox(IChunk c, int x, int y, int z) {
    short metadata = 0;
    try {
        metadata = c.getMeta(x, y, z);
    } catch (CoordinatesOutOfBoundsException e) {
        e.printStackTrace();
    }

    return new BoundingBox(new Vector3(c.getStartPosition().x+x, y, c.getStartPosition().z+z),
            new Vector3(c.getStartPosition().x+x+1, y+getHeight(metadata), c.getStartPosition().z+z+1));
}

@Override
public BoundingBox calculateBoundingBox(IChunk c, int x, int y, int z) {
    short metadata = 0;
    try {
        metadata = c.getMeta(x, y, z);
    } catch (CoordinatesOutOfBoundsException e) {
        e.printStackTrace();
    }

    return new BoundingBox(new Vector3(c.getStartPosition().x+x, y, c.getStartPosition().z+z),
            new Vector3(c.getStartPosition().x+x+1, y+getHeight(metadata), c.getStartPosition().z+z+1));
}

/** Creates an explosion that applies forces to the bodies relative to their position and the given x and y values.
 *
 * @param maxForce The maximum force to be applied to the bodies (diminishes as distance from touch increases). */
private void createExplosion (float x, float y, float maxForce) {
    float force;
    Vector2 touch = new Vector2(x, y);
    for (int i = 0; i < bodies.length; i++) {
        Body b = bodies[i];
        Vector2 v = b.getPosition();
        float dist = v.dst2(touch);

        if (dist == 0)
            force = maxForce;
        else
            force = MathUtils.clamp(maxForce / dist, 0, maxForce);

        float angle = v.cpy().sub(touch).angle();
        float xForce = force * MathUtils.cosDeg(angle);
        float yForce = force * MathUtils.sinDeg(angle);

        Vector3 touch3, v3, boundMin, boundMax, intersection;
        touch3 = new Vector3(touch.x, touch.y, 0);
        v3 = new Vector3(v.x, v.y, 0);
        boundMin = new Vector3(v.x - 1, v.y - 1, 0);
        boundMax = new Vector3(v.x + 1, v.y + 1, 0);
        intersection = Vector3.Zero;

        Intersector.intersectRayBounds(new Ray(touch3, v3), new BoundingBox(boundMin, boundMax), intersection);

        b.applyForce(new Vector2(xForce, yForce), new Vector2(intersection.x, intersection.y), true);
    }
}

public TerrainEngine(Level level) {
  this.frustrumOctreeQuery  = new FrustrumClassFilterOctreeQuery();
  this.tempObjects          = new Array<OctreeObject>();
  this.visibleChunks        = new Array<Chunk>();
  this.visibleTerrainFaces  = new Array<VoxelChunkRenderable>();
  this.visibleWaterFaces    = new Array<VoxelChunkRenderable>();
  this.chunks               = new Array<Chunk>();
  this.map                  = level.terrainMap;
  this.octree               = level.octree;
  this.geometryProvider     = level.terrainGeometryProvider;
  this.tempBox              = new BoundingBox();
  frustrumOctreeQuery.setKlass(Chunk.class);
}

public OctreeNode() {
  this.tempA    = new Vector3();
  this.tempB    = new Vector3();
  this.tempC    = new Vector3();
  this.level    = 0;
  this.objects  = new Array<OctreeObject>();
  this.nodes    = new Array<OctreeNode>();
  this.bounds   = new BoundingBox();
  this.parent   = null;
  this.maxObjects = 24;
  clear();
}

public int getIndex(BoundingBox pRect) {
  int index = -1;
  if (haveNodes()) {
    for (int i = 0; i < nodes.size; i++) {
      OctreeNode node = nodes.get(i);
      if (node.contains(pRect)) {
        index = i;
        break;
      }
    }
  }
  return index;
}

public void retrieve(Array<OctreeObject> returnObjects, BoundingBox object) {
  int index = getIndex(object);
  if (index != -1 && haveNodes()) {
    nodes.get(index).retrieve(returnObjects, object);
  }
  returnObjects.addAll(objects);
}

public Kryo create () {
  Kryo kryo = new Kryo();
  kryo.register(GameDatabase.class, new GameDatabaseSerializer());
  kryo.register(LevelState.class, new FullLevelStateSerializer());
  kryo.register(ChunkMap.class, new ChunkMapDataSerializer());
  kryo.register(Voxel.class, new VoxelSerializer());
  kryo.register(Vector3.class, new Vector3Serializer());
  kryo.register(LevelEnv.class, new LevelEnvSerializer());
  kryo.register(Vector2.class, new Vector2Serializer());
  kryo.register(Color.class, new ColorSerializer());
  kryo.register(DirectionalLight.class, new DirectionalLightSerializer());
  kryo.register(Asset.class, new AssetSerializer());
  kryo.register(BoundingBox.class, new BoundingBoxSerializer());
  kryo.register(VoxelChunkRenderable.class, new VoxelFaceRenderableSerializer());
  kryo.register(Matrix4.class, new Matrix4Serializer());
  kryo.register(Vector3i.class, new Vector3iSerializer());
  kryo.register(Teleport.class, new PlayerStartPositionSerializer());
  kryo.register(TextureAsset.class, new AssetSerializer());
  kryo.register(ModelAsset.class, new AssetSerializer());
  kryo.register(CubemapAsset.class, new AssetSerializer());
  kryo.setDefaultSerializer(TaggedFieldSerializer.class);
  kryo.register(Skybox.class, new SkyboxSerializer());
  kryo.register(CubemapSkybox.class, new SkyboxSerializer());
  kryo.register(DayNightSkybox.class, new SkyboxSerializer());
  kryo.register(WaterEnv.class, new WaterEnvSerializer());
  kryo.register(DynamicGeometryProvider.class, new TerrainGeometryProviderSerializer());
  kryo.register(VoxelChunkRenderableFactory.class, new VoxelChunkRenderableFactorySerializer());
  kryo.register(ChunkPartCollider.class, new ChunkPartColliderSerializer());
  kryo.register(OrthographicDirectionalLight.class, new OrthographicDirectionalLightSerializer());
  return kryo;
}

@Override
public VoxelChunkRenderable read(Kryo kryo, Input input, Class<VoxelChunkRenderable> type) {
  VoxelChunkRenderable renderable = new VoxelChunkRenderable();
  renderable.material             = kryo.readObjectOrNull(input, Material.class);
  renderable.direction            = kryo.readObject(input, Vector3.class);
  renderable.boundingBox          = kryo.readObject(input, BoundingBox.class);
  renderable.primitiveType        = input.readInt();
  renderable.triangleCount        = input.readInt();
  renderable.worldTransform.set(kryo.readObject(input, Matrix4.class));

  int maxVerticies                = input.readInt();
  float[] vertBuff                = new float[maxVerticies];

  for (int pos = 0; pos < maxVerticies; pos++) {
    vertBuff[pos] = input.readFloat();
  }

  int numIndicies         = input.readInt();
  short[] indiBuff        = new short[numIndicies];

  for (int pos = 0; pos < numIndicies; pos++) {
    indiBuff[pos] = input.readShort();
  }

  renderable.meshFactory = new MeshFactory(vertBuff, indiBuff, MeshVertexInfo.voxelAttributes());
  return renderable;
}

public DebugSystem(Level level) {
  super();
  this.entities         = new Array<Entity>();
  this.family           = Family.getFor(PositionComponent.class);
  this.level            = level;
  this.batch            = level.batch;
  this.context          = level.renderContext;
  this.dynamicOctree    = level.octree;
  this.terrainOctree    = level.octree;
  this.camera           = level.camera;
  this.terrain          = level.terrainEngine;
  this.frustrumDebugger = level.frustrumDebugger;
  this.tempBox          = new BoundingBox();
  this.tempVec          = new Vector3();
}

/** Extends the bounding box with the bounds of this model instance. This is a potential slow operation, it is advised to cache
 * the result.
 * @param out the {@link BoundingBox} that will be extended with the bounds.
 * @return the out parameter for chaining */
public BoundingBox extendBoundingBox (final BoundingBox out) {
    final int n = nodes.size;
    for (int i = 0; i < n; i++)
        nodes.get(i).extendBoundingBox(out);
    return out;
}