Пример #1
0
  protected void convertMesh(ModelMesh modelMesh) {
    int numIndices = 0;
    for (ModelMeshPart part : modelMesh.parts) {
      numIndices += part.indices.length;
    }
    VertexAttributes attributes = new VertexAttributes(modelMesh.attributes);
    int numVertices = modelMesh.vertices.length / (attributes.vertexSize / 4);

    Mesh mesh = new Mesh(true, numVertices, numIndices, attributes);
    meshes.add(mesh);
    disposables.add(mesh);

    BufferUtils.copy(modelMesh.vertices, mesh.getVerticesBuffer(), modelMesh.vertices.length, 0);
    int offset = 0;
    mesh.getIndicesBuffer().clear();
    for (ModelMeshPart part : modelMesh.parts) {
      MeshPart meshPart = new MeshPart();
      meshPart.id = part.id;
      meshPart.primitiveType = part.primitiveType;
      meshPart.offset = offset;
      meshPart.size = part.indices.length;
      meshPart.mesh = mesh;
      mesh.getIndicesBuffer().put(part.indices);
      offset += meshPart.size;
      meshParts.add(meshPart);
    }
    mesh.getIndicesBuffer().position(0);
    for (MeshPart part : meshParts) part.update();
  }
Пример #2
0
 @Override
 public void create() {
   super.create();
   shaderProgram = loadShader("defaultVS.glsl", "spot-phong-FS.glsl");
   spotlight =
       new Spotlight(
           new Vector3(0, 3, 0),
           new Vector3(0, (float) Math.PI / 4 + 0.3f, 0),
           new Vector3(0.3f, 1.0f, 0.3f),
           1,
           (float) Math.PI / 4);
   ModelLoader<?> cubeLoader = new ObjLoader();
   ModelData floorData = cubeLoader.loadModelData(Gdx.files.internal("box.obj"));
   floorTxt = new Texture("texture.png");
   floorMesh =
       new Mesh(
           true,
           floorData.meshes.get(0).vertices.length,
           floorData.meshes.get(0).parts[0].indices.length,
           VertexAttribute.Position(),
           VertexAttribute.Normal(),
           VertexAttribute.TexCoords(0));
   floorMesh.setVertices(floorData.meshes.get(0).vertices);
   floorMesh.setIndices(floorData.meshes.get(0).parts[0].indices);
   floor =
       new ModelObject(
           floorMesh,
           0.2f,
           new Vector3(-150, -2, -150),
           new Vector3(0, 0, 0),
           new Vector3(3000f, 0.1f, 3000f));
   ((MoveablePCamera) camera).addModel(model);
 }
  @Override
  public void create() {
    ShaderProgram.pedantic = false;

    String vs = Gdx.files.internal("signed/vertex.glsl").readString();
    String fs = Gdx.files.internal("signed/fragment.glsl").readString();

    shader = new ShaderProgram(vs, fs);

    if (!shader.isCompiled()) {
      throw new IllegalArgumentException(
          "Error compiling distance field shader: " + shader.getLog());
    }

    mesh =
        new Mesh(true, 4, 6, new VertexAttribute(VertexAttributes.Usage.Position, 3, "a_position"));
    float[] vertices = {1, -1, 0, 1, 1, 0, -1, 1, 0, -1, -1, 0};

    short[] indices = {
      0, 1, 2,
      2, 3, 0
    };
    mesh.setVertices(vertices);
    mesh.setIndices(indices);

    startTime = TimeUtils.millis();
  }
 public AnimationPart(float x, float y, float z, float w, float h, float d) {
   box = new BoundingBox();
   modelMatrix = new Matrix4();
   FloatArray fa = new FloatArray();
   this.x = x;
   this.y = y;
   this.z = z;
   this.w = w;
   this.h = h;
   this.d = d;
   addTopFace(fa, 0, 0, 0, w, h, d);
   addBotFace(fa, 0, 0, 0, w, h, d);
   addLeftFace(fa, 0, 0, 0, w, h, d);
   addRightFace(fa, 0, 0, 0, w, h, d);
   addFrontFace(fa, 0, 0, 0, w, h, d);
   addBackFace(fa, 0, 0, 0, w, h, d);
   if (fa.size > 0) {
     partMesh =
         new Mesh(
             true,
             fa.size,
             0,
             VertexAttributes.position,
             VertexAttributes.normal,
             VertexAttributes.textureCoords);
     partMesh.setVertices(fa.items);
   }
   setTexture(new Texture(Gdx.files.internal("data/grassmap.png")));
   partMesh.calculateBoundingBox(box);
   updateModelMatrix();
 }
Пример #5
0
  private void convertMesh(ModelMesh modelMesh) {
    int numIndices = 0;
    for (ModelMeshPart part : modelMesh.parts) {
      numIndices += part.indices.length;
    }
    VertexAttributes attributes = new VertexAttributes(modelMesh.attributes);
    int numVertices = modelMesh.vertices.length / (attributes.vertexSize / 4);

    Mesh mesh = new Mesh(true, numVertices, numIndices, attributes);
    meshes.add(mesh);
    disposables.add(mesh);

    BufferUtils.copy(modelMesh.vertices, mesh.getVerticesBuffer(), modelMesh.vertices.length, 0);
    int offset = 0;
    mesh.getIndicesBuffer().clear();
    for (ModelMeshPart part : modelMesh.parts) {
      MeshPart meshPart = new MeshPart();
      meshPart.id = part.id; // FIXME not storing the mesh name, part ids may collide!
      meshPart.primitiveType = part.primitiveType;
      meshPart.indexOffset = offset;
      meshPart.numVertices = part.indices.length;
      meshPart.mesh = mesh;
      mesh.getIndicesBuffer().put(part.indices);
      offset += meshPart.numVertices;
      meshParts.add(meshPart);
    }
    mesh.getIndicesBuffer().position(0);
  }
Пример #6
0
  private void renderMesh() {
    if (idx == 0) return;

    renderCalls++;
    totalRenderCalls++;
    int spritesInBatch = idx / 20;
    if (spritesInBatch > maxSpritesInBatch) maxSpritesInBatch = spritesInBatch;

    lastTexture.bind();
    mesh.setVertices(vertices, 0, idx);

    if (blendingDisabled) {
      Gdx.gl.glDisable(GL20.GL_BLEND);
    } else {
      Gdx.gl.glEnable(GL20.GL_BLEND);
      Gdx.gl.glBlendFunc(blendSrcFunc, blendDstFunc);
    }

    if (Gdx.graphics.isGL20Available()) {
      if (customShader != null) mesh.render(customShader, GL10.GL_TRIANGLES, 0, spritesInBatch * 6);
      else mesh.render(shader, GL10.GL_TRIANGLES, 0, spritesInBatch * 6);
    } else {
      mesh.render(GL10.GL_TRIANGLES, 0, spritesInBatch * 6);
    }

    idx = 0;
    currBufferIdx++;
    if (currBufferIdx == buffers.length) currBufferIdx = 0;
    mesh = buffers[currBufferIdx];
  }
Пример #7
0
  private void renderPlanet(
      GL10 gl,
      String texture,
      boolean uvtype,
      float radius,
      float x,
      float y,
      float z,
      Application app) {
    radius = radius * worldscale;

    if (texture.equals("earth")) {
      // render earth/jupiter  texture
      planetTexture.bind();
    } else if (texture.equals("sun")) {
      // render mars/sun  texture
      planetTexture.bind();
    }

    gl.glPushMatrix();
    // move away from origin
    gl.glTranslatef(x, y, z);
    // scale to 10% size of earth
    gl.glScalef(radius, radius, radius);
    gl.glRotatef((Splash.planetmove / 10) - 180, 0, 1, 0);
    if (uvtype == true) {
      // render lower planet texture
      planetMesh.render(GL10.GL_TRIANGLES);
    } else {
      // render upper planet texture
      planetMesh02.render(GL10.GL_TRIANGLES);
    }
    gl.glPopMatrix();
  }
Пример #8
0
 public void clearManagedCaches() {
   Mesh.clearAllMeshes(app);
   Texture.clearAllTextures(app);
   ShaderProgram.clearAllShaderPrograms(app);
   FrameBuffer.clearAllFrameBuffers(app);
   Gdx.app.log("AndroidGraphics", Mesh.getManagedStatus());
   Gdx.app.log("AndroidGraphics", Texture.getManagedStatus());
   Gdx.app.log("AndroidGraphics", ShaderProgram.getManagedStatus());
   Gdx.app.log("AndroidGraphics", FrameBuffer.getManagedStatus());
 }
Пример #9
0
 public void dispose() {
   sphere.dispose();
   steel.dispose();
   plane.dispose();
   wood.dispose();
   wall.dispose();
   green.dispose();
   maja.dispose();
   pink.dispose();
   black.dispose();
 }
Пример #10
0
 @Deprecated
 public static Model createFromMesh(
     final float[] vertices,
     final VertexAttribute[] attributes,
     final short[] indices,
     int primitiveType,
     final Material material) {
   final Mesh mesh = new Mesh(false, vertices.length, indices.length, attributes);
   mesh.setVertices(vertices);
   mesh.setIndices(indices);
   return createFromMesh(mesh, 0, indices.length, primitiveType, material);
 }
Пример #11
0
  private Mesh generateBlock(Mesh mesh, float width, float length, float height) {
    mesh.setVertices(
        new float[] {
          width / 2, length / 2, height / 2, -width / 2, length / 2, height / 2, -width / 2,
          -length / 2, height / 2, width / 2, -length / 2, height / 2, -width / 2, -length / 2,
          -height / 2, -width / 2, length / 2, -height / 2, width / 2, length / 2, -height / 2,
          width / 2, -length / 2, -height / 2
        });
    mesh.setIndices(new short[] {0, 1, 5, 2, 4, 7, 5, 6, 0, 7, 3, 2, 0, 1});

    return mesh;
  }
 public void rebuild() {
   FloatArray fa = new FloatArray();
   addTopFace(fa, 0, 0, 0, w, h, d);
   addBotFace(fa, 0, 0, 0, w, h, d);
   addLeftFace(fa, 0, 0, 0, w, h, d);
   addRightFace(fa, 0, 0, 0, w, h, d);
   addFrontFace(fa, 0, 0, 0, w, h, d);
   addBackFace(fa, 0, 0, 0, w, h, d);
   if (fa.size > 0) {
     partMesh.setVertices(fa.items);
   }
   partMesh.calculateBoundingBox(box);
   updateModelMatrix();
 }
  public void clearManagedCaches() {
    Mesh.clearAllMeshes(app);
    Texture.clearAllTextures(app);
    ShaderProgram.clearAllShaderPrograms(app);
    FrameBuffer.clearAllFrameBuffers(app);

    if (AndroidLiveWallpaperService
        .DEBUG) { // to prevent creating too many string buffers in live wallpapers
      Gdx.app.debug("AndroidGraphics", Mesh.getManagedStatus());
      Gdx.app.debug("AndroidGraphics", Texture.getManagedStatus());
      Gdx.app.debug("AndroidGraphics", ShaderProgram.getManagedStatus());
      Gdx.app.debug("AndroidGraphics", FrameBuffer.getManagedStatus());
    }
  }
Пример #14
0
 @Override
 public void render() {
   Gdx.gl10.glPushMatrix();
   Gdx.gl10.glTranslatef(x, y, z);
   mesh.render(GL10.GL_TRIANGLES);
   Gdx.gl10.glPopMatrix();
 }
Пример #15
0
  @Override
  public void create() {
    mesh =
        new Mesh(
            true,
            3,
            0,
            new VertexAttribute(Usage.Position, 3, "a_Position"),
            new VertexAttribute(Usage.ColorPacked, 4, "a_Color"),
            new VertexAttribute(Usage.TextureCoordinates, 2, "a_texCoords"));
    float c1 = Color.toFloatBits(255, 0, 0, 255);
    float c2 = Color.toFloatBits(255, 0, 0, 255);
    ;
    float c3 = Color.toFloatBits(0, 0, 255, 255);
    ;

    mesh.setVertices(
        new float[] {-0.5f, -0.5f, 0, c1, 0, 0, 0.5f, -0.5f, 0, c2, 1, 0, 0, 0.5f, 0, c3, 0.5f, 1});

    texture = new Texture(Gdx.files.internal("data/badlogic.jpg"));

    spriteBatch = new SpriteBatch();
    frameBuffer = new FrameBuffer(Format.RGB565, 128, 128, true);
    createShader(Gdx.graphics);
  }
 public void updateModelMatrix() {
   modelMatrix.setToTranslation(x, y, z);
   modelMatrix.rotate(1, 0, 0, rotationX);
   modelMatrix.rotate(0, 0, 1, rotationZ);
   modelMatrix.rotate(0, 1, 0, rotationY);
   partMesh.calculateBoundingBox(box);
 }
 public void dispose() {
   try {
     mMesh.dispose();
   } catch (Exception e) {
     System.out.println(mMesh + e.getMessage());
   }
 }
Пример #18
0
  /** Call this after scene. Renders the bloomed scene. */
  public void render() {
    if (capturing) {
      capturing = false;
      frameBuffer.end();
    }

    Gdx.gl.glDisable(GL20.GL_BLEND);
    Gdx.gl.glDisable(GL20.GL_DEPTH_TEST);
    Gdx.gl.glDepthMask(false);

    gaussianBlur();

    if (blending) {
      Gdx.gl.glEnable(GL20.GL_BLEND);
      Gdx.gl.glBlendFunc(GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA);
    }

    pingPongTex1.bind(1);
    original.bind(0);
    bloomShader.begin();
    {
      fullScreenQuad.render(bloomShader, GL20.GL_TRIANGLE_FAN);
    }
    bloomShader.end();
  }
Пример #19
0
  @Override
  public void render() {
    frameBuffer.begin();
    Gdx.graphics.getGL20().glViewport(0, 0, frameBuffer.getWidth(), frameBuffer.getHeight());
    Gdx.graphics.getGL20().glClearColor(0f, 1f, 0f, 1);
    Gdx.graphics.getGL20().glClear(GL20.GL_COLOR_BUFFER_BIT);
    Gdx.graphics.getGL20().glEnable(GL20.GL_TEXTURE_2D);
    texture.bind();
    meshShader.begin();
    meshShader.setUniformi("u_texture", 0);
    mesh.render(meshShader, GL20.GL_TRIANGLES);
    meshShader.end();
    frameBuffer.end();

    Gdx.graphics.getGL20().glViewport(0, 0, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
    Gdx.graphics.getGL20().glClearColor(0.2f, 0.2f, 0.2f, 1);
    Gdx.graphics.getGL20().glClear(GL20.GL_COLOR_BUFFER_BIT);

    spriteBatch.begin();
    spriteBatch.draw(
        frameBuffer.getColorBufferTexture(),
        0,
        0,
        256,
        256,
        0,
        0,
        frameBuffer.getColorBufferTexture().getWidth(),
        frameBuffer.getColorBufferTexture().getHeight(),
        false,
        true);
    spriteBatch.end();
  }
Пример #20
0
  private void gaussianBlur() {

    // cut bright areas of the picture and blit to smaller fbo

    original.bind(0);
    pingPongBuffer1.begin();
    {
      tresholdShader.begin();
      {
        // tresholdShader.setUniformi("u_texture0", 0);
        fullScreenQuad.render(tresholdShader, GL20.GL_TRIANGLE_FAN, 0, 4);
      }
      tresholdShader.end();
    }
    pingPongBuffer1.end();

    for (int i = 0; i < blurPasses; i++) {

      pingPongTex1.bind(0);

      // horizontal
      pingPongBuffer2.begin();
      {
        blurShader.begin();
        {
          blurShader.setUniformf("dir", 1f, 0f);
          fullScreenQuad.render(blurShader, GL20.GL_TRIANGLE_FAN, 0, 4);
        }
        blurShader.end();
      }
      pingPongBuffer2.end();

      pingPongTex2.bind(0);
      // vertical
      pingPongBuffer1.begin();
      {
        blurShader.begin();
        {
          blurShader.setUniformf("dir", 0f, 1f);

          fullScreenQuad.render(blurShader, GL20.GL_TRIANGLE_FAN, 0, 4);
        }
        blurShader.end();
      }
      pingPongBuffer1.end();
    }
  }
Пример #21
0
  /** End building the mesh and returns the mesh */
  public Mesh end() {
    if (this.attributes == null) throw new RuntimeException("Call begin() first");
    endpart();

    final Mesh mesh = new Mesh(true, vertices.size, indices.size, attributes);
    mesh.setVertices(vertices.items, 0, vertices.size);
    mesh.setIndices(indices.items, 0, indices.size);

    for (MeshPart p : parts) p.mesh = mesh;
    parts.clear();

    attributes = null;
    vertices.clear();
    indices.clear();

    return mesh;
  }
 public void render(Application app, boolean hit) {
   app.modelViewProjectionMatrix.set(app.cam.combined);
   app.modelViewProjectionMatrix.mul(modelMatrix);
   if (hit) app.shader.setUniformi("s_hit", 1);
   else app.shader.setUniformi("s_hit", 0);
   texture.bind(0);
   app.shader.setUniformi("s_texture", 0);
   app.shader.setUniformMatrix("u_mvpMatrix", app.modelViewProjectionMatrix);
   partMesh.render(app.shader, GL20.GL_TRIANGLES);
 }
Пример #23
0
  @Override
  public void create() {
    texture = new Texture(Gdx.files.internal("data/badlogicsmall.jpg"));
    texture.setFilter(TextureFilter.Linear, TextureFilter.Linear);

    mesh =
        new Mesh(
            true,
            4,
            6,
            new VertexAttribute(VertexAttributes.Usage.Position, 2, "a_pos"),
            new VertexAttribute(VertexAttributes.Usage.TextureCoordinates, 2, "a_texCoords"));

    float[] vertices = new float[4 * 4];

    int idx = 0;
    vertices[idx++] = -1;
    vertices[idx++] = -1;
    vertices[idx++] = 0;
    vertices[idx++] = 0;

    vertices[idx++] = -1;
    vertices[idx++] = 1;
    vertices[idx++] = 0;
    vertices[idx++] = 1;

    vertices[idx++] = 1;
    vertices[idx++] = 1;
    vertices[idx++] = 1;
    vertices[idx++] = 1;

    vertices[idx++] = 1;
    vertices[idx++] = -1;
    vertices[idx++] = 1;
    vertices[idx++] = 0;

    short[] indices = {0, 1, 2, 2, 3, 0};
    mesh.setVertices(vertices);
    mesh.setIndices(indices);

    Gdx.input.setInputProcessor(this);
  }
Пример #24
0
  public void render() {
    Gdx.gl20.glViewport(0, 0, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
    Gdx.gl20.glClear(GL20.GL_COLOR_BUFFER_BIT);

    Gdx.gl20.glActiveTexture(GL20.GL_TEXTURE0);
    texture.bind();
    shader.begin();
    shader.setUniformf("s_texture", 0);

    Gdx.gl20.glTexParameteri(GL20.GL_TEXTURE_2D, GL20.GL_TEXTURE_MIN_FILTER, GL20.GL_NEAREST);
    shader.setUniformf("u_offset", -0.6f);
    mesh.render(shader, GL20.GL_TRIANGLES);

    Gdx.gl20.glTexParameteri(
        GL20.GL_TEXTURE_2D, GL20.GL_TEXTURE_MIN_FILTER, GL20.GL_LINEAR_MIPMAP_LINEAR);
    shader.setUniformf("u_offset", 0.6f);
    mesh.render(shader, GL20.GL_TRIANGLES);

    shader.end();
  }
Пример #25
0
  /** Call this when application is exiting. */
  public void dispose() {
    if (disposeFBO) frameBuffer.dispose();

    fullScreenQuad.dispose();

    pingPongBuffer1.dispose();
    pingPongBuffer2.dispose();

    blurShader.dispose();
    bloomShader.dispose();
    tresholdShader.dispose();
  }
Пример #26
0
  private void renderStaticShip(GL10 gl, Application app) {

    shipTexture.bind();
    gl.glPushMatrix();
    gl.glTranslatef(0, 0, 0);
    shipMesh.render(GL10.GL_TRIANGLES);
    gl.glPopMatrix();
    float noise = (float) Math.random() / 2;
    renderJet(gl, 2.3f, 1f + noise, 1.1f, -.5f, 1.8f, app);
    noise = (float) Math.random() / 2;
    renderJet(gl, 2.3f, 1f + noise, -1.1f, -.5f, 1.8f, app);
  }
Пример #27
0
  public Mesh getMesh() {
    float[] verts = new float[getVertexSize() * numVertices];
    short[] indices = new short[numIndices];
    VertexAttribute[] attributes = getVertexAttributes();

    for (int i = 0; i < numIndices; i++) {
      VertexIndices vertex = triangles.get(i);
      if (vertex.index > Short.MAX_VALUE || vertex.index < Short.MIN_VALUE)
        throw new GdxRuntimeException("index to big for short: " + vertex.index);
      indices[i] = (short) vertex.index;
    }

    int idx = 0;
    int destOffset = 0;

    for (int i = 0; i < vertices.size; i++) {
      VertexIndices vertex = vertices.get(i);

      for (int j = 0; j < sources.length; j++) {
        Source source = sources[j];
        float[] data = source.data;
        int index = vertex.indices[j];
        int components = source.components;
        int sourceOffset = index * components;

        for (int k = 0; k < components; k++) {
          if ((attributes[j].usage == Usage.TextureCoordinates) && k == 1) {
            verts[destOffset++] = 1 - data[sourceOffset++];
          } else {
            verts[destOffset++] = data[sourceOffset++];
          }
        }
      }
    }

    Mesh mesh = new Mesh(true, vertices.size, indices.length, attributes);
    mesh.setVertices(verts);
    mesh.setIndices(indices);
    return mesh;
  }
Пример #28
0
  private Mesh createFullscreenQuad() {
    // vertex coord
    verts[X1] = -1;
    verts[Y1] = -1;

    verts[X2] = 1;
    verts[Y2] = -1;

    verts[X3] = 1;
    verts[Y3] = 1;

    verts[X4] = -1;
    verts[Y4] = 1;

    // tex coords
    verts[U1] = 0f;
    verts[V1] = 0f;

    verts[U2] = 1f;
    verts[V2] = 0f;

    verts[U3] = 1f;
    verts[V3] = 1f;

    verts[U4] = 0f;
    verts[V4] = 1f;

    Mesh tmpMesh =
        new Mesh(
            VertexDataType.VertexArray,
            true,
            4,
            0,
            new VertexAttribute(Usage.Position, 2, "a_position"),
            new VertexAttribute(Usage.TextureCoordinates, 2, "a_texCoord0"));

    tmpMesh.setVertices(verts);
    return tmpMesh;
  }
Пример #29
0
  private void renderSky(GL10 gl) {

    gl.glDisable(GL10.GL_LIGHTING);
    skyTexture.bind();
    gl.glColor4f(1, 1, 1, 1);

    gl.glPushMatrix();
    gl.glTranslatef(0, 0, 0);
    gl.glScalef(100f, 100f, 100f);
    skyMesh.render(GL10.GL_TRIANGLES);
    gl.glPopMatrix();
    gl.glEnable(GL10.GL_LIGHTING);
  }
Пример #30
0
 @Override
 public void onSurfaceCreated(javax.microedition.khronos.opengles.GL10 gl, EGLConfig config) {
   eglContext = ((EGL10) EGLContext.getEGL()).eglGetCurrentContext();
   setupGL(gl);
   logConfig(config);
   updatePpi();
   Mesh.invalidateAllMeshes(app);
   Texture.invalidateAllTextures(app);
   ShaderProgram.invalidateAllShaderPrograms(app);
   FrameBuffer.invalidateAllFrameBuffers(app);
   Gdx.app.log("AndroidGraphics", Mesh.getManagedStatus());
   Gdx.app.log("AndroidGraphics", Texture.getManagedStatus());
   Gdx.app.log("AndroidGraphics", ShaderProgram.getManagedStatus());
   Gdx.app.log("AndroidGraphics", FrameBuffer.getManagedStatus());
   Display display = app.getWindowManager().getDefaultDisplay();
   this.width = display.getWidth();
   this.height = display.getHeight();
   mean = new WindowedMean(5);
   this.lastFrameTime = System.nanoTime();
   gl.glViewport(0, 0, this.width, this.height);
   isSurfaceCreated = true;
 }