From db012a812e2078d74920c2000419bd8bdee9533f Mon Sep 17 00:00:00 2001 From: Alex Spinks Date: Wed, 15 Jul 2015 05:23:52 +0100 Subject: [PATCH] Super secret rendering (but actually public) --- .../fox/spiteful/avaritia/ClientProxy.java | 8 + .../items/tools/ItemSwordInfinity.java | 28 +- .../avaritia/render/CosmicItemRenderer.java | 245 ++++++++++++++++++ .../avaritia/render/ICosmicRenderItem.java | 9 + .../avaritia/render/ShaderCallback.java | 6 + .../avaritia/render/ShaderHelper.java | 179 +++++++++++++ .../assets/avaritia/shader/cosmic.frag | 19 ++ .../assets/avaritia/shader/cosmic.vert | 218 ++++++++++++++++ .../textures/items/infinity_sword_mask.png | Bin 0 -> 2984 bytes 9 files changed, 709 insertions(+), 3 deletions(-) create mode 100644 src/main/java/fox/spiteful/avaritia/render/CosmicItemRenderer.java create mode 100644 src/main/java/fox/spiteful/avaritia/render/ICosmicRenderItem.java create mode 100644 src/main/java/fox/spiteful/avaritia/render/ShaderCallback.java create mode 100644 src/main/java/fox/spiteful/avaritia/render/ShaderHelper.java create mode 100644 src/main/resources/assets/avaritia/shader/cosmic.frag create mode 100644 src/main/resources/assets/avaritia/shader/cosmic.vert create mode 100644 src/main/resources/assets/avaritia/textures/items/infinity_sword_mask.png 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 0000000000000000000000000000000000000000..bf7e75f67033717fde4c7bc511c7a5364cf2150f GIT binary patch literal 2984 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