package carpet.script.utils;

import carpet.CarpetSettings;
import com.mojang.blaze3d.systems.RenderSystem;
import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
import net.minecraft.client.MinecraftClient;
import net.minecraft.client.font.TextRenderer;
import net.minecraft.client.render.BufferBuilder;
import net.minecraft.client.render.Camera;
import net.minecraft.client.render.Tessellator;
import net.minecraft.client.render.VertexConsumerProvider;
import net.minecraft.client.util.math.AffineTransformation;
import net.minecraft.client.world.ClientWorld;
import net.minecraft.client.render.VertexFormats;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.nbt.ListTag;
import net.minecraft.util.math.Direction;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.math.Matrix4f;
import net.minecraft.util.math.Vec3d;
import net.minecraft.util.registry.RegistryKey;
import net.minecraft.world.World;
import org.lwjgl.opengl.GL11;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiFunction;

public class ShapesRenderer
{
    private final Map<RegistryKey<World>, Long2ObjectOpenHashMap<RenderedShape<? extends ShapeDispatcher.ExpiringShape>>> shapes;
    private MinecraftClient client;

    private Map<String, BiFunction<MinecraftClient, ShapeDispatcher.ExpiringShape, RenderedShape<? extends ShapeDispatcher.ExpiringShape >>> renderedShapes
            = new HashMap<String, BiFunction<MinecraftClient, ShapeDispatcher.ExpiringShape, RenderedShape<? extends ShapeDispatcher.ExpiringShape>>>()
    {{
        put("line", RenderedLine::new);
        put("box", RenderedBox::new);
        put("sphere", RenderedSphere::new);
        put("cylinder", RenderedCylinder::new);
        put("label", RenderedText::new);
    }};

    public ShapesRenderer(MinecraftClient minecraftClient)
    {
        this.client = minecraftClient;
        shapes = new HashMap<>();
    }

    public void render(Camera camera, float partialTick)
    {
        //Camera camera = this.client.gameRenderer.getCamera();
        ClientWorld iWorld = this.client.world;
        RegistryKey<World> dimensionType = iWorld.getRegistryKey();
        if (shapes.get(dimensionType) == null || shapes.get(dimensionType).isEmpty()) return;
        long currentTime = client.world.getTime();
        RenderSystem.disableTexture();
        RenderSystem.enableDepthTest();
        RenderSystem.depthFunc(515);
        RenderSystem.enableBlend();
        RenderSystem.defaultBlendFunc();
        //RenderSystem.blendFuncSeparate(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE, GlStateManager.SrcFactor.ONE, GlStateManager.DstFactor.ZERO);
        //RenderSystem.shadeModel(7425);
        RenderSystem.shadeModel(GL11.GL_FLAT);
        RenderSystem.enableAlphaTest();
        RenderSystem.alphaFunc(GL11.GL_GREATER, 0.003f);
        RenderSystem.disableCull();
        RenderSystem.disableLighting();
        RenderSystem.depthMask(false);
        // causes water to vanish
        //RenderSystem.depthMask(true);
        //RenderSystem.polygonOffset(-3f, -3f);
        //RenderSystem.enablePolygonOffset();
        //Entity entity = this.client.gameRenderer.getCamera().getFocusedEntity();

        Tessellator tessellator = Tessellator.getInstance();
        BufferBuilder bufferBuilder = tessellator.getBuffer();

        // render
        double cameraX = camera.getPos().x;
        double cameraY = camera.getPos().y;
        double cameraZ = camera.getPos().z;

        synchronized (shapes)
        {
            shapes.get(dimensionType).long2ObjectEntrySet().removeIf(
                    entry -> entry.getValue().isExpired(currentTime)
            );

            shapes.get(dimensionType).values().forEach(
                    s ->
                    {
                        if ( !s.lastCall() && s.shouldRender(dimensionType))
                            s.renderFaces(tessellator, bufferBuilder, cameraX, cameraY, cameraZ, partialTick);
                    }
            );
            //lines
            shapes.get(dimensionType).values().forEach(

                    s -> {
                        if (  !s.lastCall() && s.shouldRender(dimensionType))
                            s.renderLines(tessellator, bufferBuilder, cameraX, cameraY, cameraZ, partialTick);
                    }
            );
            //texts
            // maybe we can move it laster to lines and makes sure we don't overpass and don't have blinky transparency problems
            shapes.get(dimensionType).values().forEach(
                    s ->
                    {
                        if ( s.lastCall() && s.shouldRender(dimensionType))
                            s.renderLines(tessellator, bufferBuilder, cameraX, cameraY, cameraZ, partialTick);
                    }
            );

        }
        RenderSystem.enableCull();
        RenderSystem.depthMask(true);
        RenderSystem.lineWidth(1.0F);
        RenderSystem.enableBlend();
        RenderSystem.defaultBlendFunc();
        RenderSystem.enableTexture();
        RenderSystem.shadeModel(7424);
    }

    public void addShapes(ListTag tag)
    {
        for (int i=0, count = tag.size(); i < count; i++)
        {
            addShape(tag.getCompound(i));
        }
    }

    public void addShape(CompoundTag tag)
    {
        ShapeDispatcher.ExpiringShape shape = ShapeDispatcher.fromTag(tag);
        if (shape == null) return;
        BiFunction<MinecraftClient, ShapeDispatcher.ExpiringShape, RenderedShape<? extends ShapeDispatcher.ExpiringShape >> shapeFactory;
        shapeFactory = renderedShapes.get(tag.getString("shape"));
        if (shapeFactory == null)
        {
            CarpetSettings.LOG.info("Unrecognized shape: "+tag.getString("shape"));
        }
        else
        {
            RenderedShape<?> rshape = shapeFactory.apply(client, shape);
            RegistryKey<World> dim = shape.shapeDimension;
            long key = rshape.key();
            synchronized (shapes)
            {
                RenderedShape<?> existing = shapes.computeIfAbsent(dim, d -> new Long2ObjectOpenHashMap<>()).get(key);
                if (existing != null)
                {   // promoting previous shape
                    existing.promoteWith(rshape);
                }
                else
                {
                    shapes.get(dim).put(key, rshape);
                }
            }
        }
    }
    public void reset()
    {
        synchronized (shapes)
        {
            shapes.values().forEach(Long2ObjectOpenHashMap::clear);
        }
    }


    public abstract static class RenderedShape<T extends ShapeDispatcher.ExpiringShape>
    {
        protected T shape;
        protected MinecraftClient client;
        long expiryTick;
        double renderEpsilon = 0;
        public abstract void renderLines(Tessellator tessellator, BufferBuilder builder, double cx, double cy, double cz, float partialTick );
        public void renderFaces(Tessellator tessellator, BufferBuilder builder, double cx, double cy, double cz, float partialTick ) {}
        protected RenderedShape(MinecraftClient client, T shape)
        {
            this.shape = shape;
            expiryTick = client.world.getTime()+shape.getExpiry();
            renderEpsilon = (3+((double)shape.key())/Long.MAX_VALUE)/1000;
            this.client = client;
        }

        public boolean isExpired(long currentTick)
        {
            return  expiryTick < currentTick;
        }
        public long key()
        {
            return shape.key();
        };
        public boolean shouldRender(RegistryKey<World> dim)
        {
            if (shape.followEntity <=0 ) return true;
            if (client.world == null) return false;
            if (client.world.getRegistryKey() != dim) return false;
            if (client.world.getEntityById(shape.followEntity) == null) return false;
            return true;
        }
        public boolean lastCall()
        {
            return false;
        }

        public void promoteWith(RenderedShape<?> rshape)
        {
            expiryTick = rshape.expiryTick;
        }
    }

    public static class RenderedText extends RenderedShape<ShapeDispatcher.DisplayedText>
    {

        protected RenderedText(MinecraftClient client, ShapeDispatcher.ExpiringShape shape)
        {
            super(client, (ShapeDispatcher.DisplayedText)shape);
        }

        @Override
        public void renderLines(Tessellator tessellator, BufferBuilder builder, double cx, double cy, double cz, float partialTick)
        {
            if (shape.a == 0.0) return;
            Vec3d v1 = shape.relativiseRender(client.world, shape.pos, partialTick);
            Camera camera1 = client.gameRenderer.getCamera();
            TextRenderer textRenderer = client.textRenderer;
            double d = camera1.getPos().x;
            double e = camera1.getPos().y;
            double f = camera1.getPos().z;
            if (shape.doublesided)
                RenderSystem.disableCull();
            else
                RenderSystem.enableCull();
            RenderSystem.pushMatrix();
            RenderSystem.translatef((float)(v1.x - d), (float)(v1.y - e), (float)(v1.z - f));
            RenderSystem.normal3f(0.0F, 1.0F, 0.0F);

            if (shape.facing == null)
            {
                RenderSystem.multMatrix(new Matrix4f(camera1.getRotation()));
            }
            else
            {
                switch (shape.facing)
                {
                    case NORTH:
                        break;
                    case SOUTH:
                        RenderSystem.rotatef(180.0f, 0.0f, 1.0f, 0.0f);
                        break;
                    case EAST:
                        RenderSystem.rotatef(270.0f, 0.0f, 1.0f, 0.0f);
                        break;
                    case WEST:
                        RenderSystem.rotatef(90.0f, 0.0f, 1.0f, 0.0f);
                        break;
                    case UP:
                        RenderSystem.rotatef(90.0f, 1.0f, 0.0f, 0.0f);
                        break;
                    case DOWN:
                        RenderSystem.rotatef(-90.0f, 1.0f, 0.0f, 0.0f);
                        break;
                }
            }
            RenderSystem.scalef(shape.size* 0.0025f, -shape.size*0.0025f, shape.size*0.0025f);
            if (shape.tilt!=0.0f)
            {
                RenderSystem.rotatef(shape.tilt, 0.0f, 0.0f, 1.0f);
            }
            RenderSystem.translatef(-10*shape.indent, -10*shape.height, (float) (-10*renderEpsilon)-10*shape.raise);
            //if (visibleThroughWalls) RenderSystem.disableDepthTest();
            RenderSystem.scalef(-1.0F, 1.0F, 1.0F);

            float text_x = 0;
            if (shape.align == 0)
            {
                text_x = (float)(-textRenderer.getWidth(shape.value.getString())) / 2.0F;
            }
            else if (shape.align == 1)
            {
                text_x = (float)(-textRenderer.getWidth(shape.value.getString()));
            }
            VertexConsumerProvider.Immediate immediate = VertexConsumerProvider.immediate(Tessellator.getInstance().getBuffer());
            textRenderer.method_30882(shape.value, text_x, 0.0F, shape.textcolor, false, AffineTransformation.identity().getMatrix(), immediate, false, shape.textbck, 15728880);
            immediate.draw();
            RenderSystem.popMatrix();
            RenderSystem.enableCull();
            //RenderSystem.enableDepthTest();
            //RenderSystem.depthFunc(515);
            //RenderSystem.enableAlphaTest();
            //RenderSystem.alphaFunc(GL11.GL_GREATER, 0.003f);
        }

        @Override
        public boolean lastCall()
        {
            return true;
        }

        @Override
        public void promoteWith(RenderedShape<?> rshape)
        {
            super.promoteWith(rshape);
            try
            {
                this.shape.value = ((ShapeDispatcher.Text) rshape.shape).value;
            }
            catch (ClassCastException ignored)
            {
                CarpetSettings.LOG.error("shape "+rshape.shape.getClass()+" cannot cast to a Label");
            }
        }
    }

    public static class RenderedBox extends RenderedShape<ShapeDispatcher.Box>
    {

        private RenderedBox(MinecraftClient client, ShapeDispatcher.ExpiringShape shape)
        {
            super(client, (ShapeDispatcher.Box)shape);

        }
        @Override
        public void renderLines(Tessellator tessellator, BufferBuilder bufferBuilder, double cx, double cy, double cz, float partialTick)
        {
            if (shape.a == 0.0) return;
            Vec3d v1 = shape.relativiseRender(client.world, shape.from, partialTick);
            Vec3d v2 = shape.relativiseRender(client.world, shape.to, partialTick);
            RenderSystem.lineWidth(shape.lineWidth);
            drawBoxWireGLLines(tessellator, bufferBuilder,
                    (float)(v1.x-cx-renderEpsilon), (float)(v1.y-cy-renderEpsilon), (float)(v1.z-cz-renderEpsilon),
                    (float)(v2.x-cx+renderEpsilon), (float)(v2.y-cy+renderEpsilon), (float)(v2.z-cz+renderEpsilon),
                    v1.x!=v2.x, v1.y!=v2.y, v1.z!=v2.z,
                    shape.r, shape.g, shape.b, shape.a, shape.r, shape.g, shape.b
            );
        }
        @Override
        public void renderFaces(Tessellator tessellator, BufferBuilder bufferBuilder, double cx, double cy, double cz, float partialTick)
        {
            if (shape.fa == 0.0) return;
            Vec3d v1 = shape.relativiseRender(client.world, shape.from, partialTick);
            Vec3d v2 = shape.relativiseRender(client.world, shape.to, partialTick);
            RenderSystem.lineWidth(1.0F);
            drawBoxFaces(tessellator, bufferBuilder,
                    (float)(v1.x-cx-renderEpsilon), (float)(v1.y-cy-renderEpsilon), (float)(v1.z-cz-renderEpsilon),
                    (float)(v2.x-cx+renderEpsilon), (float)(v2.y-cy+renderEpsilon), (float)(v2.z-cz+renderEpsilon),
                    v1.x!=v2.x, v1.y!=v2.y, v1.z!=v2.z,
                    shape.fr, shape.fg, shape.fb, shape.fa
            );
        }

    }

    public static class RenderedLine extends RenderedShape<ShapeDispatcher.Line>
    {
        public RenderedLine(MinecraftClient client, ShapeDispatcher.ExpiringShape shape)
        {
            super(client, (ShapeDispatcher.Line)shape);
        }
        @Override
        public void renderLines(Tessellator tessellator, BufferBuilder bufferBuilder, double cx, double cy, double cz, float partialTick)
        {
            Vec3d v1 = shape.relativiseRender(client.world, shape.from, partialTick);
            Vec3d v2 = shape.relativiseRender(client.world, shape.to, partialTick);
            RenderSystem.lineWidth(shape.lineWidth);
            drawLine(tessellator, bufferBuilder,
                    (float)(v1.x-cx-renderEpsilon), (float)(v1.y-cy-renderEpsilon), (float)(v1.z-cz-renderEpsilon),
                    (float)(v2.x-cx+renderEpsilon), (float)(v2.y-cy+renderEpsilon), (float)(v2.z-cz+renderEpsilon),
                    shape.r, shape.g, shape.b, shape.a
            );
        }
    }

    public static class RenderedSphere extends RenderedShape<ShapeDispatcher.Sphere>
    {
        public RenderedSphere(MinecraftClient client, ShapeDispatcher.ExpiringShape shape)
        {
            super(client, (ShapeDispatcher.Sphere)shape);
        }
        @Override
        public void renderLines(Tessellator tessellator, BufferBuilder bufferBuilder, double cx, double cy, double cz, float partialTick)
        {
            if (shape.a == 0.0) return;
            Vec3d vc = shape.relativiseRender(client.world, shape.center, partialTick);
            RenderSystem.lineWidth(shape.lineWidth);
            drawSphereWireframe(tessellator, bufferBuilder,
                    (float)(vc.x-cx), (float)(vc.y-cy), (float)(vc.z-cz),
                    (float)(shape.radius+renderEpsilon), shape.subdivisions,
                    shape.r, shape.g, shape.b, shape.a);
        }
        @Override
        public void renderFaces(Tessellator tessellator, BufferBuilder bufferBuilder, double cx, double cy, double cz, float partialTick)
        {
            if (shape.fa == 0.0) return;
            Vec3d vc = shape.relativiseRender(client.world, shape.center, partialTick);
            RenderSystem.lineWidth(1.0f);
            drawSphereFaces(tessellator, bufferBuilder,
                    (float)(vc.x-cx), (float)(vc.y-cy), (float)(vc.z-cz),
                    (float)(shape.radius+renderEpsilon), shape.subdivisions,
                    shape.fr, shape.fg, shape.fb, shape.fa);
        }
    }

    public static class RenderedCylinder extends RenderedShape<ShapeDispatcher.Cylinder>
    {
        public RenderedCylinder(MinecraftClient client, ShapeDispatcher.ExpiringShape shape)
        {
            super(client, (ShapeDispatcher.Cylinder)shape);
        }
        @Override
        public void renderLines(Tessellator tessellator, BufferBuilder bufferBuilder, double cx, double cy, double cz, float partialTick)
        {
            if (shape.a == 0.0) return;
            Vec3d vc = shape.relativiseRender(client.world, shape.center, partialTick);
            RenderSystem.lineWidth(shape.lineWidth);
            double dir = MathHelper.sign(shape.height);
            drawCylinderWireframe(tessellator, bufferBuilder,
                    (float) (vc.x - cx - dir * renderEpsilon), (float) (vc.y - cy - dir * renderEpsilon), (float) (vc.z - cz - dir * renderEpsilon),
                    (float) (shape.radius + renderEpsilon), (float) (shape.height + 2*dir*renderEpsilon), shape.axis,
                    shape.subdivisions, shape.radius == 0,
                    shape.r, shape.g, shape.b, shape.a);

        }
        @Override
        public void renderFaces(Tessellator tessellator, BufferBuilder bufferBuilder, double cx, double cy, double cz, float partialTick)
        {
            if (shape.fa == 0.0) return;
            Vec3d vc = shape.relativiseRender(client.world, shape.center, partialTick);
            RenderSystem.lineWidth(1.0f);
            double dir = MathHelper.sign(shape.height);
            drawCylinderFaces(tessellator, bufferBuilder,
                    (float) (vc.x - cx - dir * renderEpsilon), (float) (vc.y - cy - dir * renderEpsilon), (float) (vc.z - cz - dir * renderEpsilon),
                    (float) (shape.radius + renderEpsilon), (float) (shape.height + 2*dir*renderEpsilon), shape.axis,
                    shape.subdivisions, shape.radius == 0,
                    shape.fr, shape.fg, shape.fb, shape.fa);
        }
    }

    // some raw shit

    public static void drawLine(Tessellator tessellator, BufferBuilder builder, float x1, float y1, float z1, float x2, float y2, float z2, float red1, float grn1, float blu1, float alpha) {
        builder.begin(GL11.GL_LINES, VertexFormats.POSITION_COLOR); // 3
        builder.vertex(x1, y1, z1).color(red1, grn1, blu1, alpha).next();
        builder.vertex(x2, y2, z2).color(red1, grn1, blu1, alpha).next();
        tessellator.draw();
    }

    public static void drawBoxWireGLLines(
            Tessellator tessellator, BufferBuilder builder,
            float x1, float y1, float z1,
            float x2, float y2, float z2,
            boolean xthick, boolean ythick, boolean zthick,
            float red1, float grn1, float blu1, float alpha, float red2, float grn2, float blu2)
    {
        builder.begin(GL11.GL_LINES, VertexFormats.POSITION_COLOR); // 3
        if (xthick)
        {
            builder.vertex(x1, y1, z1).color(red1, grn2, blu2, alpha).next();
            builder.vertex(x2, y1, z1).color(red1, grn2, blu2, alpha).next();

            builder.vertex(x2, y2, z1).color(red1, grn1, blu1, alpha).next();
            builder.vertex(x1, y2, z1).color(red1, grn1, blu1, alpha).next();

            builder.vertex(x1, y1, z2).color(red1, grn1, blu1, alpha).next();
            builder.vertex(x2, y1, z2).color(red1, grn1, blu1, alpha).next();

            builder.vertex(x1, y2, z2).color(red1, grn1, blu1, alpha).next();
            builder.vertex(x2, y2, z2).color(red1, grn1, blu1, alpha).next();
        }
        if (ythick)
        {
            builder.vertex(x1, y1, z1).color(red2, grn1, blu2, alpha).next();
            builder.vertex(x1, y2, z1).color(red2, grn1, blu2, alpha).next();

            builder.vertex(x2, y1, z1).color(red1, grn1, blu1, alpha).next();
            builder.vertex(x2, y2, z1).color(red1, grn1, blu1, alpha).next();

            builder.vertex(x1, y2, z2).color(red1, grn1, blu1, alpha).next();
            builder.vertex(x1, y1, z2).color(red1, grn1, blu1, alpha).next();

            builder.vertex(x2, y1, z2).color(red1, grn1, blu1, alpha).next();
            builder.vertex(x2, y2, z2).color(red1, grn1, blu1, alpha).next();
        }
        if (zthick)
        {
            builder.vertex(x1, y1, z1).color(red2, grn2, blu1, alpha).next();
            builder.vertex(x1, y1, z2).color(red2, grn2, blu1, alpha).next();

            builder.vertex(x1, y2, z1).color(red1, grn1, blu1, alpha).next();
            builder.vertex(x1, y2, z2).color(red1, grn1, blu1, alpha).next();

            builder.vertex(x2, y1, z2).color(red1, grn1, blu1, alpha).next();
            builder.vertex(x2, y1, z1).color(red1, grn1, blu1, alpha).next();

            builder.vertex(x2, y2, z1).color(red1, grn1, blu1, alpha).next();
            builder.vertex(x2, y2, z2).color(red1, grn1, blu1, alpha).next();
        }
        tessellator.draw();
    }

    public static void drawBoxFaces(
            Tessellator tessellator, BufferBuilder builder,
            float x1, float y1, float z1,
            float x2, float y2, float z2,
            boolean xthick, boolean ythick, boolean zthick,
            float red1, float grn1, float blu1, float alpha)
    {
        builder.begin(GL11.GL_QUADS, VertexFormats.POSITION_COLOR);

        if (xthick && ythick)
        {
            builder.vertex(x1, y1, z1).color(red1, grn1, blu1, alpha).next();
            builder.vertex(x2, y1, z1).color(red1, grn1, blu1, alpha).next();
            builder.vertex(x2, y2, z1).color(red1, grn1, blu1, alpha).next();
            builder.vertex(x1, y2, z1).color(red1, grn1, blu1, alpha).next();
            if (zthick)
            {
                builder.vertex(x1, y1, z2).color(red1, grn1, blu1, alpha).next();
                builder.vertex(x1, y2, z2).color(red1, grn1, blu1, alpha).next();
                builder.vertex(x2, y2, z2).color(red1, grn1, blu1, alpha).next();
                builder.vertex(x2, y1, z2).color(red1, grn1, blu1, alpha).next();
            }
        }


        if (zthick && ythick)
        {
            builder.vertex(x1, y1, z1).color(red1, grn1, blu1, alpha).next();
            builder.vertex(x1, y2, z1).color(red1, grn1, blu1, alpha).next();
            builder.vertex(x1, y2, z2).color(red1, grn1, blu1, alpha).next();
            builder.vertex(x1, y1, z2).color(red1, grn1, blu1, alpha).next();

            if (xthick)
            {
                builder.vertex(x2, y1, z1).color(red1, grn1, blu1, alpha).next();
                builder.vertex(x2, y1, z2).color(red1, grn1, blu1, alpha).next();
                builder.vertex(x2, y2, z2).color(red1, grn1, blu1, alpha).next();
                builder.vertex(x2, y2, z1).color(red1, grn1, blu1, alpha).next();
            }
        }

        // now at least drawing one
        if (zthick && xthick)
        {
            builder.vertex(x1, y1, z1).color(red1, grn1, blu1, alpha).next();
            builder.vertex(x2, y1, z1).color(red1, grn1, blu1, alpha).next();
            builder.vertex(x2, y1, z2).color(red1, grn1, blu1, alpha).next();
            builder.vertex(x1, y1, z2).color(red1, grn1, blu1, alpha).next();


            if (ythick)
            {
                builder.vertex(x1, y2, z1).color(red1, grn1, blu1, alpha).next();
                builder.vertex(x2, y2, z1).color(red1, grn1, blu1, alpha).next();
                builder.vertex(x2, y2, z2).color(red1, grn1, blu1, alpha).next();
                builder.vertex(x1, y2, z2).color(red1, grn1, blu1, alpha).next();
            }
        }
        tessellator.draw();
    }

    public static void drawCylinderWireframe(Tessellator tessellator, BufferBuilder builder,
                                             float cx, float cy, float cz,
                                             float r, float h, Direction.Axis axis,  int subd, boolean isFlat,
                                             float red, float grn, float blu, float alpha)
    {
        float step = (float)Math.PI / (subd/2);
        int num_steps180 = (int)(Math.PI / step)+1;
        int num_steps360 = (int)(2*Math.PI / step);
        int hsteps = 1;
        float hstep = 1.0f;
        if (!isFlat)
        {
            hsteps = (int) Math.ceil(MathHelper.abs(h) / (step * r)) + 1;
            hstep = h / (hsteps - 1);
        }// draw base

        if (axis == Direction.Axis.Y)
        {
            for (int dh = 0; dh < hsteps; dh++)
            {
                float hh = dh*hstep;
                builder.begin(GL11.GL_LINE_LOOP, VertexFormats.POSITION_COLOR);
                for (int i = 0; i <= num_steps360; i++)
                {
                    float theta = step * i;
                    float x = r * MathHelper.cos(theta);
                    float y = hh;
                    float z = r * MathHelper.sin(theta);
                    builder.vertex(x + cx, y + cy, z + cz).color(red, grn, blu, alpha).next();
                }
                tessellator.draw();
            }

            if (!isFlat)
            {
                for (int i = 0; i <= num_steps180; i++)
                {
                    builder.begin(GL11.GL_LINE_LOOP, VertexFormats.POSITION_COLOR);
                    float theta = step * i;
                    float x = r * MathHelper.cos(theta);

                    float z = r * MathHelper.sin(theta);

                    builder.vertex(cx - x, cy + 0, cz + z).color(red, grn, blu, alpha).next();
                    builder.vertex(cx + x, cy + 0, cz - z).color(red, grn, blu, alpha).next();
                    builder.vertex(cx + x, cy + h, cz - z).color(red, grn, blu, alpha).next();
                    builder.vertex(cx - x, cy + h, cz + z).color(red, grn, blu, alpha).next();
                    tessellator.draw();
                }
            }
            else
            {
                builder.begin(GL11.GL_LINES, VertexFormats.POSITION_COLOR);
                for (int i = 0; i <= num_steps180; i++)
                {
                    float theta = step * i;
                    float x = r * MathHelper.cos(theta);
                    float z = r * MathHelper.sin(theta);
                    builder.vertex(cx - x, cy, cz + z).color(red, grn, blu, alpha).next();
                    builder.vertex(cx + x, cy, cz - z).color(red, grn, blu, alpha).next();
                }
                tessellator.draw();
            }

        }
        else if (axis == Direction.Axis.X)
        {
            for (int dh = 0; dh < hsteps; dh++)
            {
                float hh = dh * hstep;
                builder.begin(GL11.GL_LINE_LOOP, VertexFormats.POSITION_COLOR);
                for (int i = 0; i <= num_steps360; i++)
                {
                    float theta = step * i;
                    float z = r * MathHelper.cos(theta);
                    float x = hh;
                    float y = r * MathHelper.sin(theta);
                    builder.vertex(x + cx, y + cy, z + cz).color(red, grn, blu, alpha).next();
                }
                tessellator.draw();
            }

            if (!isFlat)
            {
                for (int i = 0; i <= num_steps180; i++)
                {
                    builder.begin(GL11.GL_LINE_LOOP, VertexFormats.POSITION_COLOR);
                    float theta = step * i;
                    float y = r * MathHelper.cos(theta);

                    float z = r * MathHelper.sin(theta);

                    builder.vertex(cx + 0, cy - y, cz + z).color(red, grn, blu, alpha).next();
                    builder.vertex(cx + 0, cy + y, cz - z).color(red, grn, blu, alpha).next();
                    builder.vertex(cx + h, cy + y, cz - z).color(red, grn, blu, alpha).next();
                    builder.vertex(cx + h, cy - y, cz + z).color(red, grn, blu, alpha).next();
                    tessellator.draw();
                }
            }
            else
            {
                builder.begin(GL11.GL_LINES, VertexFormats.POSITION_COLOR);
                for (int i = 0; i <= num_steps180; i++)
                {
                    float theta = step * i;
                    float y = r * MathHelper.cos(theta);
                    float z = r * MathHelper.sin(theta);
                    builder.vertex(cx, cy - y, cz + z).color(red, grn, blu, alpha).next();
                    builder.vertex(cx, cy + y, cz - z).color(red, grn, blu, alpha).next();
                }
                tessellator.draw();
            }
        }
        else if (axis == Direction.Axis.Z)
        {
            for (int dh = 0; dh < hsteps; dh++)
            {
                float hh = dh * hstep;
                builder.begin(GL11.GL_LINE_LOOP, VertexFormats.POSITION_COLOR);
                for (int i = 0; i <= num_steps360; i++)
                {
                    float theta = step * i;
                    float y = r * MathHelper.cos(theta);
                    float z = hh;
                    float x = r * MathHelper.sin(theta);
                    builder.vertex(x + cx, y + cy, z + cz).color(red, grn, blu, alpha).next();
                }
                tessellator.draw();
            }
            if (!isFlat)
            {
                for (int i = 0; i <= num_steps180; i++)
                {
                    builder.begin(GL11.GL_LINE_LOOP, VertexFormats.POSITION_COLOR);
                    float theta = step * i;
                    float x = r * MathHelper.cos(theta);

                    float y = r * MathHelper.sin(theta);

                    builder.vertex(cx + x, cy - y, cz + 0).color(red, grn, blu, alpha).next();
                    builder.vertex(cx - x, cy + y, cz + 0).color(red, grn, blu, alpha).next();
                    builder.vertex(cx - x, cy + y, cz + h).color(red, grn, blu, alpha).next();
                    builder.vertex(cx + x, cy - y, cz + h).color(red, grn, blu, alpha).next();
                    tessellator.draw();
                }
            }
            else
            {
                builder.begin(GL11.GL_LINES, VertexFormats.POSITION_COLOR);
                for (int i = 0; i <= num_steps180; i++)
                {
                    float theta = step * i;
                    float x = r * MathHelper.cos(theta);
                    float y = r * MathHelper.sin(theta);
                    builder.vertex(cx + x, cy - y, cz).color(red, grn, blu, alpha).next();
                    builder.vertex(cx - x, cy + y, cz).color(red, grn, blu, alpha).next();
                }
                tessellator.draw();
            }

        }
    }

    public static void drawCylinderFaces(Tessellator tessellator, BufferBuilder builder,
                                             float cx, float cy, float cz,
                                             float r, float h, Direction.Axis axis,  int subd, boolean isFlat,
                                             float red, float grn, float blu, float alpha)
    {
        float step = (float)Math.PI / (subd/2);
        int num_steps180 = (int)(Math.PI / step)+1;
        int num_steps360 = (int)(2*Math.PI / step)+1;

        if (axis == Direction.Axis.Y)
        {

            builder.begin(GL11.GL_TRIANGLE_FAN, VertexFormats.POSITION_COLOR);
            builder.vertex(cx, cy, cz).color(red, grn, blu, alpha).next();
            for (int i = 0; i <= num_steps360; i++)
            {
                float theta = step * i;
                float x = r * MathHelper.cos(theta);
                float z = r * MathHelper.sin(theta);
                builder.vertex(x + cx, cy, z + cz).color(red, grn, blu, alpha).next();
            }
            tessellator.draw();
            if (!isFlat)
            {
                builder.begin(GL11.GL_TRIANGLE_FAN, VertexFormats.POSITION_COLOR);
                builder.vertex(cx, cy+h, cz).color(red, grn, blu, alpha).next();
                for (int i = 0; i <= num_steps360; i++)
                {
                    float theta = step * i;
                    float x = r * MathHelper.cos(theta);
                    float z = r * MathHelper.sin(theta);
                    builder.vertex(x + cx, cy+h, z + cz).color(red, grn, blu, alpha).next();
                }
                tessellator.draw();

                builder.begin(GL11.GL_QUAD_STRIP, VertexFormats.POSITION_COLOR);
                for (int i = 0; i <= num_steps360; i++)
                {
                    float theta = step * i;
                    float x = r * MathHelper.cos(theta);
                    float z = r * MathHelper.sin(theta);
                    builder.vertex(cx + x, cy + 0, cz + z).color(red, grn, blu, alpha).next();
                    builder.vertex(cx + x, cy + h, cz + z).color(red, grn, blu, alpha).next();
                }
                tessellator.draw();
            }

        }
        else if (axis == Direction.Axis.X)
        {
            builder.begin(GL11.GL_TRIANGLE_FAN, VertexFormats.POSITION_COLOR);
            builder.vertex(cx, cy, cz).color(red, grn, blu, alpha).next();
            for (int i = 0; i <= num_steps360; i++)
            {
                float theta = step * i;
                float y = r * MathHelper.cos(theta);
                float z = r * MathHelper.sin(theta);
                builder.vertex(cx, cy + y, z + cz).color(red, grn, blu, alpha).next();
            }
            tessellator.draw();
            if (!isFlat)
            {
                builder.begin(GL11.GL_TRIANGLE_FAN, VertexFormats.POSITION_COLOR);
                builder.vertex(cx+h, cy, cz).color(red, grn, blu, alpha).next();
                for (int i = 0; i <= num_steps360; i++)
                {
                    float theta = step * i;
                    float y = r * MathHelper.cos(theta);
                    float z = r * MathHelper.sin(theta);
                    builder.vertex(cx+h, cy + y, cz + z).color(red, grn, blu, alpha).next();
                }
                tessellator.draw();

                builder.begin(GL11.GL_QUAD_STRIP, VertexFormats.POSITION_COLOR);
                for (int i = 0; i <= num_steps360; i++)
                {
                    float theta = step * i;
                    float y = r * MathHelper.cos(theta);
                    float z = r * MathHelper.sin(theta);
                    builder.vertex(cx + 0, cy + y, cz + z).color(red, grn, blu, alpha).next();
                    builder.vertex(cx + h, cy + y, cz + z).color(red, grn, blu, alpha).next();
                }
                tessellator.draw();
            }
        }
        else if (axis == Direction.Axis.Z)
        {
            builder.begin(GL11.GL_TRIANGLE_FAN, VertexFormats.POSITION_COLOR);
            builder.vertex(cx, cy, cz).color(red, grn, blu, alpha).next();
            for (int i = 0; i <= num_steps360; i++)
            {
                float theta = step * i;
                float x = r * MathHelper.cos(theta);
                float y = r * MathHelper.sin(theta);
                builder.vertex(x + cx, cy+y, cz).color(red, grn, blu, alpha).next();
            }
            tessellator.draw();
            if (!isFlat)
            {
                builder.begin(GL11.GL_TRIANGLE_FAN, VertexFormats.POSITION_COLOR);
                builder.vertex(cx, cy, cz+h).color(red, grn, blu, alpha).next();
                for (int i = 0; i <= num_steps360; i++)
                {
                    float theta = step * i;
                    float x = r * MathHelper.cos(theta);
                    float y = r * MathHelper.sin(theta);
                    builder.vertex(x + cx, cy+y, cz+h).color(red, grn, blu, alpha).next();
                }
                tessellator.draw();

                builder.begin(GL11.GL_QUAD_STRIP, VertexFormats.POSITION_COLOR);
                for (int i = 0; i <= num_steps360; i++)
                {
                    float theta = step * i;
                    float x = r * MathHelper.cos(theta);
                    float y = r * MathHelper.sin(theta);
                    builder.vertex(cx + x, cy + y, cz + 0).color(red, grn, blu, alpha).next();
                    builder.vertex(cx + x, cy + y, cz + h).color(red, grn, blu, alpha).next();
                }
                tessellator.draw();
            }
        }
    }

    public static void drawSphereWireframe(Tessellator tessellator, BufferBuilder builder,
                                           float cx, float cy, float cz,
                                           float r, int subd,
                                           float red, float grn, float blu, float alpha)
    {
        float step = (float)Math.PI / (subd/2);
        int num_steps180 = (int)(Math.PI / step)+1;
        int num_steps360 = (int)(2*Math.PI / step);
        for (int i = 0; i <= num_steps360; i++)
        {
            builder.begin(GL11.GL_LINE_STRIP, VertexFormats.POSITION_COLOR);
            float theta = step * i ;
            for (int j = 0; j <= num_steps180; j++)
            {
                float phi = step * j ;
                float x = r * MathHelper.sin(phi) * MathHelper.cos(theta);
                float z = r * MathHelper.sin(phi) * MathHelper.sin(theta);
                float y = r * MathHelper.cos(phi);
                builder.vertex(x+cx, y+cy, z+cz).color(red, grn, blu, alpha).next();
            }
            tessellator.draw();
        }
        for (int j = 0; j <= num_steps180; j++)
        {
            builder.begin(GL11.GL_LINE_LOOP, VertexFormats.POSITION_COLOR);
            float phi = step * j ;

            for (int i = 0; i <= num_steps360; i++)
            {
                float theta = step * i;
                float x = r * MathHelper.sin(phi) * MathHelper.cos(theta);
                float z = r * MathHelper.sin(phi) * MathHelper.sin(theta);
                float y = r * MathHelper.cos(phi);
                builder.vertex(x+cx, y+cy, z+cz).color(red, grn, blu, alpha).next();
            }
            tessellator.draw();
        }

    }

    public static void drawSphereFaces(Tessellator tessellator, BufferBuilder builder,
                                           float cx, float cy, float cz,
                                           float r, int subd,
                                           float red, float grn, float blu, float alpha)
    {

        float step = (float)Math.PI / (subd/2);
        int num_steps180 = (int)(Math.PI / step)+1;
        int num_steps360 = (int)(2*Math.PI / step);
        for (int i = 0; i <= num_steps360; i++)
        {
            float theta = i * step;
            float thetaprime = theta+step;
            builder.begin(GL11.GL_QUAD_STRIP, VertexFormats.POSITION_COLOR);
            for (int j = 0; j <= num_steps180; j++)
            {
                float phi = j * step;
                float x = r * MathHelper.sin(phi) * MathHelper.cos(theta);
                float z = r * MathHelper.sin(phi) * MathHelper.sin(theta);
                float y = r * MathHelper.cos(phi);
                float xp = r * MathHelper.sin(phi) * MathHelper.cos(thetaprime);
                float zp = r * MathHelper.sin(phi) * MathHelper.sin(thetaprime);
                builder.vertex(x + cx, y + cy, z + cz).color(red, grn, blu, alpha).next();
                builder.vertex(xp + cx, y + cy, zp + cz).color(red, grn, blu, alpha).next();
            }
            tessellator.draw();
        }
    }
}