626 lines
16 KiB
Java
626 lines
16 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
|
|
{
|
|
List<BakedQuad>[] faces = new List[6];
|
|
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()];
|
|
}
|
|
}
|
|
|
|
public int uvRotateBottom;
|
|
public int uvRotateEast;
|
|
public int uvRotateNorth;
|
|
public int uvRotateSouth;
|
|
public int uvRotateTop;
|
|
public int uvRotateWest;
|
|
public IAESprite overrideBlockTexture;
|
|
public boolean renderAllFaces;
|
|
|
|
public double renderMinX;
|
|
public double renderMaxX;
|
|
|
|
public double renderMinY;
|
|
public double renderMaxY;
|
|
|
|
public double renderMinZ;
|
|
public double renderMaxZ;
|
|
|
|
public IBlockAccess blockAccess;
|
|
|
|
CachedModel generatedModel = new CachedModel();
|
|
|
|
// used to create faces...
|
|
final FaceBakery faceBakery = new FaceBakery();
|
|
|
|
float tx=0,ty=0,tz=0;
|
|
final float[] defUVs = { 0, 0, 1, 1 };
|
|
|
|
public void setRenderBoundsFromBlock(
|
|
final Block block )
|
|
{
|
|
if ( block == null ) return;
|
|
|
|
this.renderMinX = block.getBlockBoundsMinX();
|
|
this.renderMinY = block.getBlockBoundsMinY();
|
|
this.renderMinZ = block.getBlockBoundsMinZ();
|
|
this.renderMaxX = block.getBlockBoundsMaxX();
|
|
this.renderMaxY = block.getBlockBoundsMaxY();
|
|
this.renderMaxZ = block.getBlockBoundsMaxZ();
|
|
}
|
|
|
|
public void setRenderBounds(
|
|
final double d,
|
|
final double e,
|
|
final double f,
|
|
final double g,
|
|
final double h,
|
|
final double i )
|
|
{
|
|
this.renderMinX = d;
|
|
this.renderMinY = e;
|
|
this.renderMinZ = f;
|
|
this.renderMaxX = g;
|
|
this.renderMaxY = h;
|
|
this.renderMaxZ = i;
|
|
}
|
|
|
|
int color = -1;
|
|
|
|
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 );
|
|
}
|
|
|
|
int point =0;
|
|
int brightness = -1;
|
|
float[][] points = new float[4][];
|
|
|
|
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.blockAccess,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;
|
|
}
|
|
|
|
final float[] quadsUV = {
|
|
0,
|
|
0,
|
|
1,
|
|
1,
|
|
0,
|
|
0,
|
|
1,
|
|
1
|
|
};
|
|
public EnumSet<EnumFacing> renderFaces = EnumSet.allOf(EnumFacing.class);
|
|
public boolean flipTexture=false;
|
|
private List<SMFace> faces = new ArrayList();
|
|
|
|
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.renderMinX < 0.0001;
|
|
final Vector3f to = new Vector3f( (float) this.renderMinX * 16.0f, (float) this.renderMinY * 16.0f, (float) this.renderMinZ * 16.0f);
|
|
final Vector3f from = new Vector3f( (float) this.renderMinX * 16.0f, (float) this.renderMaxY * 16.0f, (float) this.renderMaxZ * 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.renderMinY < 0.0001;
|
|
final Vector3f to = new Vector3f( (float) this.renderMinX * 16.0f, (float) this.renderMinY * 16.0f, (float) this.renderMinZ * 16.0f );
|
|
final Vector3f from = new Vector3f( (float) this.renderMaxX * 16.0f, (float) this.renderMinY * 16.0f, (float) this.renderMaxZ * 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.renderMinZ < 0.0001;
|
|
final Vector3f to = new Vector3f( (float) this.renderMinX * 16.0f, (float) this.renderMinY * 16.0f, (float) this.renderMinZ * 16.0f );
|
|
final Vector3f from = new Vector3f( (float) this.renderMaxX * 16.0f, (float) this.renderMaxY * 16.0f, (float) this.renderMinZ * 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.renderMaxY > 0.9999;
|
|
final Vector3f to = new Vector3f( (float) this.renderMinX * 16.0f, (float) this.renderMaxY * 16.0f, (float) this.renderMinZ * 16.0f );
|
|
final Vector3f from = new Vector3f( (float) this.renderMaxX * 16.0f, (float) this.renderMaxY * 16.0f, (float) this.renderMaxZ * 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.renderMaxZ > 0.9999;
|
|
final Vector3f to = new Vector3f( (float) this.renderMinX * 16.0f, (float) this.renderMinY * 16.0f, (float) this.renderMaxZ * 16.0f );
|
|
final Vector3f from = new Vector3f( (float) this.renderMaxX * 16.0f, (float) this.renderMaxY * 16.0f, (float) this.renderMaxZ * 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.renderMaxX > 0.9999;
|
|
final Vector3f to = new Vector3f( (float) this.renderMaxX * 16.0f, (float) this.renderMinY * 16.0f, (float) this.renderMinZ * 16.0f );
|
|
final Vector3f from = new Vector3f( (float) this.renderMaxX * 16.0f, (float) this.renderMaxY * 16.0f, (float) this.renderMaxZ * 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.overrideBlockTexture != null )
|
|
texture = this.overrideBlockTexture;
|
|
|
|
this.faces.add( new SMFace( face, isEdge, this.color, to, from, defUVs2, new IconUnwrapper( texture ) ) );
|
|
}
|
|
|
|
EnumFacing currentFace = EnumFacing.UP;
|
|
|
|
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.face;
|
|
final float[] uvs = this.getFaceUvs( myFace, face.from, face.to );
|
|
|
|
final BlockFaceUV uv = new BlockFaceUV( uvs, 0 );
|
|
final BlockPartFace bpf = new BlockPartFace( myFace, face.color, "", uv );
|
|
|
|
BakedQuad bf = this.faceBakery.makeBakedQuad( face.to, face.from, bpf, face.spite, myFace, mr, null, true, true );
|
|
bf = new IColoredBakedQuad.ColoredBakedQuad( bf.getVertexData(), face.color, bf.getFace() );
|
|
|
|
if ( face.isEdge )
|
|
this.generatedModel.getFaceQuads( myFace ).add( bf );
|
|
else
|
|
this.generatedModel.getGeneralQuads().add( bf );
|
|
}
|
|
}
|
|
|
|
public IBakedModel getOutput()
|
|
{
|
|
return this.generatedModel;
|
|
}
|
|
|
|
}
|