// Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "main.h"
#include "testbase.h"
#include "utils.h"

namespace glbench {

class AttributeFetchShaderTest : public DrawElementsTestFunc {
 public:
  AttributeFetchShaderTest() {}
  virtual ~AttributeFetchShaderTest() {}
  virtual bool Run();
  virtual const char* Name() const { return "attribute_fetch_shader"; }
  virtual bool IsDrawTest() const { return false; }
  virtual const char* Unit() const { return "mvtx_sec"; }

 private:
  DISALLOW_COPY_AND_ASSIGN(AttributeFetchShaderTest);
};

const char* simple_vertex_shader =
    "attribute vec4 c1;"
    "void main() {"
    "    gl_Position = c1;"
    "}";

const char* simple_vertex_shader_2_attr =
    "attribute vec4 c1;"
    "attribute vec4 c2;"
    "void main() {"
    "    gl_Position = c1+c2;"
    "}";

const char* simple_vertex_shader_4_attr =
    "attribute vec4 c1;"
    "attribute vec4 c2;"
    "attribute vec4 c3;"
    "attribute vec4 c4;"
    "void main() {"
    "    gl_Position = c1+c2+c3+c4;"
    "}";

const char* simple_vertex_shader_8_attr =
    "attribute vec4 c1;"
    "attribute vec4 c2;"
    "attribute vec4 c3;"
    "attribute vec4 c4;"
    "attribute vec4 c5;"
    "attribute vec4 c6;"
    "attribute vec4 c7;"
    "attribute vec4 c8;"
    "void main() {"
    "    gl_Position = c1+c2+c3+c4+c5+c6+c7+c8;"
    "}";

const char* simple_fragment_shader =
    "void main() {"
    "    gl_FragColor = vec4(0.5);"
    "}";

GLuint AttributeFetchShaderProgram(int attribute_count,
                                   GLuint vertex_buffers[]) {
  const char* vertex_shader = NULL;
  switch (attribute_count) {
    case 1:
      vertex_shader = simple_vertex_shader;
      break;
    case 2:
      vertex_shader = simple_vertex_shader_2_attr;
      break;
    case 4:
      vertex_shader = simple_vertex_shader_4_attr;
      break;
    case 8:
      vertex_shader = simple_vertex_shader_8_attr;
      break;
    default:
      return 0;
  }
  GLuint program = InitShaderProgram(vertex_shader, simple_fragment_shader);

  for (int i = 0; i < attribute_count; i++) {
    char attribute[] = "c_";
    attribute[1] = '1' + i;
    int attribute_index = glGetAttribLocation(program, attribute);
    glBindBuffer(GL_ARRAY_BUFFER, vertex_buffers[i]);
    glVertexAttribPointer(attribute_index, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    glEnableVertexAttribArray(attribute_index);
  }

  return program;
}

bool AttributeFetchShaderTest::Run() {
  GLint width = 64;
  GLint height = 64;

  glViewport(0, 0, g_width, g_height);

  GLfloat* vertices = NULL;
  GLsizeiptr vertex_buffer_size = 0;
  CreateLattice(&vertices, &vertex_buffer_size, 1.f / g_width, 1.f / g_height,
                width, height);
  GLuint vertex_buffer =
      SetupVBO(GL_ARRAY_BUFFER, vertex_buffer_size, vertices);

  GLushort* indices = NULL;
  GLuint index_buffer = 0;
  GLsizeiptr index_buffer_size = 0;

  // Everything will be back-face culled.
  count_ = CreateMesh(&indices, &index_buffer_size, width, height, 0);
  index_buffer = SetupVBO(GL_ELEMENT_ARRAY_BUFFER, index_buffer_size, indices);

  glEnable(GL_CULL_FACE);

  GLuint vertex_buffers[8];
  for (GLuint i = 0; i < sizeof(vertex_buffers) / sizeof(vertex_buffers[0]);
       i++)
    vertex_buffers[i] = vertex_buffer;

  GLuint program = AttributeFetchShaderProgram(1, vertex_buffers);
  RunTest(this, "attribute_fetch_shader", count_, g_width, g_height, true);
  glDeleteProgram(program);

  program = AttributeFetchShaderProgram(2, vertex_buffers);
  RunTest(this, "attribute_fetch_shader_2_attr", count_, g_width, g_height,
          true);
  glDeleteProgram(program);

  program = AttributeFetchShaderProgram(4, vertex_buffers);
  RunTest(this, "attribute_fetch_shader_4_attr", count_, g_width, g_height,
          true);
  glDeleteProgram(program);

  program = AttributeFetchShaderProgram(8, vertex_buffers);
  RunTest(this, "attribute_fetch_shader_8_attr", count_, g_width, g_height,
          true);
  glDeleteProgram(program);

  glDeleteBuffers(1, &index_buffer);
  delete[] indices;

  glDeleteBuffers(1, &vertex_buffer);
  delete[] vertices;
  return true;
}

TestBase* GetAttributeFetchShaderTest() {
  return new AttributeFetchShaderTest();
}

}  // namespace glbench