Problème multi-texture et rotation d'un bloc rendu ISBRH



  • Bonjour, j'ai un petit problème avec mes machine, je veux faire un rendu ISBRH pour renfoncer l'écran: http://image.noelshack.com/fichiers/2016/37/1474112106-2016-09-17-13-32-42.png

    Mais 3 problème/question surviennent:

    [résolu]1. Je n'arrive pas a faire la rotation du rendu ISBRH, je ne sais pas quelle coordonnées modifier et quand je recommence depuis le début pour une face, la texture ne s'adapte plus a la rotation

    2. Je n'arrive pas a faire que ma texture s'adapte au rendu, il y a a chaque fois des décalages: http://image.noelshack.com/fichiers/2016/37/1474112106-2016-09-17-13-33-09.png

    [résolu]3. Est-ce que, une fois le rendu terminer, je pourrais l'associer à toute mes machines? Devrais-je modifier des trucs, notamment avec l'ID ou l'ID est pour le rendu il ne faut pas le changer en fonction du bloc?

    Code du rendu:

    public class RenderMachine implements ISimpleBlockRenderingHandler
    {
    
    @Override
    public void renderInventoryBlock(Block block, int metadata, int modelId, RenderBlocks renderer)
    {
    Tessellator tessellator = Tessellator.instance;
    
    renderer.setRenderBounds(0F, 0F, 0F, 1F, 1F, 1F);
    renderInInventory(tessellator, renderer, block, metadata);
    }
    
    @Override
    public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer)
    {
    TileEntity tile = world.getTileEntity(x, y, z);
    if(tile instanceof TileEntityDirectional)
    {
    TileEntityDirectional t = (TileEntityDirectional)tile;
    byte direction = t.getDirection();
    
    if(direction == 0)
    {
    renderer.setRenderBounds(0F, 0F, 0F, 1F, 1F, 0.95F);
    renderer.renderStandardBlock(block, x, y, z);
    
    renderer.setRenderBounds(0F, 0F, 0.95F, 1F, 0.1F, 1F);
    renderer.renderStandardBlock(block, x, y, z);
    
    renderer.setRenderBounds(0F, 0.9F, 0.95F, 1F, 1F, 1F);
    renderer.renderStandardBlock(block, x, y, z);
    
    renderer.setRenderBounds(0F, 0.1F, 0.95F, 0.1F, 0.9F, 1F);
    renderer.renderStandardBlock(block, x, y, z);
    
    renderer.setRenderBounds(0.9F, 0.1F, 0.95F, 1F, 0.9F, 1F);
    renderer.renderStandardBlock(block, x, y, z);
    }
    else if(direction == 1)
    {
    renderer.setRenderBounds(-0F, 0F, 0F, -0.95F, 1F, 1F);
    renderer.renderStandardBlock(block, x, y, z);
    
    renderer.setRenderBounds(-0.95F, 0F, 0F, -1F, 0.1F, 1F);
    renderer.renderStandardBlock(block, x, y, z);
    
    renderer.setRenderBounds(-0.95F, 0.9F, 0F, -1F, 1F, 1F);
    renderer.renderStandardBlock(block, x, y, z);
    
    renderer.setRenderBounds(-0.95F, 0.1F, 0.95F, -1F, 0.9F, 0.1F);
    renderer.renderStandardBlock(block, x, y, z);
    
    renderer.setRenderBounds(-0.95F, 0.1F, 0.9F, -1F, 0.9F, 1F);
    renderer.renderStandardBlock(block, x, y, z);
    }
    else if(direction == 2)
    {
    renderer.setRenderBounds(1F, 0F, 1F, 0F, 1F, 0.05F);
    renderer.renderStandardBlock(block, x, y, z);
    
    /*renderer.setRenderBounds(0F, 0F, 0.95F, 1F, 0.1F, 1F);
    renderer.renderStandardBlock(block, x, y, z);
    
    renderer.setRenderBounds(0F, 0.9F, 0.95F, 1F, 1F, 1F);
    renderer.renderStandardBlock(block, x, y, z);
    
    renderer.setRenderBounds(0F, 0.1F, 0.95F, 0.1F, 0.9F, 1F);
    renderer.renderStandardBlock(block, x, y, z);
    
    renderer.setRenderBounds(0.9F, 0.1F, 0.95F, 1F, 0.9F, 1F);
    renderer.renderStandardBlock(block, x, y, z);*/
    }
    else if(direction == 3)
    {
    renderer.setRenderBounds(0F, 0F, 0F, 1F, 1F, 0.95F);
    renderer.renderStandardBlock(block, x, y, z);
    
    renderer.setRenderBounds(0F, 0F, 0.95F, 1F, 0.1F, 1F);
    renderer.renderStandardBlock(block, x, y, z);
    
    renderer.setRenderBounds(0F, 0.9F, 0.95F, 1F, 1F, 1F);
    renderer.renderStandardBlock(block, x, y, z);
    
    renderer.setRenderBounds(0F, 0.1F, 0.95F, 0.1F, 0.9F, 1F);
    renderer.renderStandardBlock(block, x, y, z);
    
    renderer.setRenderBounds(0.9F, 0.1F, 0.95F, 1F, 0.9F, 1F);
    renderer.renderStandardBlock(block, x, y, z);
    }
    
    return true;
    }
    
    return false;
    }
    
    @Override
    public boolean shouldRender3DInInventory(int modelId)
    {
    return true;
    }
    
    @Override
    public int getRenderId()
    {
    return ClientProxy.renderISBRH;
    }
    
    private void renderInInventory(Tessellator tessellator, RenderBlocks renderer, Block block, int metadata)
    {
    GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
    tessellator.startDrawingQuads();
    tessellator.setNormal(0.0F, -1F, 0.0F);
    renderer.renderFaceYNeg(block, 0.0D, 0.0D, 0.0D, block.getIcon(0, metadata));
    tessellator.draw();
    tessellator.startDrawingQuads();
    tessellator.setNormal(0.0F, 1.0F, 0.0F);
    renderer.renderFaceYPos(block, 0.0D, 0.0D, 0.0D, block.getIcon(1, metadata));
    tessellator.draw();
    tessellator.startDrawingQuads();
    tessellator.setNormal(0.0F, 0.0F, -1F);
    renderer.renderFaceZNeg(block, 0.0D, 0.0D, 0.0D, block.getIcon(2, metadata));
    tessellator.draw();
    tessellator.startDrawingQuads();
    tessellator.setNormal(0.0F, 0.0F, 1.0F);
    renderer.renderFaceZPos(block, 0.0D, 0.0D, 0.0D, block.getIcon(5, metadata));
    tessellator.draw();
    tessellator.startDrawingQuads();
    tessellator.setNormal(-1F, 0.0F, 0.0F);
    renderer.renderFaceXNeg(block, 0.0D, 0.0D, 0.0D, block.getIcon(4, metadata));
    tessellator.draw();
    tessellator.startDrawingQuads();
    tessellator.setNormal(1.0F, 0.0F, 0.0F);
    renderer.renderFaceXPos(block, 0.0D, 0.0D, 0.0D, block.getIcon(3, metadata));
    tessellator.draw();
    GL11.glTranslatef(0.5F, 0.5F, 0.5F);
    }
    }
    

    Merci d'avance 🙂



  • Salut, oui tu pourras réutiliser le rendu pour tes autres blocs si tu utilises le même ID.

    Sinon je ne sais pas si c'est une bonne idée de mettre des coordonnées négatives. Je n'ai jamais essayé ceci dit mais ça me paraît bizarre de le faire. Possible que ça soit la source du problème des textures décalées? Car je ne vois pas ce qui pourrait causer le problème de la texture.

    Pour la rotation, c'est un peu le truc pas pratique des ISBRH, il faut se farcir toutes les directions à la main. Je te conseille de lancer le jeu en debug (avec le petit bouton affichant un insecte dans Eclipse) ainsi tu pourras faire les modifications en temps réel (il faut juste mettre à jour le chunk où se trouve le bloc pour voir les changements, en posant/cassant un bloc par ex, après avoir modifié et sauvegardé le code). Sinon tu as toujours la possibilité de modéliser ton objet dans un éditeur 3D genre McCrayFish model creator ou autre, et de récupérer les coordonnées dans le json pour les mettre dans le code de l'ISBRH (par contre ça donne des valeurs entre 0 et 16, donc fais une division par 16 à chaque fois).

    Le truc à retenir c'est que quelque soit la direction, les points 0,0,0 et 1,1,1 sont toujours aux mêmes coins du block.



  • Merci de ton aide mais j'ai un problème: j'ai fait le json, mais il indique des coordonnées par 4 et dans le rendu c'est par 6 pourrais-tu m'expliquer comment je les retranscris? Le JSON (en txt) est comme piece jointe



  • Les coordonnés par 4 sont pour les textures, elles ne t'intéressent pas dans ton cas. Il faut prendre les 6 coordonnées dans les lignes from et to. Par exemple le premier cube aura les coordonnés 0,0,0.5/16,1,1,1 (car 16/16 = 1).



  • @'KillerMapper':

    Les coordonnés par 4 sont pour les textures, elles ne t'intéressent pas dans ton cas. Il faut prendre les 6 coordonnées dans les lignes from et to. Par exemple le premier cube aura les coordonnés 0,0,0.5/16,1,1,1 (car 16/16 = 1).

    Oui mais alors j'ai pas la rotation?



  • Ah bah non il faut refaire le block à chaque fois, à moins qu'il y a un moyen de tourner le modèle dans le programme de modélisation utilisé. C'est juste pour ne pas à s'emmerder à modéliser en changeant des coordonnées dans le code que j'ai proposé l'astuce du programme de modélisation.

    Sinon faut passer par un TESR, normalement ça peut être tourné si je ne me trompe pas mais c'est plus gourmand en ressources qu'un ISBRH.



  • Ok 1 et 3 résolus, il reste le 2 au faite la texture s'adapte à chaque morceau que je pose et donc la texture est décalée sur plusieurs faces (voir énoncée)

    Envoyé de mon iPad en utilisant Tapatalk



  • @'Minantcraft':

    Ok 1 et 3 résolus, il reste le 2 au faite la texture s'adapte à chaque morceau que je pose et donc la texture est décalée sur plusieurs faces (voir énoncée)

    Envoyé de mon iPad en utilisant Tapatalk

    Envoyé de mon SM-G360F en utilisant Tapatalk



  • Up

    Envoyé de mon iPad en utilisant Tapatalk



  • Pourquoi dans le renderBounds tu mets pas des valeurs pour un cube entier ?



  • @'SCAREX':

    Pourquoi dans le renderBounds tu mets pas des valeurs pour un cube entier ?

    Je comprends pas



  • renderer.setRenderBounds(0F, 0F, 0F, 1F, 1F, 0.95F); -> Pourquoi 0.95F ?



  • @'SCAREX':

    renderer.setRenderBounds(0F, 0F, 0F, 1F, 1F, 0.95F); -> Pourquoi 0.95F ?

    Il y a plusieurs partie dans le bloc dont une qui fait presque qu'un bloc



  • Alors ton problème a des chances de venir de là : si tu modifies la taille de ton cube, les coordonnées sont légèrement différentes



  • @'SCAREX':

    Alors ton problème a des chances de venir de là : si tu modifies la taille de ton cube, les coordonnées sont légèrement différentes

    Je comprend pas le rapport avec la texture



  • Comme je l'ai dit, si tu modifies la taille de ton cube tu modifies les coordonnées de texture



  • @'SCAREX':

    Comme je l'ai dit, si tu modifies la taille de ton cube tu modifies les coordonnées de texture

    Mais comment je fais pour que la texture s'adapte au bloc et pas à chaque partie



  • Il faut changer la façon dont tu rends ton block, je ne sais pas précisément ce que tu veux faire donc je peux pas te dire.



  • Il y a une photo dans le message original