d5dfc31210
Replaces the reflexive instantiation of the Renderes with a factory method. Some optimizations to the renderers to no longer push the whole OpenGL state to the stack. General cleanup of duplicate code, etc
226 lines
6.4 KiB
Java
226 lines
6.4 KiB
Java
/*
|
|
* This file is part of Applied Energistics 2.
|
|
* Copyright (c) 2013 - 2014, AlgorithmX2, All rights reserved.
|
|
*
|
|
* Applied Energistics 2 is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Applied Energistics 2 is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with Applied Energistics 2. If not, see <http://www.gnu.org/licenses/lgpl>.
|
|
*/
|
|
|
|
package appeng.client.render.effects;
|
|
|
|
|
|
import java.util.Random;
|
|
|
|
import net.minecraft.client.Minecraft;
|
|
import net.minecraft.client.particle.EntityFX;
|
|
import net.minecraft.client.renderer.Tessellator;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.util.MathHelper;
|
|
import net.minecraft.world.World;
|
|
|
|
|
|
public class LightningFX extends EntityFX
|
|
{
|
|
private static final Random RANDOM_GENERATOR = new Random();
|
|
private static final int STEPS = 5;
|
|
|
|
private final double[][] precomputedSteps;
|
|
private final double[] vertices = new double[3];
|
|
private final double[] verticesWithUV = new double[3];
|
|
private boolean hasData = false;
|
|
|
|
public LightningFX( final World w, final double x, final double y, final double z, final double r, final double g, final double b )
|
|
{
|
|
this( w, x, y, z, r, g, b, 6 );
|
|
this.regen();
|
|
}
|
|
|
|
protected LightningFX( final World w, final double x, final double y, final double z, final double r, final double g, final double b, final int maxAge )
|
|
{
|
|
super( w, x, y, z, r, g, b );
|
|
this.precomputedSteps = new double[LightningFX.STEPS][3];
|
|
this.motionX = 0;
|
|
this.motionY = 0;
|
|
this.motionZ = 0;
|
|
this.particleMaxAge = maxAge;
|
|
this.noClip = true;
|
|
}
|
|
|
|
protected void regen()
|
|
{
|
|
double lastDirectionX = ( RANDOM_GENERATOR.nextDouble() - 0.5 ) * 0.9;
|
|
double lastDirectionY = ( RANDOM_GENERATOR.nextDouble() - 0.5 ) * 0.9;
|
|
double lastDirectionZ = ( RANDOM_GENERATOR.nextDouble() - 0.5 ) * 0.9;
|
|
|
|
for( int s = 0; s < LightningFX.STEPS; s++ )
|
|
{
|
|
this.precomputedSteps[s][0] = lastDirectionX = ( lastDirectionX + ( RANDOM_GENERATOR.nextDouble() - 0.5 ) * 0.9 ) / 2.0;
|
|
this.precomputedSteps[s][1] = lastDirectionY = ( lastDirectionY + ( RANDOM_GENERATOR.nextDouble() - 0.5 ) * 0.9 ) / 2.0;
|
|
this.precomputedSteps[s][2] = lastDirectionZ = ( lastDirectionZ + ( RANDOM_GENERATOR.nextDouble() - 0.5 ) * 0.9 ) / 2.0;
|
|
}
|
|
}
|
|
|
|
protected int getSteps()
|
|
{
|
|
return LightningFX.STEPS;
|
|
}
|
|
|
|
@Override
|
|
public int getBrightnessForRender( final float par1 )
|
|
{
|
|
final int j1 = 13;
|
|
return j1 << 20 | j1 << 4;
|
|
}
|
|
|
|
@Override
|
|
public void renderParticle( final Tessellator tess, final float l, final float rX, final float rY, final float rZ, final float rYZ, final float rXY )
|
|
{
|
|
final float j = 1.0f;
|
|
|
|
tess.setColorRGBA_F( this.particleRed * j * 0.9f, this.particleGreen * j * 0.95f, this.particleBlue * j, this.particleAlpha );
|
|
|
|
if( this.particleAge == 3 )
|
|
{
|
|
this.regen();
|
|
}
|
|
double f6 = this.particleTextureIndexX / 16.0;
|
|
final double f7 = f6 + 0.0324375F;
|
|
double f8 = this.particleTextureIndexY / 16.0;
|
|
final double f9 = f8 + 0.0324375F;
|
|
|
|
f6 = f7;
|
|
f8 = f9;
|
|
|
|
double scale = 0.02;// 0.02F * this.particleScale;
|
|
|
|
final double[] a = new double[3];
|
|
final double[] b = new double[3];
|
|
|
|
double ox = 0;
|
|
double oy = 0;
|
|
double oz = 0;
|
|
|
|
final EntityPlayer p = Minecraft.getMinecraft().thePlayer;
|
|
double offX = -rZ;
|
|
double offY = MathHelper.cos( (float) ( Math.PI / 2.0f + p.rotationPitch * 0.017453292F ) );
|
|
double offZ = rX;
|
|
|
|
for( int layer = 0; layer < 2; layer++ )
|
|
{
|
|
if( layer == 0 )
|
|
{
|
|
scale = 0.04;
|
|
offX *= 0.001;
|
|
offY *= 0.001;
|
|
offZ *= 0.001;
|
|
tess.setColorRGBA_F( this.particleRed * j * 0.4f, this.particleGreen * j * 0.25f, this.particleBlue * j * 0.45f, this.particleAlpha );
|
|
}
|
|
else
|
|
{
|
|
offX = 0;
|
|
offY = 0;
|
|
offZ = 0;
|
|
scale = 0.02;
|
|
tess.setColorRGBA_F( this.particleRed * j * 0.9f, this.particleGreen * j * 0.65f, this.particleBlue * j * 0.85f, this.particleAlpha );
|
|
}
|
|
|
|
for( int cycle = 0; cycle < 3; cycle++ )
|
|
{
|
|
this.clear();
|
|
|
|
double x = ( this.prevPosX + ( this.posX - this.prevPosX ) * l - interpPosX ) - offX;
|
|
double y = ( this.prevPosY + ( this.posY - this.prevPosY ) * l - interpPosY ) - offY;
|
|
double z = ( this.prevPosZ + ( this.posZ - this.prevPosZ ) * l - interpPosZ ) - offZ;
|
|
|
|
for( int s = 0; s < LightningFX.STEPS; s++ )
|
|
{
|
|
final double xN = x + this.precomputedSteps[s][0];
|
|
final double yN = y + this.precomputedSteps[s][1];
|
|
final double zN = z + this.precomputedSteps[s][2];
|
|
|
|
final double xD = xN - x;
|
|
final double yD = yN - y;
|
|
final double zD = zN - z;
|
|
|
|
if( cycle == 0 )
|
|
{
|
|
ox = ( yD * 0 ) - ( 1 * zD );
|
|
oy = ( zD * 0 ) - ( 0 * xD );
|
|
oz = ( xD * 1 ) - ( 0 * yD );
|
|
}
|
|
if( cycle == 1 )
|
|
{
|
|
ox = ( yD * 1 ) - ( 0 * zD );
|
|
oy = ( zD * 0 ) - ( 1 * xD );
|
|
oz = ( xD * 0 ) - ( 0 * yD );
|
|
}
|
|
if( cycle == 2 )
|
|
{
|
|
ox = ( yD * 0 ) - ( 0 * zD );
|
|
oy = ( zD * 1 ) - ( 0 * xD );
|
|
oz = ( xD * 0 ) - ( 1 * yD );
|
|
}
|
|
|
|
final double ss = Math.sqrt( ox * ox + oy * oy + oz * oz ) / ( ( ( (double) LightningFX.STEPS - (double) s ) / LightningFX.STEPS ) * scale );
|
|
ox /= ss;
|
|
oy /= ss;
|
|
oz /= ss;
|
|
|
|
a[0] = x + ox;
|
|
a[1] = y + oy;
|
|
a[2] = z + oz;
|
|
|
|
b[0] = x;
|
|
b[1] = y;
|
|
b[2] = z;
|
|
|
|
this.draw( tess, a, b, f6, f8 );
|
|
|
|
x = xN;
|
|
y = yN;
|
|
z = zN;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void clear()
|
|
{
|
|
this.hasData = false;
|
|
}
|
|
|
|
private void draw( final Tessellator tess, final double[] a, final double[] b, final double f6, final double f8 )
|
|
{
|
|
if( this.hasData )
|
|
{
|
|
tess.addVertexWithUV( a[0], a[1], a[2], f6, f8 );
|
|
tess.addVertexWithUV( this.vertices[0], this.vertices[1], this.vertices[2], f6, f8 );
|
|
tess.addVertexWithUV( this.verticesWithUV[0], this.verticesWithUV[1], this.verticesWithUV[2], f6, f8 );
|
|
tess.addVertexWithUV( b[0], b[1], b[2], f6, f8 );
|
|
}
|
|
|
|
this.hasData = true;
|
|
|
|
for( int x = 0; x < 3; x++ )
|
|
{
|
|
this.vertices[x] = a[x];
|
|
this.verticesWithUV[x] = b[x];
|
|
}
|
|
}
|
|
|
|
protected double[][] getPrecomputedSteps()
|
|
{
|
|
return this.precomputedSteps;
|
|
}
|
|
}
|