IBMTrack

package net.railsofwar.row.track.client.bakedmodel;

import net.minecraft.block.state.IBlockState;
import net.minecraft.client.renderer.block.model.*;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
import net.minecraft.util.EnumFacing;
import net.minecraftforge.client.model.IModel;
import net.minecraftforge.client.model.ModelLoader;
import net.minecraftforge.client.model.MultiModel;
import net.minecraftforge.common.model.IModelState;
import net.minecraftforge.common.property.IExtendedBlockState;
import net.railsofwar.row.track.block.BlockTrackBase;
import net.railsofwar.row.track.block.BlockTrackSWNE;
import net.railsofwar.row.track.client.ModelLibTrack;
import net.railsofwar.row.track.enumeration.EnumRailway;
import net.railsofwar.row.track.enumeration.EnumTrackDirectionSWNE;
import net.railsofwar.row.track.enumeration.EnumTrackShape;
import net.railsofwar.row.track.enumeration.EnumTrackState;
import net.railsofwar.row.track.util.PieceProperty;
import net.railsofwar.row.track.util.TrackGeometry;
import org.apache.commons.lang3.tuple.Pair;

import javax.annotation.Nullable;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static net.railsofwar.row.track.client.util.UtilModelTRSR.*;
import static net.railsofwar.row.track.client.util.UtilTrackRender.*;

public class ModelTrack implements IBakedModel{

    public static final ModelResourceLocation modelResourceLocation
            = new ModelResourceLocation("row:blockTrack");

    public ModelTrack(){
        super();
    }

    @Override
    public List<BakedQuad> getQuads(@Nullable IBlockState blockState, @Nullable EnumFacing side, long rand){
        if(blockState == null) return Collections.emptyList();
        if(side != null) return Collections.emptyList();
        assert IExtendedBlockState.class.isAssignableFrom(blockState.getClass());
        IExtendedBlockState extendedBlockState = (IExtendedBlockState) blockState;

        EnumTrackShape shape = extendedBlockState.getValue(BlockTrackBase.shape);
        int scalarA = extendedBlockState.getValue(BlockTrackBase.scalarA);
        boolean mirrored = extendedBlockState.getValue(BlockTrackBase.mirrored);
        EnumRailway railway = extendedBlockState.getValue(BlockTrackBase.railway);
        EnumTrackState trackState = extendedBlockState.getValue(BlockTrackSWNE.trackState);
        int seed = extendedBlockState.getValue(BlockTrackSWNE.seed);
        EnumTrackDirectionSWNE direction = extendedBlockState.getValue(BlockTrackSWNE.direction);

        TrackGeometry geometry = new TrackGeometry(railway, shape, scalarA, mirrored, seed);

        if(trackState == null) return Collections.emptyList();
        IModelState modelStateBase = stateTR(tern(0.5F, 0, 0.5F), rotY(direction.getAzimuth()));
        if(shape == EnumTrackShape.SWITCH_CIRCULAR){
            if(!mirrored){
                IBakedModel modelBaked = ModelLibTrack.rail750Switch1right.bake(modelStateBase, DefaultVertexFormats.ITEM, ModelLoader.defaultTextureGetter());
                return modelBaked.getQuads(null, null, rand);
            }else{
                IBakedModel modelBaked = ModelLibTrack.rail750Switch1left.bake(modelStateBase, DefaultVertexFormats.ITEM, ModelLoader.defaultTextureGetter());
                return modelBaked.getQuads(null, null, rand);
            }
        }
        switch(trackState){
            case MARKUP:
                return processGeometry(geometry, direction, rand, true, false, false, false, false);
            case SLEEPERS:
                return processGeometry(geometry, direction, rand, false, true, false, false, false);
            case RAILS:
                return processGeometry(geometry, direction, rand, false, true, true, true, false);
            case WORKING:
                return processGeometry(geometry, direction, rand, false, true, true, true, true);
            default:
                return Collections.emptyList();
        }
    }

    private List<BakedQuad> processGeometry(TrackGeometry geometry, EnumTrackDirectionSWNE direction,
                                            long random, boolean drawMarkup, boolean drawSleepers,
                                            boolean drawRailLeft, boolean drawRailRight, boolean drawSpikes){
        Map<String, Pair<IModel, IModelState>> map = new HashMap<>();
        if(drawMarkup){
            //marker(map, stateR(rotY(0F)));
            //marker(map, stateTR(tern(0F, 0F, 8F), rotY(180F))); //TODO pass marker positions with geometry
        }
        if(drawSleepers)
            for(PieceProperty l : geometry.getSleepers())
                sleeper(map, stateTSR(
                        tern(l.getPX(), l.getPY(), l.getPZ()),
                        tern(l.getSX(), l.getSY(), l.getSZ()),
                        rotAPR(l.getAzimuth(), l.getPith(), l.getRoll())));

        if(drawRailLeft){
            for(int i = 0; i < geometry.getRails().getLeft().size(); i++){
                PieceProperty r = geometry.getRails().getLeft().get(i);
                if(i < geometry.getRails().getLeft().size() - 1)
                    rail8vxLeft(map,
                            stateTSR(tern(r.getPX(), r.getPY(), r.getPZ()),
                                    tern(r.getSX(), r.getSY(), r.getSZ()),
                                    rotAPR(r.getAzimuth(), r.getPith(), r.getRoll())));
                if(i == 0) railButt(map,
                        stateTR(tern(r.getPX(), r.getPY(), r.getPZ()),
                                rotAPR(r.getAzimuth(), r.getPith(), r.getRoll())));
                if(i == geometry.getRails().getLeft().size() - 1)
                    railButt(map,
                            stateTR(tern(r.getPX(), r.getPY(), r.getPZ()),
                                    rotAPR(r.getAzimuth(), r.getPith(), r.getRoll())));
            }
        }

        if(drawRailRight){
            for(int i = 0; i < geometry.getRails().getRight().size(); i++){
                PieceProperty r = geometry.getRails().getRight().get(i);
                if(i < geometry.getRails().getRight().size() - 1)
                    rail8vxRight(map,
                            stateTSR(tern(r.getPX(), r.getPY(), r.getPZ()),
                                    tern(r.getSX(), r.getSY(), r.getSZ()),
                                    rotAPR(r.getAzimuth(), r.getPith(), r.getRoll())));
                if(i == 0) railButt(map,
                        stateTR(tern(r.getPX(), r.getPY(), r.getPZ()),
                                rotAPR(r.getAzimuth(), r.getPith(), r.getRoll())));
                if(i == geometry.getRails().getRight().size() - 1)
                    railButt(map,
                            stateTR(tern(r.getPX(), r.getPY(), r.getPZ()),
                                    rotAPR(r.getAzimuth(), r.getPith(), r.getRoll())));
            }
        }

        //spacer(map, geometry.getRailway(), 15);

        IModelState modelStateBase = stateTR(tern(0.5F, 0, 0.5F), rotY(direction.getAzimuth()));
        IBakedModel modelBaked = (new MultiModel(null, null, null, map)).bake(modelStateBase, DefaultVertexFormats.ITEM, ModelLoader.defaultTextureGetter());
        return modelBaked.getQuads(null, null, random);
    }

    @Override
    public TextureAtlasSprite getParticleTexture(){
        return null; //defaultModel.getParticleTexture();
    }

    @Override
    public boolean isAmbientOcclusion(){
        return false;
    }

    @Override
    public boolean isGui3d(){
        return false;
    }

    @Override
    public boolean isBuiltInRenderer(){
        return false;
    }

    @Override
    public ItemCameraTransforms getItemCameraTransforms(){
        return null;
    }

    @Override
    public ItemOverrideList getOverrides(){
        return null;
    }
}