mirror of
https://github.com/GTNewHorizons/CodeChickenCore.git
synced 2026-11-17 02:55:10 +00:00
Initial 1.7 commit
This commit is contained in:
1 parent
34154fc011
commit
ca675b5f31
72 files changed
+2967
-3335
No files matched your search
@@ -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]);
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user