Initial 1.7 commit

This commit is contained in:
Chicken-Bomes committed 2014-04-07 14:02:47 +10:00
1 parent 34154fc011
commit ca675b5f31
72 files changed
+2967 -3335

No files matched your search

-31
View File
@@ -1,31 +0,0 @@
package codechicken.lib.lighting;
import codechicken.lib.render.CCModel;
import codechicken.lib.render.Vertex5;
public class CCRBModel extends CCModel
{
public LC[] lightCoefficents;
/**
* Lighting sides and coefficients are computed for each vertex of the model. All faces must be axis planar and all verts are assumed to be in the range (0,0,0) to (1,1,1)
*/
public CCRBModel(CCModel m)
{
super(m.vertexMode);
verts = new Vertex5[m.verts.length];
copy(m, 0, this, 0, m.verts.length);
if(normals == null)
computeNormals();
if(colours == null)
setColour(-1);
computeLighting();
}
private void computeLighting()
{
lightCoefficents = new LC[verts.length];
for(int k = 0; k < verts.length; k++)
lightCoefficents[k] = LC.compute(verts[k].vec, normals[k]);
}
}
+65 -35
View File
@@ -1,59 +1,89 @@
package codechicken.lib.lighting;
import codechicken.lib.render.CCModel;
import codechicken.lib.util.Copyable;
import codechicken.lib.vec.Rotation;
import codechicken.lib.vec.Vector3;
public class LC
public class LC implements Copyable<LC>
{
public LC(int s, float e, float f, float g, float h)
{
side = s;
fa = e;
fb = f;
fc = g;
fd = h;
}
public int side;
public float fa;
public float fb;
public float fc;
public float fd;
public static LC compute(Vector3 vec, Vector3 normal)
{
public LC() {
this(0, 0, 0, 0, 0);
}
public LC(int s, float a, float b, float c, float d) {
side = s;
fa = a;
fb = b;
fc = c;
fd = d;
}
public LC set(int s, float a, float b, float c, float d) {
side = s;
fa = a;
fb = b;
fc = c;
fd = d;
return this;
}
public LC set(LC lc) {
return set(lc.side, lc.fa, lc.fb, lc.fc, lc.fd);
}
public LC compute(Vector3 vec, Vector3 normal) {
int side = CCModel.findSide(normal);
if(side < 0)
return new LC(12, 1, 0, 0, 0);
if (side < 0)
return set(12, 1, 0, 0, 0);
return compute(vec, side);
}
public static LC compute(Vector3 vec, int side)
{
public LC compute(Vector3 vec, int side) {
boolean offset = false;
switch(side)
{
case 0: offset = vec.y <= 0; break;
case 1: offset = vec.y >= 1; break;
case 2: offset = vec.z <= 0; break;
case 3: offset = vec.z >= 1; break;
case 4: offset = vec.x <= 0; break;
case 5: offset = vec.x >= 1; break;
switch (side) {
case 0:
offset = vec.y <= 0;
break;
case 1:
offset = vec.y >= 1;
break;
case 2:
offset = vec.z <= 0;
break;
case 3:
offset = vec.z >= 1;
break;
case 4:
offset = vec.x <= 0;
break;
case 5:
offset = vec.x >= 1;
break;
}
if(!offset)
side+=6;
if (!offset)
side += 6;
return computeO(vec, side);
}
public static LC computeO(Vector3 vec, int side)
{
Vector3 v1 = Rotation.axes[((side&0xE)+3)%6];
Vector3 v2 = Rotation.axes[((side&0xE)+5)%6];
public LC computeO(Vector3 vec, int side) {
Vector3 v1 = Rotation.axes[((side & 0xE) + 3) % 6];
Vector3 v2 = Rotation.axes[((side & 0xE) + 5) % 6];
float d1 = (float) vec.scalarProject(v1);
float d2 = 1-d1;
float d2 = 1 - d1;
float d3 = (float) vec.scalarProject(v2);
float d4 = 1-d3;
return new LC(side, d2*d4, d2*d3, d1*d4, d1*d3);
float d4 = 1 - d3;
return set(side, d2 * d4, d2 * d3, d1 * d4, d1 * d3);
}
@Override
public LC copy() {
return new LC(side, fa, fb, fc, fd);
}
}
@@ -1,28 +0,0 @@
package codechicken.lib.lighting;
import net.minecraft.world.IBlockAccess;
import codechicken.lib.vec.BlockCoord;
public class LazyLightMatrix
{
private BlockCoord pos = new BlockCoord();
private IBlockAccess access;
private boolean computed = false;
private LightMatrix lightMatrix = new LightMatrix();
public LightMatrix lightMatrix()
{
if(computed)
return lightMatrix;
computed = true;
lightMatrix.computeAt(access, pos.x, pos.y, pos.z);
return lightMatrix;
}
public void setPos(IBlockAccess access, int x, int y, int z)
{
computed = false;
this.access = access;
pos.set(x, y, z);
}
}
+63 -111
View File
@@ -1,30 +1,31 @@
package codechicken.lib.lighting;
import codechicken.lib.render.CCModel;
import codechicken.lib.colour.ColourRGBA;
import codechicken.lib.render.CCRenderState;
import codechicken.lib.render.IVertexModifier;
import codechicken.lib.render.UV;
import codechicken.lib.vec.BlockCoord;
import codechicken.lib.vec.Vector3;
import net.minecraft.block.Block;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.world.IBlockAccess;
/**
* Note that when using the class as a vertex transformer, the vertices are assumed to be within the BB (x, y, z) -> (x+1, y+1, z+1)
*/
public class LightMatrix implements IVertexModifier
public class LightMatrix implements CCRenderState.IVertexOperation
{
public static final int operationIndex = CCRenderState.registerOperation();
public int computed = 0;
public float[][] ao = new float[13][4];
public int[][] brightness = new int[13][4];
public IBlockAccess access;
public BlockCoord pos = new BlockCoord();
private int sampled = 0;
private float[] aSamples = new float[27];
private int[] bSamples = new int[27];
private Vector3 v_temp = new Vector3();
/**
* The 9 positions in the sample array for each side, sides >= 6 are centered on sample 13 (the block itself)
*/
@@ -73,137 +74,88 @@ public class LightMatrix implements IVertexModifier
}
System.out.println(Arrays.deepToString(ssamplem));
}*/
public void computeAt(IBlockAccess a, int x, int y, int z)
{
public void locate(IBlockAccess a, int x, int y, int z) {
access = a;
pos.set(x, y, z);
computed = 0;
//inc x, inc z, inc y
sample( 0, aSamples, bSamples, a, x-1, y-1, z-1);
sample( 1, aSamples, bSamples, a, x , y-1, z-1);
sample( 2, aSamples, bSamples, a, x+1, y-1, z-1);
sample( 3, aSamples, bSamples, a, x-1, y-1, z );
sample( 4, aSamples, bSamples, a, x , y-1, z );
sample( 5, aSamples, bSamples, a, x+1, y-1, z );
sample( 6, aSamples, bSamples, a, x-1, y-1, z+1);
sample( 7, aSamples, bSamples, a, x , y-1, z+1);
sample( 8, aSamples, bSamples, a, x+1, y-1, z+1);
sample( 9, aSamples, bSamples, a, x-1, y , z-1);
sample(10, aSamples, bSamples, a, x , y , z-1);
sample(11, aSamples, bSamples, a, x+1, y , z-1);
sample(12, aSamples, bSamples, a, x-1, y , z );
sample(13, aSamples, bSamples, a, x , y , z );
sample(14, aSamples, bSamples, a, x+1, y , z );
sample(15, aSamples, bSamples, a, x-1, y , z+1);
sample(16, aSamples, bSamples, a, x , y , z+1);
sample(17, aSamples, bSamples, a, x+1, y , z+1);
sample(18, aSamples, bSamples, a, x-1, y+1, z-1);
sample(19, aSamples, bSamples, a, x , y+1, z-1);
sample(20, aSamples, bSamples, a, x+1, y+1, z-1);
sample(21, aSamples, bSamples, a, x-1, y+1, z );
sample(22, aSamples, bSamples, a, x , y+1, z );
sample(23, aSamples, bSamples, a, x+1, y+1, z );
sample(24, aSamples, bSamples, a, x-1, y+1, z+1);
sample(25, aSamples, bSamples, a, x , y+1, z+1);
sample(26, aSamples, bSamples, a, x+1, y+1, z+1);
sampled = 0;
}
public int[] brightness(int side)
{
public void sample(int i) {
if ((sampled & 1 << i) == 0) {
int x = pos.x + (i % 3) - 1;
int y = pos.y + (i / 9) - 1;
int z = pos.z + (i / 3 % 3) - 1;
Block b = access.getBlock(x, y, z);
bSamples[i] = access.getLightBrightnessForSkyBlocks(x, y, z, b.getLightValue(access, x, y, z));
aSamples[i] = b.getAmbientOcclusionLightValue();
}
}
public int[] brightness(int side) {
sideSample(side);
return brightness[side];
}
public float[] ao(int side)
{
public float[] ao(int side) {
sideSample(side);
return ao[side];
}
public void sideSample(int side)
{
if((computed&1<<side) == 0)
{
public void sideSample(int side) {
if ((computed & 1 << side) == 0) {
int[] ssample = ssamplem[side];
for(int q = 0; q < 4; q++)
{
for (int q = 0; q < 4; q++) {
int[] qsample = qsamplem[q];
if(Minecraft.isAmbientOcclusionEnabled())
if (Minecraft.isAmbientOcclusionEnabled())
interp(side, q, ssample[qsample[0]], ssample[qsample[1]], ssample[qsample[2]], ssample[qsample[3]]);
else
interp(side, q, ssample[4], ssample[4], ssample[4], ssample[4]);
}
computed|=1<<side;
computed |= 1 << side;
}
}
private void sample(int i, float[] aSamples, int[] bSamples, IBlockAccess a, int x, int y, int z)
{
int bid = a.getBlockId(x, y, z);
Block b = Block.blocksList[bid];
if(b == null)
{
bSamples[i] = a.getLightBrightnessForSkyBlocks(x, y, z, 0);
aSamples[i] = 1;
}
else
{
bSamples[i] = a.getLightBrightnessForSkyBlocks(x, y, z, b.getLightValue(a, x, y, z));
aSamples[i] = b.getAmbientOcclusionLightValue(a, x, y, z);
}
}
private void interp(int s, int q, int a, int b, int c, int d)
{
private void interp(int s, int q, int a, int b, int c, int d) {
sample(a); sample(b); sample(c); sample(d);
ao[s][q] = interpAO(aSamples[a], aSamples[b], aSamples[c], aSamples[d])*sideao[s];
brightness[s][q] = interpBrightness(bSamples[a], bSamples[b], bSamples[c], bSamples[d]);
}
public static float interpAO(float a, float b, float c, float d)
{
return (a+b+c+d)/4F;
public static float interpAO(float a, float b, float c, float d) {
return (a + b + c + d) / 4F;
}
public static int interpBrightness(int a, int b, int c, int d)
{
if(a == 0)
public static int interpBrightness(int a, int b, int c, int d) {
if (a == 0)
a = d;
if(b == 0)
if (b == 0)
b = d;
if(c == 0)
if (c == 0)
c = d;
return (a+b+c+d)>>2 & 0xFF00FF;
return (a + b + c + d) >> 2 & 0xFF00FF;
}
public void setColour(Tessellator tess, LC lc, int c)
{
float[] a = ao(lc.side);
float f = (a[0]*lc.fa + a[1]*lc.fb + a[2]*lc.fc + a[3]*lc.fd);
CCRenderState.vertexColour((int)((c>>>24)*f), (int)((c>>16&0xFF)*f), (int)((c>>8&0xFF)*f), (c&0xFF));
}
public void setBrightness(Tessellator tess, LC lc)
{
int[] b = brightness(lc.side);
tess.setBrightness((int)(b[0]*lc.fa + b[1]*lc.fb + b[2]*lc.fc+b[3]*lc.fd) & 0xFF00FF);
}
@Override
public void applyModifiers(CCModel m, Tessellator tess, Vector3 vec, UV uv, Vector3 normal, int i)
{
LC lc;
if(m instanceof CCRBModel)
lc = ((CCRBModel)m).lightCoefficents[i];
else
lc = LC.compute(v_temp.set(vec).add(-pos.x, -pos.y, -pos.z), normal);
setColour(tess, lc, (m == null || m.colours == null) ? -1 : m.colours[i]);
setBrightness(tess, lc);
}
@Override
public boolean needsNormals()
{
public boolean load() {
CCRenderState.pipeline.addDependency(CCRenderState.colourAttrib);
CCRenderState.pipeline.addDependency(CCRenderState.lightCoordAttrib);
return true;
}
@Override
public void operate() {
LC lc = CCRenderState.lc;
float[] a = ao(lc.side);
float f = (a[0] * lc.fa + a[1] * lc.fb + a[2] * lc.fc + a[3] * lc.fd);
int[] b = brightness(lc.side);
CCRenderState.setColour(ColourRGBA.multiplyC(CCRenderState.colour, f));
CCRenderState.setBrightness((int) (b[0] * lc.fa + b[1] * lc.fb + b[2] * lc.fc + b[3] * lc.fd) & 0xFF00FF);
}
@Override
public int operationID() {
return operationIndex;
}
}
+45 -48
View File
@@ -3,60 +3,55 @@ package codechicken.lib.lighting;
import net.minecraft.client.renderer.Tessellator;
import codechicken.lib.render.CCModel;
import codechicken.lib.render.CCRenderState;
import codechicken.lib.render.IVertexModifier;
import codechicken.lib.render.UV;
import codechicken.lib.render.uv.UV;
import codechicken.lib.vec.Rotation;
import codechicken.lib.vec.Vector3;
public class LightModel implements IVertexModifier
public class LightModel implements CCRenderState.IVertexOperation
{
public static final int operationIndex = CCRenderState.registerOperation();
public static class Light
{
public Vector3 ambient = new Vector3();
public Vector3 diffuse = new Vector3();
public Vector3 position;
public Light(Vector3 pos)
{
public Light(Vector3 pos) {
position = pos.copy().normalize();
}
public Light setDiffuse(Vector3 vec)
{
public Light setDiffuse(Vector3 vec) {
diffuse.set(vec);
return this;
}
public Light setAmbient(Vector3 vec)
{
public Light setAmbient(Vector3 vec) {
ambient.set(vec);
return this;
}
}
public static LightModel standardLightModel;
static
{
static {
standardLightModel = new LightModel()
.setAmbient(new Vector3(0.4, 0.4, 0.4))
.addLight(new Light(new Vector3(0.2, 1, -0.7))
.setDiffuse(new Vector3(0.6, 0.6, 0.6)))
.setDiffuse(new Vector3(0.6, 0.6, 0.6)))
.addLight(new Light(new Vector3(-0.2, 1, 0.7))
.setDiffuse(new Vector3(0.6, 0.6, 0.6)));
.setDiffuse(new Vector3(0.6, 0.6, 0.6)));
}
private Vector3 ambient = new Vector3();
private Light[] lights = new Light[8];
private int lightCount;
public LightModel addLight(Light light)
{
public LightModel addLight(Light light) {
lights[lightCount++] = light;
return this;
}
public LightModel setAmbient(Vector3 vec)
{
public LightModel setAmbient(Vector3 vec) {
ambient.set(vec);
return this;
}
@@ -66,46 +61,48 @@ public class LightModel implements IVertexModifier
* @param normal The normal at the vertex
* @return The lighting applied colour
*/
public int apply(int colour, Vector3 normal)
{
public int apply(int colour, Vector3 normal) {
Vector3 n_colour = ambient.copy();
for(int l = 0; l < lightCount; l++)
{
for (int l = 0; l < lightCount; l++) {
Light light = lights[l];
double n_l = light.position.dotProduct(normal);
double f = n_l > 0 ? 1 : 0;
n_colour.x += light.ambient.x + f*light.diffuse.x*n_l;
n_colour.y += light.ambient.y + f*light.diffuse.y*n_l;
n_colour.z += light.ambient.z + f*light.diffuse.z*n_l;
n_colour.x += light.ambient.x + f * light.diffuse.x * n_l;
n_colour.y += light.ambient.y + f * light.diffuse.y * n_l;
n_colour.z += light.ambient.z + f * light.diffuse.z * n_l;
}
if(n_colour.x > 1)
if (n_colour.x > 1)
n_colour.x = 1;
if(n_colour.y > 1)
if (n_colour.y > 1)
n_colour.y = 1;
if(n_colour.z > 1)
if (n_colour.z > 1)
n_colour.z = 1;
n_colour.multiply((colour >>> 24)/255D, (colour >> 16 & 0xFF)/255D, (colour >> 8 & 0xFF)/255D);
return (int)(n_colour.x*255)<<24 | (int)(n_colour.y*255)<<16 | (int)(n_colour.z*255)<<8 | colour&0xFF;
n_colour.multiply((colour >>> 24) / 255D, (colour >> 16 & 0xFF) / 255D, (colour >> 8 & 0xFF) / 255D);
return (int) (n_colour.x * 255) << 24 | (int) (n_colour.y * 255) << 16 | (int) (n_colour.z * 255) << 8 | colour & 0xFF;
}
@Override
public void applyModifiers(CCModel m, Tessellator tess, Vector3 vec, UV uv, Vector3 normal, int i)
{
CCRenderState.setColour(apply((m == null || m.colours == null) ? -1 : m.colours[i], normal));
}
@Override
public boolean needsNormals()
{
public boolean load() {
CCRenderState.pipeline.addDependency(CCRenderState.normalAttrib);
CCRenderState.pipeline.addDependency(CCRenderState.colourAttrib);
return true;
}
public PlanarLightModel reducePlanar()
{
@Override
public void operate() {
CCRenderState.setColour(apply(CCRenderState.colour, CCRenderState.normal));
}
@Override
public int operationID() {
return operationIndex;
}
public PlanarLightModel reducePlanar() {
int[] colours = new int[6];
for(int i = 0; i < 6; i++)
for (int i = 0; i < 6; i++)
colours[i] = apply(-1, Rotation.axes[i]);
return new PlanarLightModel(colours);
}
+19 -26
View File
@@ -1,42 +1,35 @@
package codechicken.lib.lighting;
import net.minecraft.client.renderer.Tessellator;
import codechicken.lib.colour.Colour;
import codechicken.lib.colour.ColourRGBA;
import codechicken.lib.render.CCModel;
import codechicken.lib.render.CCRenderState;
import codechicken.lib.render.IVertexModifier;
import codechicken.lib.render.UV;
import codechicken.lib.vec.Vector3;
/**
* Faster precomputed version of LightModel that only works for axis planar sides
*/
public class PlanarLightModel implements IVertexModifier
public class PlanarLightModel implements CCRenderState.IVertexOperation
{
public static PlanarLightModel standardLightModel = LightModel.standardLightModel.reducePlanar();
public ColourRGBA[] colours;
public PlanarLightModel(int[] colours)
{
this.colours = new ColourRGBA[6];
for(int i = 0; i < 6; i++)
this.colours[i] = new ColourRGBA(colours[i]);
public int[] colours;
public PlanarLightModel(int[] colours) {
this.colours = colours;
}
@Override
public void applyModifiers(CCModel m, Tessellator tess, Vector3 vec, UV uv, Vector3 normal, int i)
{
ColourRGBA light = colours[CCModel.findSide(normal)];
int colour = (m == null || m.colours == null) ? -1 : m.colours[i];
Colour res = new ColourRGBA(colour).multiply(light);
CCRenderState.vertexColour(res.r&0xFF, res.g&0xFF, res.b&0xFF, res.a&0xFF) ;
}
@Override
public boolean needsNormals()
{
public boolean load() {
CCRenderState.pipeline.addDependency(CCRenderState.sideAttrib);
CCRenderState.pipeline.addDependency(CCRenderState.colourAttrib);
return true;
}
@Override
public void operate() {
CCRenderState.setColour(ColourRGBA.multiply(CCRenderState.colour, colours[CCRenderState.side]));
}
@Override
public int operationID() {
return LightModel.operationIndex;
}
}