diff --git a/src/main/java/fox/spiteful/avaritia/ClientProxy.java b/src/main/java/fox/spiteful/avaritia/ClientProxy.java index 99fcf46..186615a 100644 --- a/src/main/java/fox/spiteful/avaritia/ClientProxy.java +++ b/src/main/java/fox/spiteful/avaritia/ClientProxy.java @@ -2,7 +2,9 @@ package fox.spiteful.avaritia; import fox.spiteful.avaritia.compat.CompatClient; import fox.spiteful.avaritia.items.LudicrousItems; +import fox.spiteful.avaritia.render.CosmicItemRenderer; import fox.spiteful.avaritia.render.FancyHaloRenderer; +import fox.spiteful.avaritia.render.ShaderHelper; import net.minecraftforge.client.MinecraftForgeClient; public class ClientProxy extends CommonProxy { @@ -14,6 +16,12 @@ public class ClientProxy extends CommonProxy { MinecraftForgeClient.registerItemRenderer(LudicrousItems.resource, shiny); MinecraftForgeClient.registerItemRenderer(LudicrousItems.singularity, shiny); + CosmicItemRenderer sparkly = new CosmicItemRenderer(); + + MinecraftForgeClient.registerItemRenderer(LudicrousItems.infinity_sword, sparkly); + CompatClient.comprettify(); + + ShaderHelper.initShaders(); } } diff --git a/src/main/java/fox/spiteful/avaritia/items/tools/ItemSwordInfinity.java b/src/main/java/fox/spiteful/avaritia/items/tools/ItemSwordInfinity.java index ee23259..cd23104 100644 --- a/src/main/java/fox/spiteful/avaritia/items/tools/ItemSwordInfinity.java +++ b/src/main/java/fox/spiteful/avaritia/items/tools/ItemSwordInfinity.java @@ -1,8 +1,13 @@ package fox.spiteful.avaritia.items.tools; import com.google.common.collect.Multimap; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; import fox.spiteful.avaritia.Avaritia; import fox.spiteful.avaritia.items.LudicrousItems; +import fox.spiteful.avaritia.render.ICosmicRenderItem; +import net.minecraft.client.renderer.texture.IIconRegister; import net.minecraft.entity.EntityLivingBase; import net.minecraft.entity.SharedMonsterAttributes; import net.minecraft.entity.ai.attributes.AttributeModifier; @@ -12,16 +17,20 @@ import net.minecraft.item.ItemStack; import net.minecraft.item.ItemSword; import net.minecraft.util.DamageSource; import net.minecraft.util.EntityDamageSource; +import net.minecraft.util.IIcon; +import net.minecraft.util.ResourceLocation; import net.minecraftforge.common.util.EnumHelper; -public class ItemSwordInfinity extends ItemSword { +public class ItemSwordInfinity extends ItemSword implements ICosmicRenderItem { private static final ToolMaterial opSword = EnumHelper.addToolMaterial("INFINITY_SWORD", 32, 9999, 9999F, -3.0F, 200); - + private IIcon cosmicMask; + public ItemSwordInfinity(){ super(opSword); setUnlocalizedName("infinity_sword"); - setTextureName("avaritia:infinity_sword"); + //setTextureName("avaritia:infinity_sword"); + setTextureName("minecraft:diamond_sword"); setCreativeTab(Avaritia.tab); } @@ -53,4 +62,17 @@ public class ItemSwordInfinity extends ItemSword { public void setDamage(ItemStack stack, int damage){ super.setDamage(stack, 0); } + + @Override + public IIcon getMaskTexture(ItemStack stack) { + return cosmicMask; + } + + @SideOnly(Side.CLIENT) + @Override + public void registerIcons(IIconRegister ir) { + super.registerIcons(ir); + + this.cosmicMask = ir.registerIcon("avaritia:infinity_sword_mask"); + } } diff --git a/src/main/java/fox/spiteful/avaritia/render/CosmicItemRenderer.java b/src/main/java/fox/spiteful/avaritia/render/CosmicItemRenderer.java new file mode 100644 index 0000000..3c4b935 --- /dev/null +++ b/src/main/java/fox/spiteful/avaritia/render/CosmicItemRenderer.java @@ -0,0 +1,245 @@ +package fox.spiteful.avaritia.render; + +import org.apache.logging.log4j.Level; +import org.lwjgl.opengl.ARBShaderObjects; +import org.lwjgl.opengl.GL11; +import org.lwjgl.opengl.GL12; +import org.lwjgl.opengl.GL13; + +import cpw.mods.fml.relauncher.ReflectionHelper; + +import fox.spiteful.avaritia.Lumberjack; +import fox.spiteful.avaritia.items.LudicrousItems; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.EntityRenderer; +import net.minecraft.client.renderer.ItemRenderer; +import net.minecraft.client.renderer.RenderHelper; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.client.renderer.entity.RenderItem; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraft.util.MathHelper; +import net.minecraft.util.ResourceLocation; +import net.minecraftforge.client.IItemRenderer; + +public class CosmicItemRenderer implements IItemRenderer { + + private final ShaderCallback shaderCallback; + private float[] lightlevel = new float[3]; + private ItemStack renderStack; + + private String[] lightmapobf = new String[] {"lightmapColors", "field_78504_Q", "U"}; + + public CosmicItemRenderer() { + shaderCallback = new ShaderCallback() { + @Override + public void call(int shader) { + Minecraft mc = Minecraft.getMinecraft(); + + //int x = ARBShaderObjects.glGetUniformLocationARB(shader, "yaw"); + //ARBShaderObjects.glUniform1fARB(x, (float)((mc.thePlayer.rotationYaw * 2 * Math.PI) / 360.0)); + + //int z = ARBShaderObjects.glGetUniformLocationARB(shader, "pitch"); + //ARBShaderObjects.glUniform1fARB(z, - (float)((mc.thePlayer.rotationPitch * 2 * Math.PI) / 360.0)); + + int l = ARBShaderObjects.glGetUniformLocationARB(shader, "lightlevel"); + ARBShaderObjects.glUniform3fARB(l, lightlevel[0], lightlevel[1], lightlevel[2]); + + /*if (renderStack != null && renderStack.getItem() != null && renderStack.getItem() instanceof ICosmicRenderItem) { + ICosmicRenderItem item = (ICosmicRenderItem)(renderStack.getItem()); + IIcon maskicon = item.getMaskTexture(renderStack); + + int m = ARBShaderObjects.glGetUniformLocationARB(shader, "maskUV"); + ARBShaderObjects.glUniform4fARB(m, maskicon.getMinU(), maskicon.getMinV(), maskicon.getMaxU(), maskicon.getMaxV()); + }*/ + } + }; + } + + @Override + public boolean handleRenderType(ItemStack item, ItemRenderType type) { + //return type != ItemRenderType.INVENTORY; + return true; + } + + @Override + public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) { + return helper == ItemRendererHelper.ENTITY_ROTATION || helper == ItemRendererHelper.ENTITY_BOBBING; + } + + @Override + public void renderItem(ItemRenderType type, ItemStack item, Object... data) { + Minecraft mc = Minecraft.getMinecraft(); + this.processLightLevel(type, item, data); + //ShaderHelper.useShader(ShaderHelper.testShader, this.shaderCallback); + switch(type) { + case ENTITY : { + GL11.glPushMatrix(); + GL11.glTranslatef(-0.5F, 0F, 0F); + if(item.isOnItemFrame()) + GL11.glTranslatef(0F, -0.3F, 0.01F); + render(item); + GL11.glPopMatrix(); + + break; + } + case EQUIPPED : { + render(item); + break; + } + case EQUIPPED_FIRST_PERSON : { + render(item); + break; + } + case INVENTORY: { + GL11.glPushMatrix(); + GL11.glEnable(GL11.GL_BLEND); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + RenderHelper.enableGUIStandardItemLighting(); + + GL11.glDisable(GL11.GL_ALPHA_TEST); + GL11.glDisable(GL11.GL_DEPTH_TEST); + + RenderItem r = RenderItem.getInstance(); + r.renderItemIntoGUI(mc.fontRenderer, mc.getTextureManager(), item, 0, 0, true); + + if (item.getItem() instanceof ICosmicRenderItem) { + GL11.glEnable(GL11.GL_BLEND); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + RenderHelper.enableGUIStandardItemLighting(); + + GL11.glDisable(GL11.GL_ALPHA_TEST); + GL11.glDisable(GL11.GL_DEPTH_TEST); + + ShaderHelper.useShader(ShaderHelper.testShader, this.shaderCallback); + ICosmicRenderItem icri = (ICosmicRenderItem)(item.getItem()); + IIcon cosmicicon = icri.getMaskTexture(item); + + GL11.glColor4d(1, 1, 1, 1); + + float minu = cosmicicon.getMinU(); + float maxu = cosmicicon.getMaxU(); + float minv = cosmicicon.getMinV(); + float maxv = cosmicicon.getMaxV(); + + Tessellator t = Tessellator.instance; + + t.startDrawingQuads(); + t.addVertexWithUV(0, 0, 0, minu, minv); + t.addVertexWithUV(0, 16, 0, minu, maxv); + t.addVertexWithUV(16, 16, 0, maxu, maxv); + t.addVertexWithUV(16, 0, 0, maxu, minv); + t.draw(); + + ShaderHelper.releaseShader(); + } + + GL11.glEnable(GL11.GL_ALPHA_TEST); + GL11.glEnable(GL12.GL_RESCALE_NORMAL); + GL11.glEnable(GL11.GL_DEPTH_TEST); + + r.renderWithColor = true; + + GL11.glDisable(GL11.GL_BLEND); + GL11.glPopMatrix(); + break; + } + default : break; + } + //ShaderHelper.releaseShader(); + + //Lumberjack.log(Level.INFO, light+""); + } + + public void render(ItemStack item) { + int dmg = item.getItemDamage(); + IIcon icon = item.getItem().getIconFromDamageForRenderPass(dmg, 0); + + float f = icon.getMinU(); + float f1 = icon.getMaxU(); + float f2 = icon.getMinV(); + float f3 = icon.getMaxV(); + float scale = 1F / 16F; + + GL11.glPushMatrix(); + GL11.glEnable(GL11.GL_BLEND); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + GL11.glColor4f(1F, 1F, 1F, 1F); + ItemRenderer.renderItemIn2D(Tessellator.instance, f1, f2, f, f3, icon.getIconWidth(), icon.getIconHeight(), scale); + + if (item.getItem() instanceof ICosmicRenderItem) { + ShaderHelper.useShader(ShaderHelper.testShader, this.shaderCallback); + ICosmicRenderItem icri = (ICosmicRenderItem)(item.getItem()); + IIcon cosmicicon = icri.getMaskTexture(item); + + float minu = cosmicicon.getMinU(); + float maxu = cosmicicon.getMaxU(); + float minv = cosmicicon.getMinV(); + float maxv = cosmicicon.getMaxV(); + ItemRenderer.renderItemIn2D(Tessellator.instance, maxu, minv, minu, maxv, cosmicicon.getIconWidth(), cosmicicon.getIconHeight(), scale); + ShaderHelper.releaseShader(); + } + + GL11.glDisable(GL11.GL_BLEND); + GL11.glPopMatrix(); + + GL11.glColor4f(1F, 1F, 1F, 1F); + } + + public void processLightLevel(ItemRenderType type, ItemStack item, Object... data) { + int lightcoord = 0; + + switch(type) { + case ENTITY : { + EntityItem ent = (EntityItem)(data[1]); + if (ent != null) { + lightcoord = ent.worldObj.getLightBrightnessForSkyBlocks(MathHelper.floor_double(ent.posX), MathHelper.floor_double(ent.posY), MathHelper.floor_double(ent.posZ), 0); + } + break; + } + case EQUIPPED : { + EntityLivingBase ent = (EntityLivingBase)(data[1]); + if (ent != null) { + lightcoord = ent.worldObj.getLightBrightnessForSkyBlocks(MathHelper.floor_double(ent.posX), MathHelper.floor_double(ent.posY), MathHelper.floor_double(ent.posZ), 0); + } + break; + } + case EQUIPPED_FIRST_PERSON : { + EntityLivingBase ent = (EntityLivingBase)(data[1]); + if (ent != null) { + lightcoord = ent.worldObj.getLightBrightnessForSkyBlocks(MathHelper.floor_double(ent.posX), MathHelper.floor_double(ent.posY), MathHelper.floor_double(ent.posZ), 0); + } + break; + } + case INVENTORY: { + lightcoord = 0; + this.lightlevel[0] = 1.2f; + this.lightlevel[1] = 1.2f; + this.lightlevel[2] = 1.2f; + return; + } + default : { + lightcoord = 0; + this.lightlevel[0] = 1.0f; + this.lightlevel[1] = 1.0f; + this.lightlevel[2] = 1.0f; + return; + } + } + + int x = (lightcoord % 65536) / 16; + int y = (lightcoord / 65536) / 16; + + int[] lightmap = ReflectionHelper.getPrivateValue(EntityRenderer.class, Minecraft.getMinecraft().entityRenderer, this.lightmapobf); + + int lightcolour = lightmap[y*16+x]; + + this.lightlevel[0] = ((lightcolour >> 16) & 0xFF) / 256.0f; + this.lightlevel[1] = ((lightcolour >> 8) & 0xFF) / 256.0f; + this.lightlevel[2] = ((lightcolour) & 0xFF) / 256.0f; + + } +} diff --git a/src/main/java/fox/spiteful/avaritia/render/ICosmicRenderItem.java b/src/main/java/fox/spiteful/avaritia/render/ICosmicRenderItem.java new file mode 100644 index 0000000..8915036 --- /dev/null +++ b/src/main/java/fox/spiteful/avaritia/render/ICosmicRenderItem.java @@ -0,0 +1,9 @@ +package fox.spiteful.avaritia.render; + +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; + +public interface ICosmicRenderItem { + + public IIcon getMaskTexture(ItemStack stack); +} diff --git a/src/main/java/fox/spiteful/avaritia/render/ShaderCallback.java b/src/main/java/fox/spiteful/avaritia/render/ShaderCallback.java new file mode 100644 index 0000000..adab9ae --- /dev/null +++ b/src/main/java/fox/spiteful/avaritia/render/ShaderCallback.java @@ -0,0 +1,6 @@ +package fox.spiteful.avaritia.render; + +public abstract class ShaderCallback { + + public abstract void call(int shader); +} diff --git a/src/main/java/fox/spiteful/avaritia/render/ShaderHelper.java b/src/main/java/fox/spiteful/avaritia/render/ShaderHelper.java new file mode 100644 index 0000000..9516e21 --- /dev/null +++ b/src/main/java/fox/spiteful/avaritia/render/ShaderHelper.java @@ -0,0 +1,179 @@ +/** + * Original class written by Vazkii for Botania. + */ + +// TEMA: this is the main shader stuff, where the programs are loaded and compiled for the card. +// other relevant files are the shader in /assets/physis/shader/, and the tesr in /client/render/tile/ +// they have other comments like this in. + +package fox.spiteful.avaritia.render; + +import java.io.BufferedReader; +import java.io.InputStream; +import java.io.InputStreamReader; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.OpenGlHelper; + +import org.apache.logging.log4j.Level; +import org.lwjgl.opengl.ARBFragmentShader; +import org.lwjgl.opengl.ARBShaderObjects; +import org.lwjgl.opengl.ARBVertexShader; +import org.lwjgl.opengl.GL11; + +import fox.spiteful.avaritia.Lumberjack; + +public final class ShaderHelper { + private static final int VERT = ARBVertexShader.GL_VERTEX_SHADER_ARB; + private static final int FRAG = ARBFragmentShader.GL_FRAGMENT_SHADER_ARB; + private static final String PREFIX = "/assets/avaritia/shader/"; + + public static int testShader = 0; + + public static void initShaders() { + if(!useShaders()) + return; + + testShader = createProgram("cosmic.vert", "cosmic.frag"); + } + + public static void useShader(int shader, ShaderCallback callback) { + if(!useShaders()) + return; + + ARBShaderObjects.glUseProgramObjectARB(shader); + + if(shader != 0) { + int time = ARBShaderObjects.glGetUniformLocationARB(shader, "time"); + Minecraft mc = Minecraft.getMinecraft(); + if (mc.thePlayer != null && mc.thePlayer.worldObj != null) { + ARBShaderObjects.glUniform1iARB(time, (int)(mc.thePlayer.worldObj.getWorldTime() % Integer.MAX_VALUE)); + } + + if(callback != null) + callback.call(shader); + } + } + + public static void useShader(int shader) { + useShader(shader, null); + } + + public static void releaseShader() { + useShader(0); + } + + public static boolean useShaders() { + return OpenGlHelper.shadersSupported; + } + + // Most of the code taken from the LWJGL wiki + // http://lwjgl.org/wiki/index.php?title=GLSL_Shaders_with_LWJGL + + private static int createProgram(String vert, String frag) { + int vertId = 0, fragId = 0, program = 0; + if(vert != null) + vertId = createShader(PREFIX + vert, VERT); + if(frag != null) + fragId = createShader(PREFIX + frag, FRAG); + + program = ARBShaderObjects.glCreateProgramObjectARB(); + if(program == 0) + return 0; + + if(vert != null) + ARBShaderObjects.glAttachObjectARB(program, vertId); + if(frag != null) + ARBShaderObjects.glAttachObjectARB(program, fragId); + + ARBShaderObjects.glLinkProgramARB(program); + if(ARBShaderObjects.glGetObjectParameteriARB(program, ARBShaderObjects.GL_OBJECT_LINK_STATUS_ARB) == GL11.GL_FALSE) { + Lumberjack.log(Level.ERROR, getLogInfo(program)); + return 0; + } + + ARBShaderObjects.glValidateProgramARB(program); + if (ARBShaderObjects.glGetObjectParameteriARB(program, ARBShaderObjects.GL_OBJECT_VALIDATE_STATUS_ARB) == GL11.GL_FALSE) { + Lumberjack.log(Level.ERROR, getLogInfo(program)); + return 0; + } + + return program; + } + + private static int createShader(String filename, int shaderType){ + int shader = 0; + try { + shader = ARBShaderObjects.glCreateShaderObjectARB(shaderType); + + if(shader == 0) + return 0; + + ARBShaderObjects.glShaderSourceARB(shader, readFileAsString(filename)); + ARBShaderObjects.glCompileShaderARB(shader); + + if (ARBShaderObjects.glGetObjectParameteriARB(shader, ARBShaderObjects.GL_OBJECT_COMPILE_STATUS_ARB) == GL11.GL_FALSE) + throw new RuntimeException("Error creating shader: " + getLogInfo(shader)); + + return shader; + } + catch(Exception e) { + ARBShaderObjects.glDeleteObjectARB(shader); + e.printStackTrace(); + return -1; + } + } + + private static String getLogInfo(int obj) { + return ARBShaderObjects.glGetInfoLogARB(obj, ARBShaderObjects.glGetObjectParameteriARB(obj, ARBShaderObjects.GL_OBJECT_INFO_LOG_LENGTH_ARB)); + } + + private static String readFileAsString(String filename) throws Exception { + StringBuilder source = new StringBuilder(); + InputStream in = ShaderHelper.class.getResourceAsStream(filename); + Exception exception = null; + BufferedReader reader; + + if(in == null) + return ""; + + try { + reader = new BufferedReader(new InputStreamReader(in, "UTF-8")); + + Exception innerExc= null; + try { + String line; + while((line = reader.readLine()) != null) + source.append(line).append('\n'); + } catch(Exception exc) { + exception = exc; + } finally { + try { + reader.close(); + } catch(Exception exc) { + if(innerExc == null) + innerExc = exc; + else exc.printStackTrace(); + } + } + + if(innerExc != null) + throw innerExc; + } catch(Exception exc) { + exception = exc; + } finally { + try { + in.close(); + } catch(Exception exc) { + if(exception == null) + exception = exc; + else exc.printStackTrace(); + } + + if(exception != null) + throw exception; + } + + return source.toString(); + } +} diff --git a/src/main/resources/assets/avaritia/shader/cosmic.frag b/src/main/resources/assets/avaritia/shader/cosmic.frag new file mode 100644 index 0000000..ece02f2 --- /dev/null +++ b/src/main/resources/assets/avaritia/shader/cosmic.frag @@ -0,0 +1,19 @@ +uniform sampler2D texture0; +uniform vec3 lightlevel; + +void main (void) +{ + vec4 color; + vec4 light = gl_Color; + vec4 mask = texture2D(texture0, gl_TexCoord[0].xy); + light.rgb *= lightlevel; + + color = vec4(1.0,0.0,0.0,1.0); + + color.a *= mask.r; + vec3 shade = light.rgb * 0.1 + vec3(0.9,0.9,0.9); + color.rgb *= shade; + color = clamp(color,0.0,1.0); + + gl_FragColor = color; +} \ No newline at end of file diff --git a/src/main/resources/assets/avaritia/shader/cosmic.vert b/src/main/resources/assets/avaritia/shader/cosmic.vert new file mode 100644 index 0000000..46676f1 --- /dev/null +++ b/src/main/resources/assets/avaritia/shader/cosmic.vert @@ -0,0 +1,218 @@ +vec4 Ambient; +vec4 Diffuse; +vec4 Specular; + +attribute short activelights; + +void pointLight(in int i, in vec3 normal, in vec3 eye, in vec3 ecPosition3) +{ + float nDotVP; // normal . light direction + float nDotHV; // normal . light half vector + float pf; // power factor + float attenuation; // computed attenuation factor + float d; // distance from surface to light source + vec3 VP; // direction from surface to light position + vec3 halfVector; // direction of maximum highlights + + // Compute vector from surface to light position + VP = vec3 (gl_LightSource[i].position) - ecPosition3; + + // Compute distance between surface and light position + d = length(VP); + + // Normalize the vector from surface to light position + VP = normalize(VP); + + // Compute attenuation + attenuation = 1.0 / (gl_LightSource[i].constantAttenuation + + gl_LightSource[i].linearAttenuation * d + + gl_LightSource[i].quadraticAttenuation * d * d); + + halfVector = normalize(VP + eye); + + nDotVP = max(0.0, dot(normal, VP)); + //nDotHV = max(0.0, dot(normal, halfVector)); + + //if (nDotVP == 0.0) + //{ + pf = 0.0; + //} + //else + //{ + // pf = pow(nDotHV, gl_FrontMaterial.shininess); + //} + Ambient += gl_LightSource[i].ambient * attenuation; + Diffuse += gl_LightSource[i].diffuse * nDotVP * attenuation; + //Specular += gl_LightSource[i].specular * pf * attenuation; +} + +void spotLight(in int i, in vec3 normal, in vec3 eye, in vec3 ecPosition3) +{ + float nDotVP; // normal . light direction + float nDotHV; // normal . light half vector + float pf; // power factor + float spotDot; // cosine of angle between spotlight + float spotAttenuation; // spotlight attenuation factor + float attenuation; // computed attenuation factor + float d; // distance from surface to light source + vec3 VP; // direction from surface to light position + vec3 halfVector; // direction of maximum highlights + + // Compute vector from surface to light position + VP = vec3 (gl_LightSource[i].position) - ecPosition3; + + // Compute distance between surface and light position + d = length(VP); + + // Normalize the vector from surface to light position + VP = normalize(VP); + + // Compute attenuation + attenuation = 1.0 / (gl_LightSource[i].constantAttenuation + + gl_LightSource[i].linearAttenuation * d + + gl_LightSource[i].quadraticAttenuation * d * d); + + // See if point on surface is inside cone of illumination + spotDot = dot(-VP, normalize(gl_LightSource[i].spotDirection)); + + if (spotDot < gl_LightSource[i].spotCosCutoff) + { + spotAttenuation = 0.0; // light adds no contribution + } + else + { + spotAttenuation = pow(spotDot, gl_LightSource[i].spotExponent); + + } + // Combine the spotlight and distance attenuation. + attenuation *= spotAttenuation; + + halfVector = normalize(VP + eye); + + nDotVP = max(0.0, dot(normal, VP)); + //nDotHV = max(0.0, dot(normal, halfVector)); + + //if (nDotVP == 0.0) + //{ + pf = 0.0; + //} + //else + //{ +// pf = pow(nDotHV, gl_FrontMaterial.shininess); +// + // } + Ambient += gl_LightSource[i].ambient * attenuation; + Diffuse += gl_LightSource[i].diffuse * nDotVP * attenuation; + //Specular += gl_LightSource[i].specular * pf * attenuation; + +} + +void directionalLight(in int i, in vec3 normal) +{ + float nDotVP; // normal . light direction + float nDotHV; // normal . light half vector + float pf; // power factor + + nDotVP = max(0.0, dot(normal, normalize(vec3 (gl_LightSource[i].position)))); + //nDotHV = max(0.0, dot(normal, vec3 (gl_LightSource[i].halfVector))); + + //if (nDotVP == 0.0) + //{ + pf = 0.0; + //} + //else + //{ +// pf = pow(nDotHV, gl_FrontMaterial.shininess); + //} + Ambient += gl_LightSource[i].ambient; + Diffuse += gl_LightSource[i].diffuse * nDotVP; + //Specular += gl_LightSource[i].specular * pf; +} + +vec3 fnormal(void) +{ + //Compute the normal + vec3 normal = gl_NormalMatrix * gl_Normal; + normal = normalize(normal); + return normal; +} + +void ProcessLight(in int i, in vec3 normal, in vec3 eye, in vec3 ecPosition3) +{ + if (gl_LightSource[i].spotCutoff==180.0) + { + if (gl_LightSource[i].position.w==0.0) + { + directionalLight(i, normal); + } + else + { + pointLight(i, normal, eye, ecPosition3); + } + } + else + { + spotLight(i,normal,eye,ecPosition3); + } +} + +void flight(in vec3 normal, in vec4 ecPosition, float alphaFade) +{ + vec4 color; + vec3 ecPosition3; + vec3 eye; + int i; + + ecPosition3 = (vec3 (ecPosition)) / ecPosition.w; + eye = vec3 (0.0, 0.0, 1.0); + + // Clear the light intensity accumulators + Ambient = vec4 (0.0); + Diffuse = vec4 (0.0); + Specular = vec4 (0.0); + + if (activelights>0) + { + ProcessLight(0,normal,eye,ecPosition3); + } + if (activelights>1) + { + ProcessLight(1,normal,eye,ecPosition3); + } + //if (activelights>2) + //{ + // ProcessLight(2,normal,eye,ecPosition3); + //} + //if (activelights>3) + //{ + // ProcessLight(3,normal,eye,ecPosition3); + //} + + color = gl_FrontLightModelProduct.sceneColor + + Ambient * gl_FrontMaterial.ambient + + Diffuse * gl_FrontMaterial.diffuse; + color += Specular * gl_FrontMaterial.specular; + color = clamp( color, 0.0, 1.0 ); + gl_FrontColor = color; + gl_FrontColor.a *= alphaFade; +} + +void main (void) +{ + vec3 transformedNormal; + float alphaFade = 1.0; + + // Eye-coordinate position of vertex, needed in various calculations + vec4 ecPosition = gl_ModelViewMatrix * gl_Vertex; + + // Do fixed functionality vertex transform + gl_Position = ftransform(); + transformedNormal = fnormal(); + flight(transformedNormal, ecPosition, alphaFade); + + //Enable texture coordinates + gl_TexCoord[0] = gl_MultiTexCoord0; + //gl_TexCoord[1] = gl_MultiTexCoord1; + //gl_TexCoord[2] = gl_MultiTexCoord2; + //gl_TexCoord[3] = gl_MultiTexCoord3; +} \ No newline at end of file diff --git a/src/main/resources/assets/avaritia/textures/items/infinity_sword_mask.png b/src/main/resources/assets/avaritia/textures/items/infinity_sword_mask.png new file mode 100644 index 0000000..bf7e75f Binary files /dev/null and b/src/main/resources/assets/avaritia/textures/items/infinity_sword_mask.png differ