Examples with Polygon org.valkyrienskies.mod.common.collision.Polygon used on opensource projects

Example 1 with Polygon

use of org.valkyrienskies.mod.common.collision.Polygon in project Valkyrien-Warfare-Revamped by ValkyrienWarfare.

the class MixinWorld method preGetCollisionBoxes.

/**
 * Used for two purposes. The first, is to prevent the game from freezing by limiting the size of aabb. The second
 * is to fix player sneaking on ships.
 */
@Inject(method = "getCollisionBoxes(Lnet/minecraft/entity/Entity;Lnet/minecraft/util/math/AxisAlignedBB;ZLjava/util/List;)Z", at = @At("HEAD"), cancellable = true)
private void preGetCollisionBoxes(@Nullable Entity entityIn, AxisAlignedBB aabb, boolean p_191504_3_, @Nullable List<AxisAlignedBB> outList, CallbackInfoReturnable<Boolean> callbackInfo) {
    double deltaX = Math.abs(aabb.maxX - aabb.minX);
    double deltaY = Math.abs(aabb.maxY - aabb.minY);
    double deltaZ = Math.abs(aabb.maxZ - aabb.minZ);
    if (Math.max(deltaX, Math.max(deltaY, deltaZ)) > 99999D) {
        System.err.println(entityIn + "\ntried going extremely fast during the collision step");
        new Exception().printStackTrace();
        callbackInfo.setReturnValue(Boolean.FALSE);
        callbackInfo.cancel();
    }
    // direction, and uses that to determine if can you sneak.
    if (entityIn instanceof EntityPlayer && entityIn.isSneaking()) {
        // Add at most once ship block AABB that is colliding with the player. This is ONLY to properly allow
        // players to sneak while on ships.
        List<PhysicsObject> ships = getManager().getPhysObjectsInAABB(aabb);
        for (PhysicsObject wrapper : ships) {
            Polygon playerInLocal = new Polygon(aabb, wrapper.getShipTransformationManager().getCurrentTickTransform(), TransformType.GLOBAL_TO_SUBSPACE);
            AxisAlignedBB bb = playerInLocal.getEnclosedAABB();
            if ((bb.maxX - bb.minX) * (bb.maxZ - bb.minZ) > 9898989) {
                // This is too big, something went wrong here
                System.err.println("Why did transforming a players bounding box result in a giant bounding box?");
                System.err.println(bb + "\n" + wrapper.getShipData() + "\n" + entityIn.toString());
                new Exception().printStackTrace();
                return;
            }
            List<AxisAlignedBB> collidingBBs = getCollisionBoxes(null, bb);
            Polygon entityPoly = new Polygon(aabb.grow(-.2, 0, -.2));
            for (AxisAlignedBB inLocal : collidingBBs) {
                ShipPolygon poly = new ShipPolygon(inLocal, wrapper.getShipTransformationManager().getCurrentTickTransform(), TransformType.SUBSPACE_TO_GLOBAL, wrapper.getShipTransformationManager().normals, wrapper);
                EntityPolygonCollider collider = new EntityPolygonCollider(entityPoly, poly, poly.normals, new Vector3d());
                collider.processData();
                if (!collider.arePolygonsSeparated()) {
                    outList.add(inLocal);
                    // vanilla sneak code will work correctly.
                    return;
                }
            }
        }
    }
}

Example 2 with Polygon

use of org.valkyrienskies.mod.common.collision.Polygon in project Valkyrien-Warfare-Revamped by ValkyrienWarfare.

the class MixinWorld method getEntitiesInAABBexcluding.

/**
 * aa
 *
 * @author xd
 */
@Overwrite
public List<Entity> getEntitiesInAABBexcluding(@Nullable Entity entityIn, AxisAlignedBB boundingBox, @Nullable Predicate<? super Entity> predicate) {
    if (isBoundingBoxTooLarge(boundingBox)) {
        new Exception("Tried getting entities from giant bounding box of " + boundingBox).printStackTrace();
        return new ArrayList<>();
    }
    List<Entity> toReturn = this.getEntitiesInAABBexcludingOriginal(entityIn, boundingBox, predicate);
    BlockPos pos = new BlockPos((boundingBox.minX + boundingBox.maxX) / 2D, (boundingBox.minY + boundingBox.maxY) / 2D, (boundingBox.minZ + boundingBox.maxZ) / 2D);
    Optional<PhysicsObject> physicsObject = ValkyrienUtils.getPhysoManagingBlock(World.class.cast(this), pos);
    if (physicsObject.isPresent()) {
        Polygon poly = new Polygon(boundingBox, physicsObject.get().getShipTransformationManager().getCurrentTickTransform(), TransformType.SUBSPACE_TO_GLOBAL);
        boundingBox = poly.getEnclosedAABB().shrink(.3D);
        if (isBoundingBoxTooLarge(boundingBox)) {
            new Exception("Tried getting entities from giant bounding box of " + boundingBox).printStackTrace();
            return new ArrayList<>();
        }
        toReturn.addAll(this.getEntitiesInAABBexcludingOriginal(entityIn, boundingBox, predicate));
    }
    return toReturn;
}

Example 3 with Polygon

use of org.valkyrienskies.mod.common.collision.Polygon in project Valkyrien-Warfare-Revamped by ValkyrienWarfare.

the class PhysRenderChunk method renderBlockLayer.

public void renderBlockLayer(BlockRenderLayer layerToRender, double partialTicks, int pass, ICamera iCamera) {
    for (int i = 0; i < 16; i++) {
        IVSRenderChunk renderChunk = renderChunks[i];
        if (renderChunk != null) {
            AxisAlignedBB renderChunkBB = new AxisAlignedBB(chunk.x << 4, renderChunk.minY(), chunk.z << 4, (chunk.x << 4) + 16, renderChunk.minY() + 16, (chunk.z << 4) + 16);
            Polygon polygon = new Polygon(renderChunkBB, toRender.getShipTransformationManager().getRenderTransform(), TransformType.SUBSPACE_TO_GLOBAL);
            AxisAlignedBB inWorldBB = polygon.getEnclosedAABB();
            // Only render chunks that can be shown by the camera.
            if (iCamera.isBoundingBoxInFrustum(inWorldBB)) {
                renderChunk.renderBlockLayer(layerToRender, partialTicks, pass);
            }
        }
    }
}

Example 4 with Polygon

use of org.valkyrienskies.mod.common.collision.Polygon in project Valkyrien-Warfare-Revamped by ValkyrienWarfare.

the class EntityCollisionInjector method alterEntityMovement.

// Returns false if game should use default collision
@Nullable
public static IntermediateMovementVariableStorage alterEntityMovement(Entity entity, MoverType type, double dx, double dy, double dz) {
    final double origDx = dx;
    final double origDy = dy;
    final double origDz = dz;
    final double origPosX = entity.posX;
    final double origPosY = entity.posY;
    final double origPosZ = entity.posZ;
    boolean isLiving = entity instanceof EntityLivingBase;
    Vec3d velocity = new Vec3d(dx, dy, dz);
    Polygon playerBeforeMove = new Polygon(entity.getEntityBoundingBox());
    List<Polygon> colPolys = getCollidingPolygonsAndDoBlockCols(entity, velocity);
    PhysicsObject worldBelow = null;
    IDraggable draggable = EntityDraggable.getDraggableFromEntity(entity);
    final EntityShipMovementData lastTickEntityShipMovementData = draggable.getEntityShipMovementData();
    Vector3d total = new Vector3d();
    // Used to reset the player position after collision processing, effectively
    // using the player to integrate their velocity
    double posOffestX = 0;
    double posOffestY = 0;
    double posOffestZ = 0;
    // True IFF the player is on a ladder
    boolean isPlayerOnLadder = false;
    // region Ladder movement
    if (entity instanceof EntityLivingBase) {
        final EntityLivingBase base = (EntityLivingBase) entity;
        final List<PhysicsObject> collidingShips = ((IHasShipManager) entity.getEntityWorld()).getManager().getPhysObjectsInAABB(base.getEntityBoundingBox());
        final Iterable<Triple<PhysicsObject, BlockPos, IBlockState>> ladderCollisions = getLadderCollisions(base, collidingShips);
        // For now, just ignore the y component. I may or may not use it later.
        final float forward = ((EntityLivingBase) entity).moveForward;
        final float strafe = ((EntityLivingBase) entity).moveStrafing;
        final double f1 = Math.sin(Math.toRadians(entity.rotationYaw));
        final double f2 = Math.cos(Math.toRadians(entity.rotationYaw));
        final double intendedXVel = strafe * f2 - forward * f1;
        final double intendedYVel = 0;
        final double intendedZVel = forward * f2 + strafe * f1;
        final Vector3dc originalVelocityDirection = new Vector3d(intendedXVel, intendedYVel, intendedZVel).normalize();
        final World world = entity.world;
        final Polygon playerPolygon = new Polygon(base.getEntityBoundingBox());
        for (final Triple<PhysicsObject, BlockPos, IBlockState> ladderCollision : ladderCollisions) {
            final IBlockState ladderState = ladderCollision.getRight();
            EnumFacing ladderFacing = null;
            // For now, we only support a few blocks
            if (ladderState.getPropertyKeys().contains(BlockHorizontal.FACING)) {
                ladderFacing = ladderState.getValue(BlockHorizontal.FACING);
            }
            // We need the EnumFacing of the ladder for the code to work. If we couldn't find it then just give up :/
            if (ladderFacing != null) {
                final Vector3d ladderNormal = JOML.convertDouble(ladderFacing.getDirectionVec());
                final ShipTransform shipTransform = ladderCollision.getLeft().getShipTransform();
                // Grow the ladder BB by a small margin (makes the ladder experience better imo)
                final AxisAlignedBB ladderBB = ladderCollision.getRight().getBoundingBox(world, ladderCollision.getMiddle()).offset(ladderCollision.getMiddle()).grow(.4);
                final Polygon ladderPoly = new Polygon(ladderBB, shipTransform.getSubspaceToGlobal());
                // Determine if the player is actually colliding with the ladder
                final PhysPolygonCollider collider = new PhysPolygonCollider(playerPolygon, ladderPoly, ladderCollision.getLeft().getShipTransformationManager().normals);
                collider.processData();
                shipTransform.transformDirection(ladderNormal, TransformType.SUBSPACE_TO_GLOBAL);
                // Don't use "floor ladders"
                final boolean isLadderFacingDown = ladderNormal.y > .8;
                if (isLadderFacingDown) {
                    continue;
                }
                // If the ladder is facing up, then let the player use them like monkey bars
                final boolean isLadderFacingUp = ladderNormal.y < -.8;
                // Whether or not the player is actually colliding with a ladder, since it is close to one we give the player ladder movement.
                dx = MathHelper.clamp(dx, -.15, .15);
                dz = MathHelper.clamp(dz, -.15, .15);
                base.fallDistance = 0;
                if (!isLadderFacingUp) {
                    // Use ladders like normal
                    if (dy < -.15) {
                        dy = -.15;
                    }
                    final boolean isPlayerGoingTowardsLadder = originalVelocityDirection.dot(ladderNormal) < -.1;
                    final boolean isPlayerSneakingOnLadder = base.isSneaking() && base instanceof EntityPlayer;
                    if (isPlayerSneakingOnLadder && dy < 0) {
                        dy = 0;
                    }
                    if (!collider.seperated && isPlayerGoingTowardsLadder) {
                        dy = .2;
                    }
                } else {
                    // Use ladders like monkey bars
                    dy = .2;
                }
                worldBelow = ladderCollision.getLeft();
                isPlayerOnLadder = true;
                break;
            }
        }
    }
    // endregion
    final Vector3dc velVec = new Vector3d(dx, dy, dz);
    for (Polygon poly : colPolys) {
        if (poly instanceof ShipPolygon) {
            ShipPolygon shipPoly = (ShipPolygon) poly;
            try {
                EntityPolygonCollider fast = new EntityPolygonCollider(playerBeforeMove, shipPoly, shipPoly.normals, velVec.add(total, new Vector3d()));
                if (!fast.arePolygonsSeparated()) {
                    // fastCollisions.add(fast);
                    worldBelow = shipPoly.shipFrom;
                    Vector3d response = fast.getCollisions()[fast.getMinDistanceIndex()].getResponse();
                    // TODO: Add more potential yResponses
                    double stepSquared = entity.stepHeight * entity.stepHeight;
                    // Do not do stair stepping if the player is on a ladder.
                    boolean isStep = isLiving && entity.onGround && !isPlayerOnLadder;
                    if (response.y >= 0 && VSMath.canStandOnNormal(fast.getCollisionAxes()[fast.getMinDistanceIndex()])) {
                        Vector3d slowButStopped = new Vector3d(0, -fast.getCollisions()[fast.getMinDistanceIndex()].getCollisionPenetrationDistance() / fast.getCollisionAxes()[fast.getMinDistanceIndex()].y(), 0);
                        response = slowButStopped;
                    }
                    if (isStep) {
                        EntityLivingBase living = (EntityLivingBase) entity;
                        if (Math.abs(living.moveForward) > .01 || Math.abs(living.moveStrafing) > .01) {
                            for (int i = 3; i < 6; i++) {
                                Vector3d tempResponse = fast.getCollisions()[i].getResponse();
                                if (tempResponse.y > 0 && VSMath.canStandOnNormal(fast.getCollisions()[i].getCollisionNormal()) && tempResponse.lengthSquared() < stepSquared) {
                                    if (tempResponse.lengthSquared() < .1) {
                                        // Too small to be a real step, let it through
                                        response = tempResponse;
                                    } else {
                                        // System.out.println("Try Stepping!");
                                        AxisAlignedBB axisalignedbb = entity.getEntityBoundingBox().offset(tempResponse.x, tempResponse.y, tempResponse.z);
                                        // Don't allow the player to step if the step will put them in another polygon.
                                        boolean collidesWithAnything = false;
                                        {
                                            final AxisAlignedBB newEntityBBShrunk = axisalignedbb.shrink(.15);
                                            final Polygon newEntityBBShrunkPolygon = new Polygon(newEntityBBShrunk);
                                            for (Polygon potentialStepCollision : colPolys) {
                                                if (potentialStepCollision == poly) {
                                                    // Don't run this on ourself
                                                    continue;
                                                }
                                                if (potentialStepCollision.getEnclosedAABB().intersects(newEntityBBShrunk)) {
                                                    // Finer check
                                                    ShipPolygon potentialStepCollisionShipPoly = (ShipPolygon) potentialStepCollision;
                                                    final EntityPolygonCollider checkIfStepCollidesWithBlock = new EntityPolygonCollider(newEntityBBShrunkPolygon, potentialStepCollisionShipPoly, potentialStepCollisionShipPoly.normals, new Vector3d());
                                                    checkIfStepCollidesWithBlock.processData();
                                                    if (!checkIfStepCollidesWithBlock.arePolygonsSeparated()) {
                                                        collidesWithAnything = true;
                                                        break;
                                                    }
                                                }
                                            }
                                        }
                                        if (!collidesWithAnything) {
                                            entity.setEntityBoundingBox(axisalignedbb);
                                            // I think this correct, but it may create more problems than it solves
                                            response.zero();
                                            entity.resetPositionToBB();
                                        }
                                    }
                                }
                            }
                        }
                    }
                    // total.add(response);
                    if (Math.abs(response.x) > .01D) {
                        total.x += response.x;
                    }
                    if (Math.abs(response.y) > .01D) {
                        total.y += response.y;
                    }
                    if (Math.abs(response.z) > .01D) {
                        total.z += response.z;
                    }
                    entity.posX += response.x;
                    entity.posY += response.y;
                    entity.posZ += response.z;
                    posOffestX += response.x;
                    posOffestY += response.y;
                    posOffestZ += response.z;
                    AxisAlignedBB axisalignedbb = entity.getEntityBoundingBox().offset(response.x, response.y, response.z);
                    entity.setEntityBoundingBox(axisalignedbb);
                    entity.resetPositionToBB();
                }
            } catch (Exception e) {
            // Do nothing
            }
        }
    }
    AxisAlignedBB axisalignedbb = entity.getEntityBoundingBox().offset(-posOffestX, -posOffestY, -posOffestZ);
    entity.setEntityBoundingBox(axisalignedbb);
    entity.resetPositionToBB();
    // We are on the ship that we are riding
    if (entity.ridingEntity instanceof EntityMountable) {
        final EntityMountable entityMountable = (EntityMountable) entity.ridingEntity;
        if (entityMountable.getReferencePosOptional().isPresent()) {
            final Optional<PhysicsObject> physicsObjectOptional = ValkyrienUtils.getPhysoManagingBlock(entity.world, entityMountable.getReferencePosOptional().get());
            if (physicsObjectOptional.isPresent()) {
                worldBelow = physicsObjectOptional.get();
            }
        }
    }
    if (worldBelow == null) {
        return null;
    }
    dx += total.x;
    dy += total.y;
    dz += total.z;
    boolean alreadyOnGround = entity.onGround && (dy == origDy) && origDy < 0;
    Vector3d original = new Vector3d(origDx, origDy, origDz);
    Vector3d newMov = new Vector3d(dx - origDx, dy - origDy, dz - origDz);
    entity.collidedHorizontally = original.dot(newMov) < 0;
    entity.collidedVertically = isDifSignificant(dy, origDy);
    entity.onGround = entity.collidedVertically && origDy < 0 || alreadyOnGround;
    entity.collided = entity.collidedHorizontally || entity.collidedVertically;
    // entity.resetPositionToBB();
    double motionYBefore = entity.motionY;
    float oldFallDistance = entity.fallDistance;
    Vector3d dxyz = new Vector3d(dx, dy, dz);
    ;
    Vector3d origDxyz = new Vector3d(origDx, origDy, origDz);
    Vector3d origPosXyz = new Vector3d(origPosX, origPosY, origPosZ);
    return new IntermediateMovementVariableStorage(dxyz, origDxyz, origPosXyz, alreadyOnGround, motionYBefore, oldFallDistance, worldBelow.getShipData());
}

Example 5 with Polygon

use of org.valkyrienskies.mod.common.collision.Polygon in project Valkyrien-Warfare-Revamped by ValkyrienWarfare.

the class EntityCollisionInjector method getCollidingPolygonsAndDoBlockCols.

/*
     * This method generates an arrayList of Polygons that the player is colliding
     * with
     */
public static ArrayList<Polygon> getCollidingPolygonsAndDoBlockCols(Entity entity, Vec3d velocity) {
    ArrayList<Polygon> collisions = new ArrayList<Polygon>();
    AxisAlignedBB entityBB = entity.getEntityBoundingBox().offset(velocity.x, velocity.y, velocity.z).expand(1, 1, 1);
    List<PhysicsObject> ships = ((IHasShipManager) entity.getEntityWorld()).getManager().getPhysObjectsInAABB(entityBB);
    // and the Player
    for (PhysicsObject wrapper : ships) {
        try {
            Polygon playerInLocal = new Polygon(entityBB, wrapper.getShipTransformationManager().getCurrentTickTransform(), TransformType.GLOBAL_TO_SUBSPACE);
            AxisAlignedBB bb = playerInLocal.getEnclosedAABB();
            if ((bb.maxX - bb.minX) * (bb.maxZ - bb.minZ) > 9898989) {
                // This is too big, something went wrong here
                break;
            }
            List<AxisAlignedBB> collidingBBs = entity.world.getCollisionBoxes(entity, bb);
            // TODO: Fix the performance of this!
            if (entity.world.isRemote || entity instanceof EntityPlayer) {
                VSMath.mergeAABBList(collidingBBs);
            }
            for (AxisAlignedBB inLocal : collidingBBs) {
                ShipPolygon poly = new ShipPolygon(inLocal, wrapper.getShipTransformationManager().getCurrentTickTransform(), TransformType.SUBSPACE_TO_GLOBAL, wrapper.getShipTransformationManager().normals, wrapper);
                collisions.add(poly);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    for (PhysicsObject wrapper : ships) {
        double posX = entity.posX;
        double posY = entity.posY;
        double posZ = entity.posZ;
        Vector3d entityPos = new Vector3d(posX, posY, posZ);
        wrapper.getShipTransformationManager().getCurrentTickTransform().transformPosition(entityPos, TransformType.GLOBAL_TO_SUBSPACE);
        setEntityPositionAndUpdateBB(entity, entityPos.x, entityPos.y, entityPos.z);
        int entityChunkX = MathHelper.floor(entity.posX / 16.0D);
        int entityChunkZ = MathHelper.floor(entity.posZ / 16.0D);
        if (wrapper.getChunkClaim().containsChunk(entityChunkX, entityChunkZ)) {
            Chunk chunkIn = wrapper.getChunkAt(entityChunkX, entityChunkZ);
            int chunkYIndex = MathHelper.floor(entity.posY / 16.0D);
            if (chunkYIndex < 0) {
                chunkYIndex = 0;
            }
            if (chunkYIndex >= chunkIn.entityLists.length) {
                chunkYIndex = chunkIn.entityLists.length - 1;
            }
            chunkIn.entityLists[chunkYIndex].add(entity);
            entity.doBlockCollisions();
            chunkIn.entityLists[chunkYIndex].remove(entity);
        }
        setEntityPositionAndUpdateBB(entity, posX, posY, posZ);
    }
    return collisions;
}