Exemplo n.º 1
0
  @Override
  public void build() {
    program = new GLProgram();
    program.quickCreateResource("Diag", "cs4620/util/Diag.vert", "cs4620/util/Diag.frag", null);

    fxsi =
        new ShaderInterface(
            new ArrayBind[] {
              new ArrayBind(Semantic.Position, GLType.Float, 3, 0),
              new ArrayBind(Semantic.TexCoord, GLType.Float, 2, 3 * 4)
            });
    fxsi.build(program.semanticLinks);

    vb = new GLBuffer(BufferTarget.ArrayBuffer, BufferUsageHint.StaticDraw, true);
    vb.setAsVertex(5 * 4);
    FloatBuffer vBuf = NativeMem.createFloatBuffer(4 * 5);
    vBuf.put(
        new float[] {
          -0.5f, 0.5f, 0, 0, 1, 0.5f, 0.5f, 0, 1, 1, -0.5f, -0.5f, 0, 0, 0, 0.5f, -0.5f, 0, 1, 0
        });
    vBuf.flip();
    vb.setDataInitial(vBuf);

    ib = new GLBuffer(BufferTarget.ElementArrayBuffer, BufferUsageHint.StaticDraw, true);
    ib.setAsIndexInt();
    IntBuffer iBuf = NativeMem.createIntBuffer(6);
    iBuf.put(new int[] {0, 2, 1, 1, 2, 3});
    iBuf.flip();
    ib.setDataInitial(iBuf);

    texture = new GLTexture(TextureTarget.Texture2D, true);
    texture.internalFormat = PixelInternalFormat.Rgba;
    try {
      texture.setImage2DResource("cs4620/util/Diag.png", false);
    } catch (Exception e) {
      System.out.println("NO IMAGE\r\n" + e.getMessage());
    }
  }
Exemplo n.º 2
0
  @Override
  public void draw(GameTime gameTime) {
    GL11.glClearColor(0, 0, 0, 0);
    GL11.glClearDepth(1.0);
    GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);

    RasterizerState.CULL_CLOCKWISE.set();
    BlendState.OPAQUE.set();
    DepthState.DEFAULT.set();

    program.use();
    texture.use(TextureUnit.Texture0, program.getUniform("Texture"));
    vb.useAsAttrib(fxsi);
    ib.bind();
    GL11.glDrawElements(PrimitiveType.Triangles, 6, GLType.UnsignedInt, 0);
    ib.unbind();
    texture.unuse();
    GLProgram.unuse();

    if (!savedImage) {
      int sw = game.getWidth();
      int sh = game.getHeight();
      ByteBuffer pb = NativeMem.createByteBuffer(sw * sh * 4);
      GL11.glReadPixels(0, 0, sw, sh, PixelFormat.Rgba, GLType.UnsignedByte, pb);
      pb.position(0);
      pb.limit(sw * sh * 4);

      byte[] cb = new byte[4];
      BufferedImage im = new BufferedImage(sw, sh, BufferedImage.TYPE_INT_ARGB);
      for (int y = sh - 1; y >= 0; y--) {
        for (int x = 0; x < sw; x++) {
          pb.get(cb);
          im.setRGB(
              x, y, (cb[2] & 0xFF) | ((cb[1] & 0xFF) << 8) | ((cb[0] & 0xFF) << 16) | 0xFF000000);
        }
      }

      try {
        ImageIO.write(im, "png", new File("Diag.png"));
        System.out.println("Image Has Been Saved");
      } catch (IOException e) {
        System.out.println(e.getMessage());
      }

      savedImage = true;
    }
  }
public class RenderMaterial implements IDisposable {
  private static interface IProvider {
    void set(GLProgram p);
  }

  private static class ColorProvider implements IProvider {
    String uniformName;
    Vector4 color;

    public ColorProvider(String name, Color c) {
      uniformName = "col" + name;
      color = new Vector4(c.r() / 255.0f, c.g() / 255.0f, c.b() / 255.0f, c.a() / 255.0f);
    }

    @Override
    public void set(GLProgram p) {
      int uniform = p.getUniform(uniformName);
      if (uniform == GL.BadUniformLocation) return;
      GL20.glUniform4f(uniform, color.x, color.y, color.z, color.w);
    }
  }

  private static class TextureProvider implements IProvider {
    GLTexture t;
    int tUnit, unTextureSampler;

    public TextureProvider(
        String samplerName, GLProgram p, int unit, String texName, RenderEnvironment env) {
      tUnit = TextureUnit.Texture0 + unit;
      unTextureSampler = p.getUniform("tex" + samplerName);
      t = env.textures.get(texName);
      if (t == null) unTextureSampler = GL.BadUniformLocation;
    }

    @Override
    public void set(GLProgram p) {
      if (unTextureSampler == GL.BadUniformLocation) return;
      t.use(tUnit, unTextureSampler);
      SamplerState.LINEAR_CLAMP.set(TextureTarget.Texture2D);
    }
  }

  private static final String ROOT_DIRECTORY = "cs4620/gl/shaders/";
  private static final String PROVIDER_FORMAT_TEXTURE =
      "uniform sampler2D tex%s;\r\n"
          + "vec4 get%sColor(vec2 uv) {\r\n"
          + "  return texture2D(tex%s, uv);\r\n"
          + "}\r\n";
  private static final String PROVIDER_FORMAT_COLOR =
      "uniform vec4 col%s;\r\n"
          + "vec4 get%sColor(vec2 uv) {\r\n"
          + "  return col%s;\r\n"
          + "}\r\n";

  private static String getProvider(String provider, String type) {
    return String.format(provider, type, type, type);
  }

  public final GLProgram program = new GLProgram(false);
  public final ShaderInterface shaderInterface = new ShaderInterface(RenderMesh.VERTEX_DECLARATION);

  private IProvider pDiffuse = null;
  private IProvider pNormal = null;
  private IProvider pSpecular = null;

  public final Material sceneMaterial;

  public int unWorld, unWorldIT, unVP, unLPos, unLIntensity, unLCount;
  private FloatBuffer fbLight = NativeMem.createFloatBuffer(16 * 3);

  public RenderMaterial(Material m) {
    sceneMaterial = m;
  }

  @Override
  public void dispose() {
    program.dispose();
  }

  private String readFullResource(String name) {
    BufferedReader reader = IOUtils.openReaderResource(name);
    if (reader == null) return null;

    return IOUtils.readFull(reader);
  }

  public void loadShaders(RenderEnvironment env) {
    // Read The Vertex Shader Source
    String vsSrc = readFullResource(ROOT_DIRECTORY + sceneMaterial.materialType + ".vert");
    if (vsSrc == null) {
      vsSrc = readFullResource(ROOT_DIRECTORY + Material.T_AMBIENT + ".vert");
      if (vsSrc == null) throw new RuntimeException("Could Not Load A Vertex Shader");
    }

    // Read The Fragment Shader Source
    String fsSrc = readFullResource(ROOT_DIRECTORY + sceneMaterial.materialType + ".frag");
    if (fsSrc == null) {
      fsSrc = readFullResource(ROOT_DIRECTORY + Material.T_AMBIENT + ".frag");
      if (fsSrc == null) throw new RuntimeException("Could Not Load A Vertex Shader");
    }

    // Add In The Special Providers
    fsSrc = fsSrc.replaceFirst("#version 120", "");
    fsSrc =
        getProvider(
                sceneMaterial.inputSpecular.type == Type.TEXTURE
                    ? PROVIDER_FORMAT_TEXTURE
                    : PROVIDER_FORMAT_COLOR,
                "Specular")
            + fsSrc;
    fsSrc =
        getProvider(
                sceneMaterial.inputNormal.type == Type.TEXTURE
                    ? PROVIDER_FORMAT_TEXTURE
                    : PROVIDER_FORMAT_COLOR,
                "Normal")
            + fsSrc;
    fsSrc =
        getProvider(
                sceneMaterial.inputDiffuse.type == Type.TEXTURE
                    ? PROVIDER_FORMAT_TEXTURE
                    : PROVIDER_FORMAT_COLOR,
                "Diffuse")
            + fsSrc;
    fsSrc = "#version 120\r\n" + fsSrc;

    // Create The Program
    program.quickCreateSource(vsSrc, fsSrc, null);

    // Create Mappings
    shaderInterface.build(program.semanticLinks);
    unWorld = program.getUniform("mWorld");
    unWorldIT = program.getUniform("mWorldIT");
    unVP = program.getUniform("mViewProjection");
    unLCount = program.getUniform("numLights");
    unLPos = program.getUniform("lightPosition");
    unLIntensity = program.getUniform("lightIntensity");

    createInputProviders(env);
  }

  public void createInputProviders(RenderEnvironment env) {
    if (sceneMaterial.inputDiffuse.type == Type.TEXTURE)
      pDiffuse =
          new TextureProvider("Diffuse", program, 0, sceneMaterial.inputDiffuse.texture, env);
    else pDiffuse = new ColorProvider("Diffuse", sceneMaterial.inputDiffuse.color);

    if (sceneMaterial.inputNormal.type == Type.TEXTURE)
      pNormal = new TextureProvider("Normal", program, 0, sceneMaterial.inputNormal.texture, env);
    else pNormal = new ColorProvider("Normal", sceneMaterial.inputNormal.color);

    if (sceneMaterial.inputSpecular.type == Type.TEXTURE)
      pSpecular =
          new TextureProvider("Specular", program, 0, sceneMaterial.inputSpecular.texture, env);
    else pSpecular = new ColorProvider("Specular", sceneMaterial.inputSpecular.color);
  }

  public void useProviders() {
    pDiffuse.set(program);
    pNormal.set(program);
    pSpecular.set(program);
  }

  public void useObject(RenderObject o) {
    if (unWorld != GL.BadUniformLocation) {
      GLUniform.setST(unWorld, o.mWorldTransform, false);
    }
    if (unWorldIT != GL.BadUniformLocation) {
      GLUniform.setST(unWorldIT, o.mWorldTransformIT, false);
    }
  }

  public void useCamera(RenderCamera c) {
    if (unVP != GL.BadUniformLocation) {
      GLUniform.setST(unVP, c.mViewProjection, false);
    }
  }

  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);
    }
  }
}