800 lines
19 KiB
Java
800 lines
19 KiB
Java
|
|
package appeng.client.render;
|
|
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.EnumSet;
|
|
import java.util.List;
|
|
import javax.vecmath.Vector3f;
|
|
|
|
import net.minecraft.block.Block;
|
|
import net.minecraft.block.state.IBlockState;
|
|
import net.minecraft.client.Minecraft;
|
|
import net.minecraft.client.renderer.block.model.BakedQuad;
|
|
import net.minecraft.client.renderer.block.model.BlockFaceUV;
|
|
import net.minecraft.client.renderer.block.model.BlockPartFace;
|
|
import net.minecraft.client.renderer.block.model.FaceBakery;
|
|
import net.minecraft.client.renderer.block.model.ItemCameraTransforms;
|
|
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
|
|
import net.minecraft.client.resources.model.IBakedModel;
|
|
import net.minecraft.client.resources.model.ModelRotation;
|
|
import net.minecraft.item.Item;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.util.BlockPos;
|
|
import net.minecraft.util.EnumFacing;
|
|
import net.minecraft.util.EnumWorldBlockLayer;
|
|
import net.minecraft.world.IBlockAccess;
|
|
import net.minecraftforge.client.MinecraftForgeClient;
|
|
import net.minecraftforge.client.model.IColoredBakedQuad;
|
|
|
|
import appeng.block.AEBaseBlock;
|
|
import appeng.client.texture.BaseIcon;
|
|
import appeng.client.texture.IAESprite;
|
|
import appeng.client.texture.MissingIcon;
|
|
import appeng.items.AEBaseItem;
|
|
import appeng.items.parts.ItemMultiPart;
|
|
|
|
|
|
public class ModelGenerator
|
|
{
|
|
|
|
private static final class CachedModel implements IBakedModel
|
|
{
|
|
private List<BakedQuad>[] faces = new List[6];
|
|
private List<BakedQuad> general;
|
|
|
|
public CachedModel()
|
|
{
|
|
this.general = new ArrayList<BakedQuad>();
|
|
for( final EnumFacing f : EnumFacing.VALUES )
|
|
this.faces[f.ordinal()] = new ArrayList<BakedQuad>();
|
|
}
|
|
|
|
@Override
|
|
public boolean isGui3d()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean isBuiltInRenderer()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean isAmbientOcclusion()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public TextureAtlasSprite getTexture()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public ItemCameraTransforms getItemCameraTransforms()
|
|
{
|
|
return ItemCameraTransforms.DEFAULT;
|
|
}
|
|
|
|
@Override
|
|
public List getGeneralQuads()
|
|
{
|
|
return this.general;
|
|
}
|
|
|
|
@Override
|
|
public List getFaceQuads(
|
|
final EnumFacing p_177551_1_ )
|
|
{
|
|
return this.faces[p_177551_1_.ordinal()];
|
|
}
|
|
}
|
|
|
|
private int uvRotateBottom;
|
|
private int uvRotateEast;
|
|
private int uvRotateNorth;
|
|
private int uvRotateSouth;
|
|
private int uvRotateTop;
|
|
private int uvRotateWest;
|
|
private IAESprite overrideBlockTexture;
|
|
private boolean renderAllFaces;
|
|
|
|
private double renderMinX;
|
|
private double renderMaxX;
|
|
|
|
private double renderMinY;
|
|
private double renderMaxY;
|
|
|
|
private double renderMinZ;
|
|
private double renderMaxZ;
|
|
|
|
private IBlockAccess blockAccess;
|
|
|
|
private CachedModel generatedModel = new CachedModel();
|
|
|
|
// used to create faces...
|
|
private final FaceBakery faceBakery = new FaceBakery();
|
|
|
|
private float tx = 0, ty = 0, tz = 0;
|
|
private final float[] defUVs = { 0, 0, 1, 1 };
|
|
|
|
private final float[] quadsUV = {
|
|
0,
|
|
0,
|
|
1,
|
|
1,
|
|
0,
|
|
0,
|
|
1,
|
|
1
|
|
};
|
|
private EnumSet<EnumFacing> renderFaces = EnumSet.allOf( EnumFacing.class );
|
|
private boolean flipTexture = false;
|
|
private List<SMFace> faces = new ArrayList();
|
|
|
|
private int point = 0;
|
|
private int brightness = -1;
|
|
private float[][] points = new float[4][];
|
|
private EnumFacing currentFace = EnumFacing.UP;
|
|
private int color = -1;
|
|
|
|
public void setRenderBoundsFromBlock(
|
|
final Block block )
|
|
{
|
|
if( block == null )
|
|
return;
|
|
|
|
this.setRenderMinX( block.getBlockBoundsMinX() );
|
|
this.setRenderMinY( block.getBlockBoundsMinY() );
|
|
this.setRenderMinZ( block.getBlockBoundsMinZ() );
|
|
this.setRenderMaxX( block.getBlockBoundsMaxX() );
|
|
this.setRenderMaxY( block.getBlockBoundsMaxY() );
|
|
this.setRenderMaxZ( block.getBlockBoundsMaxZ() );
|
|
}
|
|
|
|
public void setRenderBounds(
|
|
final double d,
|
|
final double e,
|
|
final double f,
|
|
final double g,
|
|
final double h,
|
|
final double i )
|
|
{
|
|
this.setRenderMinX( d );
|
|
this.setRenderMinY( e );
|
|
this.setRenderMinZ( f );
|
|
this.setRenderMaxX( g );
|
|
this.setRenderMaxY( h );
|
|
this.setRenderMaxZ( i );
|
|
}
|
|
|
|
public void setBrightness(
|
|
final int i )
|
|
{
|
|
this.brightness = i;
|
|
}
|
|
|
|
public void setColorRGBA_F(
|
|
final int r,
|
|
final int g,
|
|
final int b,
|
|
final float a )
|
|
{
|
|
final int alpha = (int) ( a * 0xff );
|
|
this.color = alpha << 24 |
|
|
r << 16 |
|
|
b << 8 |
|
|
b;
|
|
}
|
|
|
|
public void setColorOpaque_I(
|
|
final int whiteVariant )
|
|
{
|
|
final int alpha = 0xff;
|
|
this.color = // alpha << 24 |
|
|
whiteVariant;
|
|
}
|
|
|
|
public void setColorOpaque(
|
|
final int r,
|
|
final int g,
|
|
final int b )
|
|
{
|
|
final int alpha = 0xff;
|
|
this.color = // alpha << 24 |
|
|
r << 16 |
|
|
g << 8 |
|
|
b;
|
|
}
|
|
|
|
public void setColorOpaque_F(
|
|
final int r,
|
|
final int g,
|
|
final int b )
|
|
{
|
|
final int alpha = 0xff;
|
|
this.color = // alpha << 24 |
|
|
Math.min( 0xff, Math.max( 0, r ) ) << 16 |
|
|
Math.min( 0xff, Math.max( 0, g ) ) << 8 |
|
|
Math.min( 0xff, Math.max( 0, b ) );
|
|
}
|
|
|
|
public void setColorOpaque_F(
|
|
final float rf,
|
|
final float bf,
|
|
final float gf )
|
|
{
|
|
final int r = (int) ( rf * 0xff );
|
|
final int g = (int) ( gf * 0xff );
|
|
final int b = (int) ( bf * 0xff );
|
|
final int alpha = 0xff;
|
|
this.color = // alpha << 24 |
|
|
Math.min( 0xff, Math.max( 0, r ) ) << 16 |
|
|
Math.min( 0xff, Math.max( 0, g ) ) << 8 |
|
|
Math.min( 0xff, Math.max( 0, b ) );
|
|
}
|
|
|
|
public IAESprite getIcon(
|
|
final ItemStack is )
|
|
{
|
|
final Item it = is.getItem();
|
|
|
|
if( it instanceof ItemMultiPart )
|
|
return ( (ItemMultiPart) it ).getIcon( is );
|
|
|
|
final Block blk = Block.getBlockFromItem( it );
|
|
|
|
if( blk != null )
|
|
return this.getIcon( blk.getStateFromMeta( is.getMetadata() ) )[0];
|
|
|
|
if( it instanceof AEBaseItem )
|
|
{
|
|
final IAESprite ico = ( (AEBaseItem) it ).getIcon( is );
|
|
if( ico != null )
|
|
return ico;
|
|
}
|
|
|
|
return new MissingIcon( is );
|
|
}
|
|
|
|
public IAESprite[] getIcon(
|
|
final IBlockState state )
|
|
{
|
|
final IAESprite[] out = new IAESprite[6];
|
|
|
|
final Block blk = state.getBlock();
|
|
if( blk instanceof AEBaseBlock )
|
|
{
|
|
final AEBaseBlock base = (AEBaseBlock) blk;
|
|
for( final EnumFacing face : EnumFacing.VALUES )
|
|
out[face.ordinal()] = base.getIcon( face, state );
|
|
}
|
|
else
|
|
{
|
|
final TextureAtlasSprite spite = Minecraft.getMinecraft().getBlockRendererDispatcher().getBlockModelShapes().getTexture( state );
|
|
if( spite == null )
|
|
{
|
|
out[0] = new MissingIcon( blk );
|
|
out[1] = new MissingIcon( blk );
|
|
out[2] = new MissingIcon( blk );
|
|
out[3] = new MissingIcon( blk );
|
|
out[4] = new MissingIcon( blk );
|
|
out[5] = new MissingIcon( blk );
|
|
}
|
|
else
|
|
{
|
|
final IAESprite mySpite = new BaseIcon( spite );
|
|
out[0] = mySpite;
|
|
out[1] = mySpite;
|
|
out[2] = mySpite;
|
|
out[3] = mySpite;
|
|
out[4] = mySpite;
|
|
out[5] = mySpite;
|
|
}
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
public IAESprite[] getIcon( final IBlockAccess world, final BlockPos pos )
|
|
{
|
|
final IBlockState state = world.getBlockState( pos );
|
|
final Block blk = state.getBlock();
|
|
|
|
if( blk instanceof AEBaseBlock )
|
|
{
|
|
final IAESprite[] out = new IAESprite[6];
|
|
|
|
final AEBaseBlock base = (AEBaseBlock) blk;
|
|
for( final EnumFacing face : EnumFacing.VALUES )
|
|
out[face.ordinal()] = base.getIcon( world, pos, face );
|
|
|
|
return out;
|
|
}
|
|
|
|
return this.getIcon( state );
|
|
}
|
|
|
|
public void addVertexWithUV(
|
|
final EnumFacing face,
|
|
final double x,
|
|
final double y,
|
|
final double z,
|
|
final double u,
|
|
final double v )
|
|
{
|
|
this.points[this.point++] = new float[] { (float) x + this.tx, (float) y + this.ty, (float) z + this.tz, (float) u, (float) v };
|
|
|
|
if( this.point == 4 )
|
|
{
|
|
this.brightness = -1;
|
|
final int[] vertData = {
|
|
Float.floatToRawIntBits( this.points[0][0] ),
|
|
Float.floatToRawIntBits( this.points[0][1] ),
|
|
Float.floatToRawIntBits( this.points[0][2] ),
|
|
this.brightness,
|
|
Float.floatToRawIntBits( this.points[0][3] ),
|
|
Float.floatToRawIntBits( this.points[0][4] ),
|
|
0,
|
|
|
|
Float.floatToRawIntBits( this.points[1][0] ),
|
|
Float.floatToRawIntBits( this.points[1][1] ),
|
|
Float.floatToRawIntBits( this.points[1][2] ),
|
|
this.brightness,
|
|
Float.floatToRawIntBits( this.points[1][3] ),
|
|
Float.floatToRawIntBits( this.points[1][4] ),
|
|
0,
|
|
|
|
Float.floatToRawIntBits( this.points[2][0] ),
|
|
Float.floatToRawIntBits( this.points[2][1] ),
|
|
Float.floatToRawIntBits( this.points[2][2] ),
|
|
this.brightness,
|
|
Float.floatToRawIntBits( this.points[2][3] ),
|
|
Float.floatToRawIntBits( this.points[2][4] ),
|
|
0,
|
|
|
|
Float.floatToRawIntBits( this.points[3][0] ),
|
|
Float.floatToRawIntBits( this.points[3][1] ),
|
|
Float.floatToRawIntBits( this.points[3][2] ),
|
|
this.brightness,
|
|
Float.floatToRawIntBits( this.points[3][3] ),
|
|
Float.floatToRawIntBits( this.points[3][4] ),
|
|
0,
|
|
};
|
|
|
|
this.generatedModel.general.add( new IColoredBakedQuad.ColoredBakedQuad( vertData, this.color, face ) );
|
|
|
|
this.point = 0;
|
|
}
|
|
}
|
|
|
|
public boolean renderStandardBlock(
|
|
final Block block,
|
|
final BlockPos pos )
|
|
{
|
|
// setRenderBoundsFromBlock( block );
|
|
|
|
final IAESprite[] textures = this.getIcon( this.getBlockAccess(), pos );
|
|
this.setColorOpaque_I( 0xffffff );
|
|
|
|
this.renderFaceXNeg( block, pos, textures[EnumFacing.WEST.ordinal()] );
|
|
this.renderFaceXPos( block, pos, textures[EnumFacing.EAST.ordinal()] );
|
|
this.renderFaceYNeg( block, pos, textures[EnumFacing.DOWN.ordinal()] );
|
|
this.renderFaceYPos( block, pos, textures[EnumFacing.UP.ordinal()] );
|
|
this.renderFaceZNeg( block, pos, textures[EnumFacing.NORTH.ordinal()] );
|
|
this.renderFaceZPos( block, pos, textures[EnumFacing.SOUTH.ordinal()] );
|
|
|
|
return false;
|
|
}
|
|
|
|
public void setTranslation(
|
|
final int x,
|
|
final int y,
|
|
final int z )
|
|
{
|
|
this.tx = x;
|
|
this.ty = y;
|
|
this.tz = z;
|
|
}
|
|
|
|
public boolean isAlphaPass()
|
|
{
|
|
return MinecraftForgeClient.getRenderLayer() == EnumWorldBlockLayer.TRANSLUCENT;
|
|
}
|
|
|
|
private float[] getFaceUvs(
|
|
final EnumFacing face,
|
|
final Vector3f to_16,
|
|
final Vector3f from_16 )
|
|
{
|
|
float from_a = 0;
|
|
float from_b = 0;
|
|
float to_a = 0;
|
|
float to_b = 0;
|
|
|
|
switch( face )
|
|
{
|
|
case UP:
|
|
from_a = from_16.x / 16.0f;
|
|
from_b = from_16.z / 16.0f;
|
|
to_a = to_16.x / 16.0f;
|
|
to_b = to_16.z / 16.0f;
|
|
break;
|
|
case DOWN:
|
|
from_a = from_16.x / 16.0f;
|
|
from_b = from_16.z / 16.0f;
|
|
to_a = to_16.x / 16.0f;
|
|
to_b = to_16.z / 16.0f;
|
|
break;
|
|
case SOUTH:
|
|
from_a = from_16.x / 16.0f;
|
|
from_b = from_16.y / 16.0f;
|
|
to_a = to_16.x / 16.0f;
|
|
to_b = to_16.y / 16.0f;
|
|
break;
|
|
case NORTH:
|
|
from_a = from_16.x / 16.0f;
|
|
from_b = from_16.y / 16.0f;
|
|
to_a = to_16.x / 16.0f;
|
|
to_b = to_16.y / 16.0f;
|
|
break;
|
|
case EAST:
|
|
from_a = from_16.y / 16.0f;
|
|
from_b = from_16.z / 16.0f;
|
|
to_a = to_16.y / 16.0f;
|
|
to_b = to_16.z / 16.0f;
|
|
break;
|
|
case WEST:
|
|
from_a = from_16.y / 16.0f;
|
|
from_b = from_16.z / 16.0f;
|
|
to_a = to_16.y / 16.0f;
|
|
to_b = to_16.z / 16.0f;
|
|
break;
|
|
default:
|
|
}
|
|
|
|
from_a = 1.0f - from_a;
|
|
from_b = 1.0f - from_b;
|
|
to_a = 1.0f - to_a;
|
|
to_b = 1.0f - to_b;
|
|
|
|
final float[] afloat = {// :P
|
|
16.0f * ( this.quadsUV[0] + this.quadsUV[2] * from_a + this.quadsUV[4] * from_b ), // 0
|
|
16.0f * ( this.quadsUV[1] + this.quadsUV[3] * from_a + this.quadsUV[5] * from_b ), // 1
|
|
|
|
16.0f * ( this.quadsUV[0] + this.quadsUV[2] * to_a + this.quadsUV[4] * from_b ), // 2
|
|
16.0f * ( this.quadsUV[1] + this.quadsUV[3] * to_a + this.quadsUV[5] * from_b ), // 3
|
|
|
|
16.0f * ( this.quadsUV[0] + this.quadsUV[2] * to_a + this.quadsUV[4] * to_b ), // 2
|
|
16.0f * ( this.quadsUV[1] + this.quadsUV[3] * to_a + this.quadsUV[5] * to_b ), // 3
|
|
|
|
16.0f * ( this.quadsUV[0] + this.quadsUV[2] * from_a + this.quadsUV[4] * to_b ), // 0
|
|
16.0f * ( this.quadsUV[1] + this.quadsUV[3] * from_a + this.quadsUV[5] * to_b ), // 1
|
|
};
|
|
|
|
return afloat;
|
|
}
|
|
|
|
public void renderFaceXNeg(
|
|
final Block blk,
|
|
final BlockPos pos,
|
|
final IAESprite lights )
|
|
{
|
|
final boolean isEdge = this.getRenderMinX() < 0.0001;
|
|
final Vector3f to = new Vector3f( (float) this.getRenderMinX() * 16.0f, (float) this.getRenderMinY() * 16.0f, (float) this.getRenderMinZ() * 16.0f );
|
|
final Vector3f from = new Vector3f( (float) this.getRenderMinX() * 16.0f, (float) this.getRenderMaxY() * 16.0f, (float) this.getRenderMaxZ() * 16.0f );
|
|
|
|
final EnumFacing myFace = EnumFacing.WEST;
|
|
this.addFace( myFace, isEdge, to, from, this.defUVs, lights );
|
|
}
|
|
|
|
public void renderFaceYNeg(
|
|
final Block blk,
|
|
final BlockPos pos,
|
|
final IAESprite lights )
|
|
{
|
|
final boolean isEdge = this.getRenderMinY() < 0.0001;
|
|
final Vector3f to = new Vector3f( (float) this.getRenderMinX() * 16.0f, (float) this.getRenderMinY() * 16.0f, (float) this.getRenderMinZ() * 16.0f );
|
|
final Vector3f from = new Vector3f( (float) this.getRenderMaxX() * 16.0f, (float) this.getRenderMinY() * 16.0f, (float) this.getRenderMaxZ() * 16.0f );
|
|
|
|
final EnumFacing myFace = EnumFacing.DOWN;
|
|
this.addFace( myFace, isEdge, to, from, this.defUVs, lights );
|
|
}
|
|
|
|
public void renderFaceZNeg(
|
|
final Block blk,
|
|
final BlockPos pos,
|
|
final IAESprite lights )
|
|
{
|
|
final boolean isEdge = this.getRenderMinZ() < 0.0001;
|
|
final Vector3f to = new Vector3f( (float) this.getRenderMinX() * 16.0f, (float) this.getRenderMinY() * 16.0f, (float) this.getRenderMinZ() * 16.0f );
|
|
final Vector3f from = new Vector3f( (float) this.getRenderMaxX() * 16.0f, (float) this.getRenderMaxY() * 16.0f, (float) this.getRenderMinZ() * 16.0f );
|
|
|
|
final EnumFacing myFace = EnumFacing.NORTH;
|
|
this.addFace( myFace, isEdge, to, from, this.defUVs, lights );
|
|
}
|
|
|
|
public void renderFaceYPos(
|
|
final Block blk,
|
|
final BlockPos pos,
|
|
final IAESprite lights )
|
|
{
|
|
final boolean isEdge = this.getRenderMaxY() > 0.9999;
|
|
final Vector3f to = new Vector3f( (float) this.getRenderMinX() * 16.0f, (float) this.getRenderMaxY() * 16.0f, (float) this.getRenderMinZ() * 16.0f );
|
|
final Vector3f from = new Vector3f( (float) this.getRenderMaxX() * 16.0f, (float) this.getRenderMaxY() * 16.0f, (float) this.getRenderMaxZ() * 16.0f );
|
|
|
|
final EnumFacing myFace = EnumFacing.UP;
|
|
this.addFace( myFace, isEdge, to, from, this.defUVs, lights );
|
|
}
|
|
|
|
public void renderFaceZPos(
|
|
final Block blk,
|
|
final BlockPos pos,
|
|
final IAESprite lights )
|
|
{
|
|
final boolean isEdge = this.getRenderMaxZ() > 0.9999;
|
|
final Vector3f to = new Vector3f( (float) this.getRenderMinX() * 16.0f, (float) this.getRenderMinY() * 16.0f, (float) this.getRenderMaxZ() * 16.0f );
|
|
final Vector3f from = new Vector3f( (float) this.getRenderMaxX() * 16.0f, (float) this.getRenderMaxY() * 16.0f, (float) this.getRenderMaxZ() * 16.0f );
|
|
|
|
final EnumFacing myFace = EnumFacing.SOUTH;
|
|
this.addFace( myFace, isEdge, to, from, this.defUVs, lights );
|
|
}
|
|
|
|
public void renderFaceXPos(
|
|
final Block blk,
|
|
final BlockPos pos,
|
|
final IAESprite lights )
|
|
{
|
|
final boolean isEdge = this.getRenderMaxX() > 0.9999;
|
|
final Vector3f to = new Vector3f( (float) this.getRenderMaxX() * 16.0f, (float) this.getRenderMinY() * 16.0f, (float) this.getRenderMinZ() * 16.0f );
|
|
final Vector3f from = new Vector3f( (float) this.getRenderMaxX() * 16.0f, (float) this.getRenderMaxY() * 16.0f, (float) this.getRenderMaxZ() * 16.0f );
|
|
|
|
final EnumFacing myFace = EnumFacing.EAST;
|
|
this.addFace( myFace, isEdge, to, from, this.defUVs, lights );
|
|
}
|
|
|
|
private void addFace(
|
|
final EnumFacing face, final boolean isEdge,
|
|
final Vector3f to,
|
|
final Vector3f from,
|
|
final float[] defUVs2,
|
|
IAESprite texture )
|
|
{
|
|
if( this.getOverrideBlockTexture() != null )
|
|
texture = this.getOverrideBlockTexture();
|
|
|
|
this.faces.add( new SMFace( face, isEdge, this.color, to, from, defUVs2, new IconUnwrapper( texture ) ) );
|
|
}
|
|
|
|
public void setNormal(
|
|
final float x,
|
|
final float y,
|
|
final float z )
|
|
{
|
|
if( x > 0.5 )
|
|
this.currentFace = EnumFacing.EAST;
|
|
if( x < -0.5 )
|
|
this.currentFace = EnumFacing.WEST;
|
|
if( y > 0.5 )
|
|
this.currentFace = EnumFacing.UP;
|
|
if( y < -0.5 )
|
|
this.currentFace = EnumFacing.DOWN;
|
|
if( z > 0.5 )
|
|
this.currentFace = EnumFacing.SOUTH;
|
|
if( z < -0.5 )
|
|
this.currentFace = EnumFacing.NORTH;
|
|
}
|
|
|
|
public void setOverrideBlockTexture(
|
|
final IAESprite object )
|
|
{
|
|
this.overrideBlockTexture = object;
|
|
}
|
|
|
|
public void finalizeModel( final boolean Flip )
|
|
{
|
|
ModelRotation mr = ModelRotation.X0_Y0;
|
|
|
|
if( Flip )
|
|
mr = ModelRotation.X0_Y180;
|
|
|
|
for( final SMFace face : this.faces )
|
|
{
|
|
final EnumFacing myFace = face.getFace();
|
|
final float[] uvs = this.getFaceUvs( myFace, face.getFrom(), face.getTo() );
|
|
|
|
final BlockFaceUV uv = new BlockFaceUV( uvs, 0 );
|
|
final BlockPartFace bpf = new BlockPartFace( myFace, face.getColor(), "", uv );
|
|
|
|
BakedQuad bf = this.faceBakery.makeBakedQuad( face.getTo(), face.getFrom(), bpf, face.getSpite(), myFace, mr, null, true, true );
|
|
bf = new IColoredBakedQuad.ColoredBakedQuad( bf.getVertexData(), face.getColor(), bf.getFace() );
|
|
|
|
if( face.isEdge() )
|
|
this.generatedModel.getFaceQuads( myFace ).add( bf );
|
|
else
|
|
this.generatedModel.getGeneralQuads().add( bf );
|
|
}
|
|
}
|
|
|
|
public IBakedModel getOutput()
|
|
{
|
|
return this.generatedModel;
|
|
}
|
|
|
|
public IAESprite getOverrideBlockTexture()
|
|
{
|
|
return overrideBlockTexture;
|
|
}
|
|
|
|
public IBlockAccess getBlockAccess()
|
|
{
|
|
return blockAccess;
|
|
}
|
|
|
|
public void setBlockAccess( IBlockAccess blockAccess )
|
|
{
|
|
this.blockAccess = blockAccess;
|
|
}
|
|
|
|
public boolean isRenderAllFaces()
|
|
{
|
|
return renderAllFaces;
|
|
}
|
|
|
|
public void setRenderAllFaces( boolean renderAllFaces )
|
|
{
|
|
this.renderAllFaces = renderAllFaces;
|
|
}
|
|
|
|
public int getUvRotateBottom()
|
|
{
|
|
return uvRotateBottom;
|
|
}
|
|
|
|
public int setUvRotateBottom( int uvRotateBottom )
|
|
{
|
|
this.uvRotateBottom = uvRotateBottom;
|
|
return uvRotateBottom;
|
|
}
|
|
|
|
public int getUvRotateEast()
|
|
{
|
|
return uvRotateEast;
|
|
}
|
|
|
|
public int setUvRotateEast( int uvRotateEast )
|
|
{
|
|
this.uvRotateEast = uvRotateEast;
|
|
return uvRotateEast;
|
|
}
|
|
|
|
public int getUvRotateNorth()
|
|
{
|
|
return uvRotateNorth;
|
|
}
|
|
|
|
public int setUvRotateNorth( int uvRotateNorth )
|
|
{
|
|
this.uvRotateNorth = uvRotateNorth;
|
|
return uvRotateNorth;
|
|
}
|
|
|
|
public int getUvRotateSouth()
|
|
{
|
|
return uvRotateSouth;
|
|
}
|
|
|
|
public int setUvRotateSouth( int uvRotateSouth )
|
|
{
|
|
this.uvRotateSouth = uvRotateSouth;
|
|
return uvRotateSouth;
|
|
}
|
|
|
|
public int getUvRotateTop()
|
|
{
|
|
return uvRotateTop;
|
|
}
|
|
|
|
public int setUvRotateTop( int uvRotateTop )
|
|
{
|
|
this.uvRotateTop = uvRotateTop;
|
|
return uvRotateTop;
|
|
}
|
|
|
|
public int getUvRotateWest()
|
|
{
|
|
return uvRotateWest;
|
|
}
|
|
|
|
public int setUvRotateWest( int uvRotateWest )
|
|
{
|
|
this.uvRotateWest = uvRotateWest;
|
|
return uvRotateWest;
|
|
}
|
|
|
|
public double getRenderMinX()
|
|
{
|
|
return renderMinX;
|
|
}
|
|
|
|
public void setRenderMinX( double renderMinX )
|
|
{
|
|
this.renderMinX = renderMinX;
|
|
}
|
|
|
|
public double getRenderMinY()
|
|
{
|
|
return renderMinY;
|
|
}
|
|
|
|
public void setRenderMinY( double renderMinY )
|
|
{
|
|
this.renderMinY = renderMinY;
|
|
}
|
|
|
|
public double getRenderMinZ()
|
|
{
|
|
return renderMinZ;
|
|
}
|
|
|
|
public void setRenderMinZ( double renderMinZ )
|
|
{
|
|
this.renderMinZ = renderMinZ;
|
|
}
|
|
|
|
public double getRenderMaxX()
|
|
{
|
|
return renderMaxX;
|
|
}
|
|
|
|
public void setRenderMaxX( double renderMaxX )
|
|
{
|
|
this.renderMaxX = renderMaxX;
|
|
}
|
|
|
|
public double getRenderMaxY()
|
|
{
|
|
return renderMaxY;
|
|
}
|
|
|
|
public void setRenderMaxY( double renderMaxY )
|
|
{
|
|
this.renderMaxY = renderMaxY;
|
|
}
|
|
|
|
public double getRenderMaxZ()
|
|
{
|
|
return renderMaxZ;
|
|
}
|
|
|
|
public void setRenderMaxZ( double renderMaxZ )
|
|
{
|
|
this.renderMaxZ = renderMaxZ;
|
|
}
|
|
|
|
public boolean isFlipTexture()
|
|
{
|
|
return flipTexture;
|
|
}
|
|
|
|
public void setFlipTexture( boolean flipTexture )
|
|
{
|
|
this.flipTexture = flipTexture;
|
|
}
|
|
|
|
public EnumSet<EnumFacing> getRenderFaces()
|
|
{
|
|
return renderFaces;
|
|
}
|
|
|
|
public void setRenderFaces( EnumSet<EnumFacing> renderFaces )
|
|
{
|
|
this.renderFaces = renderFaces;
|
|
}
|
|
|
|
}
|