public static void renderQuads(VertexBuffer renderer, List<BakedQuad> quads, int color, ItemStack stack) { boolean flag = (color == -1) && (!stack.isEmpty()); int i = 0; for (int j = quads.size(); i < j; i++) { BakedQuad bakedquad = quads.get(i); int k = color; if ((flag) && (bakedquad.hasTintIndex())) { ItemColors itemColors = Minecraft.getMinecraft().getItemColors(); k = itemColors.getColorFromItemstack(stack, bakedquad.getTintIndex()); if (EntityRenderer.anaglyphEnable) { k = TextureUtil.anaglyphColor(k); } k |= 0xFF000000; } LightUtil.renderQuadColor(renderer, bakedquad, k); } }
private void renderQuads(BufferBuilder renderer, List<BakedQuad> quads, int color, ItemStack stack) { boolean flag = color == -1 && !stack.isEmpty(); int i = 0; for (int j = quads.size(); i < j; ++i) { BakedQuad bakedquad = quads.get(i); int k = color; if (flag && bakedquad.hasTintIndex()) { k = this.mc.getItemColors().getColorFromItemstack(stack, bakedquad.getTintIndex()); if (EntityRenderer.anaglyphEnable) k = TextureUtil.anaglyphColor(k); k = k | -16777216; } LightUtil.renderQuadColor(renderer, bakedquad, k); } }
public static void renderModel(IBakedModel model, int color) { Tessellator tessellator = Tessellator.getInstance(); VertexBuffer buffer = tessellator.getBuffer(); buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.ITEM); // buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.ITEM); // GlStateManager.disableLighting(); List<BakedQuad> quads = model.getQuads(null,null,0); for (BakedQuad quad : quads) { LightUtil.renderQuadColor(buffer, quad, color); } tessellator.draw(); }
public static List<BakedQuad> shadeQuadFaces(List<BakedQuad> quads) { LinkedList<BakedQuad> shadedQuads = new LinkedList<>(); for (BakedQuad quad : quads) { int[] rawData = quad.getVertexData(); for (int v = 0; v < 4; v++) { for (int e = 0; e < quad.getFormat().getElementCount(); e++) { VertexFormatElement element = quad.getFormat().getElement(e); if (element.getUsage() == EnumUsage.COLOR) { float[] data = new float[4]; LightUtil.unpack(rawData, data, quad.getFormat(), v, e); data = diffuseFaceLight(quad.getFace(), data); LightUtil.pack(data, rawData, quad.getFormat(), v, e); } } } shadedQuads.add(new BakedQuad(rawData, quad.getTintIndex(), quad.getFace(), quad.getSprite(), quad.shouldApplyDiffuseLighting(), quad.getFormat())); } return shadedQuads; }
public final UnpackedBakedQuad transformQuad(BakedQuad quad) { // Fetch required information final VertexFormat format = quad.getFormat(); final float[][][] vertexData = new float[4][format.getElementCount()][4]; // Objects to be reused in the loop final Vector4f temp = new Vector4f(); //unpack and transform vertex data for (int v = 0; v < 4; v++) { for (int e = 0; e < format.getElementCount(); e++) { LightUtil.unpack(quad.getVertexData(), vertexData[v][e], format, v, e); transformUnpackedVertexDataElement(format.getElement(e).getUsage(), vertexData[v][e], temp); } } //create new quad with the transformed vertex data return new UnpackedBakedQuad(vertexData, quad.getTintIndex(), quad.getFace(), quad.getSprite(), quad.shouldApplyDiffuseLighting(), format); }
private void putVertexData(@Nonnull Builder builder, @Nonnull Vertex v, float w) { VertexFormat format = builder.getVertexFormat(); for (int e = 0; e < format.getElementCount(); e++) { switch (format.getElement(e).getUsage()) { case POSITION: builder.put(e, (float) v.x(), (float) v.y(), (float) v.z(), 1); break; case COLOR: float d = LightUtil.diffuseLight(v.nx(), v.ny(), v.nz()); builder.put(e, d * color.x, d * color.y, d * color.z, color.w); break; case UV: builder.put(e, tex.getInterpolatedU(v.u() * 16) * w, tex.getInterpolatedV(v.v() * 16) * w, 0, w); break; case NORMAL: builder.put(e, v.nx(), v.ny(), v.nz(), 0); break; default: builder.put(e); } } }
private static void renderModel(IBakedModel model, VertexFormat fmt, int color) { Tessellator tessellator = Tessellator.getInstance(); BufferBuilder worldrenderer = tessellator.getBuffer(); worldrenderer.begin(GL11.GL_QUADS, fmt); for (BakedQuad bakedquad : model.getQuads(null, null, 0)) { LightUtil.renderQuadColor(worldrenderer, bakedquad, color); } tessellator.draw(); }
private void renderQuads(final World world, final IBlockState actualState, final BlockPos pos, final List<BakedQuad> quads, final int alpha) { final Tessellator tessellator = Tessellator.getInstance(); final BufferBuilder buffer = tessellator.getBuffer(); for (final BakedQuad quad : quads) { buffer.begin(GL11.GL_QUADS, quad.getFormat()); final int color = quad.hasTintIndex() ? this.getTint(world, actualState, pos, alpha, quad.getTintIndex()) : alpha | 0xffffff; LightUtil.renderQuadColor(buffer, quad, color); tessellator.draw(); } }
private static BakedQuad transform(final BakedQuad quad, final IVertexTransformer transformer) { final VertexFormat format = quad.getFormat(); final UnpackedBakedQuad.Builder builder = new UnpackedBakedQuad.Builder(format); LightUtil.putBakedQuad(new VertexTransformerWrapper(builder, quad, transformer), quad); return builder.build(); }
private static final void renderQuads(final List<BakedQuad> quads, final int alpha) { final Tessellator tessellator = Tessellator.getInstance(); final BufferBuilder buffer = tessellator.getBuffer(); if (quads == null || quads.isEmpty()) return; buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.ITEM); quads.forEach(quad -> LightUtil.renderQuadColor(buffer, quad, alpha | 0xffffff)); tessellator.draw(); }
protected boolean checkDepth(BakedQuad quad, Vector3 hit, EnumFacing hitFace) { int[] quadData = quad.getVertexData(); VertexFormat format = quad.getFormat(); int e = VertexDataUtils.getPositionElement(format); Vector3 posVec = new Vector3(); float[] pos = new float[4]; for (int v = 0; v < 4; v++) { LightUtil.unpack(quadData, pos, format, v, e); posVec.add(pos[0], pos[1], pos[2]); } posVec.divide(4); double diff = 0; switch (hitFace.getAxis()) { case X: diff = Math.abs(hit.x - posVec.x); break; case Y: diff = Math.abs(hit.y - posVec.y); break; case Z: diff = Math.abs(hit.z - posVec.z); break; } return !(diff > 0.01); }
public static void fullyPackQuads(int[] packedData, float[][][] unpackedData, VertexFormat format) { for (int e = 0; e < format.getElementCount(); e++) { for (int v = 0; v < 4; v++) { LightUtil.pack(unpackedData[v][e], packedData, format, v, e); } } }
public static void fullyUnPackQuads(int[] packedData, float[][][] unpackedData, VertexFormat format) { for (int e = 0; e < format.getElementCount(); e++) { for (int v = 0; v < 4; v++) { LightUtil.unpack(packedData, unpackedData[v][e], format, v, e); } } }
public static void renderBakedModel(IBakedModel bakedModel) { Tessellator tessellator = Tessellator.getInstance(); BufferBuilder worldrenderer = tessellator.getBuffer(); // VertexFormat VF = new VertexFormat(); // worldrenderer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX_COLOR_NORMAL);// bakedModel.getFormat()); // OPTION A BakedQuad bakedQuad1 = (BakedQuad) bakedModel.getQuads(null, null, 0).get(0); // DARK no normal :( due to baked quad not having it worldrenderer.begin(GL11.GL_QUADS, MYFORMAT);// bakedModel.getFormat()); worldrenderer.begin(GL11.GL_QUADS, bakedQuad1.getFormat()); // for (BakedQuad bakedQuad : bakedModel.getQuads(null, null, 0)) { // worldrenderer.addVertexData(bakedQuad.getVertexData()); // // } // alt version if ever needed for (BakedQuad bakedQuad : bakedModel.getQuads(null, null, 0)) { int j = -1; j = j | -16777216; LightUtil.renderQuadColor(worldrenderer, bakedQuad, j); } tessellator.draw(); }
private int computeOcclusionHash(EnumFacing face) { List<BakedQuad> quads = getQuads(face); QuadListKeyBuilder keyBuilder = new QuadListKeyBuilder(face); for(BakedQuad q : quads) { LightUtil.putBakedQuad(keyBuilder, q); } return keyBuilder.getQuadListKey(); }
private void renderQuads(final IBlockState state, final BlockPos pos, final BufferBuilder buffer, final List<BakedQuad> quads, final int alpha) { final int size = quads.size(); for (int i = 0; i < size; i++) { final BakedQuad quad = quads.get(i); final int color = quad.getTintIndex() == -1 ? alpha | 0xffffff : this.getTint(state, pos, alpha, quad.getTintIndex()); LightUtil.renderQuadColor(buffer, quad, color); } }
public static void renderModel(IBakedModel model, int color) { Tessellator tessellator = Tessellator.getInstance(); VertexBuffer worldrenderer = tessellator.getBuffer(); worldrenderer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX_COLOR_NORMAL); for (BakedQuad bakedquad : model.getQuads(null, null, 0)) { LightUtil.renderQuadColor(worldrenderer, bakedquad, color); } tessellator.draw(); }
/** * Bakes the data inside the VertexBuffer to a baked quad. * * @return The list of quads baked. */ public List<BakedQuad> bake() { if (isDrawing) { CCLLog.log(Level.WARN, new IllegalStateException("Bake called before finishDrawing!"), "Someone is calling bake before finishDrawing!"); finishDrawing(); } State state = getVertexState(); VertexFormat format = state.getVertexFormat(); if (!format.hasUvOffset(0)) { throw new IllegalStateException("Unable to bake format that does not have UV mappings!"); } int[] rawBuffer = Arrays.copyOf(state.getRawBuffer(), state.getRawBuffer().length); List<BakedQuad> quads = new LinkedList<>(); TextureAtlasSprite sprite = TextureUtils.getMissingSprite(); int curr = 0; int next = format.getNextOffset(); int i = 0; while (rawBuffer.length >= next) { int[] quadData = Arrays.copyOfRange(rawBuffer, curr, next); Vector3 normal = new Vector3(); if (format.hasNormal()) { //Grab first normal. float[] normalData = new float[4]; LightUtil.unpack(quadData, normalData, format, 0, VertexDataUtils.getNormalElement(format)); normal = Vector3.fromArray(normalData); } else { //No normal provided in format, so we calculate. float[][] posData = new float[4][4]; for (int v = 0; v < 4; v++) { LightUtil.unpack(quadData, posData[v], format, v, VertexDataUtils.getPositionElement(format)); } normal.set(VectorUtils.calculateNormal(Vector3.fromArray(posData[0]), Vector3.fromArray(posData[1]), Vector3.fromArray(posData[3]))); } if (useSprites) { //Attempt to get sprite for vertex. if (spriteMap.containsKey(i)) { //Use provided sprite for vertex. sprite = spriteMap.get(i); } else { //Sprite not found for vertex, so we attempt to calculate the sprite. float[] uvData = new float[4]; LightUtil.unpack(quadData, uvData, format, 0, VertexDataUtils.getUVElement(format)); UV uv = new UV(uvData[0], uvData[1]); sprite = VertexDataUtils.getSpriteForUV(TextureUtils.getTextureMap(), uv); } } //Use normal to calculate facing. EnumFacing facing = VectorUtils.calcNormalSide(normal); if (facing == null) { facing = EnumFacing.UP; } BakedQuad quad = new BakedQuad(quadData, -1, facing, sprite, useDiffuseLighting, format); quads.add(quad); curr = next; next += format.getNextOffset(); i++; } return ImmutableList.copyOf(quads); }
@Override public void renderTileEntityAt(TileInfestedLeaves tile, double x, double y, double z, float partialTicks, int destroyStage) { if(tile != null) { long seed = tile.getWorld().rand.nextLong(); int color = tile.getColor(); IBlockState leafBlock = tile.getLeafBlock(); IBakedModel leafModel = Minecraft.getMinecraft().getBlockRendererDispatcher().getModelForState(leafBlock); if(leafModel == null) { leafModel = Minecraft.getMinecraft().getBlockRendererDispatcher().getModelForState(Blocks.LEAVES.getDefaultState()); } List<BakedQuad> leafQuads = Lists.newArrayList(); for(EnumFacing side : EnumFacing.VALUES) { if(leafBlock.shouldSideBeRendered(tile.getWorld(), tile.getPos(), side)) { leafQuads.addAll(leafModel.getQuads(leafBlock, side, seed)); } } Tessellator tessellator = Tessellator.getInstance(); VertexBuffer buffer = tessellator.getBuffer(); bindTexture(TextureMap.LOCATION_BLOCKS_TEXTURE); GlStateManager.pushMatrix(); GlStateManager.translate(x, y, z); RenderHelper.disableStandardItemLighting(); buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.ITEM); for(BakedQuad quad : leafQuads) { LightUtil.renderQuadColor(buffer, quad, color); } tessellator.draw(); RenderHelper.enableStandardItemLighting(); GlStateManager.popMatrix(); } }
private void recolorQuad(RawQuad result) { int color = this.myColorMap.getColor(this.isFullBrightnessIntended ? EnumColorMap.LAMP : EnumColorMap.BASE); if(this.renderPass.blockRenderLayer == BlockRenderLayer.TRANSLUCENT) { color = this.translucencyArgb | (color & 0x00FFFFFF); } if(this.isFullBrightnessIntended) { // If the surface has a lamp gradient or is otherwise pre-shaded // we don't want to see a gradient when rendering at full brightness // so make all vertices white before we recolor. result.replaceColor(color); } else if(result.surfaceInstance.isLampGradient && this.lampColorMap != null) { // if surface has a lamp gradient and rendered with shading, need // to replace the colors to form the gradient. int shadedColor = QuadHelper.shadeColor(color, (LightUtil.diffuseLight(result.getNormalFace()) + 2) / 3, false); int lampColor = this.lampColorMap.getColor(EnumColorMap.LAMP); for(int i = 0; i < result.getVertexCount(); i++) { Vertex v = result.getVertex(i); if(v != null) { int vColor = v.color == Color.WHITE ? lampColor : shadedColor; result.setVertex(i, v.withColor(vColor)); } } // if needed, change render pass of gradient surface to flat so that it doesn't get darkened by AO if(!this.lampRenderPass.isShaded && this.renderPass.isShaded) { result.renderPass = this.renderPass.flipShading(); } } else { // normal shaded surface - tint existing colors, usually WHITE to start with result.multiplyColor(color); } }
private static void renderQuads(BufferBuilder wr, List<BakedQuad> quads) { for (BakedQuad quad : quads) LightUtil.renderQuadColor(wr, quad, 0xFFFFFFFF); }
private void renderQuads(VertexBuffer renderer, List<BakedQuad> quads) { for (BakedQuad quad : quads) { LightUtil.renderQuadColor(renderer, quad, -1); } }