bukkit.fr Agrandir les tiles terrainpng itempng .pdf



Nom original: bukkit.fr-Agrandir_les_tiles_terrainpng_itempng.pdf
Titre: Agrandir les tiles (terrain.png, item.png)

Ce document au format PDF 1.4 a été généré par / wkhtmltopdf, et a été envoyé sur fichier-pdf.fr le 01/07/2012 à 14:10, depuis l'adresse IP 82.237.x.x. La présente page de téléchargement du fichier a été vue 1683 fois.
Taille du document: 189 Ko (33 pages).
Confidentialité: fichier public




Télécharger le fichier (PDF)










Aperçu du document


Agrandir les tiles (terrain.png, item.png)
http://bukkit.fr/index.php?threads/agrandir-les-tiles-terrain-png-item-png.2517//

July 1, 2012

1.
Bonjour,
Je vous présente ma méthode pour agrandir les tiles terrain.png et item.png,
pour les mettre en 512px.
Pourquoi ce tutoriel plutôt que celui déjà existant ?
1. J'ai tout refais à zéro pour avoir un résultat parfait.
2. J'assure qu'à la fin de mon tutoriel il n'y aura aucun bug, j'ai corrigé tout
les bugs existant que j'ai remarqué suite à l'agrandissement des 2 tiles
(terrain.png et item.png).
3. Retrouvé vos modifications facilement lié à cette agrandissement de tiles.
4. Un retour possible pour revenir en 256px simplement en changeant une
variable.
5. Et sur le même principe en changeant une variable, vous pouvez très
bien agrandir en 512px, 1024px ou bien 2048px ! (512 px assuré sans
aucun bug, 1024px après une rapide vérification semble fonctionnel).
Avant de commencer un peu de chiffres et de nom :
EntityBreakingFX.java (2)
EntityDiggingFX.java (2)
Gui.java (1)
GuiIngame.java (2)
ItemRenderer.java (6 + 1)
Render.java (6 + 1)
RenderBlocks.java (160 + 28)
RenderFireball.java (2)
RenderItem.java (4)
RenderSnowball.java (2)
Le nombre de fois qu'il faudra appliquer un changement, avec en rouge le
nombre de fois qu'il faudra changer la valeur Hex (voir suite).
Tutoriel en trois parties :
1. Pour commencer.
2. Les modifications.

3. Vérification.
1. Pour commencer :
J'ai fais en sorte que mon code soit dynamique il faudra donc rajouter sur
chaque page où on effectue un changement*, ce code :
Code:
private double hauteurTailleD = 512D;
private float hauteurTailleF = 512F;
private int hexTaille = 0x1f0; //0xf0 pour 256

*Notez que ce sont les fichiers que j'ai listé au début.
Ce code définis les variables pour pouvoir les réutiliser. Je les redéfinis dans
chaque fonction pour qu'a chaque fois que je fais une recherche par CTRL + H
et que je rentre "private float hauteurTaille", je puisse voir tous mes fichier
ayant une modification lié à l'agrandissement des tiles.
(?) Pour changer la taille multipliez simplement 512D et 512F, pour obtenir la
taille désirée.
2. Les modifications :
Je vais suivre l'ordre de la liste ci-dessus pour les modifications, je vous
conseil donc de tous les ouvrir en onglet dans l'ordre, ainsi vous êtes sûr de ne
pas sauter un passage. Notez que j'éviterai de faire des commentaires entre
les modifications pour rendre plus claire les instructions.
(?) Avant de commencer je vais vous expliquer :
X * (hauteurTailleF / 256F);
Ceci consiste à multiplié par 2 (512/256=2) X, ainsi si on veut revenir en 256 X
sera multiplié par 1 donc il gardera ça valeur de départ.
EntityBreakingFX.java :
Dans public void renderParticle(...), modifiez f2 et f3.
Code:
public void renderParticle(Tessellator par1Tessellator, float
par2, float par3, float par4, float par5, float par6, float par7) {
float f = ((float)(getParticleTextureIndex() % 16) +
particleTextureJitterX / 4F) / 16F;
float f1 = f + 0.01560938F;
float f2 = ((float)(getParticleTextureIndex() / 16) +
particleTextureJitterY / 4F) / (16F * (hauteurTailleF / 256F));
float f3 = f2 + 0.01560938F / (hauteurTailleF / 256F);
float f4 = 0.1F * particleScale;

EntityDiggingFX.java
Dans public void renderParticle(...), modifiez f2 et f3.
Code:
public void renderParticle(Tessellator par1Tessellator, float

par2, float par3, float par4, float par5, float par6, float par7)
{
float f = ((float)(getParticleTextureIndex() % 16) +
particleTextureJitterX / 4F) / 16F;
float f1 = f + 0.01560938F;
float f2 = ((float)(getParticleTextureIndex() / 16) +
particleTextureJitterY / 4F) / (16F * (hauteurTailleF / 256F));
float f3 = f2 + 0.01560938F / (hauteurTailleF / 256F);
float f4 = 0.1F * particleScale;
float f5 = (float)((prevPosX + (posX - prevPosX) *
(double)par2) - interpPosX);
float f6 = (float)((prevPosY + (posY - prevPosY) *
(double)par2) - interpPosY);
float f7 = (float)((prevPosZ + (posZ - prevPosZ) *
(double)par2) - interpPosZ);
float f8 = 1.0F;

Gui.java
Dans public void drawTexturedModalRect(...), copiez-collez la, renommez la en
"drawTexturedModalRecti" (rajoutez donc un "i") et remplacez f1. Pour obtenir :
Code:
public void drawTexturedModalRecti(int par1, int par2, int par3,
int par4, int par5, int par6)
{
float f = 0.00390625F;
float f1 = 0.00390625F / (hauteurTailleF / 256F);

/!\ Allez dans GuiContainer.java, ensuite dans private void
drawSlotInventory(...), remplacer l'appelle de la fonction
drawTexturedModalRect(...) par celle qu'on vient de créer
drawTexturedModalRecti(...). Vous obtenez :
Code:
private void drawSlotInventory(Slot par1Slot)
{
int i = par1Slot.xDisplayPosition;
int j = par1Slot.yDisplayPosition;
ItemStack itemstack = par1Slot.getStack();
boolean flag = false;
int k = i;
int l = j;
zLevel = 100F;
itemRenderer.zLevel = 100F;
if (itemstack == null)
{
int i1 = par1Slot.getBackgroundIconIndex();
if (i1 >= 0)
{
GL11.glDisable(GL11.GL_LIGHTING);
mc.renderEngine.bindTexture(mc.renderEngine.getTexture("/gui/items.png
"));
drawTexturedModalRecti(k, l, (i1 % 16) * 16, (i1 / 16)
* 16, 16, 16);
GL11.glEnable(GL11.GL_LIGHTING);

flag = true;
}
}

Faites de même pour la fonction protected void
genAchievementBackground(...) dans GuiAchievements.java (il y a deux
fichiers dont un sans "S"). Pour obtenir :
Code:
else if (j4 > 0)
{
l4 = Block.dirt.blockIndexInTexture;
}
drawTexturedModalRecti((k1 + k3 * 16) - k2, (l1 + i3 *
16) - l2, l4 % 16 << 4, (l4 >> 4) << 4, 16, 16);
}
}
GL11.glEnable(GL11.GL_DEPTH_TEST);
GL11.glDepthFunc(GL11.GL_LEQUAL);
GL11.glDisable(GL11.GL_TEXTURE_2D);

GuiIngame.java :
Dans private void renderPortalOverlay(...), modifiez f1 et f3.
Code:
private void
{
if (par1
{
par1
par1
par1
}

renderPortalOverlay(float par1, int par2, int par3)
< 1.0F)
*= par1;
*= par1;
= par1 * 0.8F + 0.2F;

GL11.glDisable(GL11.GL_ALPHA_TEST);
GL11.glDisable(GL11.GL_DEPTH_TEST);
GL11.glDepthMask(false);
GL11.glBlendFunc(GL11.GL_SRC_ALPHA,
GL11.GL_ONE_MINUS_SRC_ALPHA);
GL11.glColor4f(1.0F, 1.0F, 1.0F, par1);
GL11.glBindTexture(GL11.GL_TEXTURE_2D,
mc.renderEngine.getTexture("/terrain.png"));
float f = (float)(Block.portal.blockIndexInTexture % 16) /
16F;
float f1 = (float)(Block.portal.blockIndexInTexture / 16) /
(16F * (hauteurTailleF / 256F));
float f2 = (float)(Block.portal.blockIndexInTexture % 16 + 1)
/ 16F;
float f3 = (float)(Block.portal.blockIndexInTexture / 16 + 1)
/ (16F * (hauteurTailleF / 256F));
Tessellator tessellator = Tessellator.instance;
tessellator.startDrawingQuads();

Signature Hors-Sujet :B

Même ici

2.

viens vous envahir !

ItemRenderer.java :
Dans public void renderItem(...), modifiez f2 et f3.
Code:
if (par2ItemStack.itemID < 256)
{
GL11.glBindTexture(GL11.GL_TEXTURE_2D,
mc.renderEngine.getTexture("/terrain.png"));
}
else
{
GL11.glBindTexture(GL11.GL_TEXTURE_2D,
mc.renderEngine.getTexture("/gui/items.png"));
}
Tessellator tessellator = Tessellator.instance;
int i = par1EntityLiving.getItemIcon(par2ItemStack, par3);
float f = ((float)((i % 16) * 16) + 0.0F) / 256F;
float f1 = ((float)((i % 16) * 16) + 15.99F) / 256F;
float f2 = ((float)((i / 16) * 16) + 0.0F) /
hauteurTailleF;
float f3 = ((float)((i / 16) * 16) + 15.99F) /
hauteurTailleF;

Dans private void renderInsideOfBlock(...), modifiez f8 et f10.
Code:
private void renderInsideOfBlock(float par1, int par2)
{
Tessellator tessellator = Tessellator.instance;
float f = mc.thePlayer.getBrightness(par1);
f = 0.1F;
GL11.glColor4f(f, f, f, 0.5F);
GL11.glPushMatrix();
float f1 = -1F;
float f2 = 1.0F;
float f3 = -1F;
float f4 = 1.0F;
float f5 = -0.5F;
float f6 = 0.0078125F;
float f7 = (float)(par2 % 16) / 256F - f6;
float f8 = ((float)(par2 % 16) + 15.99F) / hauteurTailleF +
f6;
float f9 = (float)(par2 / 16) / 256F - f6;
float f10 = ((float)(par2 / 16) + 15.99F) / hauteurTailleF +
f6;

Dans private void renderFireInFirstPerson(...), modifiez l, f3 et f4.
(?) Pour l vous devriez avoir : "int l = j & hexTaille;".
Code:

private void renderFireInFirstPerson(float par1)
{
Tessellator tessellator = Tessellator.instance;
GL11.glColor4f(1.0F, 1.0F, 1.0F, 0.9F);
GL11.glEnable(GL11.GL_BLEND);
GL11.glBlendFunc(GL11.GL_SRC_ALPHA,
GL11.GL_ONE_MINUS_SRC_ALPHA);
float f = 1.0F;
for (int i = 0; i < 2; i++)
{
GL11.glPushMatrix();
int j = Block.fire.blockIndexInTexture + i * 16;
int k = (j & 0xf) << 4;
int l = j & hexTaille;
float f1 = (float)k / 256F;
float f2 = ((float)k + 15.99F) / 256F;
float f3 = (float)l / hauteurTailleF;
float f4 = ((float)l + 15.99F) /hauteurTailleF;
float f5 = (0.0F - f) / 2.0F;

Render.java :
Dans private void renderEntityOnFire(...), modifiez k, f4 et f6.
Code:
private void renderEntityOnFire(Entity par1Entity, double par2,
double par4, double par6, float par8)
{
GL11.glDisable(GL11.GL_LIGHTING);
int i = Block.fire.blockIndexInTexture;
int j = (i & 0xf) << 4;
int k = i & hexTaille;
float f = (float)j / 256F;
float f2 = ((float)j + 15.99F) / 256F;
float f4 = (float)k / hauteurTailleF;
float f6 = ((float)k + 15.99F) / hauteurTailleF;
GL11.glPushMatrix();
GL11.glTranslatef((float)par2, (float)par4, (float)par6);

Toujours dans cette fonction, vous devriez avoir une boucle while (f11 > 0.0F),
dedans modifiez 2 fois f5 et f7.
Code:
while (f11 > 0.0F)
{
float f1;
float f3;
float f5;
float f7;
if (l % 2 == 0)
{
f1 = (float)j / 256F;
f3 = ((float)j + 15.99F) / 256F;
f5 = (float)k / hauteurTailleF;
f7 = ((float)k + 15.99F) / hauteurTailleF;
}
else
{

f1
f3
f5
f7

=
=
=
=

(float)j / 256F;
((float)j + 15.99F) / 256F;
(float)(k + 16) / hauteurTailleF;
((float)(k + 16) + 15.99F) / hauteurTailleF;

}
if ((l / 2) % 2 == 0)
{
float f14 = f3;
f3 = f1;
f1 = f14;
}

RenderBlocks.java :
(On garde le plus gros en dessert).
RenderFireball.java :
Dans public void doRenderFireball(...), modifiez f3 et f4.
Code:
public void doRenderFireball(EntityFireball par1EntityFireball,
double par2, double par4, double par6, float par8, float par9)
{
GL11.glPushMatrix();
GL11.glTranslatef((float)par2, (float)par4, (float)par6);
GL11.glEnable(GL12.GL_RESCALE_NORMAL);
float f = field_40269_a;
GL11.glScalef(f / 1.0F, f / 1.0F, f / 1.0F);
byte byte0 = 46;
loadTexture("/gui/items.png");
Tessellator tessellator = Tessellator.instance;
float f1 = (float)((byte0 % 16) * 16 + 0) / 256F;
float f2 = (float)((byte0 % 16) * 16 + 16) / 256F;
float f3 = (float)((byte0 / 16) * 16 + 0) / hauteurTailleF;
float f4 = (float)((byte0 / 16) * 16 + 16) / hauteurTailleF;
float f5 = 1.0F;
float f6 = 0.5F;
float f7 = 0.25F;

RenderItem.java :
Dans private void func_40267_a(...), modifiez f2 et f3.
Code:
private void func_40267_a(int par1, int par2)
{
Tessellator tessellator = Tessellator.instance;
float f = (float)((par1 % 16) * 16 + 0) / 256F;
float f1 = (float)((par1 % 16) * 16 + 16) / 256F;
float f2 = (float)((par1 / 16) * 16 + 0) / hauteurTailleF;
float f3 = (float)((par1 / 16) * 16 + 16) / hauteurTailleF;
float f4 = 1.0F;
float f5 = 0.5F;
float f6 = 0.25F;

Dans private void func_40266_a(...), modifiez f1.

Code:
private void func_40266_a(int par1, int par2, int par3, int par4,
int par5)
{
for (int i = 0; i < 2; i++)
{
if (i == 0)
{
GL11.glBlendFunc(GL11.GL_SRC_COLOR, GL11.GL_ONE);
}
if (i == 1)
{
GL11.glBlendFunc(GL11.GL_SRC_COLOR, GL11.GL_ONE);
}
float f = 0.00390625F;
float f1 = 0.00390625F / (hauteurTailleF / 256F);

Dans public void renderTexturedQuad(...), modifiez f1.
Code:
public void renderTexturedQuad(int par1, int par2, int par3, int
par4, int par5, int par6)
{
float f = 0.00390625F;
float f1 = 0.00390625F / (hauteurTailleF / 256F);
Tessellator tessellator = Tessellator.instance;
tessellator.startDrawingQuads();
tessellator.addVertexWithUV(par1 + 0, par2 + par6, zLevel,
(float)(par3 + 0) * f, (float)(par4 + par6) * f1);
tessellator.addVertexWithUV(par1 + par5, par2 + par6, zLevel,
(float)(par3 + par5) * f, (float)(par4 + par6) * f1);
tessellator.addVertexWithUV(par1 + par5, par2 + 0, zLevel,
(float)(par3 + par5) * f, (float)(par4 + 0) * f1);
tessellator.addVertexWithUV(par1 + 0, par2 + 0, zLevel,
(float)(par3 + 0) * f, (float)(par4 + 0) * f1);
tessellator.draw();
}

RenderSnowball.java :
Dans private void func_40265_a(...), modifiez f2 et f3.
Code:
private void func_40265_a(Tessellator par1Tessellator, int par2)
{
float f = (float)((par2 % 16) * 16 + 0) / 256F;
float f1 = (float)((par2 % 16) * 16 + 16) / 256F;
float f2 = (float)((par2 / 16) * 16 + 0) / hauteurTailleF;
float f3 = (float)((par2 / 16) * 16 + 16) / hauteurTailleF;
float f4 = 1.0F;
float f5 = 0.5F;
float f6 = 0.25F;

3. Vérification :

Maintenant que vous avez tout finis on vas vérifier (si vous l'avez pas fait, faites
le RenderBlocks.java). Ne vous inquiétez pas c'est Eclipse qui fait tout.
Faites CTRL + H, onglet "File Search", saisissez "hauteurTaille" et validez.

Ensuite dans la fenêtre "Search" (à la place de la console d'Eclipse) vous
devriez voir exactement ceci :

EntityBreakingFX.java (4 matches)
EntityDiggingFX.java (4 matches)
Gui.java (3 matches)
GuiIngame.java (4 matches)
ItemRenderer.java (8 matches)
Render.java (8 matches)
RenderBlocks.java (162 matches)
RenderFireball.java (4 matches)
RenderItem.java (6 matches)
RenderSnowball.java (4 matches)

Si vous n'avez pas les mêmes chiffre vérifier le fichier correspondant à l'erreur.

Ainsi faites la même chose avec "hexTaille", vous obtenez ceci si tout est juste
:

EntityBreakingFX.java
EntityDiggingFX.java
Gui.java
GuiIngame.java
ItemRenderer.java (2 matches)
Render.java (2 matches)
RenderBlocks.java (30 matches)
RenderFireball.java
RenderItem.java
RenderSnowball.java

Tutoriel, proposé par Hors-Sujet.
N'aillez pas peur d'aimer un Hors-Sujet.

Signature Hors-Sujet :B
Même ici

3.

viens vous envahir !

RenderBlocks.java :
On vas s'occuper tout d'abord de hauteurTailleF et hauteurTailleD, ne vous
occupez pas de hexTaille on le garde pour la fin.
Modification 0 à 4 :
Dans private boolean renderBlockBed(...), modifiez 2 fois d2 et d3.
Code:
int k = par1Block.getMixedBrightnessForBlock(blockAccess,
par2, par3, par4);
tessellator.setBrightness(k);
tessellator.setColorOpaque_F(f7, f10, f13);
int l = par1Block.getBlockTexture(blockAccess, par2, par3,
par4, 0);
int i1 = (l & 0xf) << 4;
int j1 = l & hexTaille;
double d = (float)i1 / 256F;
double d1 = ((double)(i1 + 16) - 0.01D) / 256D;
double d2 = (float)j1 / hauteurTailleF;

double d3 = ((double)(j1 + 16) - 0.01D) / hauteurTailleD;
double d4 = (double)par2 + par1Block.minX;
double d5 = (double)par2 + par1Block.maxX;
double d6 = (double)par3 + par1Block.minY + 0.1875D;
double d7 = (double)par4 + par1Block.minZ;
double d8 = (double)par4 + par1Block.maxZ;
tessellator.addVertexWithUV(d4, d6, d8, d, d3);
tessellator.addVertexWithUV(d4, d6, d7, d, d2);
tessellator.addVertexWithUV(d5, d6, d7, d1, d2);
tessellator.addVertexWithUV(d5, d6, d8, d1, d3);
tessellator.setBrightness(par1Block.getMixedBrightnessForBlock(blockAc
cess, par2, par3 + 1, par4));
tessellator.setColorOpaque_F(f4, f5, f6);
l = par1Block.getBlockTexture(blockAccess, par2, par3, par4,
1);
i1 = (l & 0xf) << 4;
j1 = l & hexTaille;
d = (float)i1 / 256F;
d1 = ((double)(i1 + 16) - 0.01D) / 256D;
d2 = (float)j1 / hauteurTailleF;
d3 = ((double)(j1 + 16) - 0.01D) / hauteurTailleD;

Modification 4 à 6 :
Dans private boolean renderBlockBrewingStand(...), modifiez d et d1 :
Code:
float f = 1.0F;
int i = par1BlockBrewingStand.colorMultiplier(blockAccess,
par2, par3, par4);
float f1 = (float)(i >> 16 & 0xff) / 255F;
float f2 = (float)(i >> 8 & 0xff) / 255F;
float f3 = (float)(i & 0xff) / 255F;
if (EntityRenderer.anaglyphEnable)
{
float f4 = (f1 * 30F + f2 * 59F + f3 * 11F) / 100F;
float f5 = (f1 * 30F + f2 * 70F) / 100F;
float f6 = (f1 * 30F + f3 * 70F) / 100F;
f1 = f4;
f2 = f5;
f3 = f6;
}
tessellator.setColorOpaque_F(f * f1, f * f2, f * f3);
int j =
par1BlockBrewingStand.getBlockTextureFromSideAndMetadata(0, 0);
if (overrideBlockTexture >= 0)
{
j = overrideBlockTexture;
}
int k = (j & 0xf) << 4;
int l = j & hexTaille;
double d = (float)l / hauteurTailleF;
double d1 = ((float)l + 15.99F) / hauteurTailleF;
int i1 = blockAccess.getBlockMetadata(par2, par3, par4);

Modification 6 à 8 :
Dans private boolean renderBlockRepeater(Block par1Block, int par2, int par3,

int par4), modifiez d7 et d8.
Code:
renderTorchAtAngle(par1Block, (double)par2 + d1, (double)par3
+ d, (double)par4 + d2, 0.0D, 0.0D);
renderTorchAtAngle(par1Block, (double)par2 + d3, (double)par3
+ d, (double)par4 + d4, 0.0D, 0.0D);
int l = par1Block.getBlockTextureFromSide(1);
int i1 = (l & 0xf) << 4;
int j1 = l & hexTaille;
double d5 = (float)i1 / 256F;
double d6 = ((float)i1 + 15.99F) / 256F;
double d7 = (float)j1 / hauteurTailleF;
double d8 = ((float)j1 + 15.99F) / hauteurTailleF;
double d9 = 0.125D;
double d10 = par2 + 1;
double d11 = par2 + 1;
double d12 = par2 + 0;

Modification 8 à 14 :
Dans private void renderPistonRodUD(...), private void renderPistonRodSN(...),
private void renderPistonRodEW(...), modifier dans chaque fonctions (3 fois),
d1 et d3.
Code:
/**
* Render piston rod up/down
*/
private void renderPistonRodUD(double par1, double par3, double
par5, double par7, double par9, double par11, float par13, double
par14)
{
int i = 108;
if (overrideBlockTexture >= 0)
{
i = overrideBlockTexture;
}
int j = (i & 0xf) << 4;
int k = i & hexTaille;
Tessellator tessellator = Tessellator.instance;
double d = (float)(j + 0) / 256F;
double d1 = (float)(k + 0) / hauteurTailleF;
double d2 = (((double)j + par14) - 0.01D) / 256D;
double d3 = ((double)((float)k + 4F) - 0.01D) /
hauteurTailleD;
tessellator.setColorOpaque_F(par13, par13, par13);
tessellator.addVertexWithUV(par1, par7, par9, d2, d1);
tessellator.addVertexWithUV(par1, par5, par9, d, d1);
tessellator.addVertexWithUV(par3, par5, par11, d, d3);
tessellator.addVertexWithUV(par3, par7, par11, d2, d3);
}
/**
* Render piston rod south/north
*/
private void renderPistonRodSN(double par1, double par3, double
par5, double par7, double par9, double par11, float par13, double
par14)

{
int i = 108;
if (overrideBlockTexture >= 0)
{
i = overrideBlockTexture;
}
int j = (i & 0xf) << 4;
int k = i & hexTaille;
Tessellator tessellator = Tessellator.instance;
double d = (float)(j + 0) / 256F;
double d1 = (float)(k + 0) / hauteurTailleF;
double d2 = (((double)j + par14) - 0.01D) / 256D;
double d3 = ((double)((float)k + 4F) - 0.01D) /
hauteurTailleD;
tessellator.setColorOpaque_F(par13, par13, par13);
tessellator.addVertexWithUV(par1, par5, par11, d2, d1);
tessellator.addVertexWithUV(par1, par5, par9, d, d1);
tessellator.addVertexWithUV(par3, par7, par9, d, d3);
tessellator.addVertexWithUV(par3, par7, par11, d2, d3);
}
/**
* Render piston rod east/west
*/
private void renderPistonRodEW(double par1, double par3, double
par5, double par7, double par9, double par11, float par13, double
par14)
{
int i = 108;
if (overrideBlockTexture >= 0)
{
i = overrideBlockTexture;
}
int j = (i & 0xf) << 4;
int k = i & hexTaille;
Tessellator tessellator = Tessellator.instance;
double d = (float)(j + 0) / 256F;
double d1 = (float)(k + 0) / hauteurTailleF;
double d2 = (((double)j + par14) - 0.01D) / 256D;
double d3 = ((double)((float)k + 4F) - 0.01D) /
hauteurTailleD;
tessellator.setColorOpaque_F(par13, par13, par13);
tessellator.addVertexWithUV(par3, par5, par9, d2, d1);
tessellator.addVertexWithUV(par1, par5, par9, d, d1);
tessellator.addVertexWithUV(par1, par7, par11, d, d3);
tessellator.addVertexWithUV(par3, par7, par11, d2, d3);
}

Modification 14 à 20 :
Dans public boolean renderBlockLever(...), modifiez f6 et f7.
Code:
int l = (k
int i1 = k
float f4 =
float f5 =
float f6 =
float f7 =

& 0xf) << 4;
& hexTaille;
(float)l / 256F;
((float)l + 15.99F) / 256F;
(float)i1 / hauteurTailleF;
((float)i1 + 15.99F) / hauteurTailleF;

Vec3D
float
float
float

avec3d[] = new Vec3D[8];
f8 = 0.0625F;
f9 = 0.0625F;
f10 = 0.625F;

Toujours dans cette fonction dans la boucle for (int k1 = 0; k1 < 6; k1++),
modifiez 2 fois f6 et f7.
Code:
Vec3D
Vec3D
Vec3D
Vec3D

vec3d = null;
vec3d1 = null;
vec3d2 = null;
vec3d3 = null;

for (int k1 = 0; k1 < 6; k1++)
{
if (k1 == 0)
{
f4 = (float)(l + 7) / 256F;
f5 = ((float)(l + 9) - 0.01F) / 256F;
f6 = (float)(i1 + 6) / hauteurTailleF;
f7 = ((float)(i1 + 8) - 0.01F) / hauteurTailleF;
}
else if (k1 == 2)
{
f4 = (float)(l + 7) / 256F;
f5 = ((float)(l + 9) - 0.01F) / 256F;
f6 = (float)(i1 + 6) / hauteurTailleF;
f7 = ((float)(i1 + 16) - 0.01F) / hauteurTailleF;
}

Signature Hors-Sujet :B
Même ici

4.

viens vous envahir !

Modification 20 à 34 :
Dans public boolean renderBlockFire(...), modifiez 4 fois d4 et d6.
Code:
public boolean renderBlockFire(Block par1Block, int par2, int
par3, int par4)
{
Tessellator tessellator = Tessellator.instance;
int i = par1Block.getBlockTextureFromSide(0);
if (overrideBlockTexture >= 0)
{
i = overrideBlockTexture;
}
tessellator.setColorOpaque_F(1.0F, 1.0F, 1.0F);
tessellator.setBrightness(par1Block.getMixedBrightnessForBlock(blockAc
cess, par2, par3, par4));
int j = (i & 0xf) << 4;
int k = i & hexTaille;

double d = (float)j / 256F;
double d2 = ((float)j + 15.99F) / 256F;
double d4 = (float)k / hauteurTailleF;
double d6 = ((float)k + 15.99F) / hauteurTailleF;
float f = 1.4F;
if (blockAccess.isBlockNormalCube(par2, par3 - 1, par4) ||
Block.fire.canBlockCatchFire(blockAccess, par2, par3 - 1, par4))
{
double d8 = (double)par2 + 0.5D + 0.20000000000000001D;
double d9 = ((double)par2 + 0.5D) - 0.20000000000000001D;
double d12 = (double)par4 + 0.5D + 0.20000000000000001D;
double d14 = ((double)par4 + 0.5D) - 0.20000000000000001D;
double d16 = ((double)par2 + 0.5D) - 0.29999999999999999D;
double d18 = (double)par2 + 0.5D + 0.29999999999999999D;
double d20 = ((double)par4 + 0.5D) - 0.29999999999999999D;
double d22 = (double)par4 + 0.5D + 0.29999999999999999D;
tessellator.addVertexWithUV(d16, (float)par3 + f, par4 +
1, d2, d4);
tessellator.addVertexWithUV(d8, par3 + 0, par4 + 1, d2,
d6);
tessellator.addVertexWithUV(d8, par3 + 0, par4 + 0, d,
d6);
tessellator.addVertexWithUV(d16, (float)par3 + f, par4 +
0, d, d4);
tessellator.addVertexWithUV(d18, (float)par3 + f, par4 +
0, d2, d4);
tessellator.addVertexWithUV(d9, par3 + 0, par4 + 0, d2,
d6);
tessellator.addVertexWithUV(d9, par3 + 0, par4 + 1, d,
d6);
tessellator.addVertexWithUV(d18, (float)par3 + f, par4 +
1, d, d4);
d = (float)j / 256F;
d2 = ((float)j + 15.99F) / 256F;
d4 = (float)(k + 16) / hauteurTailleF;
d6 = ((float)k + 15.99F + 16F) / hauteurTailleF;
tessellator.addVertexWithUV(par2 + 1, (float)par3 + f,
d22, d2, d4);
tessellator.addVertexWithUV(par2 + 1, par3 + 0, d14, d2,
d6);
tessellator.addVertexWithUV(par2 + 0, par3 + 0, d14, d,
d6);
tessellator.addVertexWithUV(par2 + 0, (float)par3 + f,
d22, d, d4);
tessellator.addVertexWithUV(par2 + 0, (float)par3 + f,
d20, d2, d4);
tessellator.addVertexWithUV(par2 + 0, par3 + 0, d12, d2,
d6);
tessellator.addVertexWithUV(par2 + 1, par3 + 0, d12, d,
d6);
tessellator.addVertexWithUV(par2 + 1, (float)par3 + f,
d20, d, d4);
d8 = ((double)par2 + 0.5D) - 0.5D;
d9 = (double)par2 + 0.5D + 0.5D;
d12 = ((double)par4 + 0.5D) - 0.5D;
d14 = (double)par4 + 0.5D + 0.5D;
d16 = ((double)par2 + 0.5D) - 0.40000000000000002D;
d18 = (double)par2 + 0.5D + 0.40000000000000002D;
d20 = ((double)par4 + 0.5D) - 0.40000000000000002D;
d22 = (double)par4 + 0.5D + 0.40000000000000002D;
tessellator.addVertexWithUV(d16, (float)par3 + f, par4 +
0, d, d4);
tessellator.addVertexWithUV(d8, par3 + 0, par4 + 0, d,

tessellator.addVertexWithUV(d8, par3 + 0, par4 + 0, d,
d6);
tessellator.addVertexWithUV(d8, par3 + 0, par4 + 1, d2,
d6);
tessellator.addVertexWithUV(d16, (float)par3 + f, par4 +
1, d2, d4);
tessellator.addVertexWithUV(d18, (float)par3 + f, par4 +
1, d, d4);
tessellator.addVertexWithUV(d9, par3 + 0, par4 + 1, d,
d6);
tessellator.addVertexWithUV(d9, par3 + 0, par4 + 0, d2,
d6);
tessellator.addVertexWithUV(d18, (float)par3 + f, par4 +
0, d2, d4);
d = (float)j / 256F;
d2 = ((float)j + 15.99F) / 256F;
d4 = (float)k / hauteurTailleF;
d6 = ((float)k + 15.99F) / hauteurTailleF;
tessellator.addVertexWithUV(par2 + 0, (float)par3 + f,
d22, d, d4);
tessellator.addVertexWithUV(par2 + 0, par3 + 0, d14, d,
d6);
tessellator.addVertexWithUV(par2 + 1, par3 + 0, d14, d2,
d6);
tessellator.addVertexWithUV(par2
d22, d2, d4);
tessellator.addVertexWithUV(par2
d20, d, d4);
tessellator.addVertexWithUV(par2
d6);
tessellator.addVertexWithUV(par2
d6);
tessellator.addVertexWithUV(par2
d20, d2, d4);
}
else
{
float f2 = 0.2F;
float f3 = 0.0625F;
if ((par2 + par3 +
{
d = (float)j /
d2 = ((float)j
d4 = (float)(k
d6 = ((float)k
}

+ 1, (float)par3 + f,
+ 1, (float)par3 + f,
+ 1, par3 + 0, d12, d,
+ 0, par3 + 0, d12, d2,
+ 0, (float)par3 + f,

par4 & 1) == 1)
256F;
+ 15.99F) / 256F;
+ 16) / hauteurTailleF;
+ 15.99F + 16F) / hauteurTailleF;

Ensuite à la fin de la fonction modifiez 3 fois d5 et d7.
Code:
if (Block.fire.canBlockCatchFire(blockAccess, par2, par3 +
1, par4))
{
double
double
double
double
double
double
double
double
double

d11 = (double)par2 + 0.5D +
d13 = ((double)par2 + 0.5D)
d15 = (double)par4 + 0.5D +
d17 = ((double)par4 + 0.5D)
d19 = ((double)par2 + 0.5D)
d21 = (double)par2 + 0.5D +
d23 = ((double)par4 + 0.5D)
d24 = (double)par4 + 0.5D +
d1 = (float)j / 256F;

0.5D;
- 0.5D;
0.5D;
- 0.5D;
- 0.5D;
0.5D;
- 0.5D;
0.5D;

double d3 = ((float)j + 15.99F) / 256F;
double d5 = (float)k / hauteurTailleF;
double d7 = ((float)k + 15.99F) / hauteurTailleF;
par3++;
float f1 = -0.2F;
if ((par2 + par3 + par4 & 1) == 0)
{
tessellator.addVertexWithUV(d19, (float)par3 + f1,
par4 + 0, d3, d5);
tessellator.addVertexWithUV(d11, par3 + 0, par4 +
0, d3, d7);
tessellator.addVertexWithUV(d11, par3 + 0, par4 +
1, d1, d7);
tessellator.addVertexWithUV(d19, (float)par3 + f1,
par4 + 1, d1, d5);
d1 = (float)j / 256F;
d3 = ((float)j + 15.99F) / 256F;
d5 = (float)(k + 16) / hauteurTailleF;
d7 = ((float)k + 15.99F + 16F) / hauteurTailleF;
tessellator.addVertexWithUV(d21, (float)par3 + f1,
par4 + 1, d3, d5);
tessellator.addVertexWithUV(d13, par3 + 0, par4 +
1, d3, d7);
tessellator.addVertexWithUV(d13, par3 + 0, par4 +
0, d1, d7);
tessellator.addVertexWithUV(d21, (float)par3 + f1,
par4 + 0, d1, d5);
}
else
{
tessellator.addVertexWithUV(par2 + 0, (float)par3
+ f1, d24, d3, d5);
tessellator.addVertexWithUV(par2 + 0, par3 + 0,
d17, d3, d7);
tessellator.addVertexWithUV(par2 + 1, par3 + 0,
d17, d1, d7);
tessellator.addVertexWithUV(par2 + 1, (float)par3
+ f1, d24, d1, d5);
d1 = (float)j / 256F;
d3 = ((float)j + 15.99F) / 256F;
d5 = (float)(k + 16) / hauteurTailleF;
d7 = ((float)k + 15.99F + 16F) / hauteurTailleF;
tessellator.addVertexWithUV(par2 + 1, (float)par3
+ f1, d23, d3, d5);
tessellator.addVertexWithUV(par2 + 1, par3 + 0,
d15, d3, d7);
tessellator.addVertexWithUV(par2 + 0, par3 + 0,
d15, d1, d7);
tessellator.addVertexWithUV(par2 + 0, (float)par3
+ f1, d23, d1, d5);
}
}
}
return true;
}

Signature Hors-Sujet :B
Même ici

viens vous envahir !

5.

Modification 34 à 70 :
Dans public boolean renderBlockRedstoneWire(...), il y a 36 modifications à
faire !
Dans l'ordre :
3 fois d4 et d6.
12 fois le dernier paramètre de la fonction :
tessellator.addVertexWithUV(...).
1 fois d5 et d7.
16 fois le dernier paramètre de la fonction :
tessellator.addVertexWithUV(...).
Il y a beaucoup trop de caractère dans la fonction je ne peux donc la mettre en
entière dans un sujet... Mais la voici sur pastebin : http://pastebin.com/raw.php?
i=x4Nc8kKj.
Voici les passages à changer (en cas de lien mort) :
Code:
tessellator.setColorOpaque_F(f2, f3, f4);
int k = (j & 0xf) << 4;
int l = j & hexTaille;
double d = (float)k / 256F;
double d2 = ((float)k + 15.99F) / 256F;
double d4 = (float)l / hauteurTailleF;
double d6 = ((float)l + 15.99F) / hauteurTailleF;
boolean flag =
BlockRedstoneWire.isPowerProviderOrWire(blockAccess, par2 - 1, par3,
par4, 1) || !blockAccess.isBlockNormalCube(par2 - 1, par3, par4) &&
BlockRedstoneWire.isPowerProviderOrWire(blockAccess, par2 - 1, par3 1, par4, -1);
boolean flag1 =
BlockRedstoneWire.isPowerProviderOrWire(blockAccess, par2 + 1, par3,
par4, 3) || !blockAccess.isBlockNormalCube(par2 + 1, par3, par4) &&
BlockRedstoneWire.isPowerProviderOrWire(blockAccess, par2 + 1, par3 1, par4, -1);

Code:
if ((flag || flag1) && !flag2 && !flag3)
{
byte0 = 1;
}
if ((flag2 || flag3) && !flag1 && !flag)
{
byte0 = 2;
}
if (byte0 != 0)
{
d = (float)(k + 16) / 256F;

d2 = ((float)(k + 16) + 15.99F) / 256F;
d4 = (float)l / hauteurTailleF;
d6 = ((float)l + 15.99F) / hauteurTailleF;
}

Code:
if (!flag2)
{
d4 += 0.01953125D / (hauteurTailleD / 256D);
}
if (!flag3)
{
f8 -= 0.3125F;
}
if (!flag3)
{
d6 -= 0.01953125D / (hauteurTailleD / 256D);
}

f8,
f7,
f7,
f8,

f8,
f7,
f7,
f8,

f8,
f7,
f7,
f8,

/* [...] Ça nous intéresse pas. */
tessellator.setColorOpaque_F(f, f, f);
tessellator.addVertexWithUV(f6, (double)par3
d2, d6 + 0.0625D / (hauteurTailleD / 256D));
tessellator.addVertexWithUV(f6, (double)par3
d2, d4 + 0.0625D/ (hauteurTailleD / 256D));
tessellator.addVertexWithUV(f5, (double)par3
d, d4 + 0.0625D / (hauteurTailleD / 256D));
tessellator.addVertexWithUV(f5, (double)par3
d, d6 + 0.0625D / (hauteurTailleD / 256D));
}
else if (byte0 == 1)
{
/* [...] Ça nous intéresse pas. */
tessellator.setColorOpaque_F(f, f, f);
tessellator.addVertexWithUV(f6, (double)par3
d2, d6 + 0.0625D / (hauteurTailleD / 256D));
tessellator.addVertexWithUV(f6, (double)par3
d2, d4 + 0.0625D / (hauteurTailleD / 256D));
tessellator.addVertexWithUV(f5, (double)par3
d, d4 + 0.0625D / (hauteurTailleD / 256D));
tessellator.addVertexWithUV(f5, (double)par3
d, d6 + 0.0625D / (hauteurTailleD / 256D));
}
else if (byte0 == 2)
{
/* [...] Ça nous intéresse pas. */
tessellator.setColorOpaque_F(f, f, f);
tessellator.addVertexWithUV(f6, (double)par3
d2, d6 + 0.0625D / (hauteurTailleD / 256D));
tessellator.addVertexWithUV(f6, (double)par3
d, d6 + 0.0625D / (hauteurTailleD / 256D));
tessellator.addVertexWithUV(f5, (double)par3
d, d4 + 0.0625D / (hauteurTailleD / 256D));
tessellator.addVertexWithUV(f5, (double)par3
d2, d4 + 0.0625D / (hauteurTailleD / 256D));
}

+ 0.015625D,
+ 0.015625D,
+ 0.015625D,
+ 0.015625D,

+ 0.015625D,
+ 0.015625D,
+ 0.015625D,
+ 0.015625D,

+ 0.015625D,
+ 0.015625D,
+ 0.015625D,
+ 0.015625D,

Code:
if (!blockAccess.isBlockNormalCube(par2, par3 + 1, par4))

{
double
double
double
double

d1
d3
d5
d7

=
=
=
=

(float)(k + 16) / 256F;
((float)(k + 16) + 15.99F) / 256F;
(float)l / hauteurTailleF;
((float)l + 15.99F) / hauteurTailleF;

if (blockAccess.isBlockNormalCube(par2 - 1, par3, par4) &&
blockAccess.getBlockId(par2 - 1, par3 + 1, par4) ==
Block.redstoneWire.blockID)
{
/* [...] Ça nous intéresse pas. */
tessellator.setColorOpaque_F(f, f, f);
tessellator.addVertexWithUV((double)par2 + 0.015625D,
(float)(par3 + 1) + 0.021875F, par4 + 1, d3, d5 + 0.0625D /
(hauteurTailleD / 256D));
tessellator.addVertexWithUV((double)par2 + 0.015625D,
par3 + 0, par4 + 1, d1, d5 + 0.0625D / (hauteurTailleD / 256D));
tessellator.addVertexWithUV((double)par2 + 0.015625D,
par3 + 0, par4 + 0, d1, d7 + 0.0625D / (hauteurTailleD / 256D));
tessellator.addVertexWithUV((double)par2 + 0.015625D,
(float)(par3 + 1) + 0.021875F, par4 + 0, d3, d7 + 0.0625D /
(hauteurTailleD / 256D));
}
if (blockAccess.isBlockNormalCube(par2 + 1, par3, par4) &&
blockAccess.getBlockId(par2 + 1, par3 + 1, par4) ==
Block.redstoneWire.blockID)
{
/* [...] Ça nous intéresse pas. */
tessellator.setColorOpaque_F(f, f, f);
tessellator.addVertexWithUV((double)(par2 + 1) 0.015625D, par3 + 0, par4 + 1, d1, d7 + 0.0625D / (hauteurTailleD /
256D));
tessellator.addVertexWithUV((double)(par2 + 1) 0.015625D, (float)(par3 + 1) + 0.021875F, par4 + 1, d3, d7 + 0.0625D /
(hauteurTailleD / 256D));
tessellator.addVertexWithUV((double)(par2 + 1) 0.015625D, (float)(par3 + 1) + 0.021875F, par4 + 0, d3, d5 + 0.0625D /
(hauteurTailleD / 256D));
tessellator.addVertexWithUV((double)(par2 + 1) 0.015625D, par3 + 0, par4 + 0, d1, d5 + 0.0625D / (hauteurTailleD /
256D));
}
if (blockAccess.isBlockNormalCube(par2, par3, par4 - 1) &&
blockAccess.getBlockId(par2, par3 + 1, par4 - 1) ==
Block.redstoneWire.blockID)
{
/* [...] Ça nous intéresse pas. */
tessellator.setColorOpaque_F(f, f, f);
tessellator.addVertexWithUV(par2 + 1, par3 + 0,
(double)par4 + 0.015625D, d1, d7 + 0.0625D / (hauteurTailleD / 256D));
tessellator.addVertexWithUV(par2 + 1, (float)(par3 +
1) + 0.021875F, (double)par4 + 0.015625D, d3, d7 + 0.0625D /
(hauteurTailleD / 256D));
tessellator.addVertexWithUV(par2 + 0, (float)(par3 +
1) + 0.021875F, (double)par4 + 0.015625D, d3, d5 + 0.0625D /
(hauteurTailleD / 256D));
tessellator.addVertexWithUV(par2 + 0, par3 + 0,
(double)par4 + 0.015625D, d1, d5 + 0.0625D / (hauteurTailleD / 256D));
}
if (blockAccess.isBlockNormalCube(par2, par3, par4 + 1) &&
blockAccess.getBlockId(par2, par3 + 1, par4 + 1) ==

blockAccess.getBlockId(par2, par3 + 1, par4 + 1) ==
Block.redstoneWire.blockID)
{
/* [...] Ça nous intéresse pas. */
tessellator.setColorOpaque_F(f, f, f);
tessellator.addVertexWithUV(par2 + 1, (float)(par3
1) + 0.021875F, (double)(par4 + 1) - 0.015625D, d3, d5 + 0.0625D /
(hauteurTailleD / 256D));
tessellator.addVertexWithUV(par2 + 1, par3 + 0,
(double)(par4 + 1) - 0.015625D, d1, d5 + 0.0625D / (hauteurTailleD
256D));
tessellator.addVertexWithUV(par2 + 0, par3 + 0,
(double)(par4 + 1) - 0.015625D, d1, d7 + 0.0625D / (hauteurTailleD
256D));
tessellator.addVertexWithUV(par2 + 0, (float)(par3
1) + 0.021875F, (double)(par4 + 1) - 0.015625D, d3, d7 + 0.0625D /
(hauteurTailleD / 256D));
}
}

+

/
/
+

return true;

Modification 70 à 72 :
Dans public boolean renderBlockMinecartTrack(..), modifiez d2 et d3.
Code:
tessellator.setBrightness(par1BlockRail.getMixedBrightnessForBlock(blo
ckAccess, par2, par3, par4));
tessellator.setColorOpaque_F(1.0F, 1.0F, 1.0F);
int k = (j & 0xf) << 4;
int l = j & hexTaille;
double d = (float)k / 256F;
double d1 = ((float)k + 15.99F) / 256F;
double d2 = (float)l / hauteurTailleF;
double d3 = ((float)l + 15.99F) / hauteurTailleF;

Modification 72 à 74 :
Dans public boolean renderBlockLadder(...), modifiez d2 et d3.
Code:
tessellator.setColorOpaque_F(f, f, f);
f = (i & 0xf) << 4;
int j = i & hexTaille;
double d = (float)f / 256F;
double d1 = ((float)f + 15.99F) / 256F;
double d2 = (float)j / hauteurTailleF;
double d3 = ((float)j + 15.99F) / hauteurTailleF;
int k = blockAccess.getBlockMetadata(par2, par3, par4);
double d4 = 0.0D;
double d5 = 0.05000000074505806D;

Signature Hors-Sujet :B
Même ici

6.

viens vous envahir !

Modification 74 à 76 :

Dans public boolean renderBlockVine(...), modifiez d2 et d3.
Code:
j = (i & 0xf) << 4;
f1 = i & hexTaille;
d = (float)j / 256F;
double d1 = ((float)j + 15.99F) / 256F;
double d2 = (float)f1 / hauteurTailleF;
double d3 = ((float)f1 + 15.99F) / hauteurTailleF;
double d4 = 0.05000000074505806D;
int k = blockAccess.getBlockMetadata(par2, par3, par4);

Modification 76 à 81 :
Dans public boolean renderBlockPane(...), modifiez d3, d4, d7, d8 et d9.
Code:
int j1
int k1
double
double
double
double
double
int l1
int i2
double
double
double
double
double
double
double
double

= (k & 0xf) << 4;
= k & hexTaille;
d = (float)j1 / 256F;
d1 = ((float)j1 + 7.99F) / 256F;
d2 = ((float)j1 + 15.99F) / 256F;
d3 = (float)k1 / hauteurTailleF;
d4 = ((float)k1 + 15.99F) / hauteurTailleF;
= (l & 0xf) << 4;
= l & hexTaille;
d5 = (float)(l1 + 7) / 256F;
d6 = ((float)l1 + 8.99F) / 256F;
d7 = (float)i2 / hauteurTailleF;
d8 = (float)(i2 + 8) / hauteurTailleF;
d9 = ((float)i2 + 15.99F) / hauteurTailleF;
d10 = par2;
d11 = (double)par2 + 0.5D;
d12 = par2 + 1;

Modification 81 à 83 :
Dans public void renderTorchAtAngle(...), modifiez f2 et f3.
Code:
int j
int k
float
float
float
float

= (i & 0xf) << 4;
= i & hexTaille;
f = (float)j / 256F;
f1 = ((float)j + 15.99F) / 256F;
f2 = (float)k / hauteurTailleF;
f3 = ((float)k + 15.99F) / hauteurTailleF;

Modification 83 à 85 :
Dans public void drawCrossedSquares(...), modifiez d2 et d3.
Code:
int j = (i & 0xf) << 4;
int k = i & hexTaille;
double d = (float)j / 256F;
double d1 = ((float)j + 15.99F) / 256F;
double d2 = (float)k / hauteurTailleF;
double d3 = ((float)k + 15.99F) / hauteurTailleF;

Modification 85 à 87 :

Dans public void renderBlockStemSmall(...), modifiez d2 et d3.
Code:
int j = (i & 0xf) << 4;
int k = i & hexTaille;
double d = (float)j / 256F;
double d1 = ((float)j + 15.99F) / 256F;
double d2 = (float)k / hauteurTailleF;
double d3 = ((double)k + 15.989999771118164D * par3) /
hauteurTailleD;

Modification 87 à 89 :
Dans public boolean renderBlockLilyPad(...), modifiez d2 et d3.
Code:
int j = (i & 0xf) << 4;
int k = i & hexTaille;
float f = 0.015625F;
double d = (float)j / 256F;
double d1 = ((float)j + 15.99F) / 256F;
double d2 = (float)k / hauteurTailleF;
double d3 = ((float)k + 15.99F) / hauteurTailleF;
long l = (long)(par2 * 0x2fc20f) ^ (long)par4 * 0x6ebfff5L ^
(long)par3;

Modification 89 à 91 :
Dans public void renderBlockStemBig(...), modifiez d2 et d3.
Code:
int j = (i & 0xf) << 4;
int k = i & hexTaille;
double d = (float)j / 256F;
double d1 = ((float)j + 15.99F) / 256F;
double d2 = (float)k / hauteurTailleF;
double d3 = ((double)k + 15.989999771118164D * par4) /
hauteurTailleD;
double d4 = (par6 + 0.5D) - 0.5D;
double d5 = par6 + 0.5D + 0.5D;

Modification 91 à 93 :
Dans public void renderBlockCropsImpl(...), modifiez d2 et d3.
Code:
int j = (i & 0xf) << 4;
int k = i & hexTaille;
double d = (float)j / 256F;
double d1 = ((float)j + 15.99F) / 256F;
double d2 = (float)k / hauteurTailleF;
double d3 = ((float)k + 15.99F) / hauteurTailleF;
double d4 = (par3 + 0.5D) - 0.25D;
double d5 = par3 + 0.5D + 0.25D;

Modification 93 à 100 :
Dans public boolean renderBlockFluids(...), il ne s'agit pas de modifiez des
variables, mais modifiez les paramètres de la fonction
tessellator.addVertexWithUV(...).

Code:
if (f8
{
f8
}
else
{
d7
d8
}

< -999F)
= 0.0F;

= (float)(j1 + 16) / 256F;
= (float)(l1 + 16) / 256F;

double d10 = (double)(MathHelper.sin(f8) * 8F) / 256D;
double d12 = (double)(MathHelper.cos(f8) * 8F) / 256D;
tessellator.setBrightness(par1Block.getMixedBrightnessForBlock(blockAc
cess, par2, par3, par4));
float f9 = 1.0F;
tessellator.setColorOpaque_F(f4 * f9 * f, f4 * f9 * f1, f4
* f9 * f2);
tessellator.addVertexWithUV(par2 + 0, (double)par3 + d2,
par4 + 0, d7 - d12 - d10, (d8 - d12 + d10) / (hauteurTailleD / 256D));
tessellator.addVertexWithUV(par2 + 0, (double)par3 + d3,
par4 + 1, d7 - d12 + d10, (d8 + d12 + d10) / (hauteurTailleD / 256D));
tessellator.addVertexWithUV(par2 + 1, (double)par3 + d4,
par4 + 1, d7 + d12 + d10, (d8 + d12 - d10) / (hauteurTailleD / 256D));
tessellator.addVertexWithUV(par2 + 1, (double)par3 + d5,
par4 + 0, d7 + d12 - d10, (d8 - d12 - d10) / (hauteurTailleD / 256D));
}
if (renderAllFaces || flag1)
{
tessellator.setBrightness(par1Block.getMixedBrightnessForBlock(blockAc
cess, par2, par3 - 1, par4));
float f7 = 1.0F;
tessellator.setColorOpaque_F(f3 * f7, f3 * f7, f3 * f7);
renderBottomFace(par1Block, par2, (double)par3 + d6, par4,
par1Block.getBlockTextureFromSide(0));
flag2 = true;
}

Toujours dans la même fonction, modifiez d19, d20 et d21.
Code:
flag2 = true;
double d17 = (float)(k2 + 0) / 256F;
double d18 = ((double)(k2 + 16) - 0.01D) / 256D;
double d19 = ((double)l2 + (1.0D - d9) * 16D) /
hauteurTailleD;
double d20 = ((double)l2 + (1.0D - d11) * 16D) /
hauteurTailleD;
double d21 = ((double)(l2 + 16) - 0.01D) / hauteurTailleD;
tessellator.setBrightness(par1Block.getMixedBrightnessForBlock(blockAc
cess, i1, k1, i2));
float f10 = 1.0F;

Modification 100 à 110 :
Dans public void renderBottomFace(...), modifiez 5 fois d2 et d3.

Code:
int i = (par8 & 0xf) << 4;
int j = par8 & hexTaille;
double d = ((double)i + par1Block.minX * 16D) / 256D;
double d1 = (((double)i + par1Block.maxX * 16D) - 0.01D) /
256D;
double d2 = ((double)j + par1Block.minZ * 16D) /
hauteurTailleD;
double d3 = (((double)j + par1Block.maxZ * 16D) - 0.01D) /
hauteurTailleD;
if (par1Block.minX < 0.0D || par1Block.maxX > 1.0D)
{
d = ((float)i + 0.0F) / 256F;
d1 = ((float)i + 15.99F) / 256F;
}
if (par1Block.minZ < 0.0D || par1Block.maxZ > 1.0D)
{
d2 = ((float)j + 0.0F) / hauteurTailleF;
d3 = ((float)j + 15.99F) / hauteurTailleF;
}
double
double
double
double

d4
d5
d6
d7

=
=
=
=

d1;
d;
d2;
d3;

if (uvRotateBottom == 2)
{
d = ((double)i + par1Block.minZ * 16D) / 256D;
d2 = ((double)(j + 16) - par1Block.maxX * 16D) /
hauteurTailleD;
d1 = ((double)i + par1Block.maxZ * 16D) / 256D;
d3 = ((double)(j + 16) - par1Block.minX * 16D) /
hauteurTailleD;
d4 = d1;
d5 = d;
d6 = d2;
d7 = d3;
d4 = d;
d5 = d1;
d2 = d3;
d3 = d6;
}
else if (uvRotateBottom == 1)
{
d = ((double)(i + 16) - par1Block.maxZ * 16D) / 256D;
d2 = ((double)j + par1Block.minX * 16D) / hauteurTailleD;
d1 = ((double)(i + 16) - par1Block.minZ * 16D) / 256D;
d3 = ((double)j + par1Block.maxX * 16D) / hauteurTailleD;
d4 = d1;
d5 = d;
d6 = d2;
d7 = d3;
d = d4;
d1 = d5;
d6 = d3;
d7 = d2;
}
else if (uvRotateBottom == 3)
{

d = ((double)(i + 16) - par1Block.minX * 16D) / 256D;
d1 = ((double)(i + 16) - par1Block.maxX * 16D - 0.01D) /
256D;
d2 =
hauteurTailleD;
d3 =
hauteurTailleD;
d4 =
d5 =
d6 =
d7 =
}

((double)(j + 16) - par1Block.minZ * 16D) /
((double)(j + 16) - par1Block.maxZ * 16D - 0.01D) /
d1;
d;
d2;
d3;

Signature Hors-Sujet :B
Même ici

7.

viens vous envahir !

Modification 110 à 120 :
Dans public void renderTopFace(...), modifiez 5 fois d2 et d3.
Code:
int i = (par8 & 0xf) << 4;
int j = par8 & hexTaille;
double d = ((double)i + par1Block.minX * 16D) / 256D;
double d1 = (((double)i + par1Block.maxX * 16D) - 0.01D) /
256D;
double d2 = ((double)j + par1Block.minZ * 16D) /
hauteurTailleD;
double d3 = (((double)j + par1Block.maxZ * 16D) - 0.01D) /
hauteurTailleD;
if (par1Block.minX < 0.0D || par1Block.maxX > 1.0D)
{
d = ((float)i + 0.0F) / 256F;
d1 = ((float)i + 15.99F) / 256F;
}
if (par1Block.minZ < 0.0D || par1Block.maxZ > 1.0D)
{
d2 = ((float)j + 0.0F) / hauteurTailleF;
d3 = ((float)j + 15.99F) / hauteurTailleF;
}
double
double
double
double

d4
d5
d6
d7

=
=
=
=

d1;
d;
d2;
d3;

if (uvRotateTop == 1)
{
d = ((double)i + par1Block.minZ * 16D) / 256D;
d2 = ((double)(j + 16) - par1Block.maxX * 16D) /
hauteurTailleD;
d1 = ((double)i + par1Block.maxZ * 16D) / 256D;
d3 = ((double)(j + 16) - par1Block.minX * 16D) /
hauteurTailleD;
d4 = d1;
d5 = d;

d6
d7
d4
d5
d2
d3

=
=
=
=
=
=

d2;
d3;
d;
d1;
d3;
d6;

}
else if (uvRotateTop == 2)
{
d = ((double)(i + 16) - par1Block.maxZ * 16D) / 256D;
d2 = ((double)j + par1Block.minX * 16D) / hauteurTailleD;
d1 = ((double)(i + 16) - par1Block.minZ * 16D) / 256D;
d3 = ((double)j + par1Block.maxX * 16D) / hauteurTailleD;
d4 = d1;
d5 = d;
d6 = d2;
d7 = d3;
d = d4;
d1 = d5;
d6 = d3;
d7 = d2;
}
else if (uvRotateTop == 3)
{
d = ((double)(i + 16) - par1Block.minX * 16D) / 256D;
d1 = ((double)(i + 16) - par1Block.maxX * 16D - 0.01D) /
256D;
d2 =
hauteurTailleD;
d3 =
hauteurTailleD;
d4 =
d5 =
d6 =
d7 =
}

((double)(j + 16) - par1Block.minZ * 16D) /
((double)(j + 16) - par1Block.maxZ * 16D - 0.01D) /
d1;
d;
d2;
d3;

Modification 120 à 130 :
Dans public void renderEastFace(...), modifiez 5 fois d2 et d3.
Code:
int i = (par8 & 0xf) << 4;
int j = par8 & hexTaille;
double d = ((double)i + par1Block.minX * 16D) / 256D;
double d1 = (((double)i + par1Block.maxX * 16D) - 0.01D) /
256D;
double d2 = ((double)(j + 16) - par1Block.maxY * 16D) /
hauteurTailleD;
double d3 = ((double)(j + 16) - par1Block.minY * 16D - 0.01D)
/ hauteurTailleD;
if (flipTexture)
{
double d4 = d;
d = d1;
d1 = d4;
}
if (par1Block.minX < 0.0D || par1Block.maxX > 1.0D)
{
d = ((float)i + 0.0F) / 256F;

d1 = ((float)i + 15.99F) / 256F;
}
if (par1Block.minY < 0.0D || par1Block.maxY > 1.0D)
{
d2 = ((float)j + 0.0F) / hauteurTailleF;
d3 = ((float)j + 15.99F) / hauteurTailleF;
}
double
double
double
double

d5
d6
d7
d8

=
=
=
=

d1;
d;
d2;
d3;

if (uvRotateEast == 2)
{
d = ((double)i + par1Block.minY * 16D) / 256D;
d2 = ((double)(j + 16) - par1Block.minX * 16D) /
hauteurTailleD;
d1 = ((double)i + par1Block.maxY * 16D) / 256D;
d3 = ((double)(j + 16) - par1Block.maxX * 16D) /
hauteurTailleD;
d5 = d1;
d6 = d;
d7 = d2;
d8 = d3;
d5 = d;
d6 = d1;
d2 = d3;
d3 = d7;
}
else if (uvRotateEast == 1)
{
d = ((double)(i + 16) - par1Block.maxY * 16D) / 256D;
d2 = ((double)j + par1Block.maxX * 16D) / hauteurTailleD;
d1 = ((double)(i + 16) - par1Block.minY * 16D) / 256D;
d3 = ((double)j + par1Block.minX * 16D) / hauteurTailleD;
d5 = d1;
d6 = d;
d7 = d2;
d8 = d3;
d = d5;
d1 = d6;
d7 = d3;
d8 = d2;
}
else if (uvRotateEast == 3)
{
d = ((double)(i + 16) - par1Block.minX * 16D) / 256D;
d1 = ((double)(i + 16) - par1Block.maxX * 16D - 0.01D) /
256D;
d2 = ((double)j + par1Block.maxY * 16D) / hauteurTailleD;
d3 = (((double)j + par1Block.minY * 16D) - 0.01D) /
hauteurTailleD;
d5 = d1;
d6 = d;
d7 = d2;
d8 = d3;
}

Modification 130 à 140 :
Dans public void renderWestFace(...), modifiez 5 fois d2 et d3.

Code:
int i = (par8 & 0xf) << 4;
int j = par8 & hexTaille;
double d = ((double)i + par1Block.minX * 16D) / 256D;
double d1 = (((double)i + par1Block.maxX * 16D) - 0.01D) /
256D;
double d2 = ((double)(j + 16) - par1Block.maxY * 16D) /
hauteurTailleD;
double d3 = ((double)(j + 16) - par1Block.minY * 16D - 0.01D)
/ hauteurTailleD;
if (flipTexture)
{
double d4 = d;
d = d1;
d1 = d4;
}
if (par1Block.minX < 0.0D || par1Block.maxX > 1.0D)
{
d = ((float)i + 0.0F) / 256F;
d1 = ((float)i + 15.99F) / 256F;
}
if (par1Block.minY < 0.0D || par1Block.maxY > 1.0D)
{
d2 = ((float)j + 0.0F) / hauteurTailleF;
d3 = ((float)j + 15.99F) / hauteurTailleF;
}
double
double
double
double

d5
d6
d7
d8

=
=
=
=

d1;
d;
d2;
d3;

if (uvRotateWest == 1)
{
d = ((double)i + par1Block.minY * 16D) / 256D;
d3 = ((double)(j + 16) - par1Block.minX * 16D) /
hauteurTailleD;
d1 = ((double)i + par1Block.maxY * 16D) / 256D;
d2 = ((double)(j + 16) - par1Block.maxX * 16D) /
hauteurTailleD;
d5 = d1;
d6 = d;
d7 = d2;
d8 = d3;
d5 = d;
d6 = d1;
d2 = d3;
d3 = d7;
}
else if (uvRotateWest == 2)
{
d = ((double)(i + 16) - par1Block.maxY * 16D) / 256D;
d2 = ((double)j + par1Block.minX * 16D) / hauteurTailleD;
d1 = ((double)(i + 16) - par1Block.minY * 16D) / 256D;
d3 = ((double)j + par1Block.maxX * 16D) / hauteurTailleD;
d5 = d1;
d6 = d;
d7 = d2;
d8 = d3;

d = d5;
d1 = d6;
d7 = d3;
d8 = d2;
}
else if (uvRotateWest == 3)
{
d = ((double)(i + 16) - par1Block.minX * 16D) / 256D;
d1 = ((double)(i + 16) - par1Block.maxX * 16D - 0.01D) /
256D;
d2 =
d3 =
hauteurTailleD;
d5 =
d6 =
d7 =
d8 =
}

((double)j + par1Block.maxY * 16D) / hauteurTailleD;
(((double)j + par1Block.minY * 16D) - 0.01D) /
d1;
d;
d2;
d3;

Signature Hors-Sujet :B
Même ici

8.

viens vous envahir !

Modification 140 à 150 :
Dans public void renderNorthFace(...), modifiez 5 fois d2 et d3.
Code:
int i = (par8 & 0xf) << 4;
int j = par8 & hexTaille;
double d = ((double)i + par1Block.minZ * 16D) / 256D;
double d1 = (((double)i + par1Block.maxZ * 16D) - 0.01D) /
256D;
double d2 = ((double)(j + 16) - par1Block.maxY * 16D) /
hauteurTailleD;
double d3 = ((double)(j + 16) - par1Block.minY * 16D - 0.01D)
/ hauteurTailleD;
if (flipTexture)
{
double d4 = d;
d = d1;
d1 = d4;
}
if (par1Block.minZ < 0.0D || par1Block.maxZ > 1.0D)
{
d = ((float)i + 0.0F) / 256F;
d1 = ((float)i + 15.99F) / 256F;
}
if (par1Block.minY < 0.0D || par1Block.maxY > 1.0D)
{
d2 = ((float)j + 0.0F) / hauteurTailleF;
d3 = ((float)j + 15.99F) / hauteurTailleF;
}
double d5 = d1;
double d6 = d;

double d7 = d2;
double d8 = d3;
if (uvRotateNorth == 1)
{
d = ((double)i + par1Block.minY * 16D) / 256D;
d2 = ((double)(j + 16) - par1Block.maxZ * 16D) /
hauteurTailleD;
d1 = ((double)i + par1Block.maxY * 16D) / 256D;
d3 = ((double)(j + 16) - par1Block.minZ * 16D) /
hauteurTailleD;
d5 = d1;
d6 = d;
d7 = d2;
d8 = d3;
d5 = d;
d6 = d1;
d2 = d3;
d3 = d7;
}
else if (uvRotateNorth == 2)
{
d = ((double)(i + 16) - par1Block.maxY * 16D) / 256D;
d2 = ((double)j + par1Block.minZ * 16D) / hauteurTailleD;
d1 = ((double)(i + 16) - par1Block.minY * 16D) / 256D;
d3 = ((double)j + par1Block.maxZ * 16D) / hauteurTailleD;
d5 = d1;
d6 = d;
d7 = d2;
d8 = d3;
d = d5;
d1 = d6;
d7 = d3;
d8 = d2;
}
else if (uvRotateNorth == 3)
{
d = ((double)(i + 16) - par1Block.minZ * 16D) / 256D;
d1 = ((double)(i + 16) - par1Block.maxZ * 16D - 0.01D) /
256D;
d2 = ((double)j + par1Block.maxY * 16D) / hauteurTailleD;
d3 = (((double)j + par1Block.minY * 16D) - 0.01D) /
hauteurTailleD;
d5 = d1;
d6 = d;
d7 = d2;
d8 = d3;
}

Modification 150 à 160 :
Dans public void renderTopFace(...), modifiez 5 fois d2 et d3.
Code:
int i = (par8 & 0xf) << 4;
int j = par8 & hexTaille;
double d = ((double)i + par1Block.minZ * 16D) / 256D;
double d1 = (((double)i + par1Block.maxZ * 16D) - 0.01D) /
256D;
double d2 = ((double)(j + 16) - par1Block.maxY * 16D) /
hauteurTailleD;
double d3 = ((double)(j + 16) - par1Block.minY * 16D - 0.01D)

/ hauteurTailleD;
if (flipTexture)
{
double d4 = d;
d = d1;
d1 = d4;
}
if (par1Block.minZ < 0.0D || par1Block.maxZ > 1.0D)
{
d = ((float)i + 0.0F) / 256F;
d1 = ((float)i + 15.99F) / 256F;
}
if (par1Block.minY < 0.0D || par1Block.maxY > 1.0D)
{
d2 = ((float)j + 0.0F) / hauteurTailleF;
d3 = ((float)j + 15.99F) / hauteurTailleF;
}
double
double
double
double

d5
d6
d7
d8

=
=
=
=

d1;
d;
d2;
d3;

if (uvRotateSouth == 2)
{
d = ((double)i + par1Block.minY * 16D) / 256D;
d2 = ((double)(j + 16) - par1Block.minZ * 16D) /
hauteurTailleD;
d1 = ((double)i + par1Block.maxY * 16D) / 256D;
d3 = ((double)(j + 16) - par1Block.maxZ * 16D) /
hauteurTailleD;
d5 = d1;
d6 = d;
d7 = d2;
d8 = d3;
d5 = d;
d6 = d1;
d2 = d3;
d3 = d7;
}
else if (uvRotateSouth == 1)
{
d = ((double)(i + 16) - par1Block.maxY * 16D) / 256D;
d2 = ((double)j + par1Block.maxZ * 16D) / hauteurTailleD;
d1 = ((double)(i + 16) - par1Block.minY * 16D) / 256D;
d3 = ((double)j + par1Block.minZ * 16D) / hauteurTailleD;
d5 = d1;
d6 = d;
d7 = d2;
d8 = d3;
d = d5;
d1 = d6;
d7 = d3;
d8 = d2;
}
else if (uvRotateSouth == 3)
{
d = ((double)(i + 16) - par1Block.minZ * 16D) / 256D;
d1 = ((double)(i + 16) - par1Block.maxZ * 16D - 0.01D) /
256D;
d2 = ((double)j + par1Block.maxY * 16D) / hauteurTailleD;

d2 =
d3 =
hauteurTailleD;
d5 =
d6 =
d7 =
d8 =
}

((double)j + par1Block.maxY * 16D) / hauteurTailleD;
(((double)j + par1Block.minY * 16D) - 0.01D) /
d1;
d;
d2;
d3;

LA FIN EST PROCHE !
Pour finir, avec le fichier RenderBlocks.java, il suffit de changer encore les 28
valeurs hexadécimal (0xf0) par hexTaille. Il suffit donc simplement d'utiliser la
fonction replace dans eclipse c'est CTRL + F (notepad ++ ou autres c'est CTRL
+ H). Vous aurez compris, il faut mettre dans la fenêtre qui vient d’apparaitre :

Find : 0xf0
Replace with : hexTaille
Puis validez en cliquant sur Replace All.

Signature Hors-Sujet :B
Même ici

viens vous envahir !



Documents similaires


projet tri
chap2 c
uriipkj
corrigetd7poo
medicaments
ajoutmodifsupprcompterenducs


Sur le même sujet..