VulkanShader_1.21.10-0.0.4-alpha.jar
Download file
package net.vulkanmod.render.engine;
import com.mojang.blaze3d.buffers.GpuBuffer;
import com.mojang.blaze3d.buffers.GpuBufferSlice;
import com.mojang.blaze3d.buffers.GpuFence;
import com.mojang.blaze3d.opengl.GlConst;
import com.mojang.blaze3d.opengl.GlStateManager;
import com.mojang.blaze3d.pipeline.BlendFunction;
import com.mojang.blaze3d.pipeline.RenderPipeline;
import com.mojang.blaze3d.platform.DepthTestFunction;
import com.mojang.blaze3d.systems.CommandEncoder;
import com.mojang.blaze3d.systems.RenderPass;
import com.mojang.blaze3d.textures.GpuTexture;
import com.mojang.blaze3d.textures.GpuTextureView;
import com.mojang.blaze3d.vertex.VertexFormat;
import com.mojang.blaze3d.vertex.VertexFormat.class_5595;
import com.mojang.logging.LogUtils;
import java.nio.ByteBuffer;
import java.util.Collection;
import java.util.OptionalDouble;
import java.util.OptionalInt;
import java.util.function.BiConsumer;
import java.util.function.Supplier;
import net.minecraft.class_1011;
import net.minecraft.class_10866;
import net.minecraft.class_10868;
import net.minecraft.class_284;
import net.minecraft.class_310;
import net.minecraft.class_5944;
import net.minecraft.class_9848;
import net.vulkanmod.gl.VkGlFramebuffer;
import net.vulkanmod.gl.VkGlTexture;
import net.vulkanmod.interfaces.shader.ExtendedRenderPipeline;
import net.vulkanmod.vulkan.Renderer;
import net.vulkanmod.vulkan.Synchronization;
import net.vulkanmod.vulkan.VRenderSystem;
import net.vulkanmod.vulkan.Vulkan;
import net.vulkanmod.vulkan.device.DeviceManager;
import net.vulkanmod.vulkan.framebuffer.Framebuffer;
import net.vulkanmod.vulkan.memory.buffer.StagingBuffer;
import net.vulkanmod.vulkan.memory.buffer.index.AutoIndexBuffer;
import net.vulkanmod.vulkan.queue.CommandPool;
import net.vulkanmod.vulkan.queue.GraphicsQueue;
import net.vulkanmod.vulkan.shader.GraphicsPipeline;
import net.vulkanmod.vulkan.shader.Pipeline;
import net.vulkanmod.vulkan.shader.descriptor.ImageDescriptor;
import net.vulkanmod.vulkan.shader.descriptor.UBO;
import net.vulkanmod.vulkan.texture.ImageUtil;
import net.vulkanmod.vulkan.texture.VTextureSelector;
import org.jetbrains.annotations.Nullable;
import org.lwjgl.opengl.GL11;
import org.lwjgl.system.MemoryStack;
import org.lwjgl.system.MemoryUtil;
import org.lwjgl.vulkan.VK10;
import org.lwjgl.vulkan.VK11;
import org.lwjgl.vulkan.VkBufferCopy;
import org.lwjgl.vulkan.VkCommandBuffer;
import org.slf4j.Logger;
public class VkCommandEncoder implements CommandEncoder {
private static final Logger LOGGER = LogUtils.getLogger();
private final VkGpuDevice device;
private @Nullable RenderPipeline lastPipeline;
private boolean inRenderPass;
private @Nullable EGlProgram lastProgram;
private int framebufferId = VkGlFramebuffer.genFramebufferId();
protected VkCommandEncoder(VkGpuDevice glDevice) {
this.device = glDevice;
}
public RenderPass createRenderPass(Supplier<String> supplier, GpuTextureView gpuTexture, OptionalInt optionalInt) {
return this.createRenderPass(supplier, gpuTexture, optionalInt, (GpuTextureView)null, OptionalDouble.empty());
}
public RenderPass createRenderPass(Supplier<String> supplier, GpuTextureView colorTexture, OptionalInt optionalInt, @Nullable GpuTextureView depthTexture, OptionalDouble optionalDouble) {
if (this.inRenderPass) {
throw new IllegalStateException("Close the existing render pass before creating a new one!");
} else {
if (optionalDouble.isPresent() && depthTexture == null) {
LOGGER.warn("Depth clear value was provided but no depth texture is being used");
}
if (class_310.method_1551().method_1522().method_30277() == colorTexture.texture()) {
Renderer.getInstance().getMainPass().rebindMainTarget();
int j = 0;
if (optionalInt.isPresent()) {
int k = optionalInt.getAsInt();
GL11.glClearColor(class_9848.method_65101(k), class_9848.method_65102(k), class_9848.method_65103(k), class_9848.method_65100(k));
j |= 16384;
}
if (depthTexture != null && optionalDouble.isPresent()) {
GL11.glClearDepth(optionalDouble.getAsDouble());
j |= 256;
}
if (j != 0) {
GlStateManager._disableScissorTest();
GlStateManager._depthMask(true);
GlStateManager._colorMask(true, true, true, true);
GlStateManager._clear(j);
}
return new VkRenderPass(this, depthTexture != null);
} else if (colorTexture.isClosed()) {
throw new IllegalStateException("Color texture is closed");
} else if (depthTexture != null && depthTexture.isClosed()) {
throw new IllegalStateException("Depth texture is closed");
} else {
this.inRenderPass = true;
GpuTexture depthTexture1 = depthTexture != null ? depthTexture.texture() : null;
VkFbo fbo = ((VkGpuTexture)colorTexture.texture()).getFbo(depthTexture1);
fbo.bind();
int j = 0;
if (optionalInt.isPresent()) {
int k = optionalInt.getAsInt();
GL11.glClearColor(class_9848.method_65101(k), class_9848.method_65102(k), class_9848.method_65103(k), class_9848.method_65100(k));
j |= 16384;
}
if (depthTexture != null && optionalDouble.isPresent()) {
GL11.glClearDepth(optionalDouble.getAsDouble());
j |= 256;
}
if (j != 0) {
GlStateManager._disableScissorTest();
GlStateManager._depthMask(true);
GlStateManager._colorMask(true, true, true, true);
GlStateManager._clear(j);
}
GlStateManager._viewport(0, 0, colorTexture.getWidth(0), colorTexture.getHeight(0));
this.lastPipeline = null;
return new VkRenderPass(this, depthTexture != null);
}
}
}
public void clearColorTexture(GpuTexture colorAttachment, int clearColor) {
if (this.inRenderPass) {
throw new IllegalStateException("Close the existing render pass before creating a new one!");
} else {
if (Renderer.isRecording()) {
if (class_310.method_1551().method_1522().method_30277() == colorAttachment) {
Renderer.getInstance().getMainPass().rebindMainTarget();
VRenderSystem.setClearColor(class_9848.method_65101(clearColor), class_9848.method_65102(clearColor), class_9848.method_65103(clearColor), class_9848.method_65100(clearColor));
Renderer.clearAttachments(16384);
} else {
VkGpuTexture vkGpuTexture = (VkGpuTexture)colorAttachment;
VkGlFramebuffer.bindFramebuffer(36160, this.framebufferId);
VkGlFramebuffer.framebufferTexture2D(36160, 36064, 3553, vkGpuTexture.method_68427(), 0);
VkGlFramebuffer.beginRendering(VkGlFramebuffer.getFramebuffer(this.framebufferId));
VRenderSystem.setClearColor(class_9848.method_65101(clearColor), class_9848.method_65102(clearColor), class_9848.method_65103(clearColor), class_9848.method_65100(clearColor));
Renderer.clearAttachments(16384);
Renderer.getInstance().endRenderPass();
VkFbo fbo = ((VkGpuTexture)colorAttachment).getFbo((GpuTexture)null);
((VkGpuTexture)colorAttachment).setClearColor(clearColor);
Framebuffer boundFramebuffer = Renderer.getInstance().getBoundFramebuffer();
if (boundFramebuffer != null && boundFramebuffer.getColorAttachment() == ((VkGpuTexture)colorAttachment).getVulkanImage()) {
fbo.clearAttachments();
}
}
} else {
GraphicsQueue graphicsQueue = DeviceManager.getGraphicsQueue();
CommandPool.CommandBuffer commandBuffer = graphicsQueue.getCommandBuffer();
VkGpuTexture vkGpuTexture = (VkGpuTexture)colorAttachment;
VkGlFramebuffer glFramebuffer = VkGlFramebuffer.getFramebuffer(this.framebufferId);
glFramebuffer.setAttachmentTexture(36064, vkGpuTexture.method_68427());
glFramebuffer.create();
Framebuffer framebuffer = glFramebuffer.getFramebuffer();
net.vulkanmod.vulkan.framebuffer.RenderPass renderPass = glFramebuffer.getRenderPass();
MemoryStack stack = MemoryStack.stackPush();
try {
framebuffer.beginRenderPass(commandBuffer.handle, renderPass, stack);
} catch (Throwable var13) {
if (stack != null) {
try {
stack.close();
} catch (Throwable var12) {
var13.addSuppressed(var12);
}
}
throw var13;
}
if (stack != null) {
stack.close();
}
VRenderSystem.setClearColor(class_9848.method_65101(clearColor), class_9848.method_65102(clearColor), class_9848.method_65103(clearColor), class_9848.method_65100(clearColor));
Renderer.clearAttachments(commandBuffer.handle, 16384, 0, 0, framebuffer.getWidth(), framebuffer.getHeight());
renderPass.endRenderPass(commandBuffer.handle);
long fence = graphicsQueue.submitCommands(commandBuffer);
Synchronization.waitFence(fence);
}
}
}
public void clearColorAndDepthTextures(GpuTexture colorAttachment, int clearColor, GpuTexture depthAttachment, double clearDepth) {
if (this.inRenderPass) {
throw new IllegalStateException("Close the existing render pass before creating a new one!");
} else {
if (class_310.method_1551().method_1522().method_30277() == colorAttachment) {
Renderer.getInstance().getMainPass().rebindMainTarget();
VRenderSystem.clearDepth(clearDepth);
VRenderSystem.setClearColor(class_9848.method_65101(clearColor), class_9848.method_65102(clearColor), class_9848.method_65103(clearColor), class_9848.method_65100(clearColor));
Renderer.clearAttachments(16640);
} else {
VkFbo fbo = ((VkGpuTexture)colorAttachment).getFbo(depthAttachment);
((VkGpuTexture)colorAttachment).setClearColor(clearColor);
((VkGpuTexture)depthAttachment).setDepthClearValue((float)clearDepth);
Framebuffer boundFramebuffer = Renderer.getInstance().getBoundFramebuffer();
if (boundFramebuffer != null && boundFramebuffer.getColorAttachment() == ((VkGpuTexture)colorAttachment).getVulkanImage() && boundFramebuffer.getDepthAttachment() == ((VkGpuTexture)depthAttachment).getVulkanImage()) {
fbo.clearAttachments();
}
}
}
}
public void clearColorAndDepthTextures(GpuTexture colorAttachment, int clearColor, GpuTexture depthAttachment, double clearDepth, int x0, int y0, int width, int height) {
if (this.inRenderPass) {
throw new IllegalStateException("Close the existing render pass before creating a new one!");
} else {
VRenderSystem.clearDepth(clearDepth);
VRenderSystem.setClearColor(class_9848.method_65101(clearColor), class_9848.method_65102(clearColor), class_9848.method_65103(clearColor), class_9848.method_65100(clearColor));
int framebufferHeight = colorAttachment.getHeight(0);
y0 = framebufferHeight - height - y0;
Framebuffer boundFramebuffer = Renderer.getInstance().getBoundFramebuffer();
if (boundFramebuffer != null && boundFramebuffer.getColorAttachment() == ((VkGpuTexture)colorAttachment).getVulkanImage() && boundFramebuffer.getDepthAttachment() == ((VkGpuTexture)depthAttachment).getVulkanImage()) {
Renderer.clearAttachments(16640, x0, y0, width, height);
}
}
}
public void clearDepthTexture(GpuTexture depthAttachment, double clearDepth) {
if (this.inRenderPass) {
throw new IllegalStateException("Close the existing render pass before creating a new one!");
} else {
Framebuffer boundFramebuffer = Renderer.getInstance().getBoundFramebuffer();
if (boundFramebuffer != null && boundFramebuffer.getDepthAttachment() == ((VkGpuTexture)depthAttachment).getVulkanImage()) {
VRenderSystem.clearDepth(clearDepth);
Renderer.clearAttachments(256);
} else {
((VkGpuTexture)depthAttachment).setDepthClearValue((float)clearDepth);
}
}
}
public void writeToBuffer(GpuBufferSlice gpuBufferSlice, ByteBuffer byteBuffer) {
if (this.inRenderPass) {
throw new IllegalStateException("Close the existing render pass before performing additional commands");
} else {
VkGpuBuffer vkGpuBuffer = (VkGpuBuffer)gpuBufferSlice.buffer();
if (vkGpuBuffer.closed) {
throw new IllegalStateException("Buffer already closed");
} else {
int size = byteBuffer.remaining();
if (size + gpuBufferSlice.offset() > vkGpuBuffer.size()) {
throw new IllegalArgumentException("Cannot write more data than this buffer can hold (attempting to write " + size + " bytes at offset " + gpuBufferSlice.offset() + " to " + gpuBufferSlice.length() + " slice size)");
} else {
int dstOffset = gpuBufferSlice.offset();
CommandPool.CommandBuffer commandBuffer = Renderer.getInstance().getTransferCb();
StagingBuffer stagingBuffer = Vulkan.getStagingBuffer();
stagingBuffer.copyBuffer(size, byteBuffer);
long srcOffset = stagingBuffer.getOffset();
MemoryStack stack = MemoryStack.stackPush();
try {
if (!commandBuffer.isRecording()) {
commandBuffer.begin(stack);
}
VkBufferCopy.Buffer copyRegion = VkBufferCopy.calloc(1, stack);
copyRegion.size((long)size);
copyRegion.srcOffset(srcOffset);
copyRegion.dstOffset((long)dstOffset);
VK10.vkCmdCopyBuffer(commandBuffer.handle, stagingBuffer.getId(), vkGpuBuffer.buffer.getId(), copyRegion);
} catch (Throwable var14) {
if (stack != null) {
try {
stack.close();
} catch (Throwable var13) {
var14.addSuppressed(var13);
}
}
throw var14;
}
if (stack != null) {
stack.close();
}
}
}
}
}
public GpuBuffer.MappedView mapBuffer(GpuBuffer gpuBuffer, boolean readable, boolean writable) {
return this.mapBuffer(gpuBuffer.slice(), readable, writable);
}
public GpuBuffer.MappedView mapBuffer(GpuBufferSlice gpuBufferSlice, boolean readable, boolean writable) {
if (this.inRenderPass) {
throw new IllegalStateException("Close the existing render pass before performing additional commands");
} else {
VkGpuBuffer gpuBuffer = (VkGpuBuffer)gpuBufferSlice.buffer();
if (gpuBuffer.closed) {
throw new IllegalStateException("Buffer already closed");
} else if (!readable && !writable) {
throw new IllegalArgumentException("At least read or write must be true");
} else if (readable && (gpuBuffer.usage() & 1) == 0) {
throw new IllegalStateException("Buffer is not readable");
} else if (writable && (gpuBuffer.usage() & 2) == 0) {
throw new IllegalStateException("Buffer is not writable");
} else if (gpuBufferSlice.offset() + gpuBufferSlice.length() > gpuBuffer.size()) {
int var10002 = gpuBufferSlice.length();
throw new IllegalArgumentException("Cannot map more data than this buffer can hold (attempting to map " + var10002 + " bytes at offset " + gpuBufferSlice.offset() + " from " + gpuBuffer.size() + " size buffer)");
} else {
int i = 0;
if (readable) {
i |= 1;
}
if (writable) {
i |= 34;
}
ByteBuffer byteBuffer = MemoryUtil.memByteBuffer(gpuBuffer.getBuffer().getDataPtr() + (long)gpuBufferSlice.offset(), gpuBufferSlice.length());
return new VkGpuBuffer.MappedView(0, byteBuffer);
}
}
}
public void copyToBuffer(GpuBufferSlice gpuBufferSlice, GpuBufferSlice gpuBufferSlice2) {
if (this.inRenderPass) {
throw new IllegalStateException("Close the existing render pass before performing additional commands");
} else {
VkGpuBuffer vkGpuBuffer = (VkGpuBuffer)gpuBufferSlice.buffer();
if (vkGpuBuffer.closed) {
throw new IllegalStateException("Source buffer already closed");
} else if ((vkGpuBuffer.usage() & 8) == 0) {
throw new IllegalStateException("Source buffer needs USAGE_COPY_DST to be a destination for a copy");
} else {
VkGpuBuffer vkGpuBuffer2 = (VkGpuBuffer)gpuBufferSlice2.buffer();
if (vkGpuBuffer2.closed) {
throw new IllegalStateException("Target buffer already closed");
} else if ((vkGpuBuffer2.usage() & 8) == 0) {
throw new IllegalStateException("Target buffer needs USAGE_COPY_DST to be a destination for a copy");
} else if (gpuBufferSlice.length() != gpuBufferSlice2.length()) {
int var6 = gpuBufferSlice.length();
throw new IllegalArgumentException("Cannot copy from slice of size " + var6 + " to slice of size " + gpuBufferSlice2.length() + ", they must be equal");
} else if (gpuBufferSlice.offset() + gpuBufferSlice.length() > vkGpuBuffer.size()) {
int var5 = gpuBufferSlice.length();
throw new IllegalArgumentException("Cannot copy more data than the source buffer holds (attempting to copy " + var5 + " bytes at offset " + gpuBufferSlice.offset() + " from " + vkGpuBuffer.size() + " size buffer)");
} else if (gpuBufferSlice2.offset() + gpuBufferSlice2.length() > vkGpuBuffer2.size()) {
int var10002 = gpuBufferSlice2.length();
throw new IllegalArgumentException("Cannot copy more data than the target buffer can hold (attempting to copy " + var10002 + " bytes at offset " + gpuBufferSlice2.offset() + " to " + vkGpuBuffer2.size() + " size buffer)");
} else {
throw new UnsupportedOperationException();
}
}
}
}
public void writeToTexture(GpuTexture gpuTexture, class_1011 nativeImage) {
int i = gpuTexture.getWidth(0);
int j = gpuTexture.getHeight(0);
if (nativeImage.method_4307() == i && nativeImage.method_4323() == j) {
if (gpuTexture.isClosed()) {
throw new IllegalStateException("Destination texture is closed");
} else {
this.writeToTexture(gpuTexture, nativeImage, 0, 0, 0, 0, i, j, 0, 0);
}
} else {
throw new IllegalArgumentException("Cannot replace texture of size " + i + "x" + j + " with image of size " + nativeImage.method_4307() + "x" + nativeImage.method_4323());
}
}
public void writeToTexture(GpuTexture gpuTexture, class_1011 nativeImage, int level, int arrayLayer, int xOffset, int yOffset, int width, int height, int unpackSkipPixels, int unpackSkipRows) {
if (this.inRenderPass) {
throw new IllegalStateException("Close the existing render pass before performing additional commands");
} else if (level >= 0 && level < gpuTexture.getMipLevels()) {
if (unpackSkipPixels + width <= nativeImage.method_4307() && unpackSkipRows + height <= nativeImage.method_4323()) {
if (xOffset + width <= gpuTexture.getWidth(level) && yOffset + height <= gpuTexture.getHeight(level)) {
if (gpuTexture.isClosed()) {
throw new IllegalStateException("Destination texture is closed");
} else {
VTextureSelector.setActiveTexture(0);
VkGlTexture glTexture = VkGlTexture.getTexture(((class_10868)gpuTexture).method_68427());
VTextureSelector.bindTexture(glTexture.getVulkanImage());
VTextureSelector.uploadSubTexture(level, arrayLayer, width, height, xOffset, yOffset, unpackSkipRows, unpackSkipPixels, nativeImage.method_4307(), nativeImage.method_67769());
}
} else {
throw new IllegalArgumentException("Dest texture (" + width + "x" + height + ") is not large enough to write a rectangle of " + width + "x" + height + " at " + xOffset + "x" + yOffset + " (at mip level " + level + ")");
}
} else {
int var10002 = nativeImage.method_4307();
throw new IllegalArgumentException("Copy source (" + var10002 + "x" + nativeImage.method_4323() + ") is not large enough to read a rectangle of " + width + "x" + height + " from " + unpackSkipPixels + "x" + unpackSkipRows);
}
} else {
throw new IllegalArgumentException("Invalid mipLevel " + level + ", must be >= 0 and < " + gpuTexture.getMipLevels());
}
}
public void writeToTexture(GpuTexture gpuTexture, ByteBuffer byteBuffer, class_1011.class_1012 format, int level, int j, int xOffset, int yOffset, int width, int height) {
if (this.inRenderPass) {
throw new IllegalStateException("Close the existing render pass before performing additional commands");
} else if (level >= 0 && level < gpuTexture.getMipLevels()) {
if (width * height * format.method_4335() > byteBuffer.remaining()) {
throw new IllegalArgumentException("Copy would overrun the source buffer (remaining length of " + byteBuffer.remaining() + ", but copy is " + width + "x" + height + " of format " + String.valueOf(format) + ")");
} else if (xOffset + width <= gpuTexture.getWidth(level) && yOffset + height <= gpuTexture.getHeight(level)) {
if (gpuTexture.isClosed()) {
throw new IllegalStateException("Destination texture is closed");
} else if ((gpuTexture.usage() & 1) == 0) {
throw new IllegalStateException("Color texture must have USAGE_COPY_DST to be a destination for a write");
} else if (j >= gpuTexture.getDepthOrLayers()) {
throw new UnsupportedOperationException("Depth or layer is out of range, must be >= 0 and < " + gpuTexture.getDepthOrLayers());
} else {
GlStateManager._bindTexture(((VkGpuTexture)gpuTexture).id);
GlStateManager._pixelStore(3314, width);
GlStateManager._pixelStore(3316, 0);
GlStateManager._pixelStore(3315, 0);
GlStateManager._pixelStore(3317, format.method_4335());
GlStateManager._texSubImage2D(3553, level, xOffset, yOffset, width, height, GlConst.toGl(format), 5121, byteBuffer);
}
} else {
throw new IllegalArgumentException("Dest texture (" + gpuTexture.getWidth(level) + "x" + gpuTexture.getHeight(level) + ") is not large enough to write a rectangle of " + width + "x" + height + " at " + xOffset + "x" + yOffset);
}
} else {
throw new IllegalArgumentException("Invalid mipLevel, must be >= 0 and < " + gpuTexture.getMipLevels());
}
}
public void copyTextureToBuffer(GpuTexture gpuTexture, GpuBuffer gpuBuffer, int i, Runnable runnable, int j) {
if (this.inRenderPass) {
throw new IllegalStateException("Close the existing render pass before performing additional commands");
} else {
this.copyTextureToBuffer(gpuTexture, gpuBuffer, i, runnable, j, 0, 0, gpuTexture.getWidth(j), gpuTexture.getHeight(j));
}
}
public void copyTextureToBuffer(GpuTexture gpuTexture, GpuBuffer gpuBuffer, int dstOffset, Runnable runnable, int mipLevel, int xOffset, int yOffset, int width, int height) {
VkGpuBuffer vkGpuBuffer = (VkGpuBuffer)gpuBuffer;
VkGpuTexture vkGpuTexture = (VkGpuTexture)gpuTexture;
if (this.inRenderPass) {
throw new IllegalStateException("Close the existing render pass before performing additional commands");
} else if (mipLevel >= 0 && mipLevel < gpuTexture.getMipLevels()) {
if (gpuTexture.getWidth(mipLevel) * gpuTexture.getHeight(mipLevel) * vkGpuTexture.getVulkanImage().formatSize + dstOffset > gpuBuffer.size()) {
throw new IllegalArgumentException("Buffer of size " + gpuBuffer.size() + " is not large enough to hold " + width + "x" + height + " pixels (" + vkGpuTexture.getVulkanImage().formatSize + " bytes each) starting from offset " + dstOffset);
} else if (xOffset + width <= gpuTexture.getWidth(mipLevel) && yOffset + height <= gpuTexture.getHeight(mipLevel)) {
if (gpuTexture.isClosed()) {
throw new IllegalStateException("Source texture is closed");
} else if (gpuBuffer.isClosed()) {
throw new IllegalStateException("Destination buffer is closed");
} else {
ImageUtil.copyImageToBuffer(vkGpuTexture.getVulkanImage(), vkGpuBuffer.getBuffer(), mipLevel, width, height, xOffset, yOffset, dstOffset, width, height);
runnable.run();
}
} else {
throw new IllegalArgumentException("Copy source texture (" + gpuTexture.getWidth(mipLevel) + "x" + gpuTexture.getHeight(mipLevel) + ") is not large enough to read a rectangle of " + width + "x" + height + " from " + xOffset + "," + yOffset);
}
} else {
throw new IllegalArgumentException("Invalid mipLevel " + mipLevel + ", must be >= 0 and < " + gpuTexture.getMipLevels());
}
}
public void copyTextureToTexture(GpuTexture gpuTexture, GpuTexture gpuTexture2, int mipLevel, int j, int k, int l, int m, int n, int o) {
if (this.inRenderPass) {
throw new IllegalStateException("Close the existing render pass before performing additional commands");
} else if (mipLevel >= 0 && mipLevel < gpuTexture.getMipLevels() && mipLevel < gpuTexture2.getMipLevels()) {
if (j + n <= gpuTexture2.getWidth(mipLevel) && k + o <= gpuTexture2.getHeight(mipLevel)) {
if (l + n <= gpuTexture.getWidth(mipLevel) && m + o <= gpuTexture.getHeight(mipLevel)) {
if (gpuTexture.isClosed()) {
throw new IllegalStateException("Source texture is closed");
} else if (gpuTexture2.isClosed()) {
throw new IllegalStateException("Destination texture is closed");
}
} else {
throw new IllegalArgumentException("Source texture (" + gpuTexture.getWidth(mipLevel) + "x" + gpuTexture.getHeight(mipLevel) + ") is not large enough to read a rectangle of " + n + "x" + o + " at " + l + "x" + m);
}
} else {
throw new IllegalArgumentException("Dest texture (" + gpuTexture2.getWidth(mipLevel) + "x" + gpuTexture2.getHeight(mipLevel) + ") is not large enough to write a rectangle of " + n + "x" + o + " at " + j + "x" + k);
}
} else {
throw new IllegalArgumentException("Invalid mipLevel " + mipLevel + ", must be >= 0 and < " + gpuTexture.getMipLevels() + " and < " + gpuTexture2.getMipLevels());
}
}
public GpuFence createFence() {
if (this.inRenderPass) {
throw new IllegalStateException("Close the existing render pass before performing additional commands");
} else {
return new GpuFence() {
public void close() {
}
public boolean awaitCompletion(long l) {
return true;
}
};
}
}
public void presentTexture(GpuTextureView gpuTexture) {
throw new UnsupportedOperationException();
}
protected <T> void executeDrawMultiple(VkRenderPass renderPass, Collection<RenderPass.class_10884<T>> collection, @Nullable GpuBuffer gpuBuffer, VertexFormat.@Nullable class_5595 indexType, Collection<String> collection2, T object) {
if (this.trySetup(renderPass)) {
if (indexType == null) {
indexType = class_5595.field_27372;
}
Pipeline pipeline = ExtendedRenderPipeline.of(renderPass.getPipeline()).getPipeline();
for(RenderPass.class_10884 draw : collection) {
VertexFormat.class_5595 indexType2 = draw.comp_3807() == null ? indexType : draw.comp_3807();
renderPass.setIndexBuffer(draw.comp_3806() == null ? gpuBuffer : draw.comp_3806(), indexType2);
renderPass.setVertexBuffer(draw.comp_3804(), draw.comp_3805());
if (class_10866.field_57867) {
if (renderPass.indexBuffer == null) {
throw new IllegalStateException("Missing index buffer");
}
if (renderPass.indexBuffer.isClosed()) {
throw new IllegalStateException("Index buffer has been closed!");
}
if (renderPass.vertexBuffers[0] == null) {
throw new IllegalStateException("Missing vertex buffer at slot 0");
}
if (renderPass.vertexBuffers[0].isClosed()) {
throw new IllegalStateException("Vertex buffer at slot 0 has been closed!");
}
}
BiConsumer<T, RenderPass.class_10885> biConsumer = draw.comp_3810();
if (biConsumer != null) {
biConsumer.accept(object, (RenderPass.class_10885)(string, gpuBufferSlice) -> {
EGlProgram glProgram = ExtendedRenderPipeline.of(renderPass.pipeline).getProgram();
class_284 patt0$temp = glProgram.getUniform(string);
if (patt0$temp instanceof class_284.class_11272 ubo) {
try {
int blockBinding = ubo.comp_4150();
} catch (Throwable var7) {
throw new MatchException(var7.toString(), var7);
}
}
});
Renderer.getInstance().uploadAndBindUBOs(pipeline);
}
this.drawFromBuffers(renderPass, 0, draw.comp_3808(), draw.comp_3809(), indexType2, renderPass.pipeline, 1);
}
}
}
protected void executeDraw(VkRenderPass renderPass, int i, int j, int k, VertexFormat.@Nullable class_5595 indexType, int l) {
if (this.trySetup(renderPass)) {
if (class_10866.field_57867) {
if (indexType != null) {
if (renderPass.indexBuffer == null) {
throw new IllegalStateException("Missing index buffer");
}
if (renderPass.indexBuffer.isClosed()) {
throw new IllegalStateException("Index buffer has been closed!");
}
}
if (renderPass.vertexBuffers[0] == null) {
throw new IllegalStateException("Missing vertex buffer at slot 0");
}
if (renderPass.vertexBuffers[0].isClosed()) {
throw new IllegalStateException("Vertex buffer at slot 0 has been closed!");
}
}
this.drawFromBuffers(renderPass, i, j, k, indexType, renderPass.pipeline, l);
}
}
public void drawFromBuffers(VkRenderPass renderPass, int vertexOffset, int firstIndex, int vertexCount, VertexFormat.@Nullable class_5595 indexType, RenderPipeline renderPipeline, int instanceCount) {
if (instanceCount < 1) {
instanceCount = 1;
}
if (vertexOffset < 0) {
vertexOffset = 0;
}
VkCommandBuffer vkCommandBuffer = Renderer.getCommandBuffer();
VkGpuBuffer vertexBuffer = (VkGpuBuffer)renderPass.vertexBuffers[0];
MemoryStack stack = MemoryStack.stackPush();
try {
if (vertexBuffer != null) {
VK11.vkCmdBindVertexBuffers(vkCommandBuffer, 0, stack.longs(vertexBuffer.buffer.getId()), stack.longs(0L));
}
if (renderPass.indexBuffer != null) {
VkGpuBuffer indexBuffer = (VkGpuBuffer)renderPass.indexBuffer;
byte var10000;
switch (indexType) {
case field_27372 -> var10000 = 0;
case field_27373 -> var10000 = 1;
default -> throw new MatchException((String)null, (Throwable)null);
}
int vkIndexType = var10000;
VK11.vkCmdBindIndexBuffer(vkCommandBuffer, indexBuffer.buffer.getId(), 0L, vkIndexType);
VK11.vkCmdDrawIndexed(vkCommandBuffer, vertexCount, instanceCount, firstIndex, vertexOffset, 0);
} else {
AutoIndexBuffer autoIndexBuffer = Renderer.getDrawer().getAutoIndexBuffer(renderPipeline.getVertexFormatMode(), vertexCount);
if (autoIndexBuffer != null) {
int indexCount = autoIndexBuffer.getIndexCount(vertexCount);
VK11.vkCmdBindIndexBuffer(vkCommandBuffer, autoIndexBuffer.getIndexBuffer().getId(), 0L, autoIndexBuffer.getIndexBuffer().indexType.value);
VK11.vkCmdDrawIndexed(vkCommandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, 0);
} else {
VK11.vkCmdDraw(vkCommandBuffer, vertexCount, instanceCount, vertexOffset, 0);
}
}
} catch (Throwable var14) {
if (stack != null) {
try {
stack.close();
} catch (Throwable var13) {
var14.addSuppressed(var13);
}
}
throw var14;
}
if (stack != null) {
stack.close();
}
}
public boolean trySetup(VkRenderPass renderPass) {
if (VkRenderPass.VALIDATION) {
if (renderPass.pipeline == null) {
throw new IllegalStateException("Can't draw without a render pipeline");
}
for(RenderPipeline.UniformDescription uniformDescription : renderPass.pipeline.getUniforms()) {
Object object = renderPass.uniforms.get(uniformDescription.name());
if (object == null && !class_5944.field_57863.contains(uniformDescription.name())) {
String var10002 = uniformDescription.name();
throw new IllegalStateException("Missing uniform " + var10002 + " (should be " + String.valueOf(uniformDescription.type()) + ")");
}
}
}
this.applyPipelineState(renderPass.pipeline);
this.setupUniforms(renderPass);
if (renderPass.isScissorEnabled()) {
GlStateManager._enableScissorTest();
GlStateManager._scissorBox(renderPass.getScissorX(), renderPass.getScissorY(), renderPass.getScissorWidth(), renderPass.getScissorHeight());
} else {
GlStateManager._disableScissorTest();
}
return this.bindPipeline(renderPass.pipeline);
}
public void setupUniforms(VkRenderPass renderPass) {
RenderPipeline renderPipeline = renderPass.pipeline;
EGlProgram glProgram = ExtendedRenderPipeline.of(renderPass.pipeline).getProgram();
Pipeline pipeline = ExtendedRenderPipeline.of(renderPass.pipeline).getPipeline();
for(UBO ubo : pipeline.getBuffers()) {
String uniformName = ubo.name;
glProgram.getUniform(uniformName);
GpuBufferSlice gpuBufferSlice = (GpuBufferSlice)renderPass.uniforms.get(uniformName);
if (gpuBufferSlice == null) {
ubo.setUseGlobalBuffer(true);
ubo.setUpdate(true);
} else {
VkGpuBuffer gpuBuffer = (VkGpuBuffer)gpuBufferSlice.buffer();
assert ubo != null;
ubo.setUseGlobalBuffer(false);
ubo.getBufferSlice().set(gpuBuffer.buffer, gpuBufferSlice.offset(), gpuBufferSlice.length());
}
}
for(ImageDescriptor imageDescriptor : pipeline.getImageDescriptors()) {
String uniformName = imageDescriptor.name;
int samplerIndex = imageDescriptor.imageIdx;
VkTextureView textureView = (VkTextureView)renderPass.samplers.get(uniformName);
if (textureView != null) {
VkGpuTexture gpuTexture = textureView.texture();
if (!gpuTexture.isClosed()) {
GlStateManager._activeTexture('蓀' + samplerIndex);
GlStateManager._bindTexture(gpuTexture.id);
GlStateManager._texParameter(3553, 33084, textureView.baseMipLevel());
GlStateManager._texParameter(3553, 33085, textureView.baseMipLevel() + textureView.mipLevels() - 1);
gpuTexture.flushModeChanges();
}
}
}
}
public boolean bindPipeline(RenderPipeline renderPipeline) {
Pipeline pipeline = ExtendedRenderPipeline.of(renderPipeline).getPipeline();
if (pipeline == null) {
return false;
} else {
Renderer renderer = Renderer.getInstance();
renderer.bindGraphicsPipeline((GraphicsPipeline)pipeline);
renderer.uploadAndBindUBOs(pipeline);
return true;
}
}
public void applyPipelineState(RenderPipeline renderPipeline) {
if (this.lastPipeline != renderPipeline) {
this.lastPipeline = renderPipeline;
if (renderPipeline.getDepthTestFunction() != DepthTestFunction.NO_DEPTH_TEST) {
GlStateManager._enableDepthTest();
GlStateManager._depthFunc(GlConst.toGl(renderPipeline.getDepthTestFunction()));
} else {
GlStateManager._disableDepthTest();
}
if (renderPipeline.isCull()) {
GlStateManager._enableCull();
} else {
GlStateManager._disableCull();
}
if (renderPipeline.getBlendFunction().isPresent()) {
GlStateManager._enableBlend();
BlendFunction blendFunction = (BlendFunction)renderPipeline.getBlendFunction().get();
GlStateManager._blendFuncSeparate(GlConst.toGl(blendFunction.sourceColor()), GlConst.toGl(blendFunction.destColor()), GlConst.toGl(blendFunction.sourceAlpha()), GlConst.toGl(blendFunction.destAlpha()));
} else {
GlStateManager._disableBlend();
}
GlStateManager._polygonMode(1032, GlConst.toGl(renderPipeline.getPolygonMode()));
GlStateManager._depthMask(renderPipeline.isWriteDepth());
GlStateManager._colorMask(renderPipeline.isWriteColor(), renderPipeline.isWriteColor(), renderPipeline.isWriteColor(), renderPipeline.isWriteAlpha());
if (renderPipeline.getDepthBiasConstant() == 0.0F && renderPipeline.getDepthBiasScaleFactor() == 0.0F) {
GlStateManager._disablePolygonOffset();
} else {
GlStateManager._polygonOffset(renderPipeline.getDepthBiasScaleFactor(), renderPipeline.getDepthBiasConstant());
GlStateManager._enablePolygonOffset();
}
switch (renderPipeline.getColorLogic()) {
case NONE:
GlStateManager._disableColorLogicOp();
break;
case OR_REVERSE:
GlStateManager._enableColorLogicOp();
GlStateManager._logicOp(5387);
}
VRenderSystem.setPrimitiveTopologyGL(GlConst.toGl(renderPipeline.getVertexFormatMode()));
}
}
public void finishRenderPass() {
this.inRenderPass = false;
}
protected VkGpuDevice getDevice() {
return this.device;
}
}
Download file