Что нового?

Вопрос Прошу хелп с IVertexBuilder Ниже фото ошибки и код

qwcos
Q
Начинающий
Статус
Оффлайн
Регистрация
24 Ноя 2023
Сообщения
12
Реакции[?]
0
Поинты[?]
0

Перед прочтением основного контента ниже, пожалуйста, обратите внимание на обновление внутри секции Майна на нашем форуме. У нас появились:

  • бесплатные читы для Майнкрафт — любое использование на свой страх и риск;
  • маркетплейс Майнкрафт — абсолютно любая коммерция, связанная с игрой, за исключением продажи читов (аккаунты, предоставления услуг, поиск кодеров читов и так далее);
  • приватные читы для Minecraft — в этом разделе только платные хаки для игры, покупайте группу "Продавец" и выставляйте на продажу свой софт;
  • обсуждения и гайды — всё тот же раздел с вопросами, но теперь модернизированный: поиск нужных хаков, пати с игроками-читерами и другая полезная информация.

Спасибо!

Нажмите для раскрытия...
Вот код 1731334994325.png

package com.mojang.blaze3d.vertex;

import com.mojang.blaze3d.matrix.MatrixStack;

import im.Qwc.utils.render.ColorUtils;
import net.minecraft.block.BlockState;
import net.minecraft.block.Blocks;
import net.minecraft.client.renderer.BlockModelRenderer;
import net.minecraft.client.renderer.IRenderTypeBuffer;
import net.minecraft.client.renderer.LightTexture;
import net.minecraft.client.renderer.RenderType;
import net.minecraft.client.renderer.model.BakedQuad;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.vector.Matrix3f;
import net.minecraft.util.math.vector.Matrix4f;
import net.minecraft.util.math.vector.Vector3f;
import net.minecraft.util.math.vector.Vector3i;
import net.minecraftforge.client.extensions.IForgeVertexBuilder;
import net.optifine.Config;
import net.optifine.IRandomEntity;
import net.optifine.RandomEntities;
import net.optifine.reflect.Reflector;
import net.optifine.render.RenderEnv;
import net.optifine.render.VertexPosition;
import net.optifine.shaders.Shaders;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public interface IVertexBuilder extends IForgeVertexBuilder
{
Logger LOGGER = LogManager.getLogger();
ThreadLocal<RenderEnv> RENDER_ENV = ThreadLocal.withInitial(() ->
{
return new RenderEnv(Blocks.AIR.getDefaultState(), new BlockPos(0, 0, 0));
});
boolean FORGE = Reflector.ForgeHooksClient.exists();

default RenderEnv getRenderEnv(BlockState p_getRenderEnv_1_, BlockPos p_getRenderEnv_2_)
{
RenderEnv renderenv = RENDER_ENV.get();
renderenv.reset(p_getRenderEnv_1_, p_getRenderEnv_2_);
return renderenv;
}

IVertexBuilder pos(double x, double y, double z);

IVertexBuilder color(int red, int green, int blue, int alpha);

IVertexBuilder tex(float u, float v);

IVertexBuilder overlay(int u, int v);

IVertexBuilder lightmap(int u, int v);

IVertexBuilder normal(float x, float y, float z);

void endVertex();

default void addVertex(float x, float y, float z, float red, float green, float blue, float alpha, float texU, float texV, int overlayUV, int lightmapUV, float normalX, float normalY, float normalZ)
{
this.pos((double)x, (double)y, (double)z);
this.color(red, green, blue, alpha);
this.tex(texU, texV);
this.overlay(overlayUV);
this.lightmap(lightmapUV);
this.normal(normalX, normalY, normalZ);
this.endVertex();
}

default IVertexBuilder color(float red, float green, float blue, float alpha)
{
return this.color((int)(red * 255.0F), (int)(green * 255.0F), (int)(blue * 255.0F), (int)(alpha * 255.0F));
}

default IVertexBuilder color(int color)
{

float[] colors = ColorUtils.rgba(color);

return this.color((int)(colors[0] * 255.0F), (int)(colors[1] * 255.0F), (int)(colors[2] * 255.0F), (int)(colors[3] * 255.0F));
}

default IVertexBuilder lightmap(int lightmapUV)
{
return this.lightmap(lightmapUV & 65535, lightmapUV >> 16 & 65535);
}

default IVertexBuilder overlay(int overlayUV)
{
return this.overlay(overlayUV & 65535, overlayUV >> 16 & 65535);
}

default void addQuad(MatrixStack.Entry matrixEntryIn, BakedQuad quadIn, float redIn, float greenIn, float blueIn, int combinedLightIn, int combinedOverlayIn)
{
this.addQuad(matrixEntryIn, quadIn, this.getTempFloat4(1.0F, 1.0F, 1.0F, 1.0F), redIn, greenIn, blueIn, this.getTempInt4(combinedLightIn, combinedLightIn, combinedLightIn, combinedLightIn), combinedOverlayIn, false);
}

default void addVertexData(MatrixStack.Entry p_addVertexData_1_, BakedQuad p_addVertexData_2_, float[] p_addVertexData_3_, float p_addVertexData_4_, float p_addVertexData_5_, float p_addVertexData_6_, float p_addVertexData_7_, int[] p_addVertexData_8_, int p_addVertexData_9_, boolean p_addVertexData_10_)
{
this.addQuad(p_addVertexData_1_, p_addVertexData_2_, p_addVertexData_3_, p_addVertexData_4_, p_addVertexData_5_, p_addVertexData_6_, p_addVertexData_7_, p_addVertexData_8_, p_addVertexData_9_, p_addVertexData_10_);
}

default void addQuad(MatrixStack.Entry matrixEntryIn, BakedQuad quadIn, float[] colorMuls, float redIn, float greenIn, float blueIn, int[] combinedLightsIn, int combinedOverlayIn, boolean mulColor)
{
this.addQuad(matrixEntryIn, quadIn, colorMuls, redIn, greenIn, blueIn, 1.0F, combinedLightsIn, combinedOverlayIn, mulColor);
}

default void addQuad(MatrixStack.Entry p_addQuad_1_, BakedQuad p_addQuad_2_, float[] p_addQuad_3_, float p_addQuad_4_, float p_addQuad_5_, float p_addQuad_6_, float p_addQuad_7_, int[] p_addQuad_8_, int p_addQuad_9_, boolean p_addQuad_10_)
{
int[] aint = this.isMultiTexture() ? p_addQuad_2_.getVertexDataSingle() : p_addQuad_2_.getVertexData();
this.putSprite(p_addQuad_2_.getSprite());
boolean flag = BlockModelRenderer.isSeparateAoLightValue();
Vector3i vector3i = p_addQuad_2_.getFace().getDirectionVec();
float f = (float)vector3i.getX();
float f1 = (float)vector3i.getY();
float f2 = (float)vector3i.getZ();
Matrix4f matrix4f = p_addQuad_1_.getMatrix();
Matrix3f matrix3f = p_addQuad_1_.getNormal();
float f3 = matrix3f.getTransformX(f, f1, f2);
float f4 = matrix3f.getTransformY(f, f1, f2);
float f5 = matrix3f.getTransformZ(f, f1, f2);
int i = 8;
int j = DefaultVertexFormats.BLOCK.getIntegerSize();
int k = aint.length / j;
boolean flag1 = Config.isShaders() && Shaders.useVelocityAttrib && Config.isMinecraftThread();

if (flag1)
{
IRandomEntity irandomentity = RandomEntities.getRandomEntityRendered();

if (irandomentity != null)
{
VertexPosition[] avertexposition = p_addQuad_2_.getVertexPositions(irandomentity.getId());
this.setQuadVertexPositions(avertexposition);
}
}

for (int i1 = 0; i1 < k; ++i1)
{
int j1 = i1 * j;
float f6 = Float.intBitsToFloat(aint[j1 + 0]);
float f7 = Float.intBitsToFloat(aint[j1 + 1]);
float f8 = Float.intBitsToFloat(aint[j1 + 2]);
float f12 = 1.0F;
float f13 = flag ? 1.0F : p_addQuad_3_[i1];
float f9;
float f10;
float f11;

if (p_addQuad_10_)
{
int l = aint[j1 + 3];
float f14 = (float)(l & 255) / 255.0F;
float f15 = (float)(l >> 8 & 255) / 255.0F;
float f16 = (float)(l >> 16 & 255) / 255.0F;
f9 = f14 * f13 * p_addQuad_4_;
f10 = f15 * f13 * p_addQuad_5_;
f11 = f16 * f13 * p_addQuad_6_;

if (FORGE)
{
float f17 = (float)(l >> 24 & 255) / 255.0F;
f12 = f17 * p_addQuad_7_;
}
}
else
{
f9 = f13 * p_addQuad_4_;
f10 = f13 * p_addQuad_5_;
f11 = f13 * p_addQuad_6_;

if (FORGE)
{
f12 = p_addQuad_7_;
}
}

int k1 = p_addQuad_8_[i1];

if (FORGE)
{
k1 = this.applyBakedLighting(p_addQuad_8_[i1], aint, j1);
}

float f19 = Float.intBitsToFloat(aint[j1 + 4]);
float f20 = Float.intBitsToFloat(aint[j1 + 5]);
float f21 = matrix4f.getTransformX(f6, f7, f8, 1.0F);
float f22 = matrix4f.getTransformY(f6, f7, f8, 1.0F);
float f18 = matrix4f.getTransformZ(f6, f7, f8, 1.0F);

if (FORGE)
{
Vector3f vector3f = this.applyBakedNormals(aint, j1, p_addQuad_1_.getNormal());

if (vector3f != null)
{
f3 = vector3f.getX();
f4 = vector3f.getY();
f5 = vector3f.getZ();
}
}

if (flag)
{
f12 = p_addQuad_3_[i1];
}

this.addVertex(f21, f22, f18, f9, f10, f11, f12, f19, f20, p_addQuad_9_, k1, f3, f4, f5);
}
}

default IVertexBuilder pos(Matrix4f matrixIn, float x, float y, float z)
{
float f = matrixIn.getTransformX(x, y, z, 1.0F);
float f1 = matrixIn.getTransformY(x, y, z, 1.0F);
float f2 = matrixIn.getTransformZ(x, y, z, 1.0F);
return this.pos((double)f, (double)f1, (double)f2);
}

default IVertexBuilder normal(Matrix3f matrixIn, float x, float y, float z)
{
float f = matrixIn.getTransformX(x, y, z);
float f1 = matrixIn.getTransformY(x, y, z);
float f2 = matrixIn.getTransformZ(x, y, z);
return this.normal(f, f1, f2);
}

default void putSprite(TextureAtlasSprite p_putSprite_1_)
{
}

default void setSprite(TextureAtlasSprite p_setSprite_1_)
{
}

default boolean isMultiTexture()
{
return false;
}

default void setRenderType(RenderType p_setRenderType_1_)
{
}

default RenderType getRenderType()
{
return null;
}

default void setRenderBlocks(boolean p_setRenderBlocks_1_)
{
}

default Vector3f getTempVec3f(Vector3f p_getTempVec3f_1_)
{
return p_getTempVec3f_1_.copy();
}

default Vector3f getTempVec3f(float p_getTempVec3f_1_, float p_getTempVec3f_2_, float p_getTempVec3f_3_)
{
return new Vector3f(p_getTempVec3f_1_, p_getTempVec3f_2_, p_getTempVec3f_3_);
}

default float[] getTempFloat4(float p_getTempFloat4_1_, float p_getTempFloat4_2_, float p_getTempFloat4_3_, float p_getTempFloat4_4_)
{
return new float[] {p_getTempFloat4_1_, p_getTempFloat4_2_, p_getTempFloat4_3_, p_getTempFloat4_4_};
}

default int[] getTempInt4(int p_getTempInt4_1_, int p_getTempInt4_2_, int p_getTempInt4_3_, int p_getTempInt4_4_)
{
return new int[] {p_getTempInt4_1_, p_getTempInt4_2_, p_getTempInt4_3_, p_getTempInt4_4_};
}

default IRenderTypeBuffer.Impl getRenderTypeBuffer()
{
return null;
}

default void setQuadVertexPositions(VertexPosition[] p_setQuadVertexPositions_1_)
{
}

default void setMidBlock(float p_setMidBlock_1_, float p_setMidBlock_2_, float p_setMidBlock_3_)
{
}

default IVertexBuilder getSecondaryBuilder()
{
return null;
}

default int applyBakedLighting(int p_applyBakedLighting_1_, int[] p_applyBakedLighting_2_, int p_applyBakedLighting_3_)
{
int i = getLightOffset(0);
int j = LightTexture.getLightBlock(p_applyBakedLPWKtcPjpxQzc26CxTtPFuQMNfm2RfEHfK_ + i]);
int k = LightTexture.getLightSky(p_applyBakedLPWKtcPjpxQzc26CxTtPFuQMNfm2RfEHfK_ + i]);

if (j == 0 && k == 0)
{
return p_applyBakedLighting_1_;
}
else
{
int l = LightTexture.getLightBlock(p_applyBakedLighting_1_);
int i1 = LightTexture.getLightSky(p_applyBakedLighting_1_);
l = Math.max(l, j);
i1 = Math.max(i1, k);
return LightTexture.packLight(l, i1);
}
}

static int getLightOffset(int p_getLightOffset_0_)
{
return p_getLightOffset_0_ * 8 + 6;
}

default Vector3f applyBakedNormals(int[] p_applyBakedNormals_1_, int p_applyBakedNormals_2_, Matrix3f p_applyBakedNormals_3_)
{
int i = 7;
int j = p_applyBakedNormals_1_[p_applyBakedNormals_2_ + i];
byte b0 = (byte)(j >> 0 & 255);
byte b1 = (byte)(j >> 8 & 255);
byte b2 = (byte)(j >> 16 & 255);

if (b0 == 0 && b1 == 0 && b2 == 0)
{
return null;
}
else
{
Vector3f vector3f = this.getTempVec3f((float)b0 / 127.0F, (float)b1 / 127.0F, (float)b2 / 127.0F);
vector3f.transform(p_applyBakedNormals_3_);
return vector3f;
}
}
}


Прошу хелп
 
qwcos
Q
Начинающий
Статус
Оффлайн
Регистрация
24 Ноя 2023
Сообщения
12
Реакции[?]
0
Поинты[?]
0
Последнее редактирование:
lolitopez
lolitopez
Начинающий
Статус
Оффлайн
Регистрация
31 Янв 2024
Сообщения
174
Реакции[?]
2
Поинты[?]
2K
qwcos написал(а):
А сам хз как мой кривые руки туда залезли

Сможешь помочь?

Сможешь помочь?
Нажмите для раскрытия...
чем? ты аргумент не тот написал просто да и в скобках там ошибся, он подсвечивает же все
 
Войдите или зарегистрируйтесь для ответа.
Немного о главном
Полезные мелочи
О нас

Проект предоставляет различный материал, относящийся к сфере киберспорта, программирования, ПО для игр, а также позволяет его участникам общаться на многие другие темы. Почта для жалоб: admin@yougame.biz

Поделиться страницей
Сверху Снизу