コード例 #1
0
 public void useLights(ArrayList<RenderLight> lights, int s, int c) {
   if (unLPos != GL.BadUniformLocation) {
     fbLight.clear();
     Vector3 pos = new Vector3();
     for (int i = 0; i < c; i++) {
       RenderLight rl = lights.get(s + i);
       rl.mWorldTransform.mulPos(pos);
       fbLight.put(pos.x);
       fbLight.put(pos.y);
       fbLight.put(pos.z);
       pos.set(0);
     }
     fbLight.rewind();
     GL20.glUniform3(unLPos, fbLight);
   }
   if (unLIntensity != GL.BadUniformLocation) {
     fbLight.clear();
     for (int i = 0; i < c; i++) {
       RenderLight rl = lights.get(s + i);
       fbLight.put((float) rl.sceneLight.intensity.x);
       fbLight.put((float) rl.sceneLight.intensity.y);
       fbLight.put((float) rl.sceneLight.intensity.z);
     }
     fbLight.rewind();
     GL20.glUniform3(unLIntensity, fbLight);
   }
   if (unLCount != GL.BadUniformLocation) {
     GL20.glUniform1i(unLCount, c);
   }
 }
コード例 #2
0
  @Override
  public boolean gluUnProject(
      float winX,
      float winY,
      float winZ,
      float[] model,
      int modelOffset,
      float[] project,
      int projectOffset,
      int[] view,
      int viewOffset,
      float[] obj,
      int objOffset) {
    modelb.clear();
    modelb.put(model, modelOffset, 16);
    projectb.clear();
    projectb.put(project, projectOffset, 16);
    viewb.clear();
    viewb.put(view, viewOffset, 4);
    winb.clear();

    boolean result =
        org.lwjgl.util.glu.GLU.gluUnProject(winX, winY, winZ, modelb, projectb, viewb, winb);
    obj[objOffset] = winb.get(0);
    obj[objOffset + 1] = winb.get(1);
    obj[objOffset + 2] = winb.get(2);
    return result;
  }
コード例 #3
0
  protected void initParticles() {
    pAndsBuff.clear();
    velBuff.clear();
    lifespanBuff.clear();
    ageBuff.clear();

    float[] velocity = dir.dot(speed);

    for (int i = 0; i < particleCount; i++) {
      pAndsBuff.put(
          new float[] {
            ((float) Math.random() - 0.5f) * 50f, 50f, ((float) Math.random() - 0.5f) * 50f, 0.016f
          });
      velBuff.put(new float[] {velocity[0], velocity[1], velocity[2], 0f});
      ageBuff.put(0f);

      if (i < startCount) {
        lifespanBuff.put(1f);
      } else {
        lifespanBuff.put(0f);
      }
    }

    pAndsBuff.rewind();
    velBuff.rewind();
    lifespanBuff.rewind();
    ageBuff.rewind();

    newParticles = (int) (birthRate * timeBetweenAni);
  }
コード例 #4
0
ファイル: SoundStore.java プロジェクト: maesse/CubeTech
 void updateSource(int source, float x, float y, float z, float vx, float vy, float vz) {
   sourcePos.clear();
   sourceVel.clear();
   sourceVel.put(new float[] {vx, vy, vz});
   sourcePos.put(new float[] {x, y, z});
   sourcePos.flip();
   sourceVel.flip();
   AL10.alSource(sources.get(source), AL10.AL_POSITION, sourcePos);
   AL10.alSource(sources.get(source), AL10.AL_VELOCITY, sourceVel);
 }
コード例 #5
0
ファイル: SoundStore.java プロジェクト: maesse/CubeTech
  int playAsSoundAt(
      int buffer,
      int source,
      float pitch,
      float gain,
      boolean loop,
      float x,
      float y,
      float z,
      float vx,
      float vy,
      float vz,
      boolean localsound) {
    gain *= soundVolume;
    if (gain == 0) {
      gain = 0.001f;
    }
    if (soundWorks) {
      if (sounds) {

        if (source == -1) {
          return -1;
        }

        AL10.alSourceStop(sources.get(source));
        AL10.alSourcef(sources.get(source), AL10.AL_REFERENCE_DISTANCE, minDistance);
        if (localsound) {
          AL10.alSourcei(sources.get(source), AL10.AL_SOURCE_RELATIVE, AL10.AL_TRUE);
          AL10.alSourcef(sources.get(source), AL10.AL_ROLLOFF_FACTOR, 0.0f);
        } else {
          AL10.alSourcei(sources.get(source), AL10.AL_SOURCE_RELATIVE, AL10.AL_FALSE);
          AL10.alSourcef(sources.get(source), AL10.AL_ROLLOFF_FACTOR, rollOff);
        }
        AL10.alSourcei(sources.get(source), AL10.AL_BUFFER, buffer);
        AL10.alSourcef(sources.get(source), AL10.AL_PITCH, pitch);
        AL10.alSourcef(sources.get(source), AL10.AL_GAIN, gain);
        AL10.alSourcei(sources.get(source), AL10.AL_LOOPING, loop ? AL10.AL_TRUE : AL10.AL_FALSE);

        sourcePos.clear();
        sourceVel.clear();
        sourceVel.put(new float[] {vx, vy, vz});
        sourcePos.put(new float[] {x, y, z});
        sourcePos.flip();
        sourceVel.flip();
        AL10.alSource(sources.get(source), AL10.AL_POSITION, sourcePos);
        AL10.alSource(sources.get(source), AL10.AL_VELOCITY, sourceVel);

        AL10.alSourcePlay(sources.get(source));

        return source;
      }
    }

    return -1;
  }
コード例 #6
0
            @Override
            public void run() {
              ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024 * Float.SIZE / 8);
              buffer.order(ByteOrder.nativeOrder());
              FloatBuffer floatBuffer = buffer.asFloatBuffer();
              IntBuffer intBuffer = buffer.asIntBuffer();

              float[] floatArray = new float[1024 * 1024];
              int[] intArray = new int[1024 * 1024];

              // single put
              tic();
              for (int tries = 0; tries < TRIES; tries++) {
                for (int i = 0; i < floatArray.length; i++) floatBuffer.put(floatArray[i]);
                floatBuffer.clear();
              }
              toc("single put");

              // single indexed put
              tic();
              for (int tries = 0; tries < TRIES; tries++) {
                for (int i = 0; i < floatArray.length; i++) floatBuffer.put(i, floatArray[i]);
                floatBuffer.clear();
              }
              toc("single indexed put");

              // bulk put
              tic();
              for (int tries = 0; tries < TRIES; tries++) {
                floatBuffer.put(floatArray);
                floatBuffer.clear();
              }
              toc("vector put");

              // convert bulk put
              tic();
              for (int tries = 0; tries < TRIES; tries++) {
                for (int i = 0; i < floatArray.length; i++)
                  intArray[i] = Float.floatToIntBits(floatArray[i]);
                intBuffer.put(intArray);
                intBuffer.clear();
              }
              toc("convert bulk put");

              // jni bulk put
              tic();
              for (int tries = 0; tries < TRIES; tries++) {
                BufferUtils.copy(floatArray, floatBuffer, floatArray.length, 0);
                floatBuffer.clear();
              }
              toc("jni bulk put");
            }
コード例 #7
0
  private void adjustImageScaling() {
    float outputWidth = mOutputWidth;
    float outputHeight = mOutputHeight;
    if (mRotation == Rotation.ROTATION_270 || mRotation == Rotation.ROTATION_90) {
      outputWidth = mOutputHeight;
      outputHeight = mOutputWidth;
    }

    float ratio1 = outputWidth / mImageWidth;
    float ratio2 = outputHeight / mImageHeight;
    float ratioMax = Math.max(ratio1, ratio2);
    int imageWidthNew = Math.round(mImageWidth * ratioMax);
    int imageHeightNew = Math.round(mImageHeight * ratioMax);

    float ratioWidth = imageWidthNew / outputWidth;
    float ratioHeight = imageHeightNew / outputHeight;

    float[] cube = CUBE;
    float[] textureCords =
        TextureRotationUtil.getRotation(mRotation, mFlipHorizontal, mFlipVertical);
    if (mScaleType == GPUImage.ScaleType.CENTER_CROP) {
      float distHorizontal = (1 - 1 / ratioWidth) / 2;
      float distVertical = (1 - 1 / ratioHeight) / 2;
      textureCords =
          new float[] {
            addDistance(textureCords[0], distHorizontal),
                addDistance(textureCords[1], distVertical),
            addDistance(textureCords[2], distHorizontal),
                addDistance(textureCords[3], distVertical),
            addDistance(textureCords[4], distHorizontal),
                addDistance(textureCords[5], distVertical),
            addDistance(textureCords[6], distHorizontal),
                addDistance(textureCords[7], distVertical),
          };
    } else {
      cube =
          new float[] {
            CUBE[0] / ratioHeight, CUBE[1] / ratioWidth,
            CUBE[2] / ratioHeight, CUBE[3] / ratioWidth,
            CUBE[4] / ratioHeight, CUBE[5] / ratioWidth,
            CUBE[6] / ratioHeight, CUBE[7] / ratioWidth,
          };
    }

    mGLCubeBuffer.clear();
    mGLCubeBuffer.put(cube).position(0);
    mGLTextureBuffer.clear();
    mGLTextureBuffer.put(textureCords).position(0);
  }
コード例 #8
0
ファイル: RenderHelper.java プロジェクト: rstanic12/mcp726a
 private static FloatBuffer func_74521_a(
     float p_74521_0_, float p_74521_1_, float p_74521_2_, float p_74521_3_) {
   field_74522_a.clear();
   field_74522_a.put(p_74521_0_).put(p_74521_1_).put(p_74521_2_).put(p_74521_3_);
   field_74522_a.flip();
   return field_74522_a;
 }
コード例 #9
0
ファイル: FloatToFixed.java プロジェクト: jingchan/jh_rogue
  private static void convertTexCoords2D(FloatBuffer input, Buffer output) {
    if (output.capacity() < input.capacity())
      throw new RuntimeException("Output must be at least as large as input!");

    input.clear();
    output.clear();
    Vector2f temp = new Vector2f();
    int vertexCount = input.capacity() / 2;

    ShortBuffer sb = null;
    IntBuffer ib = null;

    if (output instanceof ShortBuffer) sb = (ShortBuffer) output;
    else if (output instanceof IntBuffer) ib = (IntBuffer) output;
    else throw new UnsupportedOperationException();

    for (int i = 0; i < vertexCount; i++) {
      BufferUtils.populateFromBuffer(temp, input, i);

      if (sb != null) {
        sb.put((short) (temp.getX() * Short.MAX_VALUE));
        sb.put((short) (temp.getY() * Short.MAX_VALUE));
      } else {
        int v1 = (int) (temp.getX() * ((float) (1 << 16)));
        int v2 = (int) (temp.getY() * ((float) (1 << 16)));
        ib.put(v1).put(v2);
      }
    }
  }
コード例 #10
0
ファイル: BasicFloat.java プロジェクト: susotajuraj/jdk8u-jdk
 private static void absPut(FloatBuffer b) {
   int n = b.capacity();
   b.clear();
   for (int i = 0; i < n; i++) b.put(i, (float) ic(i));
   b.limit(n);
   b.position(0);
 }
コード例 #11
0
  public void setBufferContainer(BufferContainer bufferContainer) {
    Map<Integer, Buffer> buffers = new HashMap<>();

    for (Entry<Integer, Object> entry : bufferContainer.getBuffers().entrySet()) {
      int layout = entry.getKey();
      Object buffer = entry.getValue();

      if (buffer instanceof TFloatArrayList) {

        if (((TFloatArrayList) buffer).isEmpty()) {
          throw new IllegalStateException("Buffer can't be empty");
        }

        FloatBuffer floatBuffer = BufferUtils.createFloatBuffer(((TFloatArrayList) buffer).size());
        floatBuffer.clear();
        floatBuffer.put(((TFloatArrayList) buffer).toArray());
        floatBuffer.flip();

        buffers.put(layout, floatBuffer);
      } else {
        throw new IllegalStateException("Buffer different of TFloatArrayList not yet supported");
      }
    }

    flushingNumVertices = bufferContainer.element;

    initFlush(buffers);
  }
コード例 #12
0
ファイル: BasicFloat.java プロジェクト: susotajuraj/jdk8u-jdk
 private static void bulkPutArray(FloatBuffer b) {
   int n = b.capacity();
   b.clear();
   float[] a = new float[n + 7];
   for (int i = 0; i < n; i++) a[i + 7] = (float) ic(i);
   b.put(a, 7, n);
   b.flip();
 }
コード例 #13
0
 /**
  * Gets a colxrow intead of row x col
  *
  * @return
  */
 public FloatBuffer getFloatBuffer() {
   buffer16.clear();
   // give col x row ordering
   for (int col = 0; col < 4; col++) {
     for (int row = 0; row < 4; row++) buffer16.put((float) matrix4x4[row][col]);
   }
   buffer16.rewind();
   return buffer16;
 }
コード例 #14
0
ファイル: Particle.java プロジェクト: krka/Ardor3D
  /**
   * update position (using current position and velocity), color (interpolating between start and
   * end color), size (interpolating between start and end size), spin (using parent's spin speed)
   * and current age of particle. If this particle's age is greater than its lifespan, it is set to
   * status DEAD.
   *
   * <p>Note that this only changes the parameters of the Particle, not the geometry the particle is
   * associated with.
   *
   * @param secondsPassed number of seconds passed since last update.
   * @return true if this particle is not ALIVE (in other words, if it is ready to be reused.)
   */
  public boolean updateAndCheck(final double secondsPassed) {
    if (status != Status.Alive) {
      return true;
    }
    currentAge += secondsPassed * 1000; // add ms time to age
    if (currentAge > lifeSpan) {
      killParticle();
      return true;
    }

    final Vector3 temp = Vector3.fetchTempInstance();
    _position.addLocal(_velocity.multiply(secondsPassed * 1000f, temp));
    Vector3.releaseTempInstance(temp);

    // get interpolated values from appearance ramp:
    parent.getRamp().getValuesAtAge(currentAge, lifeSpan, currColor, values, parent);

    // interpolate colors
    final int verts = ParticleSystem.getVertsForParticleType(type);
    for (int x = 0; x < verts; x++) {
      BufferUtils.setInBuffer(
          currColor, parent.getParticleGeometry().getMeshData().getColorBuffer(), startIndex + x);
    }

    // check for tex animation
    final int newTexIndex = parent.getTexAnimation().getTexIndexAtAge(currentAge, lifeSpan, parent);
    // Update tex coords if applicable
    if (currentTexIndex != newTexIndex) {
      // Only supported in Quad type for now.
      if (ParticleType.Quad.equals(parent.getParticleType())) {
        // determine side
        final float side = (float) Math.sqrt(parent.getTexQuantity());
        int index = newTexIndex;
        if (index >= parent.getTexQuantity()) {
          index %= parent.getTexQuantity();
        }
        // figure row / col
        final float row = side - (int) (index / side) - 1;
        final float col = index % side;
        // set texcoords
        final float sU = col / side, eU = (col + 1) / side;
        final float sV = row / side, eV = (row + 1) / side;
        final FloatBuffer texs =
            parent.getParticleGeometry().getMeshData().getTextureCoords(0).getBuffer();
        texs.position(startIndex * 2);
        texs.put(eU).put(sV);
        texs.put(eU).put(eV);
        texs.put(sU).put(eV);
        texs.put(sU).put(sV);
        texs.clear();
      }
      currentTexIndex = newTexIndex;
    }

    return false;
  }
コード例 #15
0
ファイル: Shader.java プロジェクト: ben-baran/old-java-game
 public void setUniformMat(int loc, boolean transposed, Matrix4f mat) {
   if (loc != -1) {
     set();
     if (buff16 == null) buff16 = BufferUtils.createFloatBuffer(16);
     buff16.clear();
     mat.store(buff16);
     buff16.flip();
     glUniformMatrix4(loc, transposed, buff16);
     stop();
   }
 }
コード例 #16
0
ファイル: BasicFloat.java プロジェクト: susotajuraj/jdk8u-jdk
 private static void bulkPutBuffer(FloatBuffer b) {
   int n = b.capacity();
   b.clear();
   FloatBuffer c = FloatBuffer.allocate(n + 7);
   c.position(7);
   for (int i = 0; i < n; i++) c.put((float) ic(i));
   c.flip();
   c.position(7);
   b.put(c);
   b.flip();
 }
コード例 #17
0
ファイル: FloatToFixed.java プロジェクト: jingchan/jh_rogue
  private static void convertToFloat(IntBuffer input, FloatBuffer output) {
    if (output.capacity() < input.capacity())
      throw new RuntimeException("Output must be at least as large as input!");

    input.clear();
    output.clear();
    for (int i = 0; i < input.capacity(); i++) {
      output.put(((float) input.get() / (float) (1 << 16)));
    }
    output.flip();
  }
コード例 #18
0
ファイル: FloatToFixed.java プロジェクト: jingchan/jh_rogue
  private static void convertToUByte(FloatBuffer input, ByteBuffer output) {
    if (output.capacity() < input.capacity())
      throw new RuntimeException("Output must be at least as large as input!");

    input.clear();
    output.clear();
    for (int i = 0; i < input.capacity(); i++) {
      output.put((byte) (input.get() * 255f));
    }
    output.flip();
  }
コード例 #19
0
ファイル: Main.java プロジェクト: carriercomm/LWJake2
  /** R_SetupGL */
  void R_SetupGL() {

    //
    // set up viewport
    //
    // int x = (int) Math.floor(r_newrefdef.x * vid.width / vid.width);
    int x = r_newrefdef.x;
    // int x2 = (int) Math.ceil((r_newrefdef.x + r_newrefdef.width) * vid.width / vid.width);
    int x2 = r_newrefdef.x + r_newrefdef.width;
    // int y = (int) Math.floor(vid.height - r_newrefdef.y * vid.height / vid.height);
    int y = vid.height - r_newrefdef.y;
    // int y2 = (int) Math.ceil(vid.height - (r_newrefdef.y + r_newrefdef.height) * vid.height /
    // vid.height);
    int y2 = vid.height - (r_newrefdef.y + r_newrefdef.height);

    int w = x2 - x;
    int h = y - y2;

    GL11.glViewport(x, y2, w, h);

    //
    // set up projection matrix
    //
    float screenaspect = (float) r_newrefdef.width / r_newrefdef.height;
    GL11.glMatrixMode(GL11.GL_PROJECTION);
    GL11.glLoadIdentity();
    MYgluPerspective(r_newrefdef.fov_y, screenaspect, 4, 4096);

    GL11.glCullFace(GL11.GL_FRONT);

    GL11.glMatrixMode(GL11.GL_MODELVIEW);
    GL11.glLoadIdentity();

    GL11.glRotatef(-90, 1, 0, 0); // put Z going up
    GL11.glRotatef(90, 0, 0, 1); // put Z going up
    GL11.glRotatef(-r_newrefdef.viewangles[2], 1, 0, 0);
    GL11.glRotatef(-r_newrefdef.viewangles[0], 0, 1, 0);
    GL11.glRotatef(-r_newrefdef.viewangles[1], 0, 0, 1);
    GL11.glTranslatef(-r_newrefdef.vieworg[0], -r_newrefdef.vieworg[1], -r_newrefdef.vieworg[2]);

    GL11.glGetFloat(GL11.GL_MODELVIEW_MATRIX, r_world_matrix);
    r_world_matrix.clear();

    //
    // set drawing parms
    //
    if (gl_cull.value != 0.0f) GL11.glEnable(GL11.GL_CULL_FACE);
    else GL11.glDisable(GL11.GL_CULL_FACE);

    GL11.glDisable(GL11.GL_BLEND);
    GL11.glDisable(GL11.GL_ALPHA_TEST);
    GL11.glEnable(GL11.GL_DEPTH_TEST);
  }
コード例 #20
0
 /** Process and setup the vertex position buffer. */
 private void processVertex() {
   FloatBuffer vertexBuffer = this.getVertexBuffer();
   if (vertexBuffer == null) {
     vertexBuffer = BufferUtils.createVector3Buffer(this.vertices.length);
     this.setVertexBuffer(vertexBuffer);
   }
   vertexBuffer.clear();
   for (int i = 0; i < this.vertices.length; i++) {
     this.vertices[i].resetInformation();
     this.vertices[i].processPosition();
     BufferUtils.setInBuffer(this.vertices[i].getPosition(), vertexBuffer, i);
   }
 }
コード例 #21
0
  public void float2byte(float[] src, int off, int len, byte[] dst, int off2) {

    if (len > (BUFFER_SIZE / 4)) {
      FloatBuffer buffer = ByteBuffer.wrap(dst, off2, len * 4).order(order).asFloatBuffer();
      buffer.put(src, off, len);
    } else {
      floatBuffer.clear();
      floatBuffer.put(src, off, len);

      byteBuffer.position(0).limit(len * 4);
      byteBuffer.get(dst, off2, len * 4);
    }
  }
コード例 #22
0
  protected void regenInfluenceOffsets(int index) {
    FloatBuffer verts, norms;
    Vector3f vertex = new Vector3f();
    Vector3f normal = new Vector3f();

    Geometry geom = getSkin(index);
    verts = geom.getVertexBuffer();
    if (verts == null) {
      logger.log(Level.FINE, "Skipping skin ''{0}'' because verts uninitialized", geom.getName());
      return;
    }
    norms = geom.getNormalBuffer();
    verts.clear();
    norms.clear();
    for (ArrayList<BoneInfluence> infs : cache[index]) {
      vertex.set(verts.get(), verts.get(), verts.get());
      normal.set(norms.get(), norms.get(), norms.get());

      if (infs == null) continue;

      if (bindMatrix != null) {
        bindMatrix.mult(vertex, vertex);
        bindMatrix.rotateVect(normal);
      }

      for (int x = infs.size() - 1; x >= 0; --x) {
        BoneInfluence infl = infs.get(x);
        if (infl.bone == null) continue;
        infl.vOffset = new Vector3f(vertex);
        infl.bone.bindMatrix.inverseTranslateVect(infl.vOffset);
        infl.bone.bindMatrix.inverseRotateVect(infl.vOffset);

        infl.nOffset = new Vector3f(normal);
        infl.bone.bindMatrix.inverseRotateVect(infl.nOffset);
      }
    }
  }
コード例 #23
0
ファイル: SoundStore.java プロジェクト: elsantiF/Voxel
  /**
   * Play the specified buffer as a sound effect with the specified pitch and gain.
   *
   * @param buffer The ID of the buffer to play
   * @param pitch The pitch to play at
   * @param gain The gain to play at
   * @param loop True if the sound should loop
   * @param x The x position to play the sound from
   * @param y The y position to play the sound from
   * @param z The z position to play the sound from
   * @return source The source that will be used
   */
  int playAsSoundAt(int buffer, float pitch, float gain, boolean loop, float x, float y, float z) {
    gain *= soundVolume;
    if (gain == 0) {
      gain = 0.001f;
    }
    if (soundWorks) {
      if (sounds) {
        int nextSource = findFreeSource();
        if (nextSource == -1) {
          return -1;
        }

        AL10.alSourceStop(sources.get(nextSource));

        AL10.alSourcei(sources.get(nextSource), AL10.AL_BUFFER, buffer);
        AL10.alSourcef(sources.get(nextSource), AL10.AL_PITCH, pitch);
        AL10.alSourcef(sources.get(nextSource), AL10.AL_GAIN, gain);
        AL10.alSourcei(
            sources.get(nextSource), AL10.AL_LOOPING, loop ? AL10.AL_TRUE : AL10.AL_FALSE);

        sourcePos.clear();
        sourceVel.clear();
        sourceVel.put(new float[] {0, 0, 0});
        sourcePos.put(new float[] {x, y, z});
        sourcePos.flip();
        sourceVel.flip();
        AL10.alSourcefv(sources.get(nextSource), AL10.AL_POSITION, sourcePos);
        AL10.alSourcefv(sources.get(nextSource), AL10.AL_VELOCITY, sourceVel);

        AL10.alSourcePlay(sources.get(nextSource));

        return nextSource;
      }
    }

    return -1;
  }
コード例 #24
0
  /**
   * Processes the given convex shape to retrieve a correctly ordered FloatBuffer to construct the
   * shape from with a TriMesh.
   *
   * @param convexShape the shape to retreieve the vertices from.
   * @return the vertices as a FloatBuffer, ordered as Triangles.
   */
  private static FloatBuffer getVertices(ConvexShape convexShape) {
    // Check there is a hull shape to render
    if (convexShape.getUserPointer() == null) {
      // create a hull approximation
      ShapeHull hull = new ShapeHull(convexShape);
      float margin = convexShape.getMargin();
      hull.buildHull(margin);
      convexShape.setUserPointer(hull);
    }

    // Assert state - should have a pointer to a hull (shape) that'll be drawn
    assert convexShape.getUserPointer() != null
        : "Should have a shape for the userPointer, instead got null";
    ShapeHull hull = (ShapeHull) convexShape.getUserPointer();

    // Assert we actually have a shape to render
    assert hull.numTriangles() > 0 : "Expecting the Hull shape to have triangles";
    int numberOfTriangles = hull.numTriangles();

    // The number of bytes needed is: (floats in a vertex) * (vertices in a triangle) * (# of
    // triangles) * (size of float in bytes)
    final int numberOfFloats = 3 * 3 * numberOfTriangles;
    FloatBuffer vertices = BufferUtils.createFloatBuffer(numberOfFloats);

    // Force the limit, set the cap - most number of floats we will use the buffer for
    vertices.limit(numberOfFloats);

    // Loop variables
    final IntArrayList hullIndicies = hull.getIndexPointer();
    final List<Vector3f> hullVertices = hull.getVertexPointer();
    Vector3f vertexA, vertexB, vertexC;
    int index = 0;

    for (int i = 0; i < numberOfTriangles; i++) {
      // Grab the data for this triangle from the hull
      vertexA = hullVertices.get(hullIndicies.get(index++));
      vertexB = hullVertices.get(hullIndicies.get(index++));
      vertexC = hullVertices.get(hullIndicies.get(index++));

      // Put the verticies into the vertex buffer
      vertices.put(vertexA.x).put(vertexA.y).put(vertexA.z);
      vertices.put(vertexB.x).put(vertexB.y).put(vertexB.z);
      vertices.put(vertexC.x).put(vertexC.y).put(vertexC.z);
    }

    vertices.clear();
    return vertices;
  }
コード例 #25
0
  public void adjustVertexData(float xOffset, float yOffset) {

    newData.clear();

    for (int i = 0; i < 12; i += 4) {
      newData.put(vertexDataAry[i] + xOffset); // new x
      newData.put(vertexDataAry[i + 1] + yOffset); // new y
      newData.put(0); // new z
      newData.put(1); // new w (clip space value)
    }

    newData.flip();

    glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
    glBufferSubData(GL_ARRAY_BUFFER, 0, newData);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
  }
コード例 #26
0
 /**
  * Process and setup the normal position buffer.
  *
  * @param init The <code>Boolean</code> initialization flag.
  */
 private void processNormal(boolean init) {
   // Triangles have to process the normal first in case the vertices are not in order.
   for (int i = 0; i < this.triangles.length; i++) {
     this.triangles[i].processNormal();
   }
   // Average vertex normals with same vertex positions.
   if (init) this.averageNormal();
   // Put into buffer.
   FloatBuffer normalBuffer = this.getNormalBuffer();
   if (normalBuffer == null) {
     normalBuffer = BufferUtils.createVector3Buffer(this.vertices.length);
     this.setNormalBuffer(normalBuffer);
   }
   normalBuffer.clear();
   for (int i = 0; i < this.vertices.length; i++) {
     BufferUtils.setInBuffer(this.vertices[i].getNormal(), normalBuffer, i);
   }
 }
コード例 #27
0
ファイル: FloatToFixed.java プロジェクト: jingchan/jh_rogue
  private static void convertNormals(FloatBuffer input, ByteBuffer output) {
    if (output.capacity() < input.capacity())
      throw new RuntimeException("Output must be at least as large as input!");

    input.clear();
    output.clear();
    Vector3f temp = new Vector3f();
    int vertexCount = input.capacity() / 3;
    for (int i = 0; i < vertexCount; i++) {
      BufferUtils.populateFromBuffer(temp, input, i);

      // offset and scale vector into -128 ... 127
      temp.multLocal(127).addLocal(0.5f, 0.5f, 0.5f);

      // quantize
      byte v1 = (byte) temp.getX();
      byte v2 = (byte) temp.getY();
      byte v3 = (byte) temp.getZ();

      // store
      output.put(v1).put(v2).put(v3);
    }
  }
コード例 #28
0
  void resetToBind() {
    for (Mesh mesh : targets) {
      if (isMeshAnimated(mesh)) {
        FloatBuffer bwBuff = (FloatBuffer) mesh.getBuffer(Type.BoneWeight).getData();
        ByteBuffer biBuff = (ByteBuffer) mesh.getBuffer(Type.BoneIndex).getData();
        if (!biBuff.hasArray() || !bwBuff.hasArray()) {
          mesh.prepareForAnim(true); // prepare for software animation
        }
        VertexBuffer bindPos = mesh.getBuffer(Type.BindPosePosition);
        VertexBuffer bindNorm = mesh.getBuffer(Type.BindPoseNormal);
        VertexBuffer pos = mesh.getBuffer(Type.Position);
        VertexBuffer norm = mesh.getBuffer(Type.Normal);
        FloatBuffer pb = (FloatBuffer) pos.getData();
        FloatBuffer nb = (FloatBuffer) norm.getData();
        FloatBuffer bpb = (FloatBuffer) bindPos.getData();
        FloatBuffer bnb = (FloatBuffer) bindNorm.getData();
        pb.clear();
        nb.clear();
        bpb.clear();
        bnb.clear();

        // reseting bind tangents if there is a bind tangent buffer
        VertexBuffer bindTangents = mesh.getBuffer(Type.BindPoseTangent);
        if (bindTangents != null) {
          VertexBuffer tangents = mesh.getBuffer(Type.Tangent);
          FloatBuffer tb = (FloatBuffer) tangents.getData();
          FloatBuffer btb = (FloatBuffer) bindTangents.getData();
          tb.clear();
          btb.clear();
          tb.put(btb).clear();
        }

        pb.put(bpb).clear();
        nb.put(bnb).clear();
      }
    }
  }
コード例 #29
0
ファイル: FloatToFixed.java プロジェクト: jingchan/jh_rogue
  private static Transform convertPositions(FloatBuffer input, BoundingBox bbox, Buffer output) {
    if (output.capacity() < input.capacity())
      throw new RuntimeException("Output must be at least as large as input!");

    Vector3f offset = bbox.getCenter().negate();
    Vector3f size = new Vector3f(bbox.getXExtent(), bbox.getYExtent(), bbox.getZExtent());
    size.multLocal(2);

    ShortBuffer sb = null;
    ByteBuffer bb = null;
    float dataTypeSize;
    float dataTypeOffset;
    if (output instanceof ShortBuffer) {
      sb = (ShortBuffer) output;
      dataTypeOffset = shortOff;
      dataTypeSize = shortSize;
    } else {
      bb = (ByteBuffer) output;
      dataTypeOffset = byteOff;
      dataTypeSize = byteSize;
    }
    Vector3f scale = new Vector3f();
    scale.set(dataTypeSize, dataTypeSize, dataTypeSize).divideLocal(size);

    Vector3f invScale = new Vector3f();
    invScale.set(size).divideLocal(dataTypeSize);

    offset.multLocal(scale);
    offset.addLocal(dataTypeOffset, dataTypeOffset, dataTypeOffset);

    // offset = (-modelOffset * shortSize)/modelSize + shortOff
    // scale = shortSize / modelSize

    input.clear();
    output.clear();
    Vector3f temp = new Vector3f();
    int vertexCount = input.capacity() / 3;
    for (int i = 0; i < vertexCount; i++) {
      BufferUtils.populateFromBuffer(temp, input, i);

      // offset and scale vector into -32768 ... 32767
      // or into -128 ... 127 if using bytes
      temp.multLocal(scale);
      temp.addLocal(offset);

      // quantize and store
      if (sb != null) {
        short v1 = (short) temp.getX();
        short v2 = (short) temp.getY();
        short v3 = (short) temp.getZ();
        sb.put(v1).put(v2).put(v3);
      } else {
        byte v1 = (byte) temp.getX();
        byte v2 = (byte) temp.getY();
        byte v3 = (byte) temp.getZ();
        bb.put(v1).put(v2).put(v3);
      }
    }

    Transform transform = new Transform();
    transform.setTranslation(offset.negate().multLocal(invScale));
    transform.setScale(invScale);
    return transform;
  }
コード例 #30
0
  public void setLighting(LightList list) {
    // XXX: This is abuse of setLighting() to
    // apply fixed function bindings
    // and do other book keeping.
    if (list == null || list.size() == 0) {
      glDisable(GL_LIGHTING);
      applyFixedFuncBindings(false);
      setModelView(worldMatrix, viewMatrix);
      return;
    }

    // Number of lights set previously
    int numLightsSetPrev = lightList.size();

    // If more than maxLights are defined, they will be ignored.
    // The GL1 renderer is not permitted to crash due to a
    // GL1 limitation. It must render anything that the GL2 renderer
    // can render (even incorrectly).
    lightList.clear();
    materialAmbientColor.set(0, 0, 0, 0);

    for (int i = 0; i < list.size(); i++) {
      Light l = list.get(i);
      if (l.getType() == Light.Type.Ambient) {
        // Gather
        materialAmbientColor.addLocal(l.getColor());
      } else {
        // Add to list
        lightList.add(l);

        // Once maximum lights reached, exit loop.
        if (lightList.size() >= maxLights) {
          break;
        }
      }
    }

    applyFixedFuncBindings(true);

    glEnable(GL_LIGHTING);

    fb16.clear();
    fb16.put(materialAmbientColor.r)
        .put(materialAmbientColor.g)
        .put(materialAmbientColor.b)
        .put(1)
        .flip();

    glLightModel(GL_LIGHT_MODEL_AMBIENT, fb16);

    if (context.matrixMode != GL_MODELVIEW) {
      glMatrixMode(GL_MODELVIEW);
      context.matrixMode = GL_MODELVIEW;
    }
    // Lights are already in world space, so just convert
    // them to view space.
    glLoadMatrix(storeMatrix(viewMatrix, fb16));

    for (int i = 0; i < lightList.size(); i++) {
      int glLightIndex = GL_LIGHT0 + i;
      Light light = lightList.get(i);
      Light.Type lightType = light.getType();
      ColorRGBA col = light.getColor();
      Vector3f pos;

      // Enable the light
      glEnable(glLightIndex);

      // OGL spec states default value for light ambient is black
      switch (lightType) {
        case Directional:
          DirectionalLight dLight = (DirectionalLight) light;

          fb16.clear();
          fb16.put(col.r).put(col.g).put(col.b).put(col.a).flip();
          glLight(glLightIndex, GL_DIFFUSE, fb16);
          glLight(glLightIndex, GL_SPECULAR, fb16);

          pos = tempVec.set(dLight.getDirection()).negateLocal().normalizeLocal();
          fb16.clear();
          fb16.put(pos.x).put(pos.y).put(pos.z).put(0.0f).flip();
          glLight(glLightIndex, GL_POSITION, fb16);
          glLightf(glLightIndex, GL_SPOT_CUTOFF, 180);
          break;
        case Point:
          PointLight pLight = (PointLight) light;

          fb16.clear();
          fb16.put(col.r).put(col.g).put(col.b).put(col.a).flip();
          glLight(glLightIndex, GL_DIFFUSE, fb16);
          glLight(glLightIndex, GL_SPECULAR, fb16);

          pos = pLight.getPosition();
          fb16.clear();
          fb16.put(pos.x).put(pos.y).put(pos.z).put(1.0f).flip();
          glLight(glLightIndex, GL_POSITION, fb16);
          glLightf(glLightIndex, GL_SPOT_CUTOFF, 180);

          if (pLight.getRadius() > 0) {
            // Note: this doesn't follow the same attenuation model
            // as the one used in the lighting shader.
            glLightf(glLightIndex, GL_CONSTANT_ATTENUATION, 1);
            glLightf(glLightIndex, GL_LINEAR_ATTENUATION, pLight.getInvRadius() * 2);
            glLightf(
                glLightIndex,
                GL_QUADRATIC_ATTENUATION,
                pLight.getInvRadius() * pLight.getInvRadius());
          } else {
            glLightf(glLightIndex, GL_CONSTANT_ATTENUATION, 1);
            glLightf(glLightIndex, GL_LINEAR_ATTENUATION, 0);
            glLightf(glLightIndex, GL_QUADRATIC_ATTENUATION, 0);
          }

          break;
        case Spot:
          SpotLight sLight = (SpotLight) light;

          fb16.clear();
          fb16.put(col.r).put(col.g).put(col.b).put(col.a).flip();
          glLight(glLightIndex, GL_DIFFUSE, fb16);
          glLight(glLightIndex, GL_SPECULAR, fb16);

          pos = sLight.getPosition();
          fb16.clear();
          fb16.put(pos.x).put(pos.y).put(pos.z).put(1.0f).flip();
          glLight(glLightIndex, GL_POSITION, fb16);

          Vector3f dir = sLight.getDirection();
          fb16.clear();
          fb16.put(dir.x).put(dir.y).put(dir.z).put(1.0f).flip();
          glLight(glLightIndex, GL_SPOT_DIRECTION, fb16);

          float outerAngleRad = sLight.getSpotOuterAngle();
          float innerAngleRad = sLight.getSpotInnerAngle();
          float spotCut = outerAngleRad * FastMath.RAD_TO_DEG;
          float spotExpo = 0.0f;
          if (outerAngleRad > 0) {
            spotExpo = (1.0f - (innerAngleRad / outerAngleRad)) * 128.0f;
          }

          glLightf(glLightIndex, GL_SPOT_CUTOFF, spotCut);
          glLightf(glLightIndex, GL_SPOT_EXPONENT, spotExpo);

          if (sLight.getSpotRange() > 0) {
            glLightf(glLightIndex, GL_LINEAR_ATTENUATION, sLight.getInvSpotRange());
          } else {
            glLightf(glLightIndex, GL_LINEAR_ATTENUATION, 0);
          }

          break;
        default:
          throw new UnsupportedOperationException("Unrecognized light type: " + lightType);
      }
    }

    // Disable lights after the index
    for (int i = lightList.size(); i < numLightsSetPrev; i++) {
      glDisable(GL_LIGHT0 + i);
    }

    // This will set view matrix as well.
    setModelView(worldMatrix, viewMatrix);
  }