public OpenALAudioDevice (OpenALAudio audio, int sampleRate, boolean isMono, int bufferSize, int bufferCount) { this.audio = audio; channels = isMono ? 1 : 2; this.bufferSize = bufferSize; this.bufferCount = bufferCount; this.format = channels > 1 ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16; this.sampleRate = sampleRate; secondsPerBuffer = (float)bufferSize / bytesPerSample / channels / sampleRate; tempBuffer = BufferUtils.createByteBuffer(bufferSize); }
public String glGetActiveAttrib (int program, int index, IntBuffer size, Buffer type) { IntBuffer typeTmp = BufferUtils.createIntBuffer(2); String name = GL20.glGetActiveAttrib(program, index, 256, size, typeTmp); size.put(typeTmp.get(0)); if (type instanceof IntBuffer) ((IntBuffer)type).put(typeTmp.get(1)); return name; }
public void doRender(List<Vector3f> verts, List<Vector3f> normals) { FloatBuffer vertBuffer = BufferUtils.createFloatBuffer(verts.size() * 6); for (int i = 0; i < verts.size(); ++i) { Vector3f vert = verts.get(i); vertBuffer.put(vert.x * scale.x + translate.x); vertBuffer.put(vert.y * scale.y + translate.y); vertBuffer.put(vert.z * scale.z + translate.z); Vector3f norm = normals.get(i); vertBuffer.put(norm.x); vertBuffer.put(norm.y); vertBuffer.put(norm.z); } vertBuffer.flip(); VertexBufferObjectUtil.bufferVboData(disposalAction.vboPosNormBuffer, vertBuffer, GL15.GL_DYNAMIC_DRAW); GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, disposalAction.vboPosNormBuffer); glVertexPointer(VECTOR3_SIZE, GL_FLOAT, STRIDE, 0); glNormalPointer(GL_FLOAT, STRIDE, NORMAL_OFFSET); GL11.glDrawElements(GL11.GL_TRIANGLES, data.getIndices().size(), GL_UNSIGNED_INT, 0); GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0); }
IntBuffer ids = BufferUtils.createIntBuffer(2); glGenBuffers(ids); cubeVbo = ids.get(); planeVbo = ids.get(); checkGLError(); IntBuffer textures = BufferUtils.createIntBuffer(5); glGenTextures(textures); skinTexture = textures.get(); FloatBuffer vertexBuffer = BufferUtils.createFloatBuffer(vertices.length); vertexBuffer.put(vertices); vertexBuffer.flip(); glBindBuffer(GL_ARRAY_BUFFER, cubeVbo); glBufferData(GL_ARRAY_BUFFER, vertexBuffer, GL_STATIC_DRAW); checkGLError(); FloatBuffer planeVertexBuffer = BufferUtils.createFloatBuffer(planeVertices.length); planeVertexBuffer.put(planeVertices); FloatBuffer lightColor = BufferUtils.createFloatBuffer(4); FloatBuffer lightPosition = BufferUtils.createFloatBuffer(4); ByteBuffer fontBuffer = BufferUtils.createByteBuffer(276480); ByteBuffer pattern = BufferUtils.createByteBuffer(128); pattern.put(new byte[] { 0, 0, -1, -1, 0, 0, -1, -1, 0, 0, -1, -1, 0, 0, -1, -1, 0, 0, -1, -1, 0, 0, -1, -1, 0,
public String glGetActiveUniform (int program, int index, IntBuffer size, Buffer type) { // FIXME this is less than ideal of course... IntBuffer typeTmp = BufferUtils.createIntBuffer(2); String name = GL20.glGetActiveUniform(program, index, 256, typeTmp); size.put(typeTmp.get(0)); if (type instanceof IntBuffer) ((IntBuffer)type).put(typeTmp.get(1)); return name; }
private void createVertexBuffer(List<TFloatIterator> parts, TIntList partSizes, int vertexCount, int vertexSize) { FloatBuffer vertexBuffer = BufferUtils.createFloatBuffer(vertexSize * vertexCount); for (int v = 0; v < vertexCount; ++v) { for (int partIndex = 0; partIndex < parts.size(); ++partIndex) { TFloatIterator part = parts.get(partIndex); for (int i = 0; i < partSizes.get(partIndex); ++i) { vertexBuffer.put(part.next()); } } } vertexBuffer.flip(); if (disposalAction.vboVertexBuffer == 0) { disposalAction.vboVertexBuffer = disposalAction.bufferPool.get(getUrn().toString()); } VertexBufferObjectUtil.bufferVboData(disposalAction.vboVertexBuffer, vertexBuffer, GL15.GL_STATIC_DRAW); vertexBuffer.flip(); }
static Lwjgl3Monitor toLwjgl3Monitor(long glfwMonitor) { IntBuffer tmp = BufferUtils.createIntBuffer(1); IntBuffer tmp2 = BufferUtils.createIntBuffer(1); GLFW.glfwGetMonitorPos(glfwMonitor, tmp, tmp2); int virtualX = tmp.get(0); int virtualY = tmp2.get(0); String name = GLFW.glfwGetMonitorName(glfwMonitor); return new Lwjgl3Monitor(glfwMonitor, virtualX, virtualY, name); } }
@Override protected void doReload(SkeletalMeshData newData) { try { GameThread.synch(() -> { this.data = newData; if (disposalAction.vboPosNormBuffer == 0) { disposalAction.vboPosNormBuffer = disposalAction.bufferPool.get(getUrn().toString()); } IntBuffer indexBuffer = BufferUtils.createIntBuffer(newData.getIndices().size()); indexBuffer.put(newData.getIndices().toArray()); indexBuffer.flip(); if (disposalAction.vboIndexBuffer == 0) { disposalAction.vboIndexBuffer = disposalAction.bufferPool.get(getUrn().toString()); } VertexBufferObjectUtil.bufferVboElementData(disposalAction.vboIndexBuffer, indexBuffer, GL15.GL_STATIC_DRAW); FloatBuffer uvBuffer = BufferUtils.createFloatBuffer(newData.getUVs().size() * 2); for (Vector2f uv : newData.getUVs()) { uvBuffer.put(uv.x); uvBuffer.put(uv.y); } uvBuffer.flip(); if (disposalAction.vboUVBuffer == 0) { disposalAction.vboUVBuffer = disposalAction.bufferPool.get(getUrn().toString()); } VertexBufferObjectUtil.bufferVboData(disposalAction.vboUVBuffer, uvBuffer, GL15.GL_STATIC_DRAW); }); } catch (InterruptedException e) { logger.error("Failed to reload {}", getUrn(), e); } }
GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0); IntBuffer bufferIds = BufferUtils.createIntBuffer(3); if (type != Type.NO_COLOR) { bufferIds.put(GL_COLOR_ATTACHMENT0_EXT); bufferIds.put(GL_COLOR_ATTACHMENT1_EXT); bufferIds.put(GL_COLOR_ATTACHMENT2_EXT); bufferIds.flip(); if (bufferIds.limit() == 0) { GL11.glReadBuffer(GL11.GL_NONE); GL20.glDrawBuffers(GL11.GL_NONE); } else { GL20.glDrawBuffers(bufferIds);
IntBuffer ib = BufferUtils.createIntBuffer(1); ib.put(name).flip(); //Necessary ? TZ GL11.glGenTextures (ib); name = ib.get(0); GL11.glBindTexture (GL11.GL_TEXTURE_2D,name); GL11.glPixelStorei (GL11.GL_UNPACK_SWAP_BYTES, 0); GL11.glPixelStorei (GL11.GL_UNPACK_ROW_LENGTH, 0); GL11.glPixelStorei (GL11.GL_UNPACK_ALIGNMENT, 1);
@Override public void render(Renderer renderer) { if (tcbo == Integer.MAX_VALUE) { if (Visage.trace) Visage.log.finest("Creating texture coord buffer"); tcbo = glGenBuffers(); FloatBuffer uv = BufferUtils.createFloatBuffer(texture.u.length+texture.v.length); for (int i = 0; i < texture.u.length; i++) { uv.put(texture.u[i]); uv.put(texture.v[i]); } uv.flip(); glBindBuffer(GL_ARRAY_BUFFER, tcbo); glBufferData(GL_ARRAY_BUFFER, uv, GL_STATIC_DRAW); } doRender(renderer, renderer.owner.cubeVbo, tcbo, RenderContext.vertices); } }
IntBuffer buffer = BufferUtils.createIntBuffer(width * height); BufferedImage pageImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB); int[] row = new int[width]; buffer.clear(); GL11.glGetTexImage(GL11.GL_TEXTURE_2D, 0, GL12.GL_BGRA, GL11.GL_UNSIGNED_BYTE, buffer); WritableRaster raster = pageImage.getRaster(); for (int y = 0; y < height; y++) { buffer.get(row); raster.setDataElements(0, y, width, 1, row);
public static void saveGlTexture(String name, int textureId, int mipmapLevels) { GL11.glBindTexture(GL11.GL_TEXTURE_2D, textureId); GL11.glPixelStorei(GL11.GL_PACK_ALIGNMENT, 1); GL11.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, 1); for(int level = 0; level <= mipmapLevels; level++) { int width = GL11.glGetTexLevelParameteri(GL11.GL_TEXTURE_2D, level, GL11.GL_TEXTURE_WIDTH); int height = GL11.glGetTexLevelParameteri(GL11.GL_TEXTURE_2D, level, GL11.GL_TEXTURE_HEIGHT); int size = width * height; BufferedImage bufferedimage = new BufferedImage(width, height, 2); File output = new File(name + "_" + level + ".png"); IntBuffer buffer = BufferUtils.createIntBuffer(size); int[] data = new int[size]; GL11.glGetTexImage(GL11.GL_TEXTURE_2D, level, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, buffer); buffer.get(data); bufferedimage.setRGB(0, 0, width, height, data, 0, width); try { ImageIO.write(bufferedimage, "png", output); FMLLog.info("[TextureDump] Exported png to: " + output.getAbsolutePath()); } catch(IOException ioexception) { FMLLog.info("[TextureDump] Unable to write: ", ioexception); } } } }
@Override public ImageFormat[] querySupportedFormats(MemoryAccess access, Image.ImageType type) { long memFlags = Utils.getMemoryAccessFlags(access); int typeFlag = LwjglImage.decodeImageType(type); Utils.tempBuffers[0].b16i.rewind(); //query count int ret = CL10.clGetSupportedImageFormats(context, memFlags, typeFlag, null, Utils.tempBuffers[0].b16i); Utils.checkError(ret, "clGetSupportedImageFormats"); int count = Utils.tempBuffers[0].b16i.get(0); if (count == 0) { return new ImageFormat[0]; } //get formats ByteBuffer formatsB = BufferUtils.createByteBuffer(count * 8); ret = CL10.clGetSupportedImageFormats(context, memFlags, typeFlag, formatsB, null); Utils.checkError(ret, "clGetSupportedImageFormats"); //convert formats ImageFormat[] formats = new ImageFormat[count]; IntBuffer formatsBi = formatsB.asIntBuffer(); formatsBi.rewind(); for (int i=0; i<count; ++i) { Image.ImageChannelOrder channelOrder = LwjglImage.encodeImageChannelOrder(formatsBi.get()); Image.ImageChannelType channelType = LwjglImage.encodeImageChannelType(formatsBi.get()); formats[i] = new ImageFormat(channelOrder, channelType); } return formats; }
private static FloatBuffer wrap(float[] data) { FloatBuffer buf = BufferUtils.createFloatBuffer(data.length); buf.put(data); buf.rewind(); return buf; }
public void dispose(int buffer) { if (buffer != 0) { pool.add(buffer); IntBuffer dataBuffer = BufferUtils.createIntBuffer(1); dataBuffer.put(0); dataBuffer.flip(); VertexBufferObjectUtil.bufferVboData(buffer, dataBuffer, GL15.GL_STATIC_DRAW); dataBuffer.flip(); if (traceBufferUsage) { usageTracker.remove(buffer); } } }
public Model(float[] vertices, float[] tex_coords, int[] indices) { drawCount = indices.length; vertexObject = glGenBuffers(); glBindBuffer(GL_ARRAY_BUFFER, vertexObject); glBufferData(GL_ARRAY_BUFFER, createBuffer(vertices), GL_STATIC_DRAW); textureCoordObject = glGenBuffers(); glBindBuffer(GL_ARRAY_BUFFER, textureCoordObject); glBufferData(GL_ARRAY_BUFFER, createBuffer(tex_coords), GL_STATIC_DRAW); indexObject = glGenBuffers(); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexObject); IntBuffer buffer = BufferUtils.createIntBuffer(indices.length); buffer.put(indices); buffer.flip(); glBufferData(GL_ELEMENT_ARRAY_BUFFER, buffer, GL_STATIC_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0); }
public LwjglFrameBufferObject(ResourceUrn urn, BaseVector2i size) { this.size = ImmutableVector2i.createOrUse(size); IntBuffer fboId = BufferUtils.createIntBuffer(1); GL30.glGenFramebuffers(fboId); frame = fboId.get(0); Texture texture = generateTexture(urn); GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, frame); GL30.glFramebufferTexture2D(GL30.GL_FRAMEBUFFER, GL30.GL_COLOR_ATTACHMENT0, GL11.GL_TEXTURE_2D, texture.getId(), 0); int result = GL30.glCheckFramebufferStatus(GL30.GL_FRAMEBUFFER); if (result != GL30.GL_FRAMEBUFFER_COMPLETE) { throw new IllegalStateException("Something went wrong with framebuffer! " + result); } GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, 0); }
public static String takeScreenshot() throws Exception { Minecraft mc = Minecraft.getMinecraft(); ScaledResolution res = new ScaledResolution(mc); int screenWidth = mc.displayWidth; int screenHeight = mc.displayHeight; int scale = res.getScaleFactor(); int width = 380 * scale; int height = 200 * scale; int left = screenWidth / 2 - width / 2; int top = screenHeight / 2 - height / 2; int i = width * height; if(pixelBuffer == null || pixelBuffer.capacity() < i) { pixelBuffer = BufferUtils.createIntBuffer(i); pixelValues = new int[i]; } GL11.glPixelStorei(GL11.GL_PACK_ALIGNMENT, 1); GL11.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, 1); pixelBuffer.clear(); GL11.glReadPixels(left, top, width, height, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, pixelBuffer); pixelBuffer.get(pixelValues); TextureUtil.processPixelValues(pixelValues, width, height); BufferedImage bufferedimage; bufferedimage = new BufferedImage(width, height, 1); bufferedimage.setRGB(0, 0, width, height, pixelValues, 0, width); ByteArrayOutputStream stream = new ByteArrayOutputStream(); ImageIO.write(bufferedimage, "png", stream); byte[] bArray = stream.toByteArray(); return Base64.getEncoder().encodeToString(bArray); }
IntBuffer pixels = BufferUtils.createIntBuffer(k); int[] intArray = new int[k]; GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT); GL11.glLoadIdentity(); mc.entityRenderer.setupOverlayRendering(); drawForSreenShot(0, 0); imgPosY = 0; for (int y = top; y < bottom + height; y += height) { GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT); mc.entityRenderer.setupOverlayRendering(); drawForSreenShot(y, x); pixels.clear(); GL11.glReadPixels(0, 0, useWidth, useHeight, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, pixels); pixels.get(intArray); RequestMonitorPopup.mirror(intArray, useWidth, useHeight); bufferedimage.setRGB(imgPosX, imgPosY, Math.min(useWidth, bufferedimage.getWidth() - imgPosX), Math.min(useHeight, bufferedimage.getHeight() - imgPosY), intArray, 0, useWidth);