Ejemplo n.º 1
0
    /** Regenerates any dirty mimaps. */
    public void regenerateMipmaps() {
      if (mipmapDirty) {
        ByteBuffer data1 =
            BufferUtils.createByteBuffer(size.getWidth() * size.getHeight() * format.bytes);
        ByteBuffer data = data1;

        GL11.glBindTexture(GL11.GL_TEXTURE_2D, id);

        // read the texture out
        GL11.glGetTexImage(GL11.GL_TEXTURE_2D, 0, format.glFormat, GL11.GL_UNSIGNED_BYTE, data);

        data.rewind();

        // regenerate the mipmaps
        GLU.gluBuild2DMipmaps(
            GL11.GL_TEXTURE_2D,
            format.glInternalFormat,
            size.getWidth(),
            size.getHeight(),
            format.glFormat,
            GL11.GL_UNSIGNED_BYTE,
            data);

        mipmapDirty = false;
      }
    }
Ejemplo n.º 2
0
  /** @see org.newdawn.slick.opengl.ImageData#getImageBufferData() */
  public ByteBuffer getImageBufferData() {
    ByteBuffer scratch = BufferUtils.createByteBuffer(rawData.length);
    scratch.put(rawData);
    scratch.flip();

    return scratch;
  }
Ejemplo n.º 3
0
class TimerLinux {

  private final ByteBuffer time =
      BufferUtils.createByteBuffer(Math.max(timespec.SIZEOF, timeval.SIZEOF));

  private final TimeSource timeSource;

  private long base;

  TimerLinux() {
    if (clock_gettime(CLOCK_MONOTONIC, time) == 0) {
      timeSource =
          new TimeSource() {
            @Override
            public double getResolution() {
              return 1e-9;
            }

            @Override
            public long getRawTime() {
              clock_gettime(CLOCK_MONOTONIC, time);
              return timespec.sec(time) * 1000000000L + timespec.nsec(time);
            }
          };
    } else {
      timeSource =
          new TimeSource() {
            @Override
            public double getResolution() {
              return 1e-6;
            }

            @Override
            public long getRawTime() {
              gettimeofday(time, null);
              return timeval.sec(time) * 1000000L + timeval.usec(time);
            }
          };
    }
  }

  public void init() {
    base = timeSource.getRawTime();
  }

  public double getTime() {
    return (double) (timeSource.getRawTime() - base) * timeSource.getResolution();
  }

  public void setTime(double time) {
    base = timeSource.getRawTime() - (long) (time / timeSource.getResolution());
  }

  private interface TimeSource {

    double getResolution();

    long getRawTime();
  }
}
  public void setupQuad() {
    // We'll define our quad using 4 vertices of the custom 'Vertex' class
    Vertex v0 = new Vertex();
    v0.setXYZ(-0.5f, 0.5f, 0f);
    v0.setRGB(1, 0, 0);
    Vertex v1 = new Vertex();
    v1.setXYZ(-0.5f, -0.5f, 0f);
    v1.setRGB(0, 1, 0);
    Vertex v2 = new Vertex();
    v2.setXYZ(0.5f, -0.5f, 0f);
    v2.setRGB(0, 0, 1);
    Vertex v3 = new Vertex();
    v3.setXYZ(0.5f, 0.5f, 0f);
    v3.setRGB(1, 1, 1);

    Vertex[] vertices = new Vertex[] {v0, v1, v2, v3};
    // Put each 'Vertex' in one FloatBuffer
    FloatBuffer verticesBuffer =
        BufferUtils.createFloatBuffer(vertices.length * Vertex.elementCount);
    for (int i = 0; i < vertices.length; i++) {
      verticesBuffer.put(vertices[i].getXYZW());
      verticesBuffer.put(vertices[i].getRGBA());
    }
    verticesBuffer.flip();

    // OpenGL expects to draw vertices in counter clockwise order by default
    byte[] indices = {
      0, 1, 2,
      2, 3, 0
    };
    indicesCount = indices.length;
    ByteBuffer indicesBuffer = BufferUtils.createByteBuffer(indicesCount);
    indicesBuffer.put(indices);
    indicesBuffer.flip();

    // Create a new Vertex Array Object in memory and select it (bind)
    vaoId = GL30.glGenVertexArrays();
    GL30.glBindVertexArray(vaoId);

    // Create a new Vertex Buffer Object in memory and select it (bind)
    vboId = GL15.glGenBuffers();
    GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vboId);
    GL15.glBufferData(GL15.GL_ARRAY_BUFFER, verticesBuffer, GL15.GL_STATIC_DRAW);
    // Put the positions in attribute list 0
    GL20.glVertexAttribPointer(0, 4, GL11.GL_FLOAT, false, Vertex.sizeInBytes, 0);
    // Put the colors in attribute list 1
    GL20.glVertexAttribPointer(
        1, 4, GL11.GL_FLOAT, false, Vertex.sizeInBytes, Vertex.elementBytes * 4);
    GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);

    // Deselect (bind to 0) the VAO
    GL30.glBindVertexArray(0);

    // Create a new VBO for the indices and select it (bind) - INDICES
    vboiId = GL15.glGenBuffers();
    GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, vboiId);
    GL15.glBufferData(GL15.GL_ELEMENT_ARRAY_BUFFER, indicesBuffer, GL15.GL_STATIC_DRAW);
    GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);
  }
Ejemplo n.º 5
0
 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);
 }
Ejemplo n.º 6
0
 public void setupVIBO() {
   ByteBuffer indexBuffer = BufferUtils.createByteBuffer(indexElementCount * getNumObjects());
   for (int i = 0; i < getNumObjects(); ++i) {
     indexBuffer.put(Rectangle.getOrder(4 * i));
   }
   indexBuffer.flip();
   setVIBO(GL15.glGenBuffers());
   GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, getVIBO());
   GL15.glBufferData(GL15.GL_ELEMENT_ARRAY_BUFFER, indexBuffer, GL15.GL_DYNAMIC_DRAW);
   GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);
 }
Ejemplo n.º 7
0
 static Texture createSampleTexture() {
   ByteBuffer byteBuffer = BufferUtils.createByteBuffer(256 * 256 * 4);
   for (int y = 0; y < 256; y++) {
     for (int x = 0; x < 256; x++) {
       byte b = (byte) (x ^ y);
       byteBuffer.put(b).put(b).put(b).put(b);
     }
   }
   ByteBuffer[][] pixels = {{byteBuffer}};
   return new Texture(TextureType.TEXTURE_2D, 4, 256, 256, 0, Format.BGRA, pixels, false, false);
 }
  public Texture(URI pngRef, int filter, int wrap) throws IOException {
    InputStream input = null;
    try {
      // get an InputStream from our URL
      input = pngRef.toURL().openStream();

      // initialize the decoder
      PNGDecoder dec = new PNGDecoder(input);

      // set up image dimensions
      width = dec.getWidth();
      height = dec.getHeight();

      // we are using RGBA, i.e. 4 components or "bytes per pixel"
      final int bpp = 4;

      // create a new byte buffer which will hold our pixel data
      ByteBuffer buf = BufferUtils.createByteBuffer(bpp * width * height);

      // decode the image into the byte buffer, in RGBA format
      dec.decode(buf, width * bpp, PNGDecoder.Format.RGBA);

      // flip the buffer into "read mode" for OpenGL
      buf.flip();

      // enable textures and generate an ID
      glEnable(target);
      id = glGenTextures();

      // bind texture
      bind();

      // setup unpack mode
      glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

      // setup parameters
      glTexParameteri(target, GL_TEXTURE_MIN_FILTER, filter);
      glTexParameteri(target, GL_TEXTURE_MAG_FILTER, filter);
      glTexParameteri(target, GL_TEXTURE_WRAP_S, wrap);
      glTexParameteri(target, GL_TEXTURE_WRAP_T, wrap);

      // pass RGBA data to OpenGL
      glTexImage2D(target, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, buf);
    } finally {
      if (input != null) {
        try {
          input.close();
        } catch (IOException e) {
        }
      }
    }
  }
Ejemplo n.º 9
0
  private void init() {
    if (glfwInit() != GL_TRUE) {
      System.err.println("Could not initialize GLFW!");
      return;
    }

    glfwWindowHint(GLFW_SAMPLES, 4);
    glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
    OSCompatibility.GLFWSpecifics();
    window = glfwCreateWindow(width, height, "Voxel Engine", NULL, NULL);
    if (window == NULL) {
      System.err.println("Could not create GLFW window!");
      return;
    }
    // Compatibility for screen with 1:X | X =/= 1 ratio
    ByteBuffer FBW = BufferUtils.createByteBuffer(4), FBH = BufferUtils.createByteBuffer(4);
    glfwGetFramebufferSize(window, FBW, FBH);
    pix_width = FBW.getInt(0);
    pix_height = FBH.getInt(0);

    InitWindow();
    InitGL();
  }
  private void setupQuad() {

    IndexedMemoryFast<Pos4> mem = Pos4.reserveFast(10, false);
    mem.add(new Pos4().xyzw(-0.5f, 0.5f, 0f, 1f));
    mem.add(new Pos4().xyzw(-0.5f, -0.5f, 0f, 1f));
    mem.add(new Pos4().xyzw(0.5f, -0.5f, 0f, 1f));
    mem.add(new Pos4().xyzw(0.5f, 0.5f, 0f, 1f));

    // RawMemory colors = new RawMemory(30);
    IndexedMemoryFast<Color4> colors = Color4.reserveFast(10, false);
    colors.add(new Color4().rgba(1f, 0f, 0f, 1f));
    colors.add(new Color4().rgba(0f, 1f, 0f, 1f));
    colors.add(new Color4().rgba(0f, 0f, 1f, 1f));
    colors.add(new Color4().rgba(1f, 1f, 1f, 1f));

    // OpenGL expects to draw vertices in counter clockwise order by default
    byte[] indices = {0, 1, 2, 2, 3, 0};
    indicesCount = indices.length;
    ByteBuffer indicesBuffer = BufferUtils.createByteBuffer(indicesCount);
    indicesBuffer.put(indices);
    indicesBuffer.flip();

    // Create a new Array Array Object in memory and select it (bind)
    vaoId = glCreateVertexArrays();
    glBindVertexArray(vaoId);

    // Create a new Array Buffer Object in memory and select it (bind) - VERTICES
    vboId = glCreateBuffers();
    glBindBuffer(GL_ARRAY_BUFFER, vboId);
    glBufferData(GL_ARRAY_BUFFER, mem.burn().getArrayBuffer(), GL_STATIC_DRAW);
    glVertexAttribPointer(0, 4, GL_FLOAT, false, 0, 0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    // Create a new VBO for the indices and select it (bind) - COLORS
    vbocId = glCreateBuffers();
    glBindBuffer(GL_ARRAY_BUFFER, vbocId);
    glBufferData(GL_ARRAY_BUFFER, colors.burn().getArrayBuffer(), GL_STATIC_DRAW);
    glVertexAttribPointer(1, 4, GL_FLOAT, false, 0, 0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    // Deselect (bind to 0) the VAO
    glBindVertexArray(0);

    // Create a new VBO for the indices and select it (bind) - INDICES
    vboiId = glCreateBuffers();
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboiId);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, indicesBuffer, GL_STATIC_DRAW);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
  }
Ejemplo n.º 11
0
  protected final void enableClipping(int yTop, int yBottom) {
    if (doubleBuffer == null) {
      doubleBuffer = BufferUtils.createByteBuffer(32).asDoubleBuffer();
    }

    doubleBuffer.clear();
    doubleBuffer.put(0).put(1).put(0).put(-yTop).flip();
    glClipPlane(GL_CLIP_PLANE0, doubleBuffer);

    doubleBuffer.clear();
    doubleBuffer.put(0).put(-1).put(0).put(yBottom).flip();
    glClipPlane(GL_CLIP_PLANE1, doubleBuffer);

    glEnable(GL_CLIP_PLANE0);
    glEnable(GL_CLIP_PLANE1);
  }
Ejemplo n.º 12
0
  private static boolean printLogInfo(int obj) {
    IntBuffer iVal = BufferUtils.createIntBuffer(1);
    glGetObjectParameterARB(obj, GL_OBJECT_INFO_LOG_LENGTH_ARB, iVal);

    int length = iVal.get();
    if (length > 1) {
      ByteBuffer infoLog = BufferUtils.createByteBuffer(length);
      iVal.flip();
      glGetInfoLogARB(obj, iVal, infoLog);
      byte[] infoBytes = new byte[length];
      infoLog.get(infoBytes);
      String out = new String(infoBytes);
      System.out.println("Info log:\n" + out);
      return false;
    }
    return true;
  }
Ejemplo n.º 13
0
  public GLImage(String _filename) {
    try {
      BufferedImage image = ImageIO.read(this.getClass().getResource("/textures/" + _filename));
      int[] pixels = new int[image.getWidth() * image.getHeight()];
      image.getRGB(0, 0, image.getWidth(), image.getHeight(), pixels, 0, image.getWidth());
      ByteBuffer buffer =
          BufferUtils.createByteBuffer(
              image.getWidth() * image.getHeight() * 4); // 4 for RGBA, 3 for RGB
      for (int y = 0; y < image.getHeight(); y++) {
        for (int x = 0; x < image.getWidth(); x++) {
          int pixel = pixels[y * image.getWidth() + x];
          buffer.put((byte) ((pixel >> 16) & 0xFF)); // red
          buffer.put((byte) ((pixel >> 8) & 0xFF)); // green
          buffer.put((byte) (pixel & 0xFF)); // blue
          buffer.put((byte) ((pixel >> 24) & 0xFF)); // alpha
        }
      }
      buffer.flip();

      this.id = GL11.glGenTextures(); // Generate texture ID
      GL11.glBindTexture(GL11.GL_TEXTURE_2D, this.id); // Bind texture ID
      // Setup wrap mode
      GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_CLAMP);
      GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_CLAMP);
      // Setup texture scaling filtering
      GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
      GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
      // Send texel data to OpenGL
      GL11.glTexImage2D(
          GL11.GL_TEXTURE_2D,
          0,
          GL11.GL_RGBA8,
          image.getWidth(),
          image.getHeight(),
          0,
          GL11.GL_RGBA,
          GL11.GL_UNSIGNED_BYTE,
          buffer);

      this.width = image.getWidth();
      this.height = image.getHeight();

    } catch (IOException e) {
      e.printStackTrace();
    }
  }
Ejemplo n.º 14
0
  private static boolean printLogInfo(int obj, String filename) {
    IntBuffer iVal = BufferUtils.createIntBuffer(1);
    ARBShaderObjects.glGetObjectParameterARB(
        obj, ARBShaderObjects.GL_OBJECT_INFO_LOG_LENGTH_ARB, iVal);

    int length = iVal.get();
    if (length > 1) {
      // We have some info we need to output.
      ByteBuffer infoLog = BufferUtils.createByteBuffer(length);
      iVal.flip();
      ARBShaderObjects.glGetInfoLogARB(obj, iVal, infoLog);
      byte[] infoBytes = new byte[length];
      infoLog.get(infoBytes);
      String out = new String(infoBytes);
      System.out.println("Info log for " + filename + ":\n" + out);
    } else return true;
    return false;
  }
Ejemplo n.º 15
0
    private void recreate() {
      id = GL11.glGenTextures();

      GL11.glBindTexture(GL11.GL_TEXTURE_2D, id);

      GL11.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, format.bytes);

      ByteBuffer data =
          BufferUtils.createByteBuffer(size.getWidth() * size.getHeight() * format.bytes);

      if (mipmap) {
        GLU.gluBuild2DMipmaps(
            GL11.GL_TEXTURE_2D,
            format.glInternalFormat,
            size.getWidth(),
            size.getHeight(),
            format.glFormat,
            GL11.GL_UNSIGNED_BYTE,
            data);
      } else {
        GL11.glTexImage2D(
            GL11.GL_TEXTURE_2D,
            0,
            format.glInternalFormat,
            size.getWidth(),
            size.getHeight(),
            0,
            format.glFormat,
            GL11.GL_UNSIGNED_BYTE,
            data);
      }
      GLUtil.checkGLError();

      for (Texture t : residentTextures) {
        RectanglePacker.Rectangle rpr = packer.findRectangle(t.getSourceImage());

        if (rpr != null) {
          writeToTexture(rpr, t.getSourceImage().getData());
        }
      }

      regenerateMipmaps();
    }
Ejemplo n.º 16
0
  /**
   * The constructor that creates the font from the given file at the given height.
   *
   * @param filePath - The path to file including the file type
   * @param fontHeight - The height (size) of the font
   */
  public TrueTypeFont(String filePath, int fontHeight) {
    this.fontHeight = fontHeight;

    long startTime = 0L;
    if (Debug.enabled) startTime = System.nanoTime();

    textureID = glGenTextures();
    cdata = STBTTBakedChar.mallocBuffer(96);

    try {
      ByteBuffer ttf = IOUtil.ioResourceToByteBuffer(filePath, 160 * 1024);

      ByteBuffer bitmap = BufferUtils.createByteBuffer(BITMAP_W * BITMAP_H);
      STBTruetype.stbtt_BakeFontBitmap(ttf, fontHeight, bitmap, BITMAP_W, BITMAP_H, 32, cdata);

      glBindTexture(GL_TEXTURE_2D, textureID);
      glTexImage2D(
          GL_TEXTURE_2D, 0, GL_ALPHA, BITMAP_W, BITMAP_H, 0, GL_ALPHA, GL_UNSIGNED_BYTE, bitmap);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    } catch (IOException e) {
      throw new RuntimeException(e);
    }

    xbuf = BufferUtils.createFloatBuffer(1);
    ybuf = BufferUtils.createFloatBuffer(1);
    quad = STBTTAlignedQuad.malloc();

    if (Debug.enabled) {
      long endTime = System.nanoTime();
      Debug.println(
          " Loaded font: "
              + filePath
              + "\n\tFont height: "
              + fontHeight
              + "px"
              + "\n\tLoad time: "
              + Debug.noNotation.format((endTime - startTime) / 1000000000.0)
              + "s",
          Debug.ANSI_CYAN);
    }
  }
Ejemplo n.º 17
0
  /**
   * Convert BufferedImage to ByteBuffer
   *
   * @param image The BufferedImage to convert
   * @return The converted image
   */
  private ByteBuffer toByteBuffer(BufferedImage image) {
    int[] pixels = new int[image.getWidth() * image.getHeight()];
    image.getRGB(0, 0, image.getWidth(), image.getHeight(), pixels, 0, image.getWidth());

    ByteBuffer buffer =
        BufferUtils.createByteBuffer(
            image.getWidth() * image.getHeight() * 4); // 4 for RGBA, 3 for RGB

    for (int y = 0; y < image.getHeight(); y++) {
      for (int x = 0; x < image.getWidth(); x++) {
        int pixel = pixels[y * image.getWidth() + x];
        buffer.put((byte) ((pixel >> 16) & 0xFF)); // Red component
        buffer.put((byte) ((pixel >> 8) & 0xFF)); // Green component
        buffer.put((byte) (pixel & 0xFF)); // Blue component
        buffer.put((byte) ((pixel >> 24) & 0xFF)); // Alpha component. Only for RGBA
      }
    }

    buffer.flip(); // FOR THE LOVE OF GOD DO NOT FORGET THIS

    return buffer;
  }
Ejemplo n.º 18
0
  /**
   * Sets one or more icons for the Display.
   *
   * <ul>
   *   <li>On Windows you should supply at least one 16x16 icon and one 32x32.
   *   <li>Linux (and similar platforms) expect one 32x32 icon.
   *   <li>Mac OS X should be supplied one 128x128 icon
   * </ul>
   *
   * The implementation will use the supplied ByteBuffers with image data in RGBA (size must be a
   * power of two) and perform any conversions nescesarry for the specific platform.
   *
   * <p><b>NOTE:</b> The display will make a deep copy of the supplied byte buffer array, for the
   * purpose of recreating the icons when you go back and forth fullscreen mode. You therefore only
   * need to set the icon once per instance.
   *
   * @param icons Array of icons in RGBA mode. Pass the icons in order of preference.
   * @return number of icons used, or 0 if display hasn't been created
   */
  public static int setIcon(ByteBuffer[] icons) {
    synchronized (GlobalLock.lock) {
      // make deep copy so we dont rely on the supplied buffers later on
      // don't recache!
      if (cached_icons != icons) {
        cached_icons = new ByteBuffer[icons.length];
        for (int i = 0; i < icons.length; i++) {
          cached_icons[i] = BufferUtils.createByteBuffer(icons[i].capacity());
          int old_position = icons[i].position();
          cached_icons[i].put(icons[i]);
          icons[i].position(old_position);
          cached_icons[i].flip();
        }
      }

      if (Display.isCreated() && parent == null) {
        return display_impl.setIcon(cached_icons);
      } else {
        return 0;
      }
    }
  }
  public BufferTexture(BufferedImage image) {
    int[] pixels = new int[image.getWidth() * image.getHeight()];
    image.getRGB(0, 0, image.getWidth(), image.getHeight(), pixels, 0, image.getWidth());

    ByteBuffer buffer = BufferUtils.createByteBuffer(image.getWidth() * image.getHeight() * 4);

    for (int y = 0; y < image.getHeight(); y++) {
      for (int x = 0; x < image.getWidth(); x++) {
        int pixel = pixels[(y * image.getWidth()) + x];
        buffer.put((byte) ((pixel >> 16) & 0xFF));
        buffer.put((byte) ((pixel >> 8) & 0xFF));
        buffer.put((byte) (pixel & 0xFF));
        buffer.put((byte) ((pixel >> 24) & 0xFF));
      }
    }

    buffer.flip();

    this.width = image.getWidth();
    this.height = image.getHeight();

    this.textureId = GL11.glGenTextures();
    GL11.glBindTexture(GL11.GL_TEXTURE_2D, this.textureId);
    GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
    GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
    GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_CLAMP);
    GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_CLAMP);
    GL11.glTexImage2D(
        GL11.GL_TEXTURE_2D,
        0,
        GL11.GL_RGBA8,
        this.width,
        this.height,
        0,
        GL11.GL_RGBA,
        GL11.GL_UNSIGNED_BYTE,
        buffer);
  }
Ejemplo n.º 20
0
 // Spout Start
 public static BufferedImage getScreenshot(int texture, int screenWidth, int screenHeight) {
   ByteBuffer buffer = BufferUtils.createByteBuffer(screenWidth * screenHeight * 3);
   byte[] pixelData = new byte[screenWidth * screenHeight * 3];
   int[] imageData = new int[screenWidth * screenHeight];
   buffer.clear();
   GL11.glBindTexture(GL11.GL_TEXTURE_2D, texture);
   GL11.glGetTexImage(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGB, GL11.GL_UNSIGNED_BYTE, buffer);
   buffer.clear();
   buffer.get(pixelData);
   for (int l = 0; l < screenWidth; l++) {
     for (int i1 = 0; i1 < screenHeight; i1++) {
       int j1 = l + (screenHeight - i1 - 1) * screenWidth;
       int k1 = pixelData[j1 * 3 + 0] & 0xff;
       int l1 = pixelData[j1 * 3 + 1] & 0xff;
       int i2 = pixelData[j1 * 3 + 2] & 0xff;
       int j2 = 0xff000000 | k1 << 16 | l1 << 8 | i2;
       imageData[l + i1 * screenWidth] = j2;
     }
   }
   BufferedImage bufferedimage = new BufferedImage(screenWidth, screenHeight, 1);
   bufferedimage.setRGB(0, 0, screenWidth, screenHeight, imageData, 0, screenWidth);
   return bufferedimage;
 }
Ejemplo n.º 21
0
  private void verifyCompile(int shaderId) {
    IntBuffer intBuffer = BufferUtils.createIntBuffer(1);
    GL20.glGetShader(shaderId, GL20.GL_INFO_LOG_LENGTH, intBuffer);

    int length = intBuffer.get();

    if (length <= 1) {
      return;
    }

    valid = false;

    ByteBuffer infoBuffer = BufferUtils.createByteBuffer(length);
    intBuffer.flip();

    GL20.glGetShaderInfoLog(shaderId, intBuffer, infoBuffer);

    int actualLength = intBuffer.get();
    byte[] infoBytes = new byte[actualLength];
    infoBuffer.get(infoBytes);

    logger.log(Level.INFO, "{0}", new String(infoBytes));
  }
Ejemplo n.º 22
0
 protected BackgroundLoader() {
   running = true;
   texture = BufferUtils.createByteBuffer(WIDTH * HEIGHT * 3);
 }
Ejemplo n.º 23
0
 /**
  * Returns a new {@link java.nio.ByteBuffer} instance with a capacity equal to {@link #SIZEOF}.
  */
 public static ByteBuffer malloc() {
   return BufferUtils.createByteBuffer(SIZEOF);
 }
Ejemplo n.º 24
0
  public static void main(String[] args) throws Exception {
    Display.setDisplayMode(new DisplayMode(640, 480));
    Display.create();

    Shape baseBox = new Shape(VertexDataUtils.createBox(new Vec3(-1, 1, -1), new Vec3(1, 3, 1)));
    Texture baseTexture = SGUtil.createTexture(GL11.GL_RGBA, 128, 128);
    RenderTarget baseTarget =
        new RenderTarget(128, 128, new DepthBuffer(GL30.GL_DEPTH24_STENCIL8), false, baseTexture);
    RenderPass basePass = new RenderPass();
    basePass.setClearMask(GL11.GL_DEPTH_BUFFER_BIT | GL11.GL_COLOR_BUFFER_BIT);
    basePass.setClearColor(new Color4f(0, 1, 1, 0));
    basePass.setView(View.createPerspective((float) Math.PI / 4f, 1, 0.1f, 100f));
    basePass
        .getView()
        .setCameraMatrix(new Mat4().rotateEulerDeg(-30, 0, 0).translate(0, 0, 10).invert_());
    basePass.setRenderTarget(baseTarget);
    basePass.addShape(
        new Shape(VertexDataUtils.createBox(new Vec3(-4, -1, -4), new Vec3(4, 0, 4))));
    basePass.addShape(baseBox);

    int w = 256;
    int h = 256;
    ByteBuffer[][] pixels = {{BufferUtils.createByteBuffer(w * h * 4)}};
    Texture shadowTexture =
        new Texture(
            TextureType.TEXTURE_2D, GL30.GL_RG32F, w, h, 0, Format.RGBA, pixels, false, false);
    shadowTexture.setWrapS(Wrap.CLAMP_TO_EDGE);
    shadowTexture.setWrapT(Wrap.CLAMP_TO_EDGE);
    // shadowTexture.setMinFilter(MinFilter.LINEAR_MIPMAP_LINEAR);
    shadowTexture.setMaxAnisotropy(4f);
    RenderTarget shadowTarget =
        new RenderTarget(w, h, new DepthBuffer(GL11.GL_DEPTH_COMPONENT), false, shadowTexture);
    RenderPass shadowPass = new RenderPass();
    shadowPass.setClearMask(GL11.GL_DEPTH_BUFFER_BIT | GL11.GL_COLOR_BUFFER_BIT);
    shadowPass.setClearColor(new Color4f(0, 0, 1, 0));
    shadowPass.setView(View.createPerspective((float) Math.PI / 4f, 1, 0.1f, 100f));
    shadowPass.setRenderTarget(shadowTarget);
    shadowPass.addShape(
        new Shape(VertexDataUtils.createBox(new Vec3(-4, -1, -4), new Vec3(4, 0, 4))));
    shadowPass.addShape(
        new Shape(VertexDataUtils.createBox(new Vec3(-1, 1, -1), new Vec3(1, 3, 1))));
    shadowPass
        .getView()
        .setCameraMatrix(new Mat4().rotateEulerDeg(-90 - 45, 120, 0).translate(0, 0, 10).invert_());

    Shape baseShape = new Shape(VertexDataUtils.createQuad(50, 100 + 256, 256, -256, 0));
    baseShape.getState().setUnit(0, new Unit(baseTexture));
    Shape shadowShape = new Shape(VertexDataUtils.createQuad(350, 100, 256, 256, 0));
    shadowShape.getState().setUnit(0, new Unit(shadowTexture));
    RenderPass finalPass = new RenderPass();
    finalPass.setClearMask(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);
    finalPass.setClearColor(new Color4f(1, 1, 0, 0));
    finalPass.setView(View.createOrtho(0, 640, 0, 480, -1000, 1000));
    finalPass.addShape(baseShape);
    finalPass.addShape(shadowShape);

    // Texture testTexture = createSampleTexture();
    shadowStuff(basePass, shadowPass, shadowTexture);

    ByteBuffer[][] blurPixels = {{BufferUtils.createByteBuffer(128 * 128 * 4)}};
    Texture blurTexture =
        new Texture(
            TextureType.TEXTURE_2D,
            GL30.GL_RG32F,
            128,
            128,
            0,
            Format.RGBA,
            blurPixels,
            false,
            false);
    blurTexture.setWrapS(Wrap.CLAMP_TO_EDGE);
    blurTexture.setWrapT(Wrap.CLAMP_TO_EDGE);

    SceneGraph finalSceneGraph = new SceneGraph();
    finalSceneGraph.addRenderPass(shadowPass);
    finalSceneGraph.addRenderPass(
        Blur.createPass(shadowTexture, blurTexture, 1.5f / shadowTexture.getWidth(), 0f));
    finalSceneGraph.addRenderPass(
        Blur.createPass(blurTexture, shadowTexture, 0, 1.5f / shadowTexture.getWidth()));
    finalSceneGraph.addRenderPass(basePass);
    finalSceneGraph.addRenderPass(finalPass);
    Renderer finalRenderer = new Renderer(finalSceneGraph);

    int angle = 0;
    long startTime = System.currentTimeMillis();
    while (!Display.isCloseRequested()) {
      if (Mouse.isButtonDown(0)) {
        angle += Mouse.getDX();
      }
      //			shadowPass.getView().setCameraMatrix(new Mat4().rotateEulerDeg(-90 - 45, angle,
      // 0).translate(0, 0, 14).invert_());
      //			basePass.getView().setCameraMatrix(new Mat4().rotateEulerDeg(-30, angle, 0).translate(0,
      // 0, 10).invert_());

      float timeSec = (System.currentTimeMillis() - startTime) / 1000f;
      baseBox.setModelMatrix(
          new Mat4()
              .rotateEulerDeg(0, timeSec * 45, 0)
              .translate(0, Math.sin(timeSec * 1.7f) * 2, 0));

      for (int i = 0; i < basePass.getShapeCount(); i++) {
        shadowPass.getShape(i).setModelMatrix(basePass.getShape(i).getModelMatrix());
      }

      // shadowRenderer.render();
      finalRenderer.render();
      Display.update();
    }

    Display.destroy();
  }
Ejemplo n.º 25
0
public class ClientRenderTexture extends ClientTexture {
  public static final int INVALID_BUFFER = -1;
  public static final int SCREEN_BUFFER = 0;
  public static ByteBuffer EMPTY_BUFFER = BufferUtils.createByteBuffer(0);

  private int framebuffer = INVALID_BUFFER;
  private boolean useDepthBuffer = false;
  private boolean useStencilBuffer = false;

  int depthTarget = INVALID_BUFFER;
  int stencilTarget = INVALID_BUFFER; // TODO: Implement stencil component

  boolean useEXT = false;

  public ClientRenderTexture() {
    super(
        null,
        (int) ((SpoutClient) Spout.getEngine()).getResolution().getX(),
        (int) ((SpoutClient) Spout.getEngine()).getResolution().getY());

    // Detect which path we should use to create framebuffers.
    // if both of these are false, we cannot use framebuffers so throw an exception
    boolean arb = GLContext.getCapabilities().GL_ARB_framebuffer_object;
    boolean ext = GLContext.getCapabilities().GL_EXT_framebuffer_object;
    if (!arb && !ext) throw new ComputerIsPotatoException("Does not support Framebuffers");

    // if arb is false, use ext
    if (!arb) useEXT = true;

    Spout.log("Using EXT: " + useEXT);
  }

  public ClientRenderTexture(boolean depth) {
    this();
    useDepthBuffer = true;
  }

  @Override
  public Texture subTexture(int x, int y, int w, int h) {
    // TODO Auto-generated method stub
    return null;
  }

  public void activate() {
    if (framebuffer == INVALID_BUFFER) return; // Can't set this to active if it's not created yet
    if (useEXT)
      EXTFramebufferObject.glBindFramebufferEXT(
          EXTFramebufferObject.GL_FRAMEBUFFER_EXT, framebuffer);
    else GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, framebuffer);
    GL11.glViewport(0, 0, width, height);
  }

  public void release() {
    if (framebuffer != INVALID_BUFFER) {
      if (useEXT)
        EXTFramebufferObject.glBindFramebufferEXT(
            EXTFramebufferObject.GL_FRAMEBUFFER_EXT, SCREEN_BUFFER);
      else GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, SCREEN_BUFFER);
      GL11.glViewport(0, 0, width, height);
    }
  }

  @Override
  public void writeGPU() {
    if (framebuffer != INVALID_BUFFER)
      throw new IllegalStateException("Framebuffer already created!");

    // Create the color buffer for this renderTexture
    textureID = GL11.glGenTextures();
    GL11.glBindTexture(GL11.GL_TEXTURE_2D, textureID);

    GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
    GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
    GL11.glTexImage2D(
        GL11.GL_TEXTURE_2D,
        0,
        GL11.GL_RGBA8,
        width,
        height,
        0,
        GL11.GL_RGBA,
        GL11.GL_INT,
        (java.nio.ByteBuffer) null); // Create the texture data

    if (useEXT) {
      framebuffer = EXTFramebufferObject.glGenFramebuffersEXT();

      EXTFramebufferObject.glBindFramebufferEXT(
          EXTFramebufferObject.GL_FRAMEBUFFER_EXT, framebuffer);
      GL11.glBindTexture(GL11.GL_TEXTURE_2D, textureID);

      EXTFramebufferObject.glFramebufferTexture2DEXT(
          EXTFramebufferObject.GL_FRAMEBUFFER_EXT,
          EXTFramebufferObject.GL_COLOR_ATTACHMENT0_EXT,
          GL11.GL_TEXTURE_2D,
          textureID,
          0);

      if (useDepthBuffer) {
        depthTarget = GL30.glGenRenderbuffers();
        EXTFramebufferObject.glBindRenderbufferEXT(
            EXTFramebufferObject.GL_RENDERBUFFER_EXT, depthTarget);
        EXTFramebufferObject.glRenderbufferStorageEXT(
            EXTFramebufferObject.GL_RENDERBUFFER_EXT,
            GL11.GL_DEPTH_COMPONENT,
            this.getWidth(),
            this.getHeight());
        EXTFramebufferObject.glFramebufferRenderbufferEXT(
            EXTFramebufferObject.GL_FRAMEBUFFER_EXT,
            GL30.GL_DEPTH_ATTACHMENT,
            EXTFramebufferObject.GL_RENDERBUFFER_EXT,
            depthTarget);
      }

      if (EXTFramebufferObject.glCheckFramebufferStatusEXT(EXTFramebufferObject.GL_FRAMEBUFFER_EXT)
          != EXTFramebufferObject.GL_FRAMEBUFFER_COMPLETE_EXT) {
        System.out.println("ERROR: Framebuffer not complete");
        throw new ComputerIsPotatoException("Framebuffer not complete");
      }

    } else {
      framebuffer = GL30.glGenFramebuffers();
      GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, framebuffer);
      GL11.glBindTexture(GL11.GL_TEXTURE_2D, textureID);

      GL30.glFramebufferTexture2D(
          GL30.GL_FRAMEBUFFER, GL30.GL_COLOR_ATTACHMENT0, GL11.GL_TEXTURE_2D, textureID, 0);

      if (useDepthBuffer) {
        depthTarget = GL30.glGenRenderbuffers();
        GL30.glBindRenderbuffer(GL30.GL_RENDERBUFFER, depthTarget);
        GL30.glRenderbufferStorage(
            GL30.GL_RENDERBUFFER, GL11.GL_DEPTH_COMPONENT, this.getWidth(), this.getHeight());
        GL30.glFramebufferRenderbuffer(
            GL30.GL_FRAMEBUFFER, GL30.GL_DEPTH_ATTACHMENT, GL30.GL_RENDERBUFFER, depthTarget);
      }
      GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, SCREEN_BUFFER);

      if (GL30.glCheckFramebufferStatus(GL30.GL_FRAMEBUFFER) != GL30.GL_FRAMEBUFFER_COMPLETE) {
        System.out.println("ERROR: Framebuffer not complete");
        throw new ComputerIsPotatoException("Framebuffer not complete");
      }
    }
    GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0);
  }

  protected boolean isGL30() {
    return ((SpoutClient) Spout.getEngine()).getRenderMode() == RenderMode.GL30;
  }

  @Override
  public boolean isLoaded() {
    return framebuffer != INVALID_BUFFER;
  }
}
Ejemplo n.º 26
0
  public static Geometry generateGalaxyPointGeometry(long seed) {

    Random rand = new Random(seed);

    /*double[] noiseSeedR = new double[16*16*16];
    double[] noiseSeedI = new double[16*16*16];

    for(int i = 0; i < noiseSeedR.length; i++) {
    	noiseSeedR[i] = 2.0 * rand.nextDouble() - 1.0;
    	noiseSeedI[i] = 2.0 * rand.nextDouble() - 1.0;
    }*/

    List<Float> starPositions = new ArrayList<Float>();
    List<Byte> color = new ArrayList<Byte>();

    // Noise noiseSeedR = new Noise(seed),
    //	noiseSeedI = new Noise(seed ^42l);

    int subdivs = 50;
    // int starsTotal = 100;

    // Go through all sectors
    for (float x = 0.5f; x < subdivs; x++) {
      for (float y = 0.5f; y < subdivs; y++) {
        for (float z = 0.5f; z < subdivs; z++) {

          // Amount of stars in this sector
          /*int amount = (int) ( (float)starsTotal/subdivs *Math.sin( x/Math.PI +
          noise(noiseSeedR, noiseSeedI, x/subdivs, y/subdivs, z/subdivs)
          + 0.5*noise(noiseSeedR, noiseSeedI, 2*x/subdivs, 2*y/subdivs, 2*z/subdivs)
          + 0.25*noise(noiseSeedR, noiseSeedI, 4*x/subdivs, 4*y/subdivs, 4*z/subdivs)
          + 0.125*noise(noiseSeedR, noiseSeedI, 8*x/subdivs, 8*y/subdivs, 8*z/subdivs)) );*/

          int amount = 1;
          for (int i = 0; i < amount; i++) {
            // Put a star in the sector
            starPositions.add(((float) x + rand.nextFloat()) / subdivs - 0.5f);
            starPositions.add(((float) y + rand.nextFloat()) / subdivs - 0.5f);
            starPositions.add(((float) z + rand.nextFloat()) / subdivs - 0.5f);

            // TODO: Improve colors

            float c = rand.nextFloat();

            if (c < 0.1f) {
              color.add((byte) 255);
              color.add((byte) (210 - (c - 1f)));
              color.add((byte) (170 - (c - 1f)));
            } else if (c < 0.9f) {
              color.add((byte) 255);
              color.add((byte) 255);
              color.add((byte) 255);
            } else {
              color.add((byte) (190 * c * c));
              color.add((byte) (210 * c));
              color.add((byte) 255);
            }
          }
        }
      }
    }

    List<Attribute> attributes = new ArrayList<Attribute>();
    Attribute at = new Attribute();
    at.buffer = BufferUtils.createFloatBuffer(starPositions.size());
    at.name = "position";
    at.size = 3;
    at.type = Type.FLOAT;

    Iterator<Float> fIt = starPositions.iterator();
    while (fIt.hasNext()) ((FloatBuffer) at.buffer).put(fIt.next());
    at.buffer.flip();

    attributes.add(at);

    Attribute atColor = new Attribute();
    atColor.buffer = BufferUtils.createByteBuffer(color.size());
    atColor.name = "color";
    atColor.normalized = true;
    atColor.size = 3;
    atColor.type = Type.UBYTE;

    Iterator<Byte> fItC = color.iterator();
    while (fItC.hasNext()) ((ByteBuffer) atColor.buffer).put(fItC.next());
    atColor.buffer.flip();

    attributes.add(atColor);

    // TODO: Are the indices needed?
    int amountOfStars = starPositions.size() / 3;
    IntBuffer indices = BufferUtils.createIntBuffer(amountOfStars);
    for (int i = 0; i < amountOfStars; i++) {
      indices.put(i);
    }
    indices.flip();

    return new Geometry(PrimitiveType.POINTS, indices, attributes);
  }
Ejemplo n.º 27
0
  @Override
  public void onLoad(ALAudioFileInputStream ais) throws Exception {
    // header telling this is a wave file
    if (ais.readInt() != RIFF_INT) {
      throw new Exception("Not a wave file");
    }
    @SuppressWarnings("unused")
    int file_size = ais.readInt() + 8;
    if (ais.readInt() != WAVE_INT) {
      throw new Exception("Not a wave file");
    }

    boolean fmt = false;
    boolean data = false;

    // read block by block
    while (ais.available() > 0) {
      int id = ais.readInt();
      int block_size = ais.readLittleInt();

      if (id == FMT_INT) {
        if (fmt) {
          throw new Exception("Multiple FMT blocks in WAV file");
        }
        fmt = true;

        @SuppressWarnings("unused")
        short audio_format = ais.readLittleShort();
        short channels = ais.readLittleShort();
        System.out.println(channels);
        int frequence = ais.readLittleInt();

        @SuppressWarnings("unused")
        int avg_bytes_per_sec = ais.readLittleInt();

        @SuppressWarnings("unused")
        short bytes_per_sample = ais.readLittleShort();
        short bits_per_sample = ais.readLittleShort();

        super.setFrequence(frequence);

        if (bits_per_sample == 8) {
          if (channels == 1) {
            super.setFormat(AL10.AL_FORMAT_MONO8);
          } else if (channels == 2) {
            super.setFormat(AL10.AL_FORMAT_STEREO8);
          } else {
            throw new Exception("Wrong number of channels (not supported): " + channels);
          }
        } else if (bits_per_sample == 16) {
          if (channels == 1) {
            super.setFormat(AL10.AL_FORMAT_MONO16);
          } else if (channels == 2) {
            super.setFormat(AL10.AL_FORMAT_STEREO16);
          } else {
            throw new Exception("Wrong number of channels (not supported): " + channels);
          }
        } else {
          throw new Exception("Wrong bits per sample: " + bits_per_sample);
        }
      } else if (id == DATA_INT) {
        if (data) {
          throw new Exception("Multiple data section in WAV file");
        }
        data = true;
        byte[] bytes = new byte[block_size];
        ais.read(bytes, 0, block_size);
        ByteBuffer buffer = BufferUtils.createByteBuffer(block_size);
        buffer.put(bytes);
        buffer.flip();
        super.setData(buffer);
      } else if (block_size >= 0 && block_size <= ais.available()) {
        ais.skip(block_size);
      } else {
        break;
      }
    }

    if (!fmt) {
      throw new Exception("No FMT");
    }

    if (!data) {
      throw new Exception("No data");
    }
  }
Ejemplo n.º 28
0
  // Spout Start - Method renamed from func_74292_a to saveScreenshot
  public static String saveScreenshot(
      File file, String imageFileName, int screenWidth, int screenHeight) {
    ByteBuffer buffer = BufferUtils.createByteBuffer(screenWidth * screenHeight * 3);
    byte[] pixelData = new byte[screenWidth * screenHeight * 3];
    int[] imageData = new int[screenWidth * screenHeight];
    try {
      // Spout Start - Renamed from file1
      File screenshotsDir = new File(file, "screenshots");
      screenshotsDir.mkdir();
      // Just intialise it up there!
      /*if (buffer == null || buffer.capacity() < i * j) {
      	 buffer = BufferUtils.createByteBuffer(i * j * 3);
      }
      if (imageData == null || imageData.length < i * j * 3) {
      	 pixelData = new byte[i * j * 3];
      	 imageData = new int[i * j];
      }*/
      // Use constants instead of magic numbers
      GL11.glPixelStorei(GL11.GL_PACK_ALIGNMENT, 1);
      GL11.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, 1);
      buffer.clear();
      GL11.glReadPixels(
          0, 0, screenWidth, screenHeight, GL11.GL_RGB, GL11.GL_UNSIGNED_BYTE, buffer);
      // Spout End
      buffer.clear();
      String s1 = (new StringBuilder()).append("").append(dateFormat.format(new Date())).toString();
      File file2;
      if (imageFileName == null) {
        for (int k = 1;
            (file2 =
                    new File(
                        screenshotsDir,
                        (new StringBuilder())
                            .append(s1)
                            .append(
                                k != 1
                                    ? (new StringBuilder()).append("_").append(k).toString()
                                    : "")
                            .append(".png")
                            .toString()))
                .exists();
            k++) {}
      } else {
        file2 = new File(screenshotsDir, imageFileName);
      }
      buffer.get(pixelData);
      for (int l = 0; l < screenWidth; l++) {
        for (int i1 = 0; i1 < screenHeight; i1++) {
          int j1 = l + (screenHeight - i1 - 1) * screenWidth;
          int k1 = pixelData[j1 * 3 + 0] & 0xff;
          int l1 = pixelData[j1 * 3 + 1] & 0xff;
          int i2 = pixelData[j1 * 3 + 2] & 0xff;
          int j2 = 0xff000000 | k1 << 16 | l1 << 8 | i2;
          imageData[l + i1 * screenWidth] = j2;
        }
      }

      BufferedImage bufferedimage = new BufferedImage(screenWidth, screenHeight, 1);
      bufferedimage.setRGB(0, 0, screenWidth, screenHeight, imageData, 0, screenWidth);
      ImageIO.write(bufferedimage, "png", file2);
      return (new StringBuilder())
          .append("Saved screenshot as ")
          .append(file2.getName())
          .toString();
    } catch (Exception exception) {
      exception.printStackTrace();
      return (new StringBuilder()).append("Failed to save: ").append(exception).toString();
    }
  }
Ejemplo n.º 29
0
 @Override
 public ByteBuffer createByteBuffer(final int size) {
   return org.lwjgl.BufferUtils.createByteBuffer(size);
 }
Ejemplo n.º 30
0
 /**
  * Creates a PixelData buffer with the specified size and format.
  *
  * <p>Note that Slick currently loads textures with an internal RGBA format; this means that even
  * if we upload, say, 2-component (e.g. GRAYALPHA) texture data, it will eventually be stored in
  * OpenGL video memory using RGBA. For better performance and memory management, create textures
  * with the same internal format as the format given to PixelData. The static 'createTexture'
  * utility method is intended for this purpose.
  *
  * <p>Also note that most drivers will expand formats to RGBA internally, so this optimization may
  * not be necessary.
  *
  * @param width the width in pixels of our data
  * @param height the height in pixels of our data
  * @param format the desired format to use during uploading (RGB, RGBA, GRAY, GRAYALPHA, ALPHA)
  */
 public PixelData(int width, int height, ImageData.Format format) {
   this.format = format;
   this.width = width;
   this.height = height;
   this.pixels = BufferUtils.createByteBuffer(width * height * format.getColorComponents());
 }