Non résolu Dessin dans le monde

[UtopiePhysique]

Bonjour,

Le titre est un peu bizarre mais vous allez j’espère vite comprendre.
J’aimerais faire des dessins dans le monde, comme la barrière qui limite une zone (enfin c’est peut être un bloc ?), ou encore le câble de la canne à pêche, ou encore les lignes au coin de 4 chunks, ou encore le maillage définissant les chunks (jaune & rouge).

Je ne sais pas si vous avez bien compris ce que je recherche, j’ai essayer de voir du côté de la canne à pêche mais j’ai rien trouver.

Cela fait un bon moment que j’avais commencer à me pencher dessus et aujourd’hui ayant beaucoup moins de temps pour les recherches j’essaye un peu la faciliter en venant demander de l’aide et en m’étant mon égo de côté.

Si quelqu’un à une piste, un bout de code, un exemple ou autre n’hésitez pas à mettre ici ^^
Ou des mots clés également j’ai essayer des trucs comme “draw line in world” etc

Merci !

Edit: J’ai quelques problèmes à refaire fonctionner mes projets, j’essaye demain de faire des tests je suis tomber sur un sujet parlant de “GL11” (l’api de LWJGL qui est présente dans minecraft), j’ai pu voir des traçages sur des screens malheureusement suite aux soucis avec Java, Gradle et tout le reste j’ai pas pu tester, je verrais cela demain, mais j’ai déjà une piste ^^

[baztoul76]

Elles serviront à faire quoi des lignes (parce que ça peut aider de le savoir) ?

[UtopiePhysique]

Cela n’aidera à rien de le savoir, mais cela servira à faire un visuel (contour des chunks etc) pour un mod PVP Faction que je dois sortir et que je n’ai plus toucher, j’ai perdu mon PC il y à peu ce qui n’a pas aider mais j’ai quelque chose bien mieux donc je vais m’y remettre dans mon temps libre

[baztoul76]

au pire tu peux “tricher” un peu et créer un bloc traversable qui possède la texture d’une ligne, ou de modifier la texture des blocs existants (air compris)

[UtopiePhysique]

Sauf qu’un bloc cela prend la place d’un bloc, donc si il y à un bloc transparent, cela le remplace.
Donc non aucune triche en plus d’être lourd

Je vais effectuer des tests j’ai reçu mon nouveau ordinateur et je vais pouvoir tester bien plus facilement avec une tel puissance

Je suis en train de finir d’installer unity etc.

Je dois voir l’utiliser du module GL11 de l’api LWJGL qui serait assez évident.

[baztoul76]

oui je pense que la solution se trouve dans LWJGL étant donné que on peut faire des blocs avec, on doit pouvoir faire des lignes
parce que je pense que créer un classe Ligne à partir de rien c’est un peu dur (mais bon ça doit être possible malgré la difficulté)
après je ne m’y connais pas trop en terme de LWGJL donc je ne vais pas beaucoup aider…

[UtopiePhysique]

J’ai toujours besoin d’aide j’ai essayé divers choses mais rien du tout … Côté serveur sa crash, du coup c’est un bordel donc pour simplifié à l’init j’ai mis une class avec un render pour essayer en attendant de voir ce que je vais faire …

Voici tout les liens que j’ai étudier et toujours rien:

https://forums.minecraftforge.net/topic/60740-1121-solved-help-to-draw-line/

https://forums.minecraftforge.net/topic/87148-1152-drawing-a-line/

https://www.minecraftforum.net/forums/mapping-and-modding-java-edition/minecraft-mods/modification-development/1428481-questions-drawing-a-line-through-3d-space-and
https://forums.minecraftforge.net/topic/68680-line-drawing-function/

https://forums.minecraftforge.net/topic/81895-problems-with-rendering-a-line-1152/

https://github.com/Draco18s/HarderStuff/blob/master/src/main/java/com/draco18s/hazards/client/HazardsClientEventHandler.java#L188

Et j’ai même pas réussi à affiché une ligne avec tout cela …

[UtopiePhysique]

Bon ! J’ai réussi à avoir un résultat !
Malheureusement je maîtrise pas encore les calculs mathématique permettant de placer l’objet dans le monde et non pas sur la caméra joueur … Encore un peu de boulot à faire.

Dès que je maîtriserais je ferais un tuto (cela risque d’être long !)

[baztoul76]

J’imagine que tu pourrais regarder le code source de schematica, je pense qu’il y a quelque chose à trouver dessus, vu que les lignes sont à peu près pareilles que les chunks, elles ont juste des limites différentes.
Après je ne connais pas le résultat que tu as obtenu alors si ça se trouve ça ne va servir à rien ce que je te dis .

[UtopiePhysique]

@baztoul76 C’est une bonne idée mais j’ai vraiment pas envie de mettre mon nez dans leurs code qui doit pas être facile ^^

Mais j’ai commencer à trouver un début de réponse, je vais programmer des fonctions simplifier de dessin de formes pré-définie et une fonction simple pour gérer le positionnement.

Avec 3 jours de repos sur 14 jours j’ai pas énormément de temps avec 45 à 50h/ semaines de travail xD

Voilà ce que j’arrive à faire, par contre si je bouge cela à une réaction assez bizarre j’ai encore du mal à bien comprendre vu le nombre de positions et les calculs à renseigner ^^

(La ligne blanche c’est ce que j’ai “créer” c’est pas un bug :P)

[baztoul76]

donc si je comprends bien la ligne se place au bon endroit, mais elle reste figée sur l’écran et ne reste pas là où elle devrait être dans le monde MC
Et ça donne ce qu’il y a au-dessus…

[UtopiePhysique]

Pire que cela, si je bouges la souris elle est figée, si je bouges dans le jeu elle ce comportement bizarrement selon la direction elle change de sens, va faire l’écran ou devient plus petite.

J’ai testé le code suivant en changeant le MODID et cela fonctionne parfaitement:

@SubscribeEvent
public static void renderWorldLastEvent(RenderWorldLastEvent event) {
    MatrixStack ms = event.getMatrixStack();
    IRenderTypeBuffer.Impl buffers = IRenderTypeBuffer.getImpl(Tessellator.getInstance().getBuffer());
    RenderSystem.disableCull();
    ms.push();
 
    for (Entity e : Minecraft.getInstance().world.getAllEntities()) {
        if (!Minecraft.getInstance().player.equals(e) && !(e instanceof ItemEntity) && !(e instanceof ExperienceOrbEntity)) {
            drawCube(ms, buffers, new AxisAlignedBB(e.getPosition()).expand(0, 1, 0), new Color(0, 255, 0, 127));
            draw3dOutline(ms, buffers, new AxisAlignedBB(e.getPosition()).expand(0, 1, 0), new Color(255, 255, 255, 255));
        }
    }
    draw3dOutline(ms, buffers, new AxisAlignedBB(new BlockPos(0, 10, 0)), new Color(255, 255, 255, 255));
 
    ms.pop();
    buffers.finish();
}
 
public static void drawCube(MatrixStack ms, IRenderTypeBuffer buffers, AxisAlignedBB aabb, Color color) {
    draw3dRectangle(ms, buffers, aabb, color, "TOP");
    draw3dRectangle(ms, buffers, aabb, color, "BOTTOM");
    draw3dRectangle(ms, buffers, aabb, color, "NORTH");
    draw3dRectangle(ms, buffers, aabb, color, "EAST");
    draw3dRectangle(ms, buffers, aabb, color, "SOUTH");
    draw3dRectangle(ms, buffers, aabb, color, "WEST");
}
 
public static void draw3dRectangle(MatrixStack ms, IRenderTypeBuffer buffers, AxisAlignedBB aabb, Color color, String side) {
    int r = color.getRed();
    int g = color.getGreen();
    int b = color.getBlue();
    int a = color.getAlpha();
    double renderPosX = Minecraft.getInstance().getRenderManager().info.getProjectedView().getX();
    double renderPosY = Minecraft.getInstance().getRenderManager().info.getProjectedView().getY();
    double renderPosZ = Minecraft.getInstance().getRenderManager().info.getProjectedView().getZ();
 
    ms.push();
    ms.translate(aabb.minX - renderPosX, aabb.minY - renderPosY, aabb.minZ - renderPosZ);
 
    IVertexBuilder buffer = buffers.getBuffer(RenderType.makeType(HypixelClient.MODID + ":rectangle_highlight", DefaultVertexFormats.POSITION_COLOR, GL11.GL_QUADS, 256, false, true, RenderType.State.getBuilder().transparency(ObfuscationReflectionHelper.getPrivateValue(RenderState.class, null, "field_228515_g_")).cull(new RenderState.CullState(false)).build(false)));
    Matrix4f mat = ms.getLast().getMatrix();
 
    float x = (float) (aabb.maxX - aabb.minX);
    float y = (float) (aabb.maxY - aabb.minY);
    float z = (float) (aabb.maxZ - aabb.minZ);
 
    switch (side) {
        case "TOP":
            buffer.pos(mat, x, y, 0).color(r, g, b, a).endVertex();
            buffer.pos(mat, 0, y, 0).color(r, g, b, a).endVertex();
            buffer.pos(mat, 0, y, z).color(r, g, b, a).endVertex();
            buffer.pos(mat, x, y, z).color(r, g, b, a).endVertex();
            break;
        case "BOTTOM":
            buffer.pos(mat, x, 0, 0).color(r, g, b, a).endVertex();
            buffer.pos(mat, 0, 0, 0).color(r, g, b, a).endVertex();
            buffer.pos(mat, 0, 0, z).color(r, g, b, a).endVertex();
            buffer.pos(mat, x, 0, z).color(r, g, b, a).endVertex();
            break;
        case "NORTH":
            buffer.pos(mat, 0, y, 0).color(r, g, b, a).endVertex();
            buffer.pos(mat, 0, 0, 0).color(r, g, b, a).endVertex();
            buffer.pos(mat, x, 0, 0).color(r, g, b, a).endVertex();
            buffer.pos(mat, x, y, 0).color(r, g, b, a).endVertex();
            break;
        case "EAST":
            buffer.pos(mat, x, y, 0).color(r, g, b, a).endVertex();
            buffer.pos(mat, x, 0, 0).color(r, g, b, a).endVertex();
            buffer.pos(mat, x, 0, z).color(r, g, b, a).endVertex();
            buffer.pos(mat, x, y, z).color(r, g, b, a).endVertex();
            break;
        case "SOUTH":
            buffer.pos(mat, 0, y, z).color(r, g, b, a).endVertex();
            buffer.pos(mat, 0, 0, z).color(r, g, b, a).endVertex();
            buffer.pos(mat, x, 0, z).color(r, g, b, a).endVertex();
            buffer.pos(mat, x, y, z).color(r, g, b, a).endVertex();
            break;
        case "WEST":
            buffer.pos(mat, 0, y, 0).color(r, g, b, a).endVertex();
            buffer.pos(mat, 0, 0, 0).color(r, g, b, a).endVertex();
            buffer.pos(mat, 0, 0, z).color(r, g, b, a).endVertex();
            buffer.pos(mat, 0, y, z).color(r, g, b, a).endVertex();
            break;
    }
    ms.pop();
}
 
public static void draw3dOutline(MatrixStack ms, IRenderTypeBuffer buffers, AxisAlignedBB aabb, Color color) {
    int r = color.getRed();
    int g = color.getGreen();
    int b = color.getBlue();
    int a = color.getAlpha();
    double renderPosX = Minecraft.getInstance().getRenderManager().info.getProjectedView().getX();
    double renderPosY = Minecraft.getInstance().getRenderManager().info.getProjectedView().getY();
    double renderPosZ = Minecraft.getInstance().getRenderManager().info.getProjectedView().getZ();
 
    ms.push();
    ms.translate(aabb.minX - renderPosX, aabb.minY - renderPosY, aabb.minZ - renderPosZ);
 
    RenderType.State glState = RenderType.State.getBuilder().line(new RenderState.LineState(OptionalDouble.of(1))).layer(ObfuscationReflectionHelper.getPrivateValue(RenderState.class, null, "field_228500_J_")).transparency(ObfuscationReflectionHelper.getPrivateValue(RenderState.class, null, "field_228515_g_")).writeMask(new RenderState.WriteMaskState(true, false)).depthTest(new RenderState.DepthTestState(GL11.GL_ALWAYS)).build(false);
    IVertexBuilder buffer = buffers.getBuffer(RenderType.makeType(HypixelClient.MODID + ":line_1_no_depth", DefaultVertexFormats.POSITION_COLOR, GL11.GL_LINES, 128, glState));
    Matrix4f mat = ms.getLast().getMatrix();
 
    float x = (float) (aabb.maxX - aabb.minX);
    float y = (float) (aabb.maxY - aabb.minY);
    float z = (float) (aabb.maxZ - aabb.minZ);
 
    // Top edges
    buffer.pos(mat, x, y, 0).color(r, g, b, a).endVertex();
    buffer.pos(mat, 0, y, 0).color(r, g, b, a).endVertex();
    buffer.pos(mat, 0, y, 0).color(r, g, b, a).endVertex();
    buffer.pos(mat, 0, y, z).color(r, g, b, a).endVertex();
    buffer.pos(mat, 0, y, z).color(r, g, b, a).endVertex();
    buffer.pos(mat, x, y, z).color(r, g, b, a).endVertex();
    buffer.pos(mat, x, y, z).color(r, g, b, a).endVertex();
    buffer.pos(mat, x, y, 0).color(r, g, b, a).endVertex();
 
    // Bottom edges
    buffer.pos(mat, x, 0, 0).color(r, g, b, a).endVertex();
    buffer.pos(mat, 0, 0, 0).color(r, g, b, a).endVertex();
    buffer.pos(mat, 0, 0, 0).color(r, g, b, a).endVertex();
    buffer.pos(mat, 0, 0, z).color(r, g, b, a).endVertex();
    buffer.pos(mat, 0, 0, z).color(r, g, b, a).endVertex();
    buffer.pos(mat, x, 0, z).color(r, g, b, a).endVertex();
    buffer.pos(mat, x, 0, z).color(r, g, b, a).endVertex();
    buffer.pos(mat, x, 0, 0).color(r, g, b, a).endVertex();
 
    // Side edges
    buffer.pos(mat, x, 0, 0).color(r, g, b, a).endVertex();
    buffer.pos(mat, x, y, 0).color(r, g, b, a).endVertex();
    buffer.pos(mat, 0, y, 0).color(r, g, b, a).endVertex();
    buffer.pos(mat, 0, 0, 0).color(r, g, b, a).endVertex();
    buffer.pos(mat, 0, y, z).color(r, g, b, a).endVertex();
    buffer.pos(mat, 0, 0, z).color(r, g, b, a).endVertex();
    buffer.pos(mat, x, 0, z).color(r, g, b, a).endVertex();
    buffer.pos(mat, x, y, z).color(r, g, b, a).endVertex();
 
    ms.pop();
}

Je vais essayer de l’étudier et de faire quelque chose de propre.
De créer des fonctions qui mâche le travail et un tuto cela donne ça:

Je vais travailler sur cela même si j’ai peu de temps

[baztoul76]

j’ai vu ton tuto, et je vois que tu as trouvé la solution
C’était plutôt simple quand on regarde bien

[UtopiePhysique]

@baztoul76 “Simple”, quand on copie colle oui, mais en sois j’ai toujours exactement du mal à comprendre, j’ai bêtement globalement compris la logique du fonctionnement, mais en lui même le fonctionnement j’ai pas encore tout compris et je sais pas si j’aurais la foi d’aller chercher plus que cela.