/** Moves the entity based on the specified heading. */
  public void moveEntityWithHeading(float strafe, float forward) {
    Entity entity = this.getPassengers().isEmpty() ? null : (Entity) this.getPassengers().get(0);

    if (this.isBeingRidden() && this.canBeSteered()) {
      this.rotationYaw = entity.rotationYaw;
      this.prevRotationYaw = this.rotationYaw;
      this.rotationPitch = entity.rotationPitch * 0.5F;
      this.setRotation(this.rotationYaw, this.rotationPitch);
      this.renderYawOffset = this.rotationYaw;
      this.rotationYawHead = this.rotationYaw;
      this.stepHeight = 1.0F;
      this.jumpMovementFactor = this.getAIMoveSpeed() * 0.1F;

      if (this.canPassengerSteer()) {
        float f =
            (float)
                    this.getEntityAttribute(SharedMonsterAttributes.MOVEMENT_SPEED)
                        .getAttributeValue()
                * 0.225F;

        if (this.boosting) {
          if (this.boostTime++ > this.totalBoostTime) {
            this.boosting = false;
          }

          f +=
              f
                  * 1.15F
                  * MathHelper.sin(
                      (float) this.boostTime / (float) this.totalBoostTime * (float) Math.PI);
        }

        this.setAIMoveSpeed(f);
        super.moveEntityWithHeading(0.0F, 1.0F);
      } else {
        this.motionX = 0.0D;
        this.motionY = 0.0D;
        this.motionZ = 0.0D;
      }

      this.prevLimbSwingAmount = this.limbSwingAmount;
      double d1 = this.posX - this.prevPosX;
      double d0 = this.posZ - this.prevPosZ;
      float f1 = MathHelper.sqrt_double(d1 * d1 + d0 * d0) * 4.0F;

      if (f1 > 1.0F) {
        f1 = 1.0F;
      }

      this.limbSwingAmount += (f1 - this.limbSwingAmount) * 0.4F;
      this.limbSwing += this.limbSwingAmount;
    } else {
      this.stepHeight = 0.5F;
      this.jumpMovementFactor = 0.02F;
      super.moveEntityWithHeading(strafe, forward);
    }
  }
  protected void preRenderCallback(EntityAntiCreeper par1EntityAntiCreeper, float par2) {
    float f1 = par1EntityAntiCreeper.getCreeperFlashIntensity(par2);
    float f2 = 1.0F + MathHelper.sin(f1 * 100.0F) * f1 * 0.01F;

    if (f1 < 0.0F) f1 = 0.0F;

    if (f1 > 1.0F) f1 = 1.0F;

    f1 *= f1;
    f1 *= f1;
    float f3 = (1.0F + f1 * 0.4F) * f2;
    float f4 = (1.0F + f1 * 0.1F) / f2;
    GL11.glScalef(f3, f4, f3);
  }
  /** Renders the desired {@code T} type Entity. */
  public void doRender(
      EntityFishHook entity, double x, double y, double z, float entityYaw, float partialTicks) {
    GlStateManager.pushMatrix();
    GlStateManager.translate((float) x, (float) y, (float) z);
    GlStateManager.enableRescaleNormal();
    GlStateManager.scale(0.5F, 0.5F, 0.5F);
    this.bindEntityTexture(entity);
    Tessellator tessellator = Tessellator.getInstance();
    VertexBuffer vertexbuffer = tessellator.getBuffer();
    int i = 1;
    int j = 2;
    float f = 0.0625F;
    float f1 = 0.125F;
    float f2 = 0.125F;
    float f3 = 0.1875F;
    float f4 = 1.0F;
    float f5 = 0.5F;
    float f6 = 0.5F;
    GlStateManager.rotate(180.0F - this.renderManager.playerViewY, 0.0F, 1.0F, 0.0F);
    GlStateManager.rotate(
        (float) (this.renderManager.options.thirdPersonView == 2 ? -1 : 1)
            * -this.renderManager.playerViewX,
        1.0F,
        0.0F,
        0.0F);

    if (this.renderOutlines) {
      GlStateManager.enableColorMaterial();
      GlStateManager.enableOutlineMode(this.getTeamColor(entity));
    }

    vertexbuffer.begin(7, DefaultVertexFormats.POSITION_TEX_NORMAL);
    vertexbuffer.pos(-0.5D, -0.5D, 0.0D).tex(0.0625D, 0.1875D).normal(0.0F, 1.0F, 0.0F).endVertex();
    vertexbuffer.pos(0.5D, -0.5D, 0.0D).tex(0.125D, 0.1875D).normal(0.0F, 1.0F, 0.0F).endVertex();
    vertexbuffer.pos(0.5D, 0.5D, 0.0D).tex(0.125D, 0.125D).normal(0.0F, 1.0F, 0.0F).endVertex();
    vertexbuffer.pos(-0.5D, 0.5D, 0.0D).tex(0.0625D, 0.125D).normal(0.0F, 1.0F, 0.0F).endVertex();
    tessellator.draw();

    if (this.renderOutlines) {
      GlStateManager.disableOutlineMode();
      GlStateManager.disableColorMaterial();
    }

    GlStateManager.disableRescaleNormal();
    GlStateManager.popMatrix();

    if (entity.angler != null && !this.renderOutlines) {
      int k = entity.angler.getPrimaryHand() == EnumHandSide.RIGHT ? 1 : -1;
      float f7 = entity.angler.getSwingProgress(partialTicks);
      float f8 = MathHelper.sin(MathHelper.sqrt_float(f7) * (float) Math.PI);
      float f9 =
          (entity.angler.prevRenderYawOffset
                  + (entity.angler.renderYawOffset - entity.angler.prevRenderYawOffset)
                      * partialTicks)
              * 0.017453292F;
      double d0 = (double) MathHelper.sin(f9);
      double d1 = (double) MathHelper.cos(f9);
      double d2 = (double) k * 0.35D;
      double d3 = 0.8D;
      double d4;
      double d5;
      double d6;
      double d7;

      if ((this.renderManager.options == null || this.renderManager.options.thirdPersonView <= 0)
          && entity.angler == Minecraft.getMinecraft().thePlayer) {
        Vec3d vec3d = new Vec3d((double) k * -0.36D, -0.05D, 0.4D);
        vec3d =
            vec3d.rotatePitch(
                -(entity.angler.prevRotationPitch
                        + (entity.angler.rotationPitch - entity.angler.prevRotationPitch)
                            * partialTicks)
                    * 0.017453292F);
        vec3d =
            vec3d.rotateYaw(
                -(entity.angler.prevRotationYaw
                        + (entity.angler.rotationYaw - entity.angler.prevRotationYaw)
                            * partialTicks)
                    * 0.017453292F);
        vec3d = vec3d.rotateYaw(f8 * 0.5F);
        vec3d = vec3d.rotatePitch(-f8 * 0.7F);
        d4 =
            entity.angler.prevPosX
                + (entity.angler.posX - entity.angler.prevPosX) * (double) partialTicks
                + vec3d.xCoord;
        d5 =
            entity.angler.prevPosY
                + (entity.angler.posY - entity.angler.prevPosY) * (double) partialTicks
                + vec3d.yCoord;
        d6 =
            entity.angler.prevPosZ
                + (entity.angler.posZ - entity.angler.prevPosZ) * (double) partialTicks
                + vec3d.zCoord;
        d7 = (double) entity.angler.getEyeHeight();
      } else {
        d4 =
            entity.angler.prevPosX
                + (entity.angler.posX - entity.angler.prevPosX) * (double) partialTicks
                - d1 * d2
                - d0 * 0.8D;
        d5 =
            entity.angler.prevPosY
                + (double) entity.angler.getEyeHeight()
                + (entity.angler.posY - entity.angler.prevPosY) * (double) partialTicks
                - 0.45D;
        d6 =
            entity.angler.prevPosZ
                + (entity.angler.posZ - entity.angler.prevPosZ) * (double) partialTicks
                - d0 * d2
                + d1 * 0.8D;
        d7 = entity.angler.isSneaking() ? -0.1875D : 0.0D;
      }

      double d13 = entity.prevPosX + (entity.posX - entity.prevPosX) * (double) partialTicks;
      double d8 = entity.prevPosY + (entity.posY - entity.prevPosY) * (double) partialTicks + 0.25D;
      double d9 = entity.prevPosZ + (entity.posZ - entity.prevPosZ) * (double) partialTicks;
      double d10 = (double) ((float) (d4 - d13));
      double d11 = (double) ((float) (d5 - d8)) + d7;
      double d12 = (double) ((float) (d6 - d9));
      GlStateManager.disableTexture2D();
      GlStateManager.disableLighting();
      vertexbuffer.begin(3, DefaultVertexFormats.POSITION_COLOR);
      int l = 16;

      for (int i1 = 0; i1 <= 16; ++i1) {
        float f10 = (float) i1 / 16.0F;
        vertexbuffer
            .pos(
                x + d10 * (double) f10,
                y + d11 * (double) (f10 * f10 + f10) * 0.5D + 0.25D,
                z + d12 * (double) f10)
            .color(0, 0, 0, 255)
            .endVertex();
      }

      tessellator.draw();
      GlStateManager.enableLighting();
      GlStateManager.enableTexture2D();
      super.doRender(entity, x, y, z, entityYaw, partialTicks);
    }
  }
示例#4
0
    public BakedFluid(
        Optional<TRSRTransformation> transformation,
        ImmutableMap<TransformType, TRSRTransformation> transforms,
        VertexFormat format,
        int color,
        TextureAtlasSprite still,
        TextureAtlasSprite flowing,
        boolean gas,
        boolean statePresent,
        int[] cornerRound,
        int flowRound) {
      this.transformation = transformation;
      this.transforms = transforms;
      this.format = format;
      this.color = color;
      this.still = still;
      this.flowing = flowing;
      this.gas = gas;

      faceQuads = Maps.newEnumMap(EnumFacing.class);
      for (EnumFacing side : EnumFacing.values()) {
        faceQuads.put(side, ImmutableList.<BakedQuad>of());
      }

      if (statePresent) {
        float[] y = new float[4];
        for (int i = 0; i < 4; i++) {
          if (gas) {
            y[i] = 1 - cornerRound[i] / 768f;
          } else {
            y[i] = cornerRound[i] / 768f;
          }
        }

        float flow = (float) Math.toRadians(flowRound);

        // top

        TextureAtlasSprite topSprite = flowing;
        float scale = 4;
        if (flow < -17F) {
          flow = 0;
          scale = 8;
          topSprite = still;
        }

        float c = MathHelper.cos(flow) * scale;
        float s = MathHelper.sin(flow) * scale;

        EnumFacing side = gas ? EnumFacing.DOWN : EnumFacing.UP;
        UnpackedBakedQuad.Builder builder;
        ImmutableList.Builder<BakedQuad> topFaceBuilder = ImmutableList.builder();
        for (int k = 0; k < 2; k++) {
          builder = new UnpackedBakedQuad.Builder(format);
          builder.setQuadOrientation(side);
          builder.setTexture(topSprite);
          for (int i = gas ? 3 : 0; i != (gas ? -1 : 4); i += (gas ? -1 : 1)) {
            int l = (k * 3) + (1 - 2 * k) * i;
            putVertex(
                builder,
                side,
                x[l],
                y[l],
                z[l],
                topSprite.getInterpolatedU(8 + c * (x[l] * 2 - 1) + s * (z[l] * 2 - 1)),
                topSprite.getInterpolatedV(
                    8 + c * (x[(l + 1) % 4] * 2 - 1) + s * (z[(l + 1) % 4] * 2 - 1)));
          }
          topFaceBuilder.add(builder.build());
        }
        faceQuads.put(side, topFaceBuilder.build());

        // bottom

        side = side.getOpposite();
        builder = new UnpackedBakedQuad.Builder(format);
        builder.setQuadOrientation(side);
        builder.setTexture(still);
        for (int i = gas ? 3 : 0; i != (gas ? -1 : 4); i += (gas ? -1 : 1)) {
          putVertex(
              builder,
              side,
              z[i],
              gas ? 1 : 0,
              x[i],
              still.getInterpolatedU(z[i] * 16),
              still.getInterpolatedV(x[i] * 16));
        }
        faceQuads.put(side, ImmutableList.<BakedQuad>of(builder.build()));

        // sides

        for (int i = 0; i < 4; i++) {
          side = EnumFacing.getHorizontal((5 - i) % 4);
          BakedQuad q[] = new BakedQuad[2];

          for (int k = 0; k < 2; k++) {
            builder = new UnpackedBakedQuad.Builder(format);
            builder.setQuadOrientation(side);
            builder.setTexture(flowing);
            for (int j = 0; j < 4; j++) {
              int l = (k * 3) + (1 - 2 * k) * j;
              float yl = z[l] * y[(i + x[l]) % 4];
              if (gas && z[l] == 0) yl = 1;
              putVertex(
                  builder,
                  side,
                  x[(i + x[l]) % 4],
                  yl,
                  z[(i + x[l]) % 4],
                  flowing.getInterpolatedU(x[l] * 8),
                  flowing.getInterpolatedV((gas ? yl : 1 - yl) * 8));
            }
            q[k] = builder.build();
          }
          faceQuads.put(side, ImmutableList.of(q[0], q[1]));
        }
      } else {
        // 1 quad for inventory
        UnpackedBakedQuad.Builder builder = new UnpackedBakedQuad.Builder(format);
        builder.setQuadOrientation(EnumFacing.UP);
        builder.setTexture(still);
        for (int i = 0; i < 4; i++) {
          putVertex(
              builder,
              EnumFacing.UP,
              z[i],
              x[i],
              0,
              still.getInterpolatedU(z[i] * 16),
              still.getInterpolatedV(x[i] * 16));
        }
        faceQuads.put(EnumFacing.SOUTH, ImmutableList.<BakedQuad>of(builder.build()));
      }
    }