Anvilcraft/DimDoors
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

changes to RiftRender

Browse source
This commit is contained in:
StevenRS11 2013-08-20 21:43:33 -04:00
parent 57b6a5efb2
commit d9a9091a2b
7 changed files with 453 additions and 172 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

202
StevenDimDoors/mod_pocketDim/TileEntityRift.java
View file

@ -3,6 +3,7 @@ package StevenDimDoors.mod_pocketDim;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Random; import java.util.Random;
@ -31,48 +32,42 @@ public class TileEntityRift extends TileEntity
public boolean isNearRift=false; public boolean isNearRift=false;
private int count=200; private int count=200;
private int count2 = 0; private int count2 = 0;
private int soundCount = 0;
public HashMap<Integer, double[]> renderingCenters = new HashMap<Integer, double[]>();
public LinkData nearestRiftData; public LinkData nearestRiftData;
Random rand = new Random(); Random rand = new Random();
public float age = 0;
public boolean canUpdate() public boolean canUpdate()
{ {
return true; return true;
} }
public void clearBlocksOnRift()
public void updateEntity()
{ {
for(double[] coord: this.renderingCenters.values())
{
int x = MathHelper.floor_double(coord[0]+.5);
int y = MathHelper.floor_double(coord[1]+.5);
int z = MathHelper.floor_double(coord[2]+.5);
this.worldObj.setBlockToAir(this.xCoord+x, this.yCoord+y, this.zCoord+z);
this.worldObj.setBlockToAir(this.xCoord-x, this.yCoord+y, this.zCoord-z);
}
}
public void spawnEndermen()
{
if(count>200&&dimHelper.instance.getDimData(this.worldObj.provider.dimensionId)!=null) if(count>200&&dimHelper.instance.getDimData(this.worldObj.provider.dimensionId)!=null)
{ {
/**
if(rand.nextBoolean())
{
}
**/
nearestRiftData = dimHelper.instance.getDimData(this.worldObj.provider.dimensionId).findNearestRift(worldObj, 5, xCoord, yCoord, zCoord); nearestRiftData = dimHelper.instance.getDimData(this.worldObj.provider.dimensionId).findNearestRift(worldObj, 5, xCoord, yCoord, zCoord);
if(nearestRiftData!=null) if(nearestRiftData!=null)
{ {
this.xOffset=this.xCoord-nearestRiftData.locXCoord;
this.yOffset=this.yCoord-nearestRiftData.locYCoord;
this.zOffset=this.zCoord-nearestRiftData.locZCoord;
this.distance=(int) (MathHelper.abs(xOffset)+MathHelper.abs(yOffset)+MathHelper.abs(zOffset));
this.isNearRift=true;
if(!this.worldObj.isRemote&&distance>1)
{
try
{
grow(distance);
}
catch(Exception e)
{
}
}
if(rand.nextInt(30)==0&&!this.worldObj.isRemote) if(rand.nextInt(30)==0&&!this.worldObj.isRemote)
{ {
@ -82,29 +77,11 @@ public class TileEntityRift extends TileEntity
{ {
EntityEnderman creeper = new EntityEnderman(worldObj); EntityEnderman enderman = new EntityEnderman(worldObj);
creeper.setLocationAndAngles(this.xCoord+.5, this.yCoord-1, this.zCoord+.5, 5, 6); enderman.setLocationAndAngles(this.xCoord+.5, this.yCoord-1, this.zCoord+.5, 5, 6);
worldObj.spawnEntityInWorld(creeper); worldObj.spawnEntityInWorld(enderman);
} }
/**
if(dimHelper.instance.getDimData(this.worldObj.provider.dimensionId)!=null)
{
ArrayList rifts = dimHelper.instance.getDimData(this.worldObj.provider.dimensionId).findRiftsInRange(worldObj, 6, this.xCoord, this.yCoord, this.zCoord);
if(rifts.size()>15)
{
MobObelisk creeper = new MobObelisk(worldObj);
creeper.setLocationAndAngles(this.xCoord+.5, yCoordHelper.getFirstUncovered(this.worldObj, this.xCoord, this.yCoord, this.zCoord), this.zCoord+.5, 5, 6);
worldObj.spawnEntityInWorld(creeper);
} }
}
**/
}
} }
else else
{ {
@ -112,16 +89,9 @@ public class TileEntityRift extends TileEntity
} }
count=0; count=0;
} }
else if(dimHelper.instance.getLinkDataFromCoords(xCoord, yCoord, zCoord, this.worldObj.provider.dimensionId)==null)
{
this.invalidate();
this.worldObj.setBlockToAir(xCoord, yCoord, zCoord);
} }
count++; public void closeRift()
if(this.shouldClose)
{ {
// System.out.println(count2);
if(count2>20&&count2<22) if(count2>20&&count2<22)
{ {
nearestRiftData = dimHelper.instance.getDimData(this.worldObj.provider.dimensionId).findNearestRift(worldObj, 10, xCoord, yCoord, zCoord); nearestRiftData = dimHelper.instance.getDimData(this.worldObj.provider.dimensionId).findNearestRift(worldObj, 10, xCoord, yCoord, zCoord);
@ -148,51 +118,95 @@ public class TileEntityRift extends TileEntity
} }
count2++; count2++;
} }
public void updateEntity()
{
if(rand.nextInt(10)==0)
{
age = age + 1;
this.calculateNextRenderQuad(age, rand);
}
this.clearBlocksOnRift();
this.spawnEndermen();
count++;
if(this.shouldClose)
{
closeRift();
}
if(dimHelper.instance.getLinkDataFromCoords(xCoord, yCoord, zCoord, this.worldObj.provider.dimensionId)==null)
{
this.invalidate();
this.worldObj.setBlockToAir(xCoord, yCoord, zCoord);
}
} }
public void grow(int distance) public void grow(int distance)
{ {
int count=0;
if(rand.nextInt(distance*2)==0) }
public void calculateNextRenderQuad(float age, Random rand)
{ {
int iteration = MathHelper.floor_double((Math.log(Math.pow(age+1,1.5))));
double fl =Math.log(iteration+1)/(iteration);
double[] coords= new double[4];
double noise = ((rand.nextGaussian())/(10)*(iteration+1));
int x=0,y=0,z=0; if(!this.renderingCenters.containsKey(iteration-1))
while(count<100)
{ {
count++; if(rand.nextBoolean())
x=this.xCoord+(1-(rand.nextInt(2)*2)*rand.nextInt(6));
y=this.yCoord+(1-(rand.nextInt(2)*2)*rand.nextInt(4));
z=this.zCoord+(1-(rand.nextInt(2)*2)*rand.nextInt(6));
if(this.worldObj.isAirBlock(x, y, z))
{ {
break; coords[0] = fl*1.5;
coords[1] = rand.nextGaussian()/10;
coords[2] = 0;
coords[3] = 1;
} }
else
}
if (count<100)
{ {
coords[0] = 0;
coords[1] = rand.nextGaussian()/10;
coords[2] = fl*1.5;
coords[3] = 0;
LinkData link = dimHelper.instance.getLinkDataFromCoords(this.xCoord, this.yCoord, this.zCoord, worldObj); }
if(link!=null) this.renderingCenters.put(iteration-1,coords);
}
else if(!this.renderingCenters.containsKey(iteration))
{ {
if(!this.hasGrownRifts&&rand.nextInt(3)==0) if(this.renderingCenters.get(iteration-1)[3]==0)
{ {
// System.out.println(link.numberofChildren); coords[0]=noise/2+this.renderingCenters.get(iteration-1)[0];
link.numberofChildren++; coords[1]=noise+this.renderingCenters.get(iteration-1)[1];
dimHelper.instance.createLink(this.worldObj.provider.dimensionId, link.destDimID, x, y, z, link.destXCoord, link.destYCoord, link.destZCoord).numberofChildren=link.numberofChildren+1; coords[2]= this.renderingCenters.get(iteration-1)[2]+fl;
this.hasGrownRifts=true; coords[3] = 0;
} }
else
{
coords[0]=this.renderingCenters.get(iteration-1)[0]+fl;
coords[1]=noise+this.renderingCenters.get(iteration-1)[1];
coords[2]=noise/2+this.renderingCenters.get(iteration-1)[2];
coords[3] = 1;
} }
}
this.renderingCenters.put(iteration,coords);
} }
} }
@Override
public boolean shouldRenderInPass(int pass)
{
return pass == 1;
}
@Override @Override
public void readFromNBT(NBTTagCompound nbt) public void readFromNBT(NBTTagCompound nbt)
{ {
@ -201,14 +215,21 @@ public class TileEntityRift extends TileEntity
try try
{ {
this.xOffset = nbt.getInteger("xOffset");
this.yOffset = nbt.getInteger("yOffset");
this.zOffset = nbt.getInteger("zOffset");
this.hasGrownRifts =nbt.getBoolean("grownRifts");
this.count=nbt.getInteger("count"); this.count=nbt.getInteger("count");
this.count2=nbt.getInteger("count2"); this.count2=nbt.getInteger("count2");
this.shouldClose=nbt.getBoolean("shouldClose"); this.shouldClose=nbt.getBoolean("shouldClose");
this.age=nbt.getFloat("age");
for(int key=0; key<=nbt.getInteger("hashMapSize");key++)
{
double[] coords = new double[4];
coords[0]= nbt.getDouble(key+"+0");
coords[1]= nbt.getDouble(key+"+1");
coords[2]= nbt.getDouble(key+"+2");
coords[3]= nbt.getDouble(key+"+3");
this.renderingCenters.put(key, coords);
}
@ -216,7 +237,7 @@ public class TileEntityRift extends TileEntity
} }
catch (Exception e) catch (Exception e)
{ {
e.printStackTrace();
} }
} }
@ -225,12 +246,19 @@ public class TileEntityRift extends TileEntity
{ {
int i = 0; int i = 0;
super.writeToNBT(nbt); super.writeToNBT(nbt);
nbt.setInteger("xOffset", this.xOffset);
nbt.setInteger("yOffset", this.yOffset); for(Integer key:this.renderingCenters.keySet())
nbt.setInteger("zOffset", this.zOffset); {
nbt.setBoolean("grownRifts",this.hasGrownRifts); nbt.setDouble(key+"+0", this.renderingCenters.get(key)[0]);
nbt.setDouble(key+"+1", this.renderingCenters.get(key)[1]);
nbt.setDouble(key+"+2", this.renderingCenters.get(key)[2]);
nbt.setDouble(key+"+3", this.renderingCenters.get(key)[3]);
}
nbt.setInteger("hashMapSize", this.renderingCenters.size());
nbt.setInteger("count", this.count); nbt.setInteger("count", this.count);
nbt.setInteger("count2", this.count2); nbt.setInteger("count2", this.count2);
nbt.setFloat("age", this.age);
nbt.setBoolean("shouldClose", this.shouldClose); nbt.setBoolean("shouldClose", this.shouldClose);
} }

10
StevenDimDoors/mod_pocketDim/blocks/BlockRift.java
View file

@ -37,13 +37,12 @@ public class BlockRift extends BlockContainer
private static final int BLOCK_DESTRUCTION_CHANCE = 50; private static final int BLOCK_DESTRUCTION_CHANCE = 50;
private final DDProperties properties; private final DDProperties properties;
private final ArrayList<Integer> blocksImmuneToRift; private static ArrayList<Integer> blocksImmuneToRift;
public BlockRift(int i, int j, Material par2Material, DDProperties properties) public BlockRift(int i, int j, Material par2Material, DDProperties properties)
{ {
super(i, par2Material); super(i, par2Material);
this.setTickRandomly(true); this.setTickRandomly(true);
this.setLightOpacity(14);
this.properties = properties; this.properties = properties;
this.blocksImmuneToRift = new ArrayList<Integer>(); this.blocksImmuneToRift = new ArrayList<Integer>();
this.blocksImmuneToRift.add(properties.FabricBlockID); this.blocksImmuneToRift.add(properties.FabricBlockID);
@ -223,11 +222,14 @@ public class BlockRift extends BlockContainer
} }
} }
/** /**
* regulates the render effect, especially when multiple rifts start to link up. Has 3 main parts- Grows toward and away from nearest rft, bends toward it, and a randomization function * regulates the render effect, especially when multiple rifts start to link up. Has 3 main parts- Grows toward and away from nearest rft, bends toward it, and a randomization function
*/ */
/**
@Override @Override
@SideOnly(Side.CLIENT) @SideOnly(Side.CLIENT)
public void randomDisplayTick(World par1World, int par2, int par3, int par4, Random rand) public void randomDisplayTick(World par1World, int par2, int par3, int par4, Random rand)
{ {
@ -334,8 +336,8 @@ public class BlockRift extends BlockContainer
} }
} }
} }
**/
public boolean isBlockImmune(World world, int x, int y, int z) public static boolean isBlockImmune(World world, int x, int y, int z)
{ {
Block block = Block.blocksList[world.getBlockId(x, y, z)]; Block block = Block.blocksList[world.getBlockId(x, y, z)];
if (block != null) if (block != null)

26
StevenDimDoors/mod_pocketDim/ticking/LimboGatewayGenerator.java Normal file
View file

@ -0,0 +1,26 @@
package StevenDimDoors.mod_pocketDim.ticking;
import java.util.ArrayList;
import java.util.Random;
import net.minecraft.entity.Entity;
import net.minecraft.server.MinecraftServer;
import net.minecraft.world.GameRules;
import net.minecraft.world.World;
import StevenDimDoors.mod_pocketDim.DDProperties;
import StevenDimDoors.mod_pocketDim.DimData;
import StevenDimDoors.mod_pocketDim.helpers.dimHelper;
import StevenDimDoors.mod_pocketDim.helpers.yCoordHelper;
import StevenDimDoors.mod_pocketDim.util.ChunkLocation;
public class LimboGatewayGenerator implements IRegularTickReceiver
{
@Override
public void notifyTick()
{
}
}

2
StevenDimDoors/mod_pocketDimClient/ClientProxy.java
View file

@ -10,6 +10,7 @@ import net.minecraftforge.client.MinecraftForgeClient;
import StevenDimDoors.mod_pocketDim.CommonProxy; import StevenDimDoors.mod_pocketDim.CommonProxy;
import StevenDimDoors.mod_pocketDim.Spells; import StevenDimDoors.mod_pocketDim.Spells;
import StevenDimDoors.mod_pocketDim.TileEntityDimDoor; import StevenDimDoors.mod_pocketDim.TileEntityDimDoor;
import StevenDimDoors.mod_pocketDim.TileEntityRift;
import StevenDimDoors.mod_pocketDim.mod_pocketDim; import StevenDimDoors.mod_pocketDim.mod_pocketDim;
import StevenDimDoors.mod_pocketDim.ticking.CommonTickHandler; import StevenDimDoors.mod_pocketDim.ticking.CommonTickHandler;
import StevenDimDoors.mod_pocketDim.ticking.MobMonolith; import StevenDimDoors.mod_pocketDim.ticking.MobMonolith;
@ -24,6 +25,7 @@ public class ClientProxy extends CommonProxy
//MinecraftForgeClient.preloadTexture(BLOCK_PNG); //MinecraftForgeClient.preloadTexture(BLOCK_PNG);
ClientRegistry.bindTileEntitySpecialRenderer(TileEntityDimDoor.class, new RenderDimDoor()); ClientRegistry.bindTileEntitySpecialRenderer(TileEntityDimDoor.class, new RenderDimDoor());
ClientRegistry.bindTileEntitySpecialRenderer(TileEntityRift.class, new RenderRift());
//MinecraftForgeClient.preloadTexture(RIFT2_PNG); //MinecraftForgeClient.preloadTexture(RIFT2_PNG);

71
StevenDimDoors/mod_pocketDimClient/RenderDimDoor.java
View file

@ -164,8 +164,7 @@ public class RenderDimDoor extends TileEntitySpecialRenderer
GL11.glRotatef((float)(count * count * 4321 + count * 9) * 2.0F, 0.0F, 0.0F, 1.0F); GL11.glRotatef((float)(count * count * 4321 + count * 9) * 2.0F, 0.0F, 0.0F, 1.0F);
GL11.glTranslatef(0.5F, 0.5F, 0.5F); GL11.glTranslatef(0.5F, 0.5F, 0.5F);
Tessellator var24 = Tessellator.instance; GL11.glBegin(GL11.GL_QUADS);
var24.startDrawingQuads();
@ -180,7 +179,7 @@ public class RenderDimDoor extends TileEntitySpecialRenderer
var22 = 1.0F; var22 = 1.0F;
yConverted = 1.0F; yConverted = 1.0F;
} }
var24.setColorRGBA_F(var21 * var17, var22 * var17, var23 * var17, 1.0F); GL11.glColor4d(var21 * var17, var22 * var17, var23 * var17, 1.0F);
if(tile.openOrClosed) if(tile.openOrClosed)
{ {
@ -188,60 +187,60 @@ public class RenderDimDoor extends TileEntitySpecialRenderer
{ {
case 0: case 0:
var24.addVertex(x+.01F, y-1 , z); GL11.glVertex3d(x+.01F, y-1 , z);
var24.addVertex(x+.01, y-1, z+1.0D); GL11.glVertex3d(x+.01, y-1, z+1.0D);
var24.addVertex(x+.01 , y+1 , z + 1.0D); GL11.glVertex3d(x+.01 , y+1 , z + 1.0D);
var24.addVertex(x+.01 , y+1 , z); GL11.glVertex3d(x+.01 , y+1 , z);
break; break;
case 1: case 1:
var24.addVertex(x , y+1 , z+.01); GL11.glVertex3d(x , y+1 , z+.01);
var24.addVertex(x+1 , y+1 , z+.01); GL11.glVertex3d(x+1 , y+1 , z+.01);
var24.addVertex(x+1, y-1, z+.01); GL11.glVertex3d(x+1, y-1, z+.01);
var24.addVertex(x, y-1, z+.01); GL11.glVertex3d(x, y-1, z+.01);
break; break;
case 2: // case 2: //
var24.addVertex(x+.99 , y+1 , z); GL11.glVertex3d(x+.99 , y+1 , z);
var24.addVertex(x+.99 , y+1 , z + 1.0D); GL11.glVertex3d(x+.99 , y+1 , z + 1.0D);
var24.addVertex(x+.99, y-1, z+1.0D); GL11.glVertex3d(x+.99, y-1, z+1.0D);
var24.addVertex(x+.99, y-1, z); GL11.glVertex3d(x+.99, y-1, z);
break; break;
case 3: case 3:
var24.addVertex(x, y-1, z+.99); GL11.glVertex3d(x, y-1, z+.99);
var24.addVertex(x+1, y-1, z+.99); GL11.glVertex3d(x+1, y-1, z+.99);
var24.addVertex(x+1 , y+1 , z+.99); GL11.glVertex3d(x+1 , y+1 , z+.99);
var24.addVertex(x , y+1 , z+.99); GL11.glVertex3d(x , y+1 , z+.99);
break; break;
case 4:// case 4://
// GL11.glTranslatef(); // GL11.glTranslatef();
var24.addVertex(x+.15F, y-1 , z); GL11.glVertex3d(x+.15F, y-1 , z);
var24.addVertex(x+.15, y-1, z+1.0D); GL11.glVertex3d(x+.15, y-1, z+1.0D);
var24.addVertex(x+.15 , y+1 , z + 1.0D); GL11.glVertex3d(x+.15 , y+1 , z + 1.0D);
var24.addVertex(x+.15 , y+1 , z); GL11.glVertex3d(x+.15 , y+1 , z);
break; break;
case 5: case 5:
var24.addVertex(x , y+1 , z+.15); GL11.glVertex3d(x , y+1 , z+.15);
var24.addVertex(x+1 , y+1 , z+.15); GL11.glVertex3d(x+1 , y+1 , z+.15);
var24.addVertex(x+1, y-1, z+.15); GL11.glVertex3d(x+1, y-1, z+.15);
var24.addVertex(x, y-1, z+.15); GL11.glVertex3d(x, y-1, z+.15);
break; break;
case 6: // case 6: //
var24.addVertex(x+.85 , y+1 , z); GL11.glVertex3d(x+.85 , y+1 , z);
var24.addVertex(x+.85 , y+1 , z + 1.0D); GL11.glVertex3d(x+.85 , y+1 , z + 1.0D);
var24.addVertex(x+.85, y-1, z+1.0D); GL11.glVertex3d(x+.85, y-1, z+1.0D);
var24.addVertex(x+.85, y-1, z); GL11.glVertex3d(x+.85, y-1, z);
break; break;
case 7: case 7:
var24.addVertex(x, y-1, z+.85); GL11.glVertex3d(x, y-1, z+.85);
var24.addVertex(x+1, y-1, z+.85); GL11.glVertex3d(x+1, y-1, z+.85);
var24.addVertex(x+1 , y+1 , z+.85); GL11.glVertex3d(x+1 , y+1 , z+.85);
var24.addVertex(x , y+1 , z+.85); GL11.glVertex3d(x , y+1 , z+.85);
break; break;
default: default:
break; break;
@ -253,7 +252,7 @@ public class RenderDimDoor extends TileEntitySpecialRenderer
var24.draw(); GL11.glEnd();
GL11.glPopMatrix(); GL11.glPopMatrix();
GL11.glMatrixMode(GL11.GL_MODELVIEW); GL11.glMatrixMode(GL11.GL_MODELVIEW);

224
StevenDimDoors/mod_pocketDimClient/RenderRift.java
View file

@ -0,0 +1,224 @@
package StevenDimDoors.mod_pocketDimClient;
import java.nio.FloatBuffer;
import java.util.HashMap;
import java.util.Random;
import net.minecraft.block.Block;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.ActiveRenderInfo;
import net.minecraft.client.renderer.GLAllocation;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
import net.minecraft.tileentity.TileEntity;
import org.lwjgl.opengl.GL11;
import static org.lwjgl.opengl.GL11.*;
import StevenDimDoors.mod_pocketDim.DDProperties;
import StevenDimDoors.mod_pocketDim.TileEntityDimDoor;
import StevenDimDoors.mod_pocketDim.TileEntityRift;
import StevenDimDoors.mod_pocketDim.mod_pocketDim;
import StevenDimDoors.mod_pocketDim.blocks.dimDoor;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class RenderRift extends TileEntitySpecialRenderer
{
@Override
public void renderTileEntityAt(TileEntity te, double xWorld, double yWorld,
double zWorld, float f)
{
yWorld = yWorld+.75;
GL11.glPushMatrix();
GL11.glDisable(GL11.GL_CULL_FACE);
GL11.glDisable(GL_TEXTURE_2D);
GL11.glDisable(GL_LIGHTING);
//GL11.glLogicOp(GL11.GL_INVERT);
// GL11.glEnable(GL11.GL_COLOR_LOGIC_OP);
GL11.glColor4f(.3F, .3F, .3F, .2F);
GL11.glEnable(GL_BLEND);
glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO);
/**
* just draws the verticies
*/
//testDraw(TileEntityRift.class.cast(te).renderingCenters, xWorld, yWorld, zWorld);
this.drawCrack(TileEntityRift.class.cast(te).renderingCenters, xWorld, yWorld, zWorld);
this.drawCrackRotated(TileEntityRift.class.cast(te).renderingCenters, xWorld, yWorld, zWorld);
GL11.glEnable(GL11.GL_CULL_FACE);
GL11.glEnable(GL11.GL_LIGHTING);
GL11.glEnable(GL_TEXTURE_2D);
GL11.glDisable(GL11.GL_COLOR_LOGIC_OP);
GL11.glPopMatrix();
}
public void drawCrack(HashMap<Integer, double[]> quads,double xWorld,double yWorld,double zWorld)
{
GL11.glBegin(GL11.GL_QUAD_STRIP);
drawVertex(xWorld+.5, yWorld-Math.log(quads.size()+1)/8, zWorld+.5);
drawVertex(xWorld+.5, yWorld+Math.log(quads.size()+1)/8, zWorld+.5);
for(int i = 0;;i++)
{
if(!quads.containsKey(i))
{
break;
}
double[] coords = quads.get(i);
double width=Math.log(quads.size()-i+1)/8;
if(coords[3]==0)
{
if(quads.containsKey(i+1))
{
drawVertex(xWorld+coords[0]+.5, yWorld+coords[1]-width/2 , zWorld+coords[2]);
drawVertex(xWorld+coords[0]+.5 , yWorld+coords[1]+width/2 , zWorld+coords[2]);
}
else
{
drawVertex(xWorld+coords[0]+.5, yWorld+coords[1]-width/200 , zWorld+coords[2]);
drawVertex(xWorld+coords[0]+.5 , yWorld+coords[1]+width/200 , zWorld+coords[2]);
}
}
else
{
if(quads.containsKey(i+1))
{
drawVertex(xWorld+coords[0], yWorld+coords[1]-width/2 , zWorld+coords[2]+.5);
drawVertex(xWorld+coords[0], yWorld+coords[1]+width/2 , zWorld+coords[2]+.5);
}
else
{
drawVertex(xWorld+coords[0], yWorld+coords[1]+width/200 , zWorld+coords[2]+.5);
drawVertex(xWorld+coords[0], yWorld+coords[1]-width/200, zWorld+coords[2]+.5);
}
}
}
GL11.glEnd();
}
public void drawCrackRotated(HashMap<Integer, double[]> quads,double xWorld,double yWorld,double zWorld)
{
GL11.glBegin(GL11.GL_QUAD_STRIP);
drawVertex(xWorld+.5, yWorld+Math.log(quads.size()+1)/8, zWorld+.5);
drawVertex(xWorld+.5, yWorld-Math.log(quads.size()+1)/8, zWorld+.5);
for(int i = 0;;i++)
{
if(!quads.containsKey(i))
{
break;
}
double[] coords = quads.get(i);
double width=Math.log(quads.size()-i+1)/8;
if(coords[3]==0)
{
if(quads.containsKey(i+1))
{
drawVertex(xWorld+coords[0]+.5, yWorld-(coords[1]-width/2) , zWorld-coords[2]+1);
drawVertex(xWorld+coords[0]+.5 , yWorld-(coords[1]+width/2) , zWorld-coords[2]+1);
}
else
{
drawVertex(xWorld+coords[0]+.5, yWorld-(coords[1]-width/200) , zWorld-coords[2]+1);
drawVertex(xWorld+coords[0]+.5 , yWorld-(coords[1]+width/200) , zWorld-coords[2]+1);
}
}
else
{
if(quads.containsKey(i+1))
{
drawVertex(xWorld-coords[0]+1, yWorld-(coords[1]-width/2) , zWorld+coords[2]+.5);
drawVertex(xWorld-coords[0]+1, yWorld-(coords[1]+width/2) , zWorld+coords[2]+.5);
}
else
{
drawVertex(xWorld-coords[0]+1, yWorld-(coords[1]+width/200) , zWorld+coords[2]+.5);
drawVertex(xWorld-coords[0]+1, yWorld-(coords[1]-width/200), zWorld+coords[2]+.5);
}
}
}
GL11.glEnd();
}
public void testDraw(HashMap<Integer, double[]> quads,double xWorld,double yWorld,double zWorld)
{
GL11.glBegin(GL11.GL_QUADS);
for(int i = 0;;i++)
{
if(!quads.containsKey(i))
{
break;
}
double[] coords = quads.get(i);
drawVertex(xWorld-coords[0], yWorld , zWorld+.1);
drawVertex(xWorld-coords[0], yWorld+.1 , zWorld+.1);
drawVertex(xWorld-coords[0], yWorld +.1, zWorld);
drawVertex(xWorld-coords[0], yWorld , zWorld);
}
GL11.glEnd();
}
public void drawVertex(double x, double y, double z)
{
GL11.glVertex3f((float)x,(float)y,(float)z);
}
public double[] rotateCoords(int rotation, double[] coords)
{
double[] rotatedCoords = new double[4];
if(rotation == 180)
{
rotatedCoords[0]=-coords[0];
rotatedCoords[1]=-coords[1];
rotatedCoords[2]=-coords[2];
rotatedCoords[3]=-coords[3];
//return rotatedCoords;
}
return coords;
}
}