mffs/src/main/java/mffs/item/module/projector/ItemModeCylinder.java

package mffs.item.module.projector;

import calclavia.lib.CalculationHelper;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import java.util.HashSet;
import java.util.Set;
import mffs.api.IFieldInteraction;
import mffs.api.IProjector;
import mffs.item.mode.ItemMode;
import mffs.render.model.ModelCube;
import net.minecraft.tileentity.TileEntity;
import org.lwjgl.opengl.GL11;
import universalelectricity.core.vector.Vector3;

public class ItemModeCylinder extends ItemMode {

  public ItemModeCylinder() { super("modeCylinder"); }

  @Override
  public Set<Vector3> getExteriorPoints(final IFieldInteraction projector) {
    final Set<Vector3> fieldBlocks = new HashSet<>();
    final Vector3 posScale = projector.getPositiveScale();
    final Vector3 negScale = projector.getNegativeScale();
    final int radius = (posScale.intX() + negScale.intX() + posScale.intZ() +
                        negScale.intZ()) /
                       2;
    final int height = posScale.intY() + negScale.intY();
    for (float x = (float)(-radius); x <= radius; ++x) {
      for (float z = (float)(-radius); z <= radius; ++z) {
        for (float y = 0.0f; y < height; ++y) {
          if ((y == 0.0f || y == height - 1) &&
              x * x + z * z + 0.0f <= radius * radius) {
            fieldBlocks.add(new Vector3(x, y, z));
          }
          if (x * x + z * z + 0.0f <= radius * radius &&
              x * x + z * z + 0.0f >= (radius - 1) * (radius - 1)) {
            fieldBlocks.add(new Vector3(x, y, z));
          }
        }
      }
    }
    return fieldBlocks;
  }

  @Override
  public Set<Vector3> getInteriorPoints(final IFieldInteraction projector) {
    final Set<Vector3> fieldBlocks = new HashSet<>();
    final Vector3 translation = projector.getTranslation();
    final Vector3 posScale = projector.getPositiveScale();
    final Vector3 negScale = projector.getNegativeScale();
    final int radius = (posScale.intX() + negScale.intX() + posScale.intZ() +
                        negScale.intZ()) /
                       2;
    final int height = posScale.intY() + negScale.intY();
    for (int x = -radius; x <= radius; ++x) {
      for (int z = -radius; z <= radius; ++z) {
        for (int y = 0; y < height; ++y) {
          final Vector3 position = new Vector3(x, y, z);
          if (this.isInField(
                  projector,
                  Vector3.add(position, new Vector3((TileEntity)projector))
                      .add(translation))) {
            fieldBlocks.add(position);
          }
        }
      }
    }
    return fieldBlocks;
  }

  @Override
  public boolean isInField(final IFieldInteraction projector,
                           final Vector3 position) {
    final Vector3 posScale = projector.getPositiveScale();
    final Vector3 negScale = projector.getNegativeScale();
    final int radius = (posScale.intX() + negScale.intX() + posScale.intZ() +
                        negScale.intZ()) /
                       2;
    final Vector3 projectorPos = new Vector3((TileEntity)projector);
    projectorPos.add(projector.getTranslation());
    final Vector3 relativePosition = position.clone().subtract(projectorPos);
    CalculationHelper.rotateByAngle(relativePosition,
                                    -projector.getRotationYaw(),
                                    -projector.getRotationPitch());
    return relativePosition.x * relativePosition.x +
        relativePosition.z * relativePosition.z + 0.0 <=
        radius * radius;
  }

  @SideOnly(Side.CLIENT)
  @Override
  public void render(final IProjector projector, final double x, final double y,
                     final double z, final float f, final long ticks) {
    final float scale = 0.15f;
    final float detail = 0.5f;
    GL11.glScalef(scale, scale, scale);
    final float radius = 1.5f;
    int i = 0;
    for (float renderX = -radius; renderX <= radius; renderX += detail) {
      for (float renderZ = -radius; renderZ <= radius; renderZ += detail) {
        for (float renderY = -radius; renderY <= radius; renderY += detail) {
          if ((renderX * renderX + renderZ * renderZ + 0.0f <=
                   radius * radius &&
               renderX * renderX + renderZ * renderZ + 0.0f >=
                   (radius - 1.0f) * (radius - 1.0f)) ||
              ((renderY == 0.0f || renderY == radius - 1.0f) &&
               renderX * renderX + renderZ * renderZ + 0.0f <=
                   radius * radius)) {
            if (i % 2 == 0) {
              final Vector3 vector = new Vector3(renderX, renderY, renderZ);
              GL11.glTranslated(vector.x, vector.y, vector.z);
              ModelCube.INSTNACE.render();
              GL11.glTranslated(-vector.x, -vector.y, -vector.z);
            }
            ++i;
          }
        }
      }
    }
  }
}