예제 #1
0
    virtual void startup()
    {
        static const char * vs_source[] =
        {
            "#version 430 core                                                       \n"
            "                                                                   \n"
            "in vec4 position;                                                  \n"
            "                                                                   \n"
            "uniform mat4 mv_matrix;                                            \n"
            "uniform mat4 proj_matrix;                                          \n"
            "                                                                   \n"
            "out VS_OUT                                                         \n"
            "{                                                                  \n"
            "    vec2 tc;                                                       \n"
            "} vs_out;                                                          \n"
            "                                                                   \n"
            "void main(void)                                                    \n"
            "{                                                                  \n"
            "    gl_Position = proj_matrix * mv_matrix * position;              \n"
            "    vs_out.tc = position.xy;                     \n"
            "}                                                                  \n"
        };

        static const char * fs_source[] =
        {
            "#version 430 core                                                       \n"
            "                                                                   \n"
            "out vec4 color;                                                    \n"
            "                                                                   \n"
            "in VS_OUT                                                          \n"
            "{                                                                  \n"
            "    vec2 tc;                                                       \n"
            "} fs_in;                                                           \n"
            "                                                                   \n"
            "void main(void)                                                    \n"
            "{                                                                  \n"
            "    float val = abs(fs_in.tc.x + fs_in.tc.y) * 20.0f;              \n"
            "    color = vec4(fract(val) >= 0.5 ? 1.0 : 0.25);                  \n"
            "}                                                                  \n"
        };

        program = glCreateProgram();
        GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(fs, 1, fs_source, NULL);
        glCompileShader(fs);

        GLuint vs = glCreateShader(GL_VERTEX_SHADER);
        glShaderSource(vs, 1, vs_source, NULL);
        glCompileShader(vs);

        glAttachShader(program, vs);
        glAttachShader(program, fs);

        glLinkProgram(program);

        mv_location = glGetUniformLocation(program, "mv_matrix");
        proj_location = glGetUniformLocation(program, "proj_matrix");

        glGenVertexArrays(1, &vao);
        glBindVertexArray(vao);

        static const GLushort vertex_indices[] =
        {
            0, 1, 2,
            2, 1, 3,
            2, 3, 4,
            4, 3, 5,
            4, 5, 6,
            6, 5, 7,
            6, 7, 0,
            0, 7, 1,
            6, 0, 2,
            2, 4, 6,
            7, 5, 3,
            7, 3, 1
        };

        static const GLfloat vertex_positions[] =
        {
            -0.25f, -0.25f, -0.25f,
            -0.25f,  0.25f, -0.25f,
             0.25f, -0.25f, -0.25f,
             0.25f,  0.25f, -0.25f,
             0.25f, -0.25f,  0.25f,
             0.25f,  0.25f,  0.25f,
            -0.25f, -0.25f,  0.25f,
            -0.25f,  0.25f,  0.25f,
        };

        glGenBuffers(1, &position_buffer);
        glBindBuffer(GL_ARRAY_BUFFER, position_buffer);
        glBufferData(GL_ARRAY_BUFFER,
                     sizeof(vertex_positions),
                     vertex_positions,
                     GL_STATIC_DRAW);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
        glEnableVertexAttribArray(0);

        glGenBuffers(1, &index_buffer);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER,
                     sizeof(vertex_indices),
                     vertex_indices,
                     GL_STATIC_DRAW);

        glEnable(GL_CULL_FACE);
    }
예제 #2
0
void VertexManager::vFlush(bool useDstAlpha)
{
  GLVertexFormat* nativeVertexFmt = (GLVertexFormat*)VertexLoaderManager::GetCurrentVertexFormat();
  u32 stride = nativeVertexFmt->GetVertexStride();

  if (m_last_vao != nativeVertexFmt->VAO)
  {
    glBindVertexArray(nativeVertexFmt->VAO);
    m_last_vao = nativeVertexFmt->VAO;
  }

  PrepareDrawBuffers(stride);

  // Makes sure we can actually do Dual source blending
  bool dualSourcePossible = g_ActiveConfig.backend_info.bSupportsDualSourceBlend;

  // If host supports GL_ARB_blend_func_extended, we can do dst alpha in
  // the same pass as regular rendering.
  if (useDstAlpha && dualSourcePossible)
  {
    ProgramShaderCache::SetShader(DSTALPHA_DUAL_SOURCE_BLEND, m_current_primitive_type);
  }
  else
  {
    ProgramShaderCache::SetShader(DSTALPHA_NONE, m_current_primitive_type);
  }

  // upload global constants
  ProgramShaderCache::UploadConstants();

  // setup the pointers
  nativeVertexFmt->SetupVertexPointers();

  Draw(stride);

  // run through vertex groups again to set alpha
  if (useDstAlpha && !dualSourcePossible)
  {
    ProgramShaderCache::SetShader(DSTALPHA_ALPHA_PASS, m_current_primitive_type);

    // only update alpha
    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE);

    glDisable(GL_BLEND);

    Draw(stride);

    // restore color mask
    g_renderer->SetColorMask();

    if (bpmem.blendmode.blendenable || bpmem.blendmode.subtract)
      glEnable(GL_BLEND);
  }

#if defined(_DEBUG) || defined(DEBUGFAST)
  if (g_ActiveConfig.iLog & CONF_SAVESHADERS)
  {
    // save the shaders
    ProgramShaderCache::PCacheEntry prog = ProgramShaderCache::GetShaderProgram();
    std::string filename = StringFromFormat(
        "%sps%.3d.txt", File::GetUserPath(D_DUMPFRAMES_IDX).c_str(), g_ActiveConfig.iSaveTargetId);
    std::ofstream fps;
    OpenFStream(fps, filename, std::ios_base::out);
    fps << prog.shader.strpprog;

    filename = StringFromFormat("%svs%.3d.txt", File::GetUserPath(D_DUMPFRAMES_IDX).c_str(),
                                g_ActiveConfig.iSaveTargetId);
    std::ofstream fvs;
    OpenFStream(fvs, filename, std::ios_base::out);
    fvs << prog.shader.strvprog;
  }

  if (g_ActiveConfig.iLog & CONF_SAVETARGETS)
  {
    std::string filename =
        StringFromFormat("%starg%.3d.png", File::GetUserPath(D_DUMPFRAMES_IDX).c_str(),
                         g_ActiveConfig.iSaveTargetId);
    TargetRectangle tr;
    tr.left = 0;
    tr.right = Renderer::GetTargetWidth();
    tr.top = 0;
    tr.bottom = Renderer::GetTargetHeight();
    g_renderer->SaveScreenshot(filename, tr);
  }
#endif
  g_Config.iSaveTargetId++;

  ClearEFBCache();
}
예제 #3
0
void TextRenderer::LoadText(unsigned int _w, unsigned int _h)
{
    m_TextShader = new ShaderHandler();

    m_TextShader->CreateShaderProgram();
    m_TextShader->AddShader("../../../Content/Shaders/text_vertex.glsl", GL_VERTEX_SHADER);
    m_TextShader->AddShader("../../../Content/Shaders/text_fragment.glsl", GL_FRAGMENT_SHADER);
    m_TextShader->LinkShaderProgram();

    LoadLetters();

    float w = (8.f * (Text::LETTERS-1)) / (_w);
    float h = 8.0f / (_h);

    // Load texture file and convert to openGL format
    GLbyte imgData[64 * Text::LETTERS];
    int k = 0;
    int x = 0;
    for (int i = 0; i < 8; i++)
    {
        for (int j = 0; j < m_letters64.size(); j++)
        {
            for (int g = 0; g < 8; g++)
            {
                imgData[k] = (*m_letters64[j])[i * 8 + g];//[j];
                k++;
                x++;
            }
        }
    }

    glActiveTexture(GL_TEXTURE3);
    glGenTextures(1, &m_TextInfo.TexHandle);
    glBindTexture(GL_TEXTURE_2D, m_TextInfo.TexHandle);

    // Copy file to OpenGL
    //glActiveTexture(GL_TEXTURE0); error = glGetError();
    glGenTextures(1, &m_TextInfo.TexHandle);
    glBindTexture(GL_TEXTURE_2D, m_TextInfo.TexHandle);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    //gluBuild2DMipmaps(GL_TEXTURE_2D, channels, width, height, GL_RGBA, GL_UNSIGNED_BYTE, imgData);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RED,(GLsizei)(8 * m_letters64.size()), 8, 0, GL_RED, GL_BYTE, imgData);

    m_TextInfo.Height = h;
    m_TextInfo.Width = w;
    m_TextInfo.X = 0;
    m_TextInfo.Y = 0;

    //buffra datan till 2D shader
    float positionData[] = {
        -1.0, -1.0,
        -1.0, 1.0,
        1.0, -1.0,
        -1.0, 1.0,
        1.0, 1.0,
        1.0, -1.0
    };

    float texCoordData[] = {
        0.0f, 1.0f,
        0.0f, 0.0f,
        1.0f, 1.0f,
        0.0f, 0.0f,
        1.0f, 0.0f,
        1.0f, 1.0f
    };

    int nrOfPoints = 12;

    GLuint m_2DVBO[2];
    glGenBuffers(2, m_2DVBO);

    // "Bind" (switch focus to) first buffer
    glBindBuffer(GL_ARRAY_BUFFER, m_2DVBO[0]);
    glBufferData(GL_ARRAY_BUFFER, nrOfPoints * sizeof(float), positionData, GL_STATIC_DRAW);

    glBindBuffer(GL_ARRAY_BUFFER, m_2DVBO[1]);
    glBufferData(GL_ARRAY_BUFFER, nrOfPoints * sizeof(float), texCoordData, GL_STATIC_DRAW);

    // create 1 VAO
    glGenVertexArrays(1, &m_2DVAO);
    glBindVertexArray(m_2DVAO);

    // enable "vertex attribute arrays"
    glEnableVertexAttribArray(0); // position
    glEnableVertexAttribArray(1); // texCoord

    // map index 0 to position buffer
    glBindBuffer(GL_ARRAY_BUFFER, m_2DVBO[0]);
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (GLubyte *)NULL);

    glBindBuffer(GL_ARRAY_BUFFER, m_2DVBO[1]);
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, (GLubyte *)NULL);



    glBindVertexArray(0); // disable VAO
    glUseProgram(0); // disable shader program
    glDeleteBuffers(2, m_2DVBO);

    GLenum error = glGetError();
    if (error != GL_NO_ERROR)
    {
        printf("Error loading text %d\n", error);
    }
}
예제 #4
0
void InitLivin(int width, int height){
   int i;
   char letterpath[] = "data/x.obj"; /* character mesh mask */
   char letterlist[LETTERNUM] = "bceginrsty"; /* Cybernetic genetics characters */
   char greetingspath[21];

   /* OpenGL related initialization */
   glClearColor(0.0, 0.0, 0.0, 0.0);
   glEnable(GL_DEPTH_TEST);
   glEnable(GL_BLEND);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
   
   perspectiveMatrix(pmatrix, 35.0, (float)width/(float)height, 0.1, 1500.0);

   /* Demo related initialization */
   head      = openDepthVideo("data/head.dv");
   matat     = openDepthVideo("data/matat.dv");
   face      = initFace("shaders/face.vs", "shaders/face.fs");
   armface   = initFace("shaders/face.vs", "shaders/face.fs");
   knock     = openOutline("data/knock.pyd",           "shaders/knock.vs",   "shaders/knock.fs");
   jump      = openOutline("data/jump.pyd",            "shaders/jump.vs",    "shaders/outline.fs");
   hang      = openOutline("data/hanging.pyd",         "shaders/hang.vs",    "shaders/outline.fs");
   run       = openOutline("data/run.pyd",             "shaders/run.vs",     "shaders/outline.fs");
   falling   = openOutline("data/falling_letters.pyd", "shaders/run.vs",     "shaders/outline.fs");
   door      = openOutline("data/door.pyd",            "shaders/door.vs",    "shaders/door.fs");
   trap      = openOutline("data/trap.pyd",            "shaders/trap.vs",    "shaders/outline.fs");
   fractalme = openOutline("data/fractalme.pyd",       "shaders/frme.vs",    "shaders/frme.fs");
   /* Acrobatic outlines */
   tiger     = openOutline("data/tiger.pyd",           "shaders/acrobat.vs", "shaders/outline.fs");
   hop       = openOutline("data/hop.pyd",             "shaders/acrobat.vs", "shaders/outline.fs");
   katf      = openOutline("data/kezenatfordulas.pyd", "shaders/acrobat.vs", "shaders/outline.fs");
   flip      = openOutline("data/flip.pyd",            "shaders/acrobat.vs", "shaders/outline.fs");
   run2      = openOutline("data/run2.pyd",            "shaders/acrobat.vs", "shaders/outline.fs");
   catwheel  = openOutline("data/catwheel.pyd",        "shaders/acrobat.vs", "shaders/outline.fs");
   tbill     = openOutline("data/tarkobillenes.pyd",   "shaders/acrobat.vs", "shaders/outline.fs");

   createBox();
   createBackground();
   initGreetings();
   createDistBack();
   bigcube = createBigCube(600);

   titletex   = loadPNGTexture("data/title.png");
   greentex   = loadPNGTexture("data/green.png");
   creditstex = loadPNGTexture("data/credits.png");
   bgalphatex = loadPNGTexture("data/bg_alpha.png");
   whitetex   = loadPNGTexture("data/white.png");
   icubetex   = loadPNGTexture("data/innercube.png");
   headouttex = loadPNGTexture("data/headout.png");
   chesstex   = loadPNGTexture("data/chessboard.png");
   atpartytex = loadPNGTexture("data/at_party.png");

   for(i = 0; i < 12; i++){
      sprintf(greetingspath, "data/greetings%d.png", i+1);
      greetingstex[i] = loadPNGTexture(greetingspath);
   }

   for(i = 0; i < MAXKNOCKINGMAN; i++){
      knockingmans[i * 3 + 0] = drand48() * 4.0 + 8.0;
      knockingmans[i * 3 + 1] = drand48() * 6.0 + 1.0;
      knockingmans[i * 3 + 2] = drand48();
   }

   /* Shaders */
   background_src[0] = loadShader(GL_VERTEX_SHADER,          "shaders/background.vs");
   background_src[1] = loadShader(GL_FRAGMENT_SHADER,        "shaders/background.fs");
   background_src[2] = loadShader(GL_TESS_EVALUATION_SHADER, "shaders/background.te");
   background_src[3] = loadShader(GL_TESS_CONTROL_SHADER,    "shaders/background.tc");
   background_src[4] = loadShader(GL_GEOMETRY_SHADER,        "shaders/background.gs");
   background_shader = createProgram(5, background_src);

   title_src[0]      = background_src[0];
   title_src[1]      = loadShader(GL_FRAGMENT_SHADER, "shaders/title.fs");
   title_src[2]      = background_src[2];
   title_src[3]      = background_src[3];
   title_src[4]      = background_src[4];
   title_shader      = createProgram(5, title_src);

   scroll_src[0]     = background_src[0];
   scroll_src[1]     = loadShader(GL_FRAGMENT_SHADER, "shaders/scroll.fs");
   scroll_src[2]     = background_src[2];
   scroll_src[3]     = background_src[3];
   scroll_src[4]     = background_src[4];
   scroll_shader     = createProgram(5, scroll_src);

   credits_src[0]    = background_src[0];
   credits_src[1]    = loadShader(GL_FRAGMENT_SHADER, "shaders/credits.fs");
   credits_src[2]    = background_src[2];
   credits_src[3]    = background_src[3];
   credits_src[4]    = loadShader(GL_GEOMETRY_SHADER, "shaders/credits.gs");
   credits_shader    = createProgram(5, credits_src);

   letter_src[0]     = loadShader(GL_VERTEX_SHADER,   "shaders/letter.vs");
   letter_src[1]     = loadShader(GL_FRAGMENT_SHADER, "shaders/letter.fs");
   letter_shader     = createProgram(2, letter_src);

   cube_src[0]       = loadShader(GL_VERTEX_SHADER,   "shaders/cube.vs");
   cube_src[1]       = loadShader(GL_FRAGMENT_SHADER, "shaders/cube.fs");
   cube_src[2]       = loadShader(GL_GEOMETRY_SHADER, "shaders/cube.gs");
   cube_shader       = createProgram(3, cube_src);

   gr_src[0]         = loadShader(GL_VERTEX_SHADER,   "shaders/greetings.vs");
   gr_src[1]         = loadShader(GL_FRAGMENT_SHADER, "shaders/greetings.fs");
   gr_shader         = createProgram(2, gr_src);

   dbgr_src[0]       = loadShader(GL_VERTEX_SHADER,   "shaders/dbgr.vs");
   dbgr_src[1]       = loadShader(GL_FRAGMENT_SHADER, "shaders/dbgr.fs");
   dbgr_shader       = createProgram(2, dbgr_src);

   bigcube_src[0]    = loadShader(GL_VERTEX_SHADER,   "shaders/bigcube.vs");
   bigcube_src[1]    = loadShader(GL_FRAGMENT_SHADER, "shaders/bigcube.fs");
   bigcube_shader    = createProgram(2, bigcube_src);

   /* Letters */
   for(i = 0; i < LETTERNUM; i++){
      letterpath[5] = letterlist[i];
      letters[i] = loadOBJ(letterpath);

      glBindVertexArray(letters[i]->vao);
      bindVarToBuff(letter_shader, "vertex", letters[i]->vbo[MESHVERTEXINDEX], 3);
      bindVarToBuff(letter_shader, "normal", letters[i]->vbo[MESHNORMALINDEX], 3);
      bindVarToBuff(letter_shader, "tcoord", letters[i]->vbo[MESHTEXINDEX],    2);
   }

   cube = loadOBJ("data/cube.obj");
   glBindVertexArray(cube->vao);
   bindVarToBuff(cube_shader, "vertex", cube->vbo[MESHVERTEXINDEX], 3);
   bindVarToBuff(cube_shader, "normal", cube->vbo[MESHNORMALINDEX], 3);
   bindVarToBuff(cube_shader, "tcoord", cube->vbo[MESHTEXINDEX],    2);

   initExplosion();

   startTime();
}
예제 #5
0
int main()
{
    sf::Window window(sf::VideoMode(1280, 720), "OpenGLCube");

    //GLEW
    glewExperimental = GL_TRUE;
    glewInit();

    //Vertex Shader Source
    const GLchar* vertexShaderSource[] =
    {
    "#version 150\n"
    "\n"
    "in vec2 position;\n"
    "in vec2 texcoord;\n"
    "in vec3 color;\n"
    "\n"
    "out vec3 Color;\n"
    "out vec2 Texcoord;\n"
    "\n"
    "void main()\n"
    "{\n"
    "   Texcoord = texcoord;"
    "   Color = color;\n"
    "   gl_Position = vec4(position, 0.0, 1.0);\n"
    "}\n"
    };

    //Fragment Shader Source
    const GLchar* fragmentShaderSource[] =
    {
    "#version 150\n"
    "\n"
    "in vec3 Color;\n"
    "in vec2 Texcoord;\n"
    "\n"
    "out vec4 outColor;\n"
    "\n"
    "uniform sampler2D tex;"
    "\n"
    "void main()\n"
    "{\n"
    "   outColor = texture(tex, Texcoord) * vec4(Color, 1.0);\n"
    "}\n"
    };
    //Create Vertex Array Object
    //VAO's are used to store information about our vertex data so we don't have to resend everything if we change shaders
    GLuint vaoHandle;
    glGenVertexArrays(1, &vaoHandle); //Reserve memory for 1 vao

    //Active the VAO
    //Only calls after a VAO will stick, so we have to create and bind it before anything else
    glBindVertexArray(vaoHandle);

    //Triangle Vertices
    /*float vertices[] =
    {
        0.0f,   0.5f,   1.0f,   0.0f,   0.0f, // X/Y/R/G/B/A
        0.5f,  -0.5f,   0.0f,   1.0f,   0.0f,
       -0.5f,  -0.5f,   0.0f,   0.0f,   1.0f,
    };*/

    //Rectangle Vertices
    float vertices[] =
    {   //Pos           //Col               //Tex
        -0.5f,  0.5f,   1.0f, 0.0f, 0.0f,   0.0f, 0.0f, //Top-Left
         0.5f,  0.5f,   0.0f, 1.0f, 0.0f,   1.0f, 0.0f, //Top-Right
         0.5f, -0.5f,   0.0f, 0.0f, 1.0f,   1.0f, 1.0f, //Bottom-Right
        -0.5f, -0.5f,   1.0f, 1.0f, 1.0f,   0.0f, 1.0f  //Bottom-Left
    };

    //Create Vertex Buffer Object
    //This is so that we can upload our vertices to the GPU memory
    GLuint vboHandle; //Handle to the VBO
    glGenBuffers(1, &vboHandle); //Generate 1 VBO and return the handle to us
    glBindBuffer(GL_ARRAY_BUFFER, vboHandle); //Set our VBO to the active one used by OpenGL
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); //Upload our vertices to the GPU
    //GL_STATIC_DRAW: The vertex data will be uploaded once and drawn many times (e.g. the world).
    //GL_DYNAMIC_DRAW: The vertex data will be changed from time to time, but drawn many times more than that.
    //GL_STREAM_DRAW: The vertex data will change almost every time it's drawn (e.g. user interface).

    //Element Buffer specifies the order in which to draw, as well as reuse existing vertices
    GLuint elements[] =
    {
        0, 1, 2, //Top-Left, Top-Right, Bottom-Right
        2, 3, 0 //Bottom-Right, Bottom-Left, Top-Left
    };

    GLuint eboHandle;
    glGenBuffers(1, &eboHandle); //Generate memory for 1 EBO

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, eboHandle); //Set as active
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elements), elements, GL_STATIC_DRAW); //Upload to GPU

    //Create Shaders
    GLuint vertexShaderHandle = glCreateShader(GL_VERTEX_SHADER); //Reserve memory in OpenGL
    GLuint fragmentShaderHandle = glCreateShader(GL_FRAGMENT_SHADER); //Reserve memory in OpenGL

    //Upload Shader Source
    glShaderSource(vertexShaderHandle, 1, vertexShaderSource, NULL); //Compile the shader
    glShaderSource(fragmentShaderHandle, 1, fragmentShaderSource, NULL); //Compile the shader

    //Compile Shaders
    glCompileShader(vertexShaderHandle);
    glCompileShader(fragmentShaderHandle);

    //Check Shader Compilation for errors
    GLint status;
    glGetShaderiv(vertexShaderHandle, GL_COMPILE_STATUS, &status);
    if (!status)
    {
        std::cout << "VertexShader failed\n";
        char buffer[512];
        glGetShaderInfoLog(vertexShaderHandle, 512, NULL, buffer);
        std::cout << buffer << "\n\n";
    }

    glGetShaderiv(fragmentShaderHandle, GL_COMPILE_STATUS, &status);
    if (!status)
    {
        std::cout << "FragmentShader failed\n";
        char buffer[512];
        glGetShaderInfoLog(vertexShaderHandle, 512, NULL, buffer);
        std::cout << buffer << "\n\n";
    }

    //Create a program that knows about each shader, like in C++ with adding library headers
    GLuint shaderProgramHandle = glCreateProgram(); //Reserve memory
    glAttachShader(shaderProgramHandle, vertexShaderHandle);
    glAttachShader(shaderProgramHandle, fragmentShaderHandle);
    //glBindFragDataLocation(shaderProgramHandle, 0, "outColor") //Not sure what 0 is, but it's a default. This tells the fragment shader where to send its output

    //Link the shaders in the program, similar to building a C++ project
    glLinkProgram(shaderProgramHandle);

    //Activate the shader program, similar to running a C++ project
    //Only one program can be active at once
    glUseProgram(shaderProgramHandle);

    //Get a handle to our input position in the vertex shader (now in the shader program)
    GLint positionAttributeHandle = glGetAttribLocation(shaderProgramHandle, "position");

    //Enable the positionAttribute so that it can be used
    glEnableVertexAttribArray(positionAttributeHandle);

    //Tell OpenGL what this input looks like. handle, numValues, valueType, normalize (true/false)
    //The last two values specify how the attribute is detailed in the Vertex Array
    //The first of the two is how many bytes are between each attribute
    //The second of the two is how many bytes from the start is the first attribute located, i.e. the offset from the start
    //This also binds the current VBO to this attribute, so it doesn't need to be specified when drawing.
    glVertexAttribPointer(positionAttributeHandle, 2, GL_FLOAT, GL_FALSE, 7*sizeof(float), 0);

    GLint colorAttributeHandle = glGetAttribLocation(shaderProgramHandle, "color");
    glEnableVertexAttribArray(colorAttributeHandle);
    glVertexAttribPointer(colorAttributeHandle, 3, GL_FLOAT, GL_FALSE, 7*sizeof(float), (void*)(2*sizeof(float)));

    GLint texAttributeHandle = glGetAttribLocation(shaderProgramHandle, "texcoord");
    glEnableVertexAttribArray(texAttributeHandle);
    glVertexAttribPointer(texAttributeHandle, 2, GL_FLOAT, GL_FALSE, 7*sizeof(float), (void*)(5*sizeof(float)));

    //Generate texture
    GLuint texHandle;
    glGenTextures(1, &texHandle);

    //Set texture as active
    glBindTexture(GL_TEXTURE_2D, texHandle);

    //Texture
    float pixels[] =
    {
        0.2f,   0.2f,   0.2f,
        1.0f,   1.0f,   1.0f,
        1.0f,   1.0f,   1.0f,
        0.2f,   0.2f,   0.2f
    };

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 2, 2, 0, GL_RGB, GL_FLOAT, pixels);
    //2nd: level of detail, 0 = base, others = mipmap
    //3rd: pixel format
    //4th&5th: width and height
    //6th: must always be zero (border)
    //7th&8th: pixel format in array
    //9th: pixel array

    //Set Wrapping
    //GL_REPEAT: The integer part of the coordinate will be ignored and a repeating pattern is formed.
    //GL_MIRRORED_REPEAT: The texture will also be repeated, but it will be mirrored when the integer part of the coordinate is odd.
    //GL_CLAMP_TO_EDGE: The coordinate will simply be clamped between 0 and 1.
    //GL_CLAMP_TO_BORDER: The coordinates that fall outside the range will be given a specified border color.
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

    //For border clamp colour
    //float color[] = {1.0f, 0.0f, 0.0f, 1.0f};
    //glTexParameterfv(GL_TEXTURE_2D, GL-TEXTURE_BORDER_COLOR, color);

    //Set filtering
    //GL_NEAREST: Returns the pixel that is closest to the coordinates.
    //GL_LINEAR: Returns the weighted average of the 4 pixels surrounding the given coordinates.
    //GL_NEAREST_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR, GL_LINEAR_MIPMAP_LINEAR: Sample from mipmaps instead.

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

    //Generate mipmap
    //Mipmaps are different resolution copies of the texture
    glGenerateMipmap(GL_TEXTURE_2D);

    //Game Loop
    sf::Time prevFrameTime = sf::seconds(1.f/60.f);
    sf::Clock frameTime;
    sf::Clock totalTime;
    sf::Event event;
    while (window.isOpen())
    {
        //Event
        while (window.pollEvent(event))
        {
            switch (event.type)
            {
                case sf::Event::Closed:
                {
                    window.close();
                    break;
                }

                default:
                {
                    break;
                }
            }
        }

        //Update

        //Draw
        glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        //glDrawArrays(GL_TRIANGLES, 0, 6); //Draw an array of vertices that we binded before to our VBO
        //The second argument is the offset from the beginner of the vertices, the third argument is the number of vertices

        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
        //2nd: # of indicies. 3rd: element type. 4th: offset between elements.

        window.display();

        //PostDraw

        prevFrameTime = frameTime.restart();
        //std::cout << "FPS: " << 1.f / prevFrameTime.asSeconds() << "\n";
    }

    glDeleteProgram(shaderProgramHandle);
    glDeleteShader(fragmentShaderHandle);
    glDeleteShader(vertexShaderHandle);

    glDeleteBuffers(1, &vboHandle);
    glDeleteBuffers(1, &eboHandle);
    glDeleteVertexArrays(1, &vaoHandle);

    return 0;
}
예제 #6
0
int main() {

	std::cout << glfwGetVersionString() << std::endl;

	GLuint texture{ 0 }, sampler{ 0 };
	GLuint vbo{ 0 }, vao{ 0 };
	GLuint vs{ 0 }, fs{ 0 }, program{ 0 };
	FT_Library ft_lib{ nullptr };
	FT_Face face{ nullptr };

	auto cleanup = [&]() {
		FT_Done_Face(face);
		FT_Done_FreeType(ft_lib);
		glDeleteTextures(1, &texture);
		glDeleteSamplers(1, &sampler);
		glDeleteBuffers(1, &vbo);
		glDeleteVertexArrays(1, &vao);
		glDeleteShader(vs);
		glDeleteShader(fs);
		glDeleteProgram(program);
	};

	// Initialize and load our freetype face
	if (FT_Init_FreeType(&ft_lib) != 0) {
		std::cerr << "Couldn't initialize FreeType library\n";
		cleanup();
		return 1;
	}

	if (FT_New_Face(ft_lib, "../Dependencies/fonts/Kalypsa-Medium.ttf", 0, &face) != 0) {
		std::cerr << "Unable to load myfont.ttf\n";
		cleanup();
		return 1;
	}

	// Create a GLFW window
	if (glfwInit() != GL_TRUE) {
		std::cerr << "Couldn't load GLFW library\n";
		cleanup();
		return 1;
	}

	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

	const int WIDTH = 640;
	const int HEIGHT = 480;
	const double SCALEX = 2.0 / WIDTH;
	const double SCALEY = 2.0 / HEIGHT;

	auto window = glfwCreateWindow(WIDTH, HEIGHT, "OpenGL Text Rendering", nullptr, nullptr);
	glfwMakeContextCurrent(window);
	glViewport(0, 0, WIDTH, HEIGHT);

	// Initialize our texture and VBOs
	glGenBuffers(1, &vbo);
	glGenVertexArrays(1, &vao);
	glGenTextures(1, &texture);
	glGenSamplers(1, &sampler);
	glSamplerParameteri(sampler, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glSamplerParameteri(sampler, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glSamplerParameteri(sampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	// Initialize shader
	vs = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(vs, 1, &VERTEX_SHADER, 0);
	glCompileShader(vs);

	fs = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(fs, 1, &FRAGMENT_SHADER, 0);
	glCompileShader(fs);

	program = glCreateProgram();
	glAttachShader(program, vs);
	glAttachShader(program, fs);
	glLinkProgram(program);

	// Set some initialize GL state
	glEnable(GL_BLEND);
	glDisable(GL_CULL_FACE);
	glDisable(GL_DEPTH_TEST);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glClearColor(0.1, 0.2, 0.4, 0);

	// Get shader uniforms
	glUseProgram(program);
	glBindAttribLocation(program, 0, "in_Position");
	GLuint texUniform = glGetUniformLocation(program, "tex");
	GLuint colorUniform = glGetUniformLocation(program, "color");

	while (glfwWindowShouldClose(window) != GL_TRUE) {
		glfwMakeContextCurrent(window);
		glClear(GL_COLOR_BUFFER_BIT);

		// Bind stuff
		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D, texture);
		glBindSampler(0, sampler);
		glBindVertexArray(vao);
		glEnableVertexAttribArray(0);
		glBindBuffer(GL_ARRAY_BUFFER, vbo);
		glUseProgram(program);
		glUniform4f(colorUniform, 1, 1, 1, 1);
		glUniform1i(texUniform, 0);

		FT_Set_Pixel_Sizes(face, 0, 50);
		render_text("Hello World!", face, -0.5, 0, SCALEX, SCALEY);

		glfwSwapBuffers(window);
		glfwPollEvents();
	}

	cleanup();
	return 0;
}
예제 #7
0
GLUSboolean update(GLUSfloat time)
{
	GLfloat modelMatrix[16];
	GLfloat normalMatrix[9];

	//
	// Render to FBO.
	//

	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, g_texture[0]);

	glActiveTexture(GL_TEXTURE1);
	glBindTexture(GL_TEXTURE_CUBE_MAP, g_texture[1]);

	glActiveTexture(GL_TEXTURE2);
	glBindTexture(GL_TEXTURE_2D, g_texture[2]);

	glActiveTexture(GL_TEXTURE0);

	glBindFramebuffer(GL_FRAMEBUFFER, g_fullscreenFBO);

	glEnable(GL_MULTISAMPLE);

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	// Render the background.

	// Rendering the sphere from inside, so change front facing.
	glFrontFace(GL_CW);

	glUseProgram(g_backgroundProgram.program);

	glUniformMatrix4fv(g_viewProjectionMatrixBackgroundLocation, 1, GL_FALSE, g_viewProjectionMatrix);

	glBindVertexArray(g_backgroundVAO);

	glDrawElements(GL_TRIANGLES, g_numberIndicesBackground, GL_UNSIGNED_INT, 0);

	glFrontFace(GL_CCW);

	// Render model using BRDF and IBL.

	glusMatrix4x4Identityf(modelMatrix);
	glusMatrix4x4Scalef(modelMatrix, 0.001f, 0.001f, 0.001f);

	glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelMatrix);

	glUseProgram(g_modelProgram.program);

	glBindVertexArray(g_modelVAO);

	// Roughness of material.
	glUniform1f(g_roughnessMaterialModelLocation, g_roughness);
	glUniform1f(g_R0MaterialModelLocation, g_R0);
	glUniform3fv(g_colorMaterialModelLocation, 1, g_colorMaterial);

	glUniformMatrix4fv(g_viewProjectionMatrixModelLocation, 1, GL_FALSE, g_viewProjectionMatrix);
	glUniformMatrix4fv(g_modelMatrixModelLocation, 1, GL_FALSE, modelMatrix);
	glUniformMatrix3fv(g_normalMatrixModelLocation, 1, GL_FALSE, normalMatrix);

	glDrawArrays(GL_TRIANGLES, 0, g_numberVerticesModel);

	//
	// Render full screen to resolve the buffer: MSAA, tone mapping and gamma correction.
	//

	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, g_fullscreenTexture);

	glBindFramebuffer(GL_FRAMEBUFFER, 0);

	glDisable(GL_MULTISAMPLE);

	// No clear needed, as we just draw over the last content.
	glDisable(GL_DEPTH_TEST);

	glUseProgram(g_fullscreenProgram.program);

	glUniform1f(g_exposureFullscreenLocation, g_exposure);
	glUniform1f(g_gammaFullscreenLocation, g_gamma);

	glBindVertexArray(g_fullscreenVAO);

	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

	glEnable(GL_DEPTH_TEST);

	return GLUS_TRUE;
}
예제 #8
0
/*!
	Initialize the scene, reserve shaders, compile and cache program

	\param[in] None.
	\return None

*/
void Cube::InitModel()
{
	if (! ( program = ProgramManagerObj->Program( (char *)"Cube" ))){
		program = ProgramManagerObj->ProgramInit( (char *)"Cube" );
		ProgramManagerObj->AddProgram( program );
	}

    //Initialize Vertex and Fragment shader
	program->VertexShader	= ShaderManager::ShaderInit( VERTEX_SHADER_PRG,	GL_VERTEX_SHADER	);
	program->FragmentShader	= ShaderManager::ShaderInit( FRAGMENT_SHADER_PRG, GL_FRAGMENT_SHADER	);

    // Compile Vertex shader
	CACHE *m = reserveCache( VERTEX_SHADER_PRG, true );
	if( m ) {
		if( !ShaderManager::ShaderCompile( program->VertexShader, ( char * )m->buffer, 1 ) ) exit( 1 );
        freeCache( m );
	}

    // Compile Fragment shader
	m = reserveCache( FRAGMENT_SHADER_PRG, true );
	if( m ) {
		if( !ShaderManager::ShaderCompile( program->FragmentShader, ( char * )m->buffer, 1 ) ) exit( 2 );
        freeCache( m );
	}

    // Link program
    if( !ProgramManagerObj->ProgramLink( program, 1 ) ) exit( 3 );

    glUseProgram( program->ProgramID );


    // Create VBO
 	size = 24*sizeof(float);
    glGenBuffers(1, &vId);
	glBindBuffer( GL_ARRAY_BUFFER, vId );
	glBufferData( GL_ARRAY_BUFFER, size + size, 0, GL_STATIC_DRAW );
	glBufferSubData( GL_ARRAY_BUFFER, 0,			size,	cubeVerts );
	glBufferSubData( GL_ARRAY_BUFFER, size,			size,	cubeColors );


    // Create VBO for transformation matrix
    glGenBuffers(1, &matrixId);
	glBindBuffer( GL_ARRAY_BUFFER, matrixId );


    glm::mat4 transformMatrix[dimension][dimension][dimension];
    glBufferData(GL_ARRAY_BUFFER, sizeof(transformMatrix) , 0, GL_DYNAMIC_DRAW);

    // Create IBO
	unsigned short indexSize = sizeof( unsigned short )*36;
    glGenBuffers(1, &iId);
	glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, iId );
	glBufferData( GL_ELEMENT_ARRAY_BUFFER, indexSize, 0, GL_STATIC_DRAW );
	glBufferSubData( GL_ELEMENT_ARRAY_BUFFER, 0, indexSize,	cubeIndices );

    glGenVertexArrays(1, &Vertex_VAO_Id);
    glBindVertexArray(Vertex_VAO_Id);

    // Create VBO  and set attribute parameters
	glBindBuffer( GL_ARRAY_BUFFER, vId );
    glEnableVertexAttribArray(VERTEX_LOCATION);
    glEnableVertexAttribArray(COLOR_LOCATION);
    glVertexAttribPointer(VERTEX_LOCATION, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
    glVertexAttribPointer(COLOR_LOCATION, 3, GL_FLOAT, GL_FALSE, 0, (void*)size);

    // Create VBO for transformation matrix and set attribute parameters
	glBindBuffer( GL_ARRAY_BUFFER, matrixId );
    glEnableVertexAttribArray(MATRIX1_LOCATION);
    glEnableVertexAttribArray(MATRIX2_LOCATION);
    glEnableVertexAttribArray(MATRIX3_LOCATION);
    glEnableVertexAttribArray(MATRIX4_LOCATION);

    glVertexAttribPointer(MATRIX1_LOCATION, 4, GL_FLOAT, GL_FALSE, sizeof(glm::mat4), (void*)(sizeof(float) * 0));
    glVertexAttribPointer(MATRIX2_LOCATION, 4, GL_FLOAT, GL_FALSE, sizeof(glm::mat4), (void*)(sizeof(float) * 4));
    glVertexAttribPointer(MATRIX3_LOCATION, 4, GL_FLOAT, GL_FALSE, sizeof(glm::mat4), (void*)(sizeof(float) * 8));
    glVertexAttribPointer(MATRIX4_LOCATION, 4, GL_FLOAT, GL_FALSE, sizeof(glm::mat4), (void*)(sizeof(float) * 12));

    glVertexAttribDivisor(MATRIX1_LOCATION, 1);
    glVertexAttribDivisor(MATRIX2_LOCATION, 1);
    glVertexAttribDivisor(MATRIX3_LOCATION, 1);
    glVertexAttribDivisor(MATRIX4_LOCATION, 1);

    // Bind IBO
    glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, iId );


    // Make sure the VAO is not changed from outside code
    glBindVertexArray(0);

    return;
}
예제 #9
0
void
My_TestGLDrawing::InitTest()
{
    _renderIndex = HdRenderIndex::New(&_renderDelegate);
    TF_VERIFY(_renderIndex != nullptr);
    _delegate = new Hdx_UnitTestDelegate(_renderIndex);

    _delegate->SetRefineLevel(_refineLevel);

    // prepare render task
    SdfPath renderSetupTask("/renderSetupTask");
    SdfPath renderTask("/renderTask");
    _delegate->AddRenderSetupTask(renderSetupTask);
    _delegate->AddRenderTask(renderTask);

    // render task parameters.
    HdxRenderTaskParams param
        = _delegate->GetTaskParam(
            renderSetupTask, HdTokens->params).Get<HdxRenderTaskParams>();
    param.enableLighting = true; // use default lighting
    _delegate->SetTaskParam(renderSetupTask, HdTokens->params, VtValue(param));
    _delegate->SetTaskParam(renderTask, HdTokens->collection,
                           VtValue(HdRprimCollection(HdTokens->geometry,
                                   _reprName)));

    // prepare scene
    _delegate->AddCube(SdfPath("/cube0"), _GetTranslate( 5, 0, 5));
    _delegate->AddCube(SdfPath("/cube1"), _GetTranslate(-5, 0, 5));
    _delegate->AddCube(SdfPath("/cube2"), _GetTranslate(-5, 0,-5));
    _delegate->AddCube(SdfPath("/cube3"), _GetTranslate( 5, 0,-5));

    {
        _delegate->AddInstancer(SdfPath("/instancerTop"));
        _delegate->AddCube(SdfPath("/protoTop"),
                         GfMatrix4d(1), false, SdfPath("/instancerTop"));

        std::vector<SdfPath> prototypes;
        prototypes.push_back(SdfPath("/protoTop"));

        VtVec3fArray scale(3);
        VtVec4fArray rotate(3);
        VtVec3fArray translate(3);
        VtIntArray prototypeIndex(3);

        scale[0] = GfVec3f(1);
        rotate[0] = GfVec4f(0);
        translate[0] = GfVec3f(3, 0, 2);
        prototypeIndex[0] = 0;

        scale[1] = GfVec3f(1);
        rotate[1] = GfVec4f(0);
        translate[1] = GfVec3f(0, 0, 2);
        prototypeIndex[1] = 0;

        scale[2] = GfVec3f(1);
        rotate[2] = GfVec4f(0);
        translate[2] = GfVec3f(-3, 0, 2);
        prototypeIndex[2] = 0;

        _delegate->SetInstancerProperties(SdfPath("/instancerTop"),
                                        prototypeIndex,
                                        scale, rotate, translate);
    }

    {
        _delegate->AddInstancer(SdfPath("/instancerBottom"));
        _delegate->AddCube(SdfPath("/protoBottom"),
                         GfMatrix4d(1), false, SdfPath("/instancerBottom"));

        std::vector<SdfPath> prototypes;
        prototypes.push_back(SdfPath("/protoBottom"));

        VtVec3fArray scale(3);
        VtVec4fArray rotate(3);
        VtVec3fArray translate(3);
        VtIntArray prototypeIndex(3);

        scale[0] = GfVec3f(1);
        rotate[0] = GfVec4f(0);
        translate[0] = GfVec3f(3, 0, -2);
        prototypeIndex[0] = 0;

        scale[1] = GfVec3f(1);
        rotate[1] = GfVec4f(0);
        translate[1] = GfVec3f(0, 0, -2);
        prototypeIndex[1] = 0;

        scale[2] = GfVec3f(1);
        rotate[2] = GfVec4f(0);
        translate[2] = GfVec3f(-3, 0, -2);
        prototypeIndex[2] = 0;

        _delegate->SetInstancerProperties(SdfPath("/instancerBottom"),
                                        prototypeIndex,
                                        scale, rotate, translate);
    }

    SetCameraTranslate(GfVec3f(0, 0, -20));

    // XXX: Setup a VAO, the current drawing engine will not yet do this.
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);
    glBindVertexArray(0);
}
예제 #10
0
void BlockParticleManager::RenderInstanced(bool noWorldOffset)
{
    glShader* pShader = m_pRenderer->GetShader(m_instanceShader);

    GLint in_position = glGetAttribLocation(pShader->GetProgramObject(), "in_position");
    GLint in_color = glGetAttribLocation(pShader->GetProgramObject(), "in_color");
    GLint in_model_matrix = glGetAttribLocation(pShader->GetProgramObject(), "in_model_matrix");

    int numBlockParticles = (int)m_vpBlockParticlesList.size();
    int numBlockParticlesRender = GetNumRenderableParticles(noWorldOffset);
    if (numBlockParticlesRender > 0)
    {
        float* newMatrices = new float[16 * numBlockParticlesRender];
        float* newColors = new float[4 * numBlockParticlesRender];

        int counter = 0;
        for (int i = 0; i < numBlockParticles; i++)
        {
            // If we are a emitter creation particle, don't render.
            if (m_vpBlockParticlesList[i]->m_createEmitters == true)
            {
                continue;
            }

            // If we are to be erased, don't render
            if (m_vpBlockParticlesList[i]->m_erase == true)
            {
                continue;
            }

            // If we are rendering the special viewport particles and our parent particle effect viewport flag isn't set, don't render.
            if (noWorldOffset)
            {
                if (m_vpBlockParticlesList[i]->m_pParent == NULL ||
                        m_vpBlockParticlesList[i]->m_pParent->m_pParent == NULL ||
                        m_vpBlockParticlesList[i]->m_pParent->m_pParent->m_renderNoWoldOffsetViewport == false)
                {
                    continue;
                }
            }

            newColors[counter + 0] = m_vpBlockParticlesList[i]->m_currentRed;
            newColors[counter + 1] = m_vpBlockParticlesList[i]->m_currentGreen;
            newColors[counter + 2] = m_vpBlockParticlesList[i]->m_currentBlue;
            newColors[counter + 3] = m_vpBlockParticlesList[i]->m_currentAlpha;
            counter += 4;
        }
        counter = 0;
        for (int i = 0; i < numBlockParticles; i++)
        {
            // If we are a emitter creation particle, don't render.
            if (m_vpBlockParticlesList[i]->m_createEmitters == true)
            {
                continue;
            }

            // If we are to be erased, don't render
            if (m_vpBlockParticlesList[i]->m_erase == true)
            {
                continue;
            }

            // If we are rendering the special viewport particles and our parent particle effect viewport flag isn't set, don't render.
            if (noWorldOffset)
            {
                if (m_vpBlockParticlesList[i]->m_pParent == NULL ||
                        m_vpBlockParticlesList[i]->m_pParent->m_pParent == NULL ||
                        m_vpBlockParticlesList[i]->m_pParent->m_pParent->m_renderNoWoldOffsetViewport == false)
                {
                    continue;
                }
            }

            m_vpBlockParticlesList[i]->CalculateWorldTransformMatrix();

            if (noWorldOffset)
            {
                newMatrices[counter + 0] = m_vpBlockParticlesList[i]->m_worldMatrix_NoPositionOffset.m[0];
                newMatrices[counter + 1] = m_vpBlockParticlesList[i]->m_worldMatrix_NoPositionOffset.m[1];
                newMatrices[counter + 2] = m_vpBlockParticlesList[i]->m_worldMatrix_NoPositionOffset.m[2];
                newMatrices[counter + 3] = m_vpBlockParticlesList[i]->m_worldMatrix_NoPositionOffset.m[3];
                newMatrices[counter + 4] = m_vpBlockParticlesList[i]->m_worldMatrix_NoPositionOffset.m[4];
                newMatrices[counter + 5] = m_vpBlockParticlesList[i]->m_worldMatrix_NoPositionOffset.m[5];
                newMatrices[counter + 6] = m_vpBlockParticlesList[i]->m_worldMatrix_NoPositionOffset.m[6];
                newMatrices[counter + 7] = m_vpBlockParticlesList[i]->m_worldMatrix_NoPositionOffset.m[7];
                newMatrices[counter + 8] = m_vpBlockParticlesList[i]->m_worldMatrix_NoPositionOffset.m[8];
                newMatrices[counter + 9] = m_vpBlockParticlesList[i]->m_worldMatrix_NoPositionOffset.m[9];
                newMatrices[counter + 10] = m_vpBlockParticlesList[i]->m_worldMatrix_NoPositionOffset.m[10];
                newMatrices[counter + 11] = m_vpBlockParticlesList[i]->m_worldMatrix_NoPositionOffset.m[11];
                newMatrices[counter + 12] = m_vpBlockParticlesList[i]->m_worldMatrix_NoPositionOffset.m[12];
                newMatrices[counter + 13] = m_vpBlockParticlesList[i]->m_worldMatrix_NoPositionOffset.m[13];
                newMatrices[counter + 14] = m_vpBlockParticlesList[i]->m_worldMatrix_NoPositionOffset.m[14];
                newMatrices[counter + 15] = m_vpBlockParticlesList[i]->m_worldMatrix_NoPositionOffset.m[15];
            }
            else
            {
                newMatrices[counter + 0] = m_vpBlockParticlesList[i]->m_worldMatrix.m[0];
                newMatrices[counter + 1] = m_vpBlockParticlesList[i]->m_worldMatrix.m[1];
                newMatrices[counter + 2] = m_vpBlockParticlesList[i]->m_worldMatrix.m[2];
                newMatrices[counter + 3] = m_vpBlockParticlesList[i]->m_worldMatrix.m[3];
                newMatrices[counter + 4] = m_vpBlockParticlesList[i]->m_worldMatrix.m[4];
                newMatrices[counter + 5] = m_vpBlockParticlesList[i]->m_worldMatrix.m[5];
                newMatrices[counter + 6] = m_vpBlockParticlesList[i]->m_worldMatrix.m[6];
                newMatrices[counter + 7] = m_vpBlockParticlesList[i]->m_worldMatrix.m[7];
                newMatrices[counter + 8] = m_vpBlockParticlesList[i]->m_worldMatrix.m[8];
                newMatrices[counter + 9] = m_vpBlockParticlesList[i]->m_worldMatrix.m[9];
                newMatrices[counter + 10] = m_vpBlockParticlesList[i]->m_worldMatrix.m[10];
                newMatrices[counter + 11] = m_vpBlockParticlesList[i]->m_worldMatrix.m[11];
                newMatrices[counter + 12] = m_vpBlockParticlesList[i]->m_worldMatrix.m[12];
                newMatrices[counter + 13] = m_vpBlockParticlesList[i]->m_worldMatrix.m[13];
                newMatrices[counter + 14] = m_vpBlockParticlesList[i]->m_worldMatrix.m[14];
                newMatrices[counter + 15] = m_vpBlockParticlesList[i]->m_worldMatrix.m[15];
            }
            counter += 16;
        }

        glBindVertexArray(m_vertexArray);

        if (m_colourBuffer != -1)
        {
            glDeleteBuffers(1, &m_colourBuffer);
        }
        // Bind buffer for colors and copy data into buffer
        glGenBuffers(1, &m_colourBuffer);
        glBindBuffer(GL_ARRAY_BUFFER, m_colourBuffer);
        glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 4 * numBlockParticlesRender, newColors, GL_STATIC_READ);
        glEnableVertexAttribArray(in_color);
        glVertexAttribPointer(in_color, 4, GL_FLOAT, GL_FALSE, 4 * 4, 0);
        glVertexAttribDivisor(in_color, 1);

        if (m_matrixBuffer != -1)
        {
            glDeleteBuffers(1, &m_matrixBuffer);
        }
        // Bind buffer for matrix and copy data into buffer
        glGenBuffers(1, &m_matrixBuffer);
        glBindBuffer(GL_ARRAY_BUFFER, m_matrixBuffer);
        for (int i = 0; i < 4; i++)
        {
            glVertexAttribPointer(in_model_matrix + i,		// Location
                                  4, GL_FLOAT, GL_FALSE,	// vec4
                                  4 * 16,						// Stride
                                  reinterpret_cast<void *>(16 * i));		// Start offset

            glEnableVertexAttribArray(in_model_matrix + i);
            glVertexAttribDivisor(in_model_matrix + i, 1);
        }
        glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 16 * numBlockParticlesRender, newMatrices, GL_STATIC_READ);

        delete[] newColors;
        delete[] newMatrices;
    }

    // Render the block particle instances
    m_pRenderer->BeginGLSLShader(m_instanceShader);

    GLint projMatrixLoc = glGetUniformLocation(pShader->GetProgramObject(), "projMatrix");
    GLint viewMatrixLoc = glGetUniformLocation(pShader->GetProgramObject(), "viewMatrix");

    Matrix4x4 projMat;
    Matrix4x4 viewMat;
    m_pRenderer->GetProjectionMatrix(&projMat);
    m_pRenderer->GetModelViewMatrix(&viewMat);

    glUniformMatrix4fv(projMatrixLoc, 1, false, projMat.m);
    glUniformMatrix4fv(viewMatrixLoc, 1, false, viewMat.m);

    GLint in_light_position = glGetUniformLocation(pShader->GetProgramObject(), "in_light_position");
    GLint in_light_const_a = glGetUniformLocation(pShader->GetProgramObject(), "in_light_const_a");
    GLint in_light_linear_a = glGetUniformLocation(pShader->GetProgramObject(), "in_light_linear_a");
    GLint in_light_quad_a = glGetUniformLocation(pShader->GetProgramObject(), "in_light_quad_a");
    GLint in_light_ambient = glGetUniformLocation(pShader->GetProgramObject(), "in_light_ambient");
    GLint in_light_diffuse = glGetUniformLocation(pShader->GetProgramObject(), "in_light_diffuse");

    if (m_renderWireFrame)
    {
        m_pRenderer->SetLineWidth(1.0f);
        m_pRenderer->SetRenderMode(RM_WIREFRAME);
        m_pRenderer->SetCullMode(CM_NOCULL);
    }
    else
    {
        m_pRenderer->SetCullMode(CM_BACK);
        m_pRenderer->SetRenderMode(RM_SOLID);
    }

    m_pRenderer->EnableTransparency(BF_SRC_ALPHA, BF_ONE_MINUS_SRC_ALPHA);

    glDrawElementsInstanced(GL_QUADS, 24, GL_UNSIGNED_INT, indices, numBlockParticlesRender);

    m_pRenderer->DisableTransparency();

    m_pRenderer->EndGLSLShader(m_instanceShader);

    glBindVertexArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
예제 #11
0
void BlockParticleManager::SetupGLBuffers()
{
    if (m_instanceShader != -1)
    {
        glShader* pShader = m_pRenderer->GetShader(m_instanceShader);

        GLint in_position = glGetAttribLocation(pShader->GetProgramObject(), "in_position");
        GLint in_normal = glGetAttribLocation(pShader->GetProgramObject(), "in_normal");
        GLint in_color = glGetAttribLocation(pShader->GetProgramObject(), "in_color");
        GLint in_model_matrix = glGetAttribLocation(pShader->GetProgramObject(), "in_model_matrix");

        glBindFragDataLocation(pShader->GetProgramObject(), 0, "outputColor");
        glBindFragDataLocation(pShader->GetProgramObject(), 1, "outputPosition");
        glBindFragDataLocation(pShader->GetProgramObject(), 2, "outputNormal");

        if (m_vertexArray != -1)
        {
            glDeleteVertexArrays(1, &m_vertexArray);
        }

        glGenVertexArrays(1, &m_vertexArray);
        glBindVertexArray(m_vertexArray);

        if (m_positionBuffer != -1)
        {
            glDeleteBuffers(1, &m_positionBuffer);
        }
        glGenBuffers(1, &m_positionBuffer);
        glBindBuffer(GL_ARRAY_BUFFER, m_positionBuffer);
        int sizeOfVertices = sizeof(vertices);
        glBufferData(GL_ARRAY_BUFFER, sizeOfVertices, vertices, GL_STATIC_DRAW);
        glEnableVertexAttribArray(in_position);
        glVertexAttribPointer(in_position, 4, GL_FLOAT, 0, 0, 0);

        if (m_normalBuffer != -1)
        {
            glDeleteBuffers(1, &m_normalBuffer);
        }
        glGenBuffers(1, &m_normalBuffer);
        glBindBuffer(GL_ARRAY_BUFFER, m_normalBuffer);
        int sizeOfNormals = sizeof(normals);
        glBufferData(GL_ARRAY_BUFFER, sizeOfNormals, normals, GL_STATIC_DRAW);
        glEnableVertexAttribArray(in_normal);
        glVertexAttribPointer(in_normal, 4, GL_FLOAT, 0, 0, 0);

        glBindVertexArray(0);
        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    }

    float l_length = 0.5f;
    float l_height = 0.5f;
    float l_width = 0.5f;

    // Create the cube static buffer
    m_vertexBuffer[0].x = l_length;
    m_vertexBuffer[0].y = -l_height;
    m_vertexBuffer[0].z = -l_width;
    m_vertexBuffer[0].nx = 0.0f;
    m_vertexBuffer[0].ny = 0.0f;
    m_vertexBuffer[0].nz = -1.0f;

    m_vertexBuffer[1].x = -l_length;
    m_vertexBuffer[1].y = -l_height;
    m_vertexBuffer[1].z = -l_width;
    m_vertexBuffer[1].nx = 0.0f;
    m_vertexBuffer[1].ny = 0.0f;
    m_vertexBuffer[1].nz = -1.0f;

    m_vertexBuffer[2].x = -l_length;
    m_vertexBuffer[2].y = l_height;
    m_vertexBuffer[2].z = -l_width;
    m_vertexBuffer[2].nx = 0.0f;
    m_vertexBuffer[2].ny = 0.0f;
    m_vertexBuffer[2].nz = -1.0f;

    m_vertexBuffer[3].x = l_length;
    m_vertexBuffer[3].y = l_height;
    m_vertexBuffer[3].z = -l_width;
    m_vertexBuffer[3].nx = 0.0f;
    m_vertexBuffer[3].ny = 0.0f;
    m_vertexBuffer[3].nz = -1.0f;

    //
    m_vertexBuffer[4].x = -l_length;
    m_vertexBuffer[4].y = -l_height;
    m_vertexBuffer[4].z = l_width;
    m_vertexBuffer[4].nx = 0.0f;
    m_vertexBuffer[4].ny = 0.0f;
    m_vertexBuffer[4].nz = 1.0f;

    m_vertexBuffer[5].x = l_length;
    m_vertexBuffer[5].y = -l_height;
    m_vertexBuffer[5].z = l_width;
    m_vertexBuffer[5].nx = 0.0f;
    m_vertexBuffer[5].ny = 0.0f;
    m_vertexBuffer[5].nz = 1.0f;

    m_vertexBuffer[6].x = l_length;
    m_vertexBuffer[6].y = l_height;
    m_vertexBuffer[6].z = l_width;
    m_vertexBuffer[6].nx = 0.0f;
    m_vertexBuffer[6].ny = 0.0f;
    m_vertexBuffer[6].nz = 1.0f;

    m_vertexBuffer[7].x = -l_length;
    m_vertexBuffer[7].y = l_height;
    m_vertexBuffer[7].z = l_width;
    m_vertexBuffer[7].nx = 0.0f;
    m_vertexBuffer[7].ny = 0.0f;
    m_vertexBuffer[7].nz = 1.0f;

    //
    m_vertexBuffer[8].x = l_length;
    m_vertexBuffer[8].y = -l_height;
    m_vertexBuffer[8].z = l_width;
    m_vertexBuffer[8].nx = 1.0f;
    m_vertexBuffer[8].ny = 0.0f;
    m_vertexBuffer[8].nz = 0.0f;

    m_vertexBuffer[9].x = l_length;
    m_vertexBuffer[9].y = -l_height;
    m_vertexBuffer[9].z = -l_width;
    m_vertexBuffer[9].nx = 1.0f;
    m_vertexBuffer[9].ny = 0.0f;
    m_vertexBuffer[9].nz = 0.0f;

    m_vertexBuffer[10].x = l_length;
    m_vertexBuffer[10].y = l_height;
    m_vertexBuffer[10].z = -l_width;
    m_vertexBuffer[10].nx = 1.0f;
    m_vertexBuffer[10].ny = 0.0f;
    m_vertexBuffer[10].nz = 0.0f;

    m_vertexBuffer[11].x = l_length;
    m_vertexBuffer[11].y = l_height;
    m_vertexBuffer[11].z = l_width;
    m_vertexBuffer[11].nx = 1.0f;
    m_vertexBuffer[11].ny = 0.0f;
    m_vertexBuffer[11].nz = 0.0f;

    //
    m_vertexBuffer[12].x = -l_length;
    m_vertexBuffer[12].y = -l_height;
    m_vertexBuffer[12].z = -l_width;
    m_vertexBuffer[12].nx = -1.0f;
    m_vertexBuffer[12].ny = 0.0f;
    m_vertexBuffer[12].nz = 0.0f;

    m_vertexBuffer[13].x = -l_length;
    m_vertexBuffer[13].y = -l_height;
    m_vertexBuffer[13].z = l_width;
    m_vertexBuffer[13].nx = -1.0f;
    m_vertexBuffer[13].ny = 0.0f;
    m_vertexBuffer[13].nz = 0.0f;

    m_vertexBuffer[14].x = -l_length;
    m_vertexBuffer[14].y = l_height;
    m_vertexBuffer[14].z = l_width;
    m_vertexBuffer[14].nx = -1.0f;
    m_vertexBuffer[14].ny = 0.0f;
    m_vertexBuffer[14].nz = 0.0f;

    m_vertexBuffer[15].x = -l_length;
    m_vertexBuffer[15].y = l_height;
    m_vertexBuffer[15].z = -l_width;
    m_vertexBuffer[15].nx = -1.0f;
    m_vertexBuffer[15].ny = 0.0f;
    m_vertexBuffer[15].nz = 0.0f;

    //
    m_vertexBuffer[16].x = -l_length;
    m_vertexBuffer[16].y = -l_height;
    m_vertexBuffer[16].z = -l_width;
    m_vertexBuffer[16].nx = 0.0f;
    m_vertexBuffer[16].ny = -1.0f;
    m_vertexBuffer[16].nz = 0.0f;

    m_vertexBuffer[17].x = l_length;
    m_vertexBuffer[17].y = -l_height;
    m_vertexBuffer[17].z = -l_width;
    m_vertexBuffer[17].nx = 0.0f;
    m_vertexBuffer[17].ny = -1.0f;
    m_vertexBuffer[17].nz = 0.0f;

    m_vertexBuffer[18].x = l_length;
    m_vertexBuffer[18].y = -l_height;
    m_vertexBuffer[18].z = l_width;
    m_vertexBuffer[18].nx = 0.0f;
    m_vertexBuffer[18].ny = -1.0f;
    m_vertexBuffer[18].nz = 0.0f;

    m_vertexBuffer[19].x = -l_length;
    m_vertexBuffer[19].y = -l_height;
    m_vertexBuffer[19].z = l_width;
    m_vertexBuffer[19].nx = 0.0f;
    m_vertexBuffer[19].ny = -1.0f;
    m_vertexBuffer[19].nz = 0.0f;

    //
    m_vertexBuffer[20].x = l_length;
    m_vertexBuffer[20].y = l_height;
    m_vertexBuffer[20].z = -l_width;
    m_vertexBuffer[20].nx = 0.0f;
    m_vertexBuffer[20].ny = 1.0f;
    m_vertexBuffer[20].nz = 0.0f;

    m_vertexBuffer[21].x = -l_length;
    m_vertexBuffer[21].y = l_height;
    m_vertexBuffer[21].z = -l_width;
    m_vertexBuffer[21].nx = 0.0f;
    m_vertexBuffer[21].ny = 1.0f;
    m_vertexBuffer[21].nz = 0.0f;

    m_vertexBuffer[22].x = -l_length;
    m_vertexBuffer[22].y = l_height;
    m_vertexBuffer[22].z = l_width;
    m_vertexBuffer[22].nx = 0.0f;
    m_vertexBuffer[22].ny = 1.0f;
    m_vertexBuffer[22].nz = 0.0f;

    m_vertexBuffer[23].x = l_length;
    m_vertexBuffer[23].y = l_height;
    m_vertexBuffer[23].z = l_width;
    m_vertexBuffer[23].nx = 0.0f;
    m_vertexBuffer[23].ny = 1.0f;
    m_vertexBuffer[23].nz = 0.0f;

    for (int i = 0; i < 24; i++)
    {
        m_vertexBuffer[i].r = 1.0f;
        m_vertexBuffer[i].g = 1.0f;
        m_vertexBuffer[i].b = 1.0f;
        m_vertexBuffer[i].a = 1.0f;
    }
}
예제 #12
0
GLUSboolean init(GLUSvoid)
{
    GLUStextfile vertexSource;
    GLUStextfile fragmentSource;

    GLUStgaimage image;

    GLUSshape plane;

    //

    glusMatrix4x4LookAtf(g_viewMatrix, g_camera.eye[0], g_camera.eye[1], g_camera.eye[2], g_camera.center[0], g_camera.center[1], g_camera.center[2], g_camera.up[0], g_camera.up[1], g_camera.up[2]);

    //

    if (!initWavefront(g_viewMatrix, &g_light))
    {
    	return GLUS_FALSE;
    }

    //

    glusFileLoadText("../Example19_ES/shader/basic_proj.vert.glsl", &vertexSource);
    glusFileLoadText("../Example19_ES/shader/texture_multi_proj.frag.glsl", &fragmentSource);

    glusProgramBuildFromSource(&g_program, (const GLUSchar**) &vertexSource.text, (const GLUSchar**) &fragmentSource.text);

    glusFileDestroyText(&vertexSource);
    glusFileDestroyText(&fragmentSource);

    //

    // Retrieve the uniform locations in the program.
    g_viewProjectionMatrixLocation = glGetUniformLocation(g_program.program, "u_viewProjectionMatrix");
    g_viewProjectionBiasTextureMatrixLocation = glGetUniformLocation(g_program.program, "u_viewProjectionBiasTextureMatrix");
    g_modelMatrixLocation = glGetUniformLocation(g_program.program, "u_modelMatrix");
    g_normalMatrixLocation = glGetUniformLocation(g_program.program, "u_normalMatrix");
    g_lightDirectionLocation = glGetUniformLocation(g_program.program, "u_lightDirection");
    g_repeatLocation =  glGetUniformLocation(g_program.program, "u_repeat");
    g_textureLocation = glGetUniformLocation(g_program.program, "u_texture");
    g_mirrorTextureLocation = glGetUniformLocation(g_program.program, "u_mirrorTexture");

    // Retrieve the attribute locations in the program.
    g_vertexLocation = glGetAttribLocation(g_program.program, "a_vertex");
    g_normalLocation = glGetAttribLocation(g_program.program, "a_normal");
    g_texCoordLocation = glGetAttribLocation(g_program.program, "a_texCoord");

    //

    // Texture set up.

    glusImageLoadTga("ice.tga", &image);

    glGenTextures(1, &g_texture);
    glBindTexture(GL_TEXTURE_2D, g_texture);

    glTexImage2D(GL_TEXTURE_2D, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);

    // Mipmap generation is now included in OpenGL 3 and above
    glGenerateMipmap(GL_TEXTURE_2D);

    // Trilinear filtering
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

    glBindTexture(GL_TEXTURE_2D, 0);

    //
    // Setting up the offscreen frame buffer.
    //

    glGenTextures(1, &g_mirrorTexture);
    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D, g_mirrorTexture);

    glTexImage2D(GL_TEXTURE_2D, 0, GLUS_RGB, TEXTURE_WIDTH, TEXTURE_HEIGHT, 0, GLUS_RGB, GL_UNSIGNED_BYTE, 0);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glBindTexture(GL_TEXTURE_2D, 0);

    //

    glGenRenderbuffers(1, &g_depthMirrorTexture);
    glBindRenderbuffer(GL_RENDERBUFFER, g_depthMirrorTexture);
    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, TEXTURE_WIDTH, TEXTURE_HEIGHT);

    glBindRenderbuffer(GL_RENDERBUFFER, 0);

    //

    glGenFramebuffers(1, &g_fboMirrorTexture);
    glBindFramebuffer(GL_FRAMEBUFFER, g_fboMirrorTexture);

    // Attach the color buffer ...
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, g_mirrorTexture, 0);

    // ... and the depth buffer,
    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, g_depthMirrorTexture);

    if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
    {
        printf("GL_FRAMEBUFFER_COMPLETE error 0x%x", glCheckFramebufferStatus(GL_FRAMEBUFFER));

        return GLUS_FALSE;
    }

    glBindFramebuffer(GL_FRAMEBUFFER, 0);

    //
    //
    //

    glusShapeCreatePlanef(&plane, 3.0f);

    g_numberIndicesSphere = plane.numberIndices;

    glGenBuffers(1, &g_verticesVBO);
    glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
    glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) plane.vertices, GL_STATIC_DRAW);

    glGenBuffers(1, &g_normalsVBO);
    glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO);
    glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 3 * sizeof(GLfloat), (GLfloat*) plane.normals, GL_STATIC_DRAW);

    glGenBuffers(1, &g_texCoordsVBO);
    glBindBuffer(GL_ARRAY_BUFFER, g_texCoordsVBO);
    glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 2 * sizeof(GLfloat), (GLfloat*) plane.texCoords, GL_STATIC_DRAW);

    glBindBuffer(GL_ARRAY_BUFFER, 0);

    glGenBuffers(1, &g_indicesVBO);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, plane.numberIndices * sizeof(GLuint), (GLuint*) plane.indices, GL_STATIC_DRAW);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    glusShapeDestroyf(&plane);

    //

    glUseProgram(g_program.program);

    glGenVertexArrays(1, &g_vao);
    glBindVertexArray(g_vao);

    glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
    glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(g_vertexLocation);

    glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO);
    glVertexAttribPointer(g_normalLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(g_normalLocation);

    glBindBuffer(GL_ARRAY_BUFFER, g_texCoordsVBO);
    glVertexAttribPointer(g_texCoordLocation, 2, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(g_texCoordLocation);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);

    //

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, g_texture);
    glUniform1i(g_textureLocation, 0);

    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D, g_mirrorTexture);
    glUniform1i(g_mirrorTextureLocation, 1);

    // How many times the surface texture is repeated.
    glUniform1f(g_repeatLocation, 6.0f);

    //

    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

    glClearDepthf(1.0f);

    glEnable(GL_DEPTH_TEST);

    glEnable(GL_CULL_FACE);

    return GLUS_TRUE;
}
예제 #13
0
GLUSvoid terminate(GLUSvoid)
{
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    if (g_verticesVBO)
    {
        glDeleteBuffers(1, &g_verticesVBO);

        g_verticesVBO = 0;
    }

    if (g_normalsVBO)
    {
        glDeleteBuffers(1, &g_normalsVBO);

        g_normalsVBO = 0;
    }

    if (g_texCoordsVBO)
    {
        glDeleteBuffers(1, &g_texCoordsVBO);

        g_texCoordsVBO = 0;
    }

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    if (g_indicesVBO)
    {
        glDeleteBuffers(1, &g_indicesVBO);

        g_indicesVBO = 0;
    }

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, 0);

	if (g_texture)
    {
        glDeleteTextures(1, &g_texture);

        g_texture = 0;
    }

    glBindVertexArray(0);

    if (g_vao)
    {
        glDeleteVertexArrays(1, &g_vao);

        g_vao = 0;
    }

    glUseProgram(0);

    glusProgramDestroy(&g_program);

    //

    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D, 0);

    if (g_mirrorTexture)
    {
        glDeleteTextures(1, &g_mirrorTexture);

        g_mirrorTexture = 0;
    }

    glBindRenderbuffer(GL_RENDERBUFFER, 0);

    if (g_depthMirrorTexture)
    {
        glDeleteRenderbuffers(1, &g_depthMirrorTexture);

        g_depthMirrorTexture = 0;
    }

    glBindFramebuffer(GL_FRAMEBUFFER, 0);

	if (g_fboMirrorTexture)
	{
		glDeleteFramebuffers(1, &g_fboMirrorTexture);

		g_fboMirrorTexture = 0;
	}

    terminateWavefront();
}
예제 #14
0
GLUSboolean update(GLUSfloat time)
{
	// Bias needed to convert the from [-1;1] to [0;1]
	GLfloat biasMatrix[16] = {0.5f, 0.0f, 0.0f, 0.0f,
								0.0f, 0.5f, 0.0f, 0.0f,
								0.0f, 0.0f, 0.5f, 0.0f,
								0.5f, 0.5f, 0.5f, 1.0f};
	// Frame buffer has another view port and so perspective projection. Needed for projected texturing of the mirror texture.
	GLfloat viewProjectionBiasTextureMatrix[16];

	// This matrix is used to flip the rendered object upside down.
	GLfloat scaleMatrix[16];

	// Store current width and height for later reseting.
	GLuint width = g_width;
	GLuint height = g_height;

	//
    // Upside down rendering to frame buffer.
	//
    glBindFramebuffer(GL_FRAMEBUFFER, g_fboMirrorTexture);

	reshape(TEXTURE_WIDTH, TEXTURE_HEIGHT);

    glClearColor(1.0f, 1.0f, 1.0f, 0.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glusMatrix4x4Identityf(scaleMatrix);
    glusMatrix4x4Scalef(scaleMatrix, 1.0f, -1.0f, 1.0f);

    glFrontFace(GL_CW);

    if (!updateWavefront(time, scaleMatrix))
    {
    	return GLUS_FALSE;
    }

    glBindFramebuffer(GL_FRAMEBUFFER, 0);

    // Save the current projection matrix for later usage.

    glusMatrix4x4Copyf(viewProjectionBiasTextureMatrix, g_viewProjectionMatrix, GLUS_FALSE);

    glusMatrix4x4Multiplyf(viewProjectionBiasTextureMatrix, biasMatrix, viewProjectionBiasTextureMatrix);

    //
    // Scene rendering
    //

    reshape(width, height);

    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // Normal rendering
    glusMatrix4x4Identityf(scaleMatrix);

    glFrontFace(GL_CCW);

    if (!updateWavefront(time, scaleMatrix))
    {
    	return GLUS_FALSE;
    }

    glUseProgram(g_program.program);

    // This matrix is needed to calculate the vertices into the frame buffer render pass.
    glUniformMatrix4fv(g_viewProjectionBiasTextureMatrixLocation, 1, GL_FALSE, viewProjectionBiasTextureMatrix);

    glBindVertexArray(g_vao);

    glDrawElements(GL_TRIANGLES, g_numberIndicesSphere, GL_UNSIGNED_INT, 0);

    return GLUS_TRUE;
}
예제 #15
0
void SetupRC()
{
	bool loadFromFile = false;
    instancingShader = gltLoadShaderPair("instancing.vs",
                                         "instancing.fs",
										 loadFromFile);
    glLinkProgram(instancingShader);
    glUseProgram(instancingShader);
	glFinish();

  
	ModelViewMatrix = glGetUniformLocation(instancingShader, "ModelViewMatrix");
	ProjectionMatrix = glGetUniformLocation(instancingShader, "ProjectionMatrix");
	NormalMatrix = glGetUniformLocation(instancingShader, "NormalMatrix");
	uniform_texture_diffuse = glGetUniformLocation(instancingShader, "Diffuse");

    GLuint offset = 0;

    glGenVertexArrays(1, &cube_vao);
    glGenBuffers(1, &cube_vbo);
    glBindVertexArray(cube_vao);
    glBindBuffer(GL_ARRAY_BUFFER, cube_vbo);

	instance_positions_ptr = (GLfloat*)new float[NUM_OBJECTS*4];
	instance_quaternion_ptr = (GLfloat*)new float[NUM_OBJECTS*4];
	int index=0;
	for (int i=0;i<NUM_OBJECTS_X;i++)
		for (int j=0;j<NUM_OBJECTS_Y;j++)
			for (int k=0;k<NUM_OBJECTS_Z;k++)
		{
			instance_positions_ptr[index*4]=-(i-NUM_OBJECTS_X/2)*10;
			instance_positions_ptr[index*4+1]=-(j-NUM_OBJECTS_Y/2)*10;
			instance_positions_ptr[index*4+2]=-k*10;
			instance_positions_ptr[index*4+3]=1;

			instance_quaternion_ptr[index*4]=0;
			instance_quaternion_ptr[index*4+1]=0;
			instance_quaternion_ptr[index*4+2]=0;
			instance_quaternion_ptr[index*4+3]=1;
			index++;
		}

	glBufferData(GL_ARRAY_BUFFER, sizeof(cube_vertices) + sizeof(instance_colors) + POSITION_BUFFER_SIZE+ORIENTATION_BUFFER_SIZE, NULL, GL_DYNAMIC_DRAW);//GL_STATIC_DRAW);

	///initialize parts of the buffer
	glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(cube_vertices), cube_vertices);
	glBufferSubData(GL_ARRAY_BUFFER, sizeof(cube_vertices), sizeof(instance_colors), instance_colors);
    glBufferSubData(GL_ARRAY_BUFFER, sizeof(cube_vertices) + sizeof(instance_colors), POSITION_BUFFER_SIZE, instance_positions_ptr);
    glBufferSubData(GL_ARRAY_BUFFER, sizeof(cube_vertices) + sizeof(instance_colors)+POSITION_BUFFER_SIZE,ORIENTATION_BUFFER_SIZE , instance_quaternion_ptr);

	

	glBindBuffer(GL_ARRAY_BUFFER,0);

	glGenBuffers(1, &index_vbo);
	int indexBufferSize = sizeof(cube_indices);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_vbo);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexBufferSize, NULL, GL_STATIC_DRAW);
	glBufferSubData(GL_ELEMENT_ARRAY_BUFFER,0,indexBufferSize,cube_indices);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
	

}
	void TreeNode::init(Tree * tree, HeightMapNode * heightMapNode){
		_heightMapNode = heightMapNode;
		this-> tree = tree;

		std::vector<float> vertices;
		std::vector<float> normals;
		std::vector<int> indices;

		glm::vec3 * branchNodes = tree->branchNodes;
		float radius = tree->radius;
		float twigging = 0.7*(1.0-pow(2,-1*(float)tree->MAXDEPTH));

		{
			//make trunk
			glm::vec3 curr = branchNodes[0];
			glm::vec3 next = branchNodes[1];
			glm::vec3 axis1 = glm::normalize(next - curr);
			glm::vec3 axis2 = glm::normalize(glm::vec3(0,float(-1)*axis1.z,axis1.y));
			glm::vec3 axis3 = glm::cross(axis1,axis2);
			//generate vertices
			int subdivisions = 20;
			for(int i=0;i<=subdivisions;i++){
				float angle = 2*PI*((float)i/(float) subdivisions);
				//bottom
				glm::vec3 norm = float(cos(angle))*axis2 + float(sin(angle))*axis3;
				glm::vec3 point1 = (float(cos(angle))*axis2 + float(sin(angle))*axis3)*radius + curr;
				vertices.push_back(point1.x);
				vertices.push_back(point1.y);
				vertices.push_back(point1.z);
				vertices.push_back(norm.x);
				vertices.push_back(norm.y);
				vertices.push_back(norm.z);

				//top
				glm::vec3 point2 = (float(cos(angle))*axis2 + float(sin(angle))*axis3)*radius + next;
				vertices.push_back(point2.x);
				vertices.push_back(point2.y);
				vertices.push_back(point2.z);
				vertices.push_back(norm.x);
				vertices.push_back(norm.y);
				vertices.push_back(norm.z);
			}
			//generate triangles
			// 0 2 1, 1 2 3, 2 4 3, 3 4 5
			for(int i= 0; i< subdivisions;i++){
				int k = 2*i;
				indices.push_back(k);
				indices.push_back(k+2);
				indices.push_back(k+1);
				
				indices.push_back(k+1);
				indices.push_back(k+2);
				indices.push_back(k+3);
			}



			//rest of the branches
			for(int branch=1;branch < tree->numNodes/2;branch++){

				int leftI = 2*branch;
				int rightI = leftI+1;


				curr = branchNodes[branch];

				//for the left
				next = branchNodes[leftI];
				axis1 = glm::normalize(next - curr);
				axis2 = glm::normalize(glm::vec3(0,float(-1)*axis1.z,axis1.y));
				axis3 = glm::cross(axis1,axis2);
				int start = vertices.size()/6;
				for(int i=0;i<=subdivisions;i++){
					float angle = 2*PI*((float)i/(float) subdivisions);
					//bottom
					glm::vec3 norm = float(cos(angle))*axis2 + float(sin(angle))*axis3;

					glm::vec3 point1 = (float(cos(angle))*axis2 + float(sin(angle))*axis3 )
										*radius*(float)pow(twigging,floor(log2(branch)))+ curr;
					vertices.push_back(point1.x);
					vertices.push_back(point1.y);
					vertices.push_back(point1.z);
					vertices.push_back(norm.x);
					vertices.push_back(norm.y);
					vertices.push_back(norm.z);
					//top
					glm::vec3 point2 = (float(cos(angle))*axis2 + float(sin(angle))*axis3)*radius*(float)pow(twigging,floor(log2(branch)) + 1) + next;

					vertices.push_back(point2.x);
					vertices.push_back(point2.y);
					vertices.push_back(point2.z);
					vertices.push_back(norm.x);
					vertices.push_back(norm.y);
					vertices.push_back(norm.z);
				}

				for(int i= 0; i< subdivisions;i++){
					int k = 2*i + start;
					indices.push_back(k);
					indices.push_back(k+2);
					indices.push_back(k+1);
					
					indices.push_back(k+1);
					indices.push_back(k+2);
					indices.push_back(k+3);
				}



				//for the right
				next = branchNodes[rightI];

				axis1 = glm::normalize(next - curr);
				axis2 = glm::vec3(0,float(-1)*axis1.z,axis1.y);
				axis3 = glm::cross(axis1,axis2);
				start = vertices.size()/6;
				for(int i=0;i<=subdivisions;i++){
					float angle = 2*PI*((float)i/(float) subdivisions);
					//bottom
					glm::vec3 norm = float(cos(angle))*axis2 + float(sin(angle))*axis3;
					glm::vec3 point1 = (float(cos(angle))*axis2 + float(sin(angle))*axis3 )
										*radius*(float)pow(twigging,floor(log2(branch)))+ curr;
					vertices.push_back(point1.x);
					vertices.push_back(point1.y);
					vertices.push_back(point1.z);
					vertices.push_back(norm.x);
					vertices.push_back(norm.y);
					vertices.push_back(norm.z);
					//top
					glm::vec3 point2 = (float(cos(angle))*axis2 + float(sin(angle))*axis3)*radius*(float)pow(twigging,floor(log2(branch)) + 1) + next;
					vertices.push_back(point2.x);
					vertices.push_back(point2.y);
					vertices.push_back(point2.z);
					vertices.push_back(norm.x);
					vertices.push_back(norm.y);
					vertices.push_back(norm.z);
				}

				for(int i= 0; i< subdivisions;i++){
					int k = 2*i + start;
					indices.push_back(k);
					indices.push_back(k+2);
					indices.push_back(k+1);
					
					indices.push_back(k+1);
					indices.push_back(k+2);
					indices.push_back(k+3);
				}
				nindices = indices.size();
			}


		}

		{
			glGenVertexArrays(1, &vao);
			glBindVertexArray(vao);

			glGenBuffers(1, &vbo);
			glBindBuffer(GL_ARRAY_BUFFER, vbo);
			glBufferData(GL_ARRAY_BUFFER, vertices.size()*sizeof(float), &vertices[0], GL_STATIC_DRAW);

			glGenBuffers(1, &ibo);
			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);

			glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size()*sizeof(int), &indices[0], GL_STATIC_DRAW);

			// glActiveTexture(GL_TEXTURE0);
			// glGenTextures(1, &tex);
			// glBindTexture(GL_TEXTURE_2D, tex);

			// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
			// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
			// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
			// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

			// glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, heightMap->getResolutionX(), heightMap->getResolutionY(), 0, GL_RED, GL_FLOAT, heightMap->getHeightData());
		}

		{	
			std::vector<std::string> files;
			files.push_back(core::Resources::pathForResource("Shaders/Common.glsl"));
			files.push_back(core::Resources::pathForResource("Shaders/Terrain/Helper.glsl"));
			files.push_back(core::Resources::pathForResource("Shaders/Tree/Tree.glsl"));
			// files.push_back(core::Resources::pathForResource("Shaders/Terrain/Material.glsl"));

			materialShader.loadFromFiles(files);

			materialShader.addUniform("modelMatrix");
			materialShader.addUniform("viewMatrix");
			materialShader.addUniform("projectionMatrix");
			
			materialShader.addUniform("terrain_heightMap");
			materialShader.addUniform("terrain_size");
			materialShader.addUniform("terrain_height");

			materialShader.addAttribute("position");
			materialShader.addAttribute("normal");
			glBindVertexArray(vao);
			materialShader.use();

			glUniform1f(materialShader("terrain_size"), heightMapNode->heightMap->getSizeX());
			glUniform1f(materialShader("terrain_height"), heightMapNode->height);

			glEnableVertexAttribArray(materialShader["position"]);
			glVertexAttribPointer(materialShader["position"], 3, GL_FLOAT, GL_FALSE, 6*sizeof(float), 0);
			glEnableVertexAttribArray(materialShader["normal"]);
			glVertexAttribPointer(materialShader["normal"], 3, GL_FLOAT, GL_FALSE, 6*sizeof(float), (void *) (3*sizeof(float)));

			materialShader.unUse();
			glBindVertexArray(0);
		}
	}
	bool render()
	{
		glm::vec2 WindowSize(this->getWindowSize());

		{
			glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]);
			glm::mat4* Pointer = (glm::mat4*)glMapBufferRange(
				GL_UNIFORM_BUFFER, 0,	sizeof(glm::mat4),
				GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);

			glm::mat4 Projection = glm::perspectiveFov(glm::pi<float>() * 0.25f, WindowSize.x, WindowSize.y, 0.1f, 100.0f);
			glm::mat4 Model = glm::mat4(1.0f);
			*Pointer = Projection * this->view() * Model;

			// Make sure the uniform buffer is uploaded
			glUnmapBuffer(GL_UNIFORM_BUFFER);
		}

		glViewportIndexedf(0, 0, 0, WindowSize.x, WindowSize.y);
		glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f)[0]);

		glBindProgramPipeline(PipelineName);
		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D_ARRAY, TextureName);
		glBindVertexArray(VertexArrayName);
		glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]);

		glBeginQuery(GL_VERTICES_SUBMITTED_ARB, this->QueryName[statistics::VERTICES_SUBMITTED]);
		glBeginQuery(GL_PRIMITIVES_SUBMITTED_ARB, this->QueryName[statistics::PRIMITIVES_SUBMITTED]);
		glBeginQuery(GL_VERTEX_SHADER_INVOCATIONS_ARB, this->QueryName[statistics::VERTEX_SHADER_INVOCATIONS]);
		glBeginQuery(GL_TESS_CONTROL_SHADER_PATCHES_ARB, this->QueryName[statistics::TESS_CONTROL_SHADER_PATCHES]);
		glBeginQuery(GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB, this->QueryName[statistics::TESS_EVALUATION_SHADER_INVOCATIONS]);
		glBeginQuery(GL_GEOMETRY_SHADER_INVOCATIONS, this->QueryName[statistics::GEOMETRY_SHADER_INVOCATIONS]);
		glBeginQuery(GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB, this->QueryName[statistics::GEOMETRY_SHADER_PRIMITIVES_EMITTED]);
		glBeginQuery(GL_FRAGMENT_SHADER_INVOCATIONS_ARB, this->QueryName[statistics::FRAGMENT_SHADER_INVOCATIONS]);
		glBeginQuery(GL_COMPUTE_SHADER_INVOCATIONS_ARB, this->QueryName[statistics::COMPUTE_SHADER_INVOCATIONS]);
		glBeginQuery(GL_CLIPPING_INPUT_PRIMITIVES_ARB, this->QueryName[statistics::CLIPPING_INPUT_PRIMITIVES]);
		glBeginQuery(GL_CLIPPING_OUTPUT_PRIMITIVES_ARB, this->QueryName[statistics::CLIPPING_OUTPUT_PRIMITIVES]);
			glDrawElementsInstancedBaseVertexBaseInstance(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, 0, 1, 0, 0);
		glEndQuery(GL_VERTICES_SUBMITTED_ARB);
		glEndQuery(GL_PRIMITIVES_SUBMITTED_ARB);
		glEndQuery(GL_VERTEX_SHADER_INVOCATIONS_ARB);
		glEndQuery(GL_TESS_CONTROL_SHADER_PATCHES_ARB);
		glEndQuery(GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB);
		glEndQuery(GL_GEOMETRY_SHADER_INVOCATIONS);
		glEndQuery(GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB);
		glEndQuery(GL_FRAGMENT_SHADER_INVOCATIONS_ARB);
		glEndQuery(GL_COMPUTE_SHADER_INVOCATIONS_ARB);
		glEndQuery(GL_CLIPPING_INPUT_PRIMITIVES_ARB);
		glEndQuery(GL_CLIPPING_OUTPUT_PRIMITIVES_ARB);

		std::array<GLuint, statistics::MAX> QueryResult;
		for(std::size_t i = 0; i < QueryResult.size(); ++i)
			glGetQueryObjectuiv(this->QueryName[i], GL_QUERY_RESULT, &QueryResult[i]);

		fprintf(stdout, "Verts: %d; Prims: (%d, %d); Shaders(%d, %d, %d, %d, %d, %d); Clip(%d, %d)\r",
			QueryResult[statistics::VERTICES_SUBMITTED],
			QueryResult[statistics::PRIMITIVES_SUBMITTED],
			QueryResult[statistics::GEOMETRY_SHADER_PRIMITIVES_EMITTED],
			QueryResult[statistics::VERTEX_SHADER_INVOCATIONS],
			QueryResult[statistics::TESS_CONTROL_SHADER_PATCHES],
			QueryResult[statistics::TESS_EVALUATION_SHADER_INVOCATIONS],
			QueryResult[statistics::GEOMETRY_SHADER_INVOCATIONS],
			QueryResult[statistics::FRAGMENT_SHADER_INVOCATIONS],
			QueryResult[statistics::COMPUTE_SHADER_INVOCATIONS],
			QueryResult[statistics::CLIPPING_INPUT_PRIMITIVES],
			QueryResult[statistics::CLIPPING_OUTPUT_PRIMITIVES]);

		return true;
	}
		void FillPath(Geometry::Path& path,Graphics::Colour colour)
		{
			const unsigned int first_offset = total_vertex_count;
			const unsigned int vertex_count = path.size() + 1;

			ShapeSegmentData data = {{colour.red,colour.green,colour.blue,colour.alpha},{0,0}};
			double x_max;
			double x_min;
			double y_max;
			double y_min;


			if(!path.isClosed())
			{
				throw std::runtime_error("Path must be closed to use draw a shape.");
			}

			x_max = std::numeric_limits<double>::lowest();
			x_min = -x_max;
			y_max = std::numeric_limits<double>::lowest();
			y_min = -y_max;
			for(Point& point : path)
			{
				if(point.x < x_min)
				{
					x_min = point.x;
				}
				if(point.x > x_max)
				{
					x_max = point.x;
				}
				if(point.y < y_min)
				{
					y_min = point.y;
				}
				if(point.y > y_max)
				{
					y_max = point.y;
				}
			}

			glBindBuffer(GL_ARRAY_BUFFER,buffer_handle);
			data.position[0] = (x_min + x_max) / 2;
			data.position[1] = (y_min + y_max) / 2;
			glBufferSubData(GL_ARRAY_BUFFER,total_vertex_count * sizeof(data),sizeof(data),&data);
			++total_vertex_count;

			for(Point& point : path)
			{
				data.position[0] = point.x;
				data.position[1] = point.y;
				glBufferSubData(GL_ARRAY_BUFFER,total_vertex_count * sizeof(data),sizeof(data),&data);
				++total_vertex_count;
			}
			glBindBuffer(GL_ARRAY_BUFFER,0);


			Point translate = OpenGL::GetOrigin();
			OpenGL::AddRenderTask([first_offset,vertex_count,translate](){
				glUseProgram(program_handle);
				glBindVertexArray(array_handle);
				glBindBuffer(GL_ARRAY_BUFFER,buffer_handle);

					glUniform2f(uniform_translate,translate.x,translate.y);
					glDrawArrays(GL_TRIANGLE_FAN,first_offset,vertex_count);

				glBindBuffer(GL_ARRAY_BUFFER,0);
				glBindVertexArray(0);
				glUseProgram(0);

				total_vertex_count -= vertex_count;
			});
		}
예제 #19
0
GLUSboolean init(GLUSvoid)
{
	GLUSshape backgroundSphere;

	GLUSshape wavefront;

	// 6 sides of diffuse and specular; all roughness levels of specular.
	GLUShdrimage image[6 * NUMBER_ROUGHNESS + 6];

	// The look up table (LUT) is stored in a raw binary file.
	GLUSbinaryfile rawimage;

	GLUStextfile vertexSource;
	GLUStextfile fragmentSource;

	GLchar buffer[27] = "doge2/doge2_POS_X_00_s.hdr";

	GLint i, k, m;

	//

	glusLoadTextFile("../Example33/shader/brdf.vert.glsl", &vertexSource);
	glusLoadTextFile("../Example33/shader/brdf.frag.glsl", &fragmentSource);

	glusBuildProgramFromSource(&g_modelProgram, (const GLchar**)&vertexSource.text, 0, 0, 0, (const GLchar**)&fragmentSource.text);

	glusDestroyTextFile(&vertexSource);
	glusDestroyTextFile(&fragmentSource);

	g_viewProjectionMatrixModelLocation = glGetUniformLocation(g_modelProgram.program, "u_viewProjectionMatrix");
	g_modelMatrixModelLocation = glGetUniformLocation(g_modelProgram.program, "u_modelMatrix");
	g_normalMatrixModelLocation = glGetUniformLocation(g_modelProgram.program, "u_normalMatrix");
	g_eyeModelLocation = glGetUniformLocation(g_modelProgram.program, "u_eye");
	g_textureSpecularModelLocation = glGetUniformLocation(g_modelProgram.program, "u_textureSpecular");
	g_textureDiffuseModelLocation = glGetUniformLocation(g_modelProgram.program, "u_textureDiffuse");
	g_textureLUTModelLocation = glGetUniformLocation(g_modelProgram.program, "u_textureLUT");
	g_colorMaterialModelLocation = glGetUniformLocation(g_modelProgram.program, "u_colorMaterial");
	g_roughnessMaterialModelLocation = glGetUniformLocation(g_modelProgram.program, "u_roughnessMaterial");
	g_roughnessScaleModelLocation = glGetUniformLocation(g_modelProgram.program, "u_roughnessScale");
	g_R0MaterialModelLocation = glGetUniformLocation(g_modelProgram.program, "u_R0Material");

	g_vertexModelLocation = glGetAttribLocation(g_modelProgram.program, "a_vertex");
	g_normalModelLocation = glGetAttribLocation(g_modelProgram.program, "a_normal");

	//

	glusLoadTextFile("../Example33/shader/fullscreen.vert.glsl", &vertexSource);
	glusLoadTextFile("../Example33/shader/fullscreen.frag.glsl", &fragmentSource);

	glusBuildProgramFromSource(&g_fullscreenProgram, (const GLchar**)&vertexSource.text, 0, 0, 0, (const GLchar**)&fragmentSource.text);

	glusDestroyTextFile(&vertexSource);
	glusDestroyTextFile(&fragmentSource);

	//

	g_framebufferTextureFullscreenLocation = glGetUniformLocation(g_fullscreenProgram.program, "u_framebufferTexture");

	g_msaaSamplesFullscreenLocation = glGetUniformLocation(g_fullscreenProgram.program, "u_msaaSamples");
	g_exposureFullscreenLocation = glGetUniformLocation(g_fullscreenProgram.program, "u_exposure");
	g_gammaFullscreenLocation = glGetUniformLocation(g_fullscreenProgram.program, "u_gamma");

	//
	//

	glusLoadTextFile("../Example33/shader/background.vert.glsl", &vertexSource);
	glusLoadTextFile("../Example33/shader/background.frag.glsl", &fragmentSource);

	glusBuildProgramFromSource(&g_backgroundProgram, (const GLUSchar**)&vertexSource.text, 0, 0, 0, (const GLUSchar**)&fragmentSource.text);

	glusDestroyTextFile(&vertexSource);
	glusDestroyTextFile(&fragmentSource);

	//

	g_viewProjectionMatrixBackgroundLocation = glGetUniformLocation(g_backgroundProgram.program, "u_viewProjectionMatrix");
	g_textureBackgroundLocation = glGetUniformLocation(g_backgroundProgram.program, "u_texture");

	g_vertexBackgroundLocation = glGetAttribLocation(g_backgroundProgram.program, "a_vertex");

	//
	// Setting up the full screen frame buffer.
	//

	glGenTextures(1, &g_fullscreenTexture);
	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, g_fullscreenTexture);

	// Create MSAA texture.
	glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, MSAA_SAMPLES, GL_RGB32F, SCREEN_WIDTH, SCREEN_HEIGHT, GL_TRUE);

	glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0);

	// No need to access the depth buffer, so a render buffer is sufficient.

	glGenRenderbuffers(1, &g_fullscreenDepthRenderbuffer);
	glBindRenderbuffer(GL_RENDERBUFFER, g_fullscreenDepthRenderbuffer);
	glRenderbufferStorageMultisample(GL_RENDERBUFFER, MSAA_SAMPLES, GL_DEPTH_COMPONENT, SCREEN_WIDTH, SCREEN_HEIGHT);

	glBindRenderbuffer(GL_RENDERBUFFER, 0);

	//

	glGenFramebuffers(1, &g_fullscreenFBO);
	glBindFramebuffer(GL_FRAMEBUFFER, g_fullscreenFBO);

	// Attach the color buffer ...
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, g_fullscreenTexture, 0);

	// ... and the depth buffer.
	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, g_fullscreenDepthRenderbuffer);

	if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
	{
		printf("GL_FRAMEBUFFER_COMPLETE error 0x%x", glCheckFramebufferStatus(GL_FRAMEBUFFER));

		return GLUS_FALSE;
	}

	glBindFramebuffer(GL_FRAMEBUFFER, 0);

	//
	//
	//

	for (i = 0; i < 2; i++)
	{
		if (i == 0)
		{
			buffer[21] = 's';
		}
		else
		{
			buffer[21] = 'd';
		}

		for (k = 0; k < NUMBER_ROUGHNESS; k++)
		{
			if (i == 1 && k > 0)
			{
				continue;
			}

			buffer[18] = '0' + k / 10;
			buffer[19] = '0' + k % 10;

			for (m = 0; m < 6; m++)
			{
				if (m % 2 == 0)
				{
					buffer[12] = 'P';
					buffer[13] = 'O';
					buffer[14] = 'S';
				}
				else
				{
					buffer[12] = 'N';
					buffer[13] = 'E';
					buffer[14] = 'G';
				}

				switch (m)
				{
					case 0:
					case 1:
						buffer[16] = 'X';
						break;
					case 2:
					case 3:
						buffer[16] = 'Y';
						break;
					case 4:
					case 5:
						buffer[16] = 'Z';
						break;
				}

				printf("Loading '%s' ...", buffer);

				if (!glusLoadHdrImage(buffer, &image[i*NUMBER_ROUGHNESS*6 + k*6 + m]))
				{
					printf(" error!\n");
					continue;
				}

				printf(" done.\n");
			}
		}
	}

    glGenTextures(1, &g_texture[0]);
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, g_texture[0]);

	glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGB32F, image[0].width, image[0].height, 6*NUMBER_ROUGHNESS, 0, GL_RGB, GL_FLOAT, 0);

	glusLogPrintError(GLUS_LOG_INFO, "glTexImage3D()");

    for (i = 0; i < NUMBER_ROUGHNESS; i++)
    {
        for (k = 0; k < 6; k++)
        {
        	glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 0, 0,  6*i + k, image[i*6 + k].width, image[i*6 + k].height, 1, image[i*6 + k].format, GL_FLOAT, image[i*6 + k].data);

        	glusLogPrintError(GLUS_LOG_INFO, "glTexSubImage3D() %d %d", i, k);
        }
    }

    glTexParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, 0);

    //

    glGenTextures(1, &g_texture[1]);
    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_CUBE_MAP, g_texture[1]);

    for (i = 0; i < 6; i++)
    {
        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, image[i + 6*NUMBER_ROUGHNESS].format, image[i + 6*NUMBER_ROUGHNESS].width, image[i + 6*NUMBER_ROUGHNESS].height, 0, image[i + 6*NUMBER_ROUGHNESS].format, GL_FLOAT, image[i + 6*NUMBER_ROUGHNESS].data);

    	glusLogPrintError(GLUS_LOG_INFO, "glTexImage2D() %d", i);
    }

    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glBindTexture(GL_TEXTURE_CUBE_MAP, 0);

    //

	printf("Loading 'doge2/EnvironmentBRDF_1024.data' ...");
    if (!glusLoadBinaryFile("doge2/EnvironmentBRDF_1024.data", &rawimage))
    {
		printf(" error!\n");
    }
    else
    {
    	printf(" done.\n");
    }

    glGenTextures(1, &g_texture[2]);
    glActiveTexture(GL_TEXTURE2);
    glBindTexture(GL_TEXTURE_2D, g_texture[2]);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RG32F, 1024, 1024, 0, GL_RG, GL_FLOAT, (GLfloat*)rawimage.binary);

    glusLogPrintError(GLUS_LOG_INFO, "glTexImage2D()");

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glBindTexture(GL_TEXTURE_2D, 0);

    glusDestroyBinaryFile(&rawimage);

    //

	for (i = 0; i < 2; i++)
	{
		for (k = 0; k < NUMBER_ROUGHNESS; k++)
		{
			if (i == 1 && k > 0)
			{
				continue;
			}

			for (m = 0; m < 6; m++)
			{
				glusDestroyHdrImage(&image[i*NUMBER_ROUGHNESS*6 + k*6 + m]);
			}
		}
	}

	//

	glusCreateSpheref(&backgroundSphere, 500.0f, 32);
	g_numberIndicesBackground = backgroundSphere.numberIndices;

	glGenBuffers(1, &g_verticesBackgroundVBO);
	glBindBuffer(GL_ARRAY_BUFFER, g_verticesBackgroundVBO);
	glBufferData(GL_ARRAY_BUFFER, backgroundSphere.numberVertices * 4 * sizeof(GLfloat), (GLfloat*)backgroundSphere.vertices, GL_STATIC_DRAW);

	glBindBuffer(GL_ARRAY_BUFFER, 0);

	glGenBuffers(1, &g_indicesBackgroundVBO);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesBackgroundVBO);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, backgroundSphere.numberIndices * sizeof(GLuint), (GLuint*)backgroundSphere.indices, GL_STATIC_DRAW);

	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

	glusDestroyShapef(&backgroundSphere);

	//
	//

	// Use a helper function to load an wavefront object file.
	glusLoadObjFile("venusm.obj", &wavefront);

	g_numberVerticesModel = wavefront.numberVertices;

	glGenBuffers(1, &g_verticesModelVBO);
	glBindBuffer(GL_ARRAY_BUFFER, g_verticesModelVBO);
	glBufferData(GL_ARRAY_BUFFER, wavefront.numberVertices * 4 * sizeof(GLfloat), (GLfloat*)wavefront.vertices, GL_STATIC_DRAW);

	glGenBuffers(1, &g_normalsModelVBO);
	glBindBuffer(GL_ARRAY_BUFFER, g_normalsModelVBO);
	glBufferData(GL_ARRAY_BUFFER, wavefront.numberVertices * 3 * sizeof(GLfloat), (GLfloat*)wavefront.normals, GL_STATIC_DRAW);

	glBindBuffer(GL_ARRAY_BUFFER, 0);

	glusDestroyShapef(&wavefront);

	//

	glUseProgram(g_modelProgram.program);

	glUniform4fv(g_eyeModelLocation, 1, g_eye);
	glUniform1i(g_textureSpecularModelLocation, 0);
	glUniform1i(g_textureDiffuseModelLocation, 1);
	glUniform1i(g_textureLUTModelLocation, 2);
	glUniform1f(g_roughnessScaleModelLocation, (GLfloat)(NUMBER_ROUGHNESS - 1));

	glGenVertexArrays(1, &g_modelVAO);
	glBindVertexArray(g_modelVAO);

	glBindBuffer(GL_ARRAY_BUFFER, g_verticesModelVBO);
	glVertexAttribPointer(g_vertexModelLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
	glEnableVertexAttribArray(g_vertexModelLocation);

	glBindBuffer(GL_ARRAY_BUFFER, g_normalsModelVBO);
	glVertexAttribPointer(g_normalModelLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
	glEnableVertexAttribArray(g_normalModelLocation);

	//

	glUseProgram(g_fullscreenProgram.program);

	glUniform1i(g_framebufferTextureFullscreenLocation, 0);
	glUniform1i(g_msaaSamplesFullscreenLocation, MSAA_SAMPLES);

	glGenVertexArrays(1, &g_fullscreenVAO);
	glBindVertexArray(g_fullscreenVAO);

	//

	glUseProgram(g_backgroundProgram.program);

	glUniform1i(g_textureBackgroundLocation, 0);

	glGenVertexArrays(1, &g_backgroundVAO);
	glBindVertexArray(g_backgroundVAO);

	glBindBuffer(GL_ARRAY_BUFFER, g_verticesBackgroundVBO);
	glVertexAttribPointer(g_vertexBackgroundLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
	glEnableVertexAttribArray(g_vertexBackgroundLocation);

	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesBackgroundVBO);

	//

	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

	glClearDepth(1.0f);

	glEnable(GL_CULL_FACE);

	return GLUS_TRUE;
}
예제 #20
0
void SceneBase::Init()
{
	// Black background
	glClearColor(0.0f, 0.7f, 0.0f, 0.0f);
	// Enable depth test
	glEnable(GL_DEPTH_TEST);
	// Accept fragment if it closer to the camera than the former one
	glDepthFunc(GL_LESS); 
	
	glEnable(GL_CULL_FACE);
	
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	glGenVertexArrays(1, &m_vertexArrayID);
	glBindVertexArray(m_vertexArrayID);

	m_programID = LoadShaders( "Shader//comg.vertexshader", "Shader//comg.fragmentshader" );
	
	// Get a handle for our uniform
	m_parameters[U_MVP] = glGetUniformLocation(m_programID, "MVP");
	//m_parameters[U_MODEL] = glGetUniformLocation(m_programID, "M");
	//m_parameters[U_VIEW] = glGetUniformLocation(m_programID, "V");
	m_parameters[U_MODELVIEW] = glGetUniformLocation(m_programID, "MV");
	m_parameters[U_MODELVIEW_INVERSE_TRANSPOSE] = glGetUniformLocation(m_programID, "MV_inverse_transpose");
	m_parameters[U_MATERIAL_AMBIENT] = glGetUniformLocation(m_programID, "material.kAmbient");
	m_parameters[U_MATERIAL_DIFFUSE] = glGetUniformLocation(m_programID, "material.kDiffuse");
	m_parameters[U_MATERIAL_SPECULAR] = glGetUniformLocation(m_programID, "material.kSpecular");
	m_parameters[U_MATERIAL_SHININESS] = glGetUniformLocation(m_programID, "material.kShininess");
	m_parameters[U_LIGHTENABLED] = glGetUniformLocation(m_programID, "lightEnabled");
	m_parameters[U_NUMLIGHTS] = glGetUniformLocation(m_programID, "numLights");
	m_parameters[U_LIGHT0_TYPE] = glGetUniformLocation(m_programID, "lights[0].type");
	m_parameters[U_LIGHT0_POSITION] = glGetUniformLocation(m_programID, "lights[0].position_cameraspace");
	m_parameters[U_LIGHT0_COLOR] = glGetUniformLocation(m_programID, "lights[0].color");
	m_parameters[U_LIGHT0_POWER] = glGetUniformLocation(m_programID, "lights[0].power");
	m_parameters[U_LIGHT0_KC] = glGetUniformLocation(m_programID, "lights[0].kC");
	m_parameters[U_LIGHT0_KL] = glGetUniformLocation(m_programID, "lights[0].kL");
	m_parameters[U_LIGHT0_KQ] = glGetUniformLocation(m_programID, "lights[0].kQ");
	m_parameters[U_LIGHT0_SPOTDIRECTION] = glGetUniformLocation(m_programID, "lights[0].spotDirection");
	m_parameters[U_LIGHT0_COSCUTOFF] = glGetUniformLocation(m_programID, "lights[0].cosCutoff");
	m_parameters[U_LIGHT0_COSINNER] = glGetUniformLocation(m_programID, "lights[0].cosInner");
	m_parameters[U_LIGHT0_EXPONENT] = glGetUniformLocation(m_programID, "lights[0].exponent");
	// Get a handle for our "colorTexture" uniform
	m_parameters[U_COLOR_TEXTURE_ENABLED] = glGetUniformLocation(m_programID, "colorTextureEnabled");
	m_parameters[U_COLOR_TEXTURE] = glGetUniformLocation(m_programID, "colorTexture");
	// Get a handle for our "textColor" uniform
	m_parameters[U_TEXT_ENABLED] = glGetUniformLocation(m_programID, "textEnabled");
	m_parameters[U_TEXT_COLOR] = glGetUniformLocation(m_programID, "textColor");
	
	// Use our shader
	glUseProgram(m_programID);

	lights[0].type = Light::LIGHT_DIRECTIONAL;
	lights[0].position.Set(0, 20, 0);
	lights[0].color.Set(1, 1, 1);
	lights[0].power = 1;
	lights[0].kC = 1.f;
	lights[0].kL = 0.01f;
	lights[0].kQ = 0.001f;
	lights[0].cosCutoff = cos(Math::DegreeToRadian(45));
	lights[0].cosInner = cos(Math::DegreeToRadian(30));
	lights[0].exponent = 3.f;
	lights[0].spotDirection.Set(0.f, 1.f, 0.f);
	
	glUniform1i(m_parameters[U_NUMLIGHTS], 0);
	glUniform1i(m_parameters[U_TEXT_ENABLED], 0);

	glUniform1i(m_parameters[U_LIGHT0_TYPE], lights[0].type);
	glUniform3fv(m_parameters[U_LIGHT0_COLOR], 1, &lights[0].color.r);
	glUniform1f(m_parameters[U_LIGHT0_POWER], lights[0].power);
	glUniform1f(m_parameters[U_LIGHT0_KC], lights[0].kC);
	glUniform1f(m_parameters[U_LIGHT0_KL], lights[0].kL);
	glUniform1f(m_parameters[U_LIGHT0_KQ], lights[0].kQ);
	glUniform1f(m_parameters[U_LIGHT0_COSCUTOFF], lights[0].cosCutoff);
	glUniform1f(m_parameters[U_LIGHT0_COSINNER], lights[0].cosInner);
	glUniform1f(m_parameters[U_LIGHT0_EXPONENT], lights[0].exponent);

	camera.Init(Vector3(0, 0, 1), Vector3(0, 0, 0), Vector3(0, 1, 0));

	for(int i = 0; i < NUM_GEOMETRY; ++i)
	{
		meshList[i] = NULL;
	}
	meshList[GEO_AXES] = MeshBuilder::GenerateAxes("reference", 1000, 1000, 1000);
	meshList[GEO_BALL] = MeshBuilder::GenerateSphere("ball", Color(1, 1, 1), 10, 10, 1.f);
	meshList[GEO_BALL2] = MeshBuilder::GenerateSphere("ball2", Color(1, 0, 0), 10, 10, 1.f);
	meshList[GEO_CUBE] = MeshBuilder::GenerateCube("cube", Color(1, 1, 1), 1.f);
	meshList[GEO_TEXT] = MeshBuilder::GenerateText("text", 16, 16);
	meshList[GEO_TEXT]->textureID = LoadTGA("Image//calibri.tga");
	meshList[GEO_TEXT]->material.kAmbient.Set(1, 0, 0);
	
	meshList[GEO_SHIP] = MeshBuilder::GenerateQuad("space ship",Color(1,1,1),2.f);
	meshList[GEO_SHIP]->textureID = LoadTGA("Image//spaceship.tga");
	
	meshList[GEO_ESHIP] = MeshBuilder::GenerateQuad("enemy space ship",Color(1,1,1),2.f);
	meshList[GEO_ESHIP]->textureID = LoadTGA("Image//enemyship.tga");

	meshList[GEO_ASTEROID] = MeshBuilder::GenerateQuad("asteroid", Color(1,1,1),2.f);
	meshList[GEO_ASTEROID]->textureID = LoadTGA("Image//asteroid.tga");

	meshList[GEO_MISSILE] = MeshBuilder::GenerateQuad("missile", Color(1,1,1),2.f);
	meshList[GEO_MISSILE]->textureID = LoadTGA("Image//missile.tga");

	meshList[GEO_PLANETS] = MeshBuilder::GenerateQuad("planets", Color(1,1,1),2.f);
	meshList[GEO_PLANETS]->textureID = LoadTGA("Image//planet.tga");

	meshList[GEO_BACKGROUND] = MeshBuilder::GenerateQuad("background",Color(1,1,1),2.f);
	meshList[GEO_BACKGROUND]->textureID = LoadTGA("Image//background.tga");

	meshList[GEO_POWERUP] = MeshBuilder::GenerateQuad("power up",Color(1,1,1),2.f);
	meshList[GEO_POWERUP]->textureID = LoadTGA("Image//powerup.tga");

	meshList[GEO_EBULLETS] = MeshBuilder::GenerateSphere("ball", Color(1, 0, 0), 10, 10, 1.f);

	meshList[GEO_START] = MeshBuilder::GenerateQuad("start menu",Color(1,1,1),2.f);
	meshList[GEO_START]->textureID = LoadTGA("Image//Menu.tga");

	meshList[GEO_WIN] = MeshBuilder::GenerateQuad("win menu",Color(1,1,1),2.f);
	meshList[GEO_WIN]->textureID = LoadTGA("Image//winscreen.tga");

	meshList[GEO_DRAW] = MeshBuilder::GenerateQuad("draw screen",Color(1,1,1),2.f);
	meshList[GEO_DRAW]->textureID = LoadTGA("Image//draw.tga");

	meshList[GEO_INSTRUCT] = MeshBuilder::GenerateQuad("tutorial screen",Color(1,1,1),2.f);
	meshList[GEO_INSTRUCT]->textureID = LoadTGA("Image//instruction.tga");

	meshList[GEO_WIN1] = MeshBuilder::GenerateQuad("win menu",Color(1,1,1),2.f);
	meshList[GEO_WIN1]->textureID = LoadTGA("Image//win1.tga");
	
	meshList[GEO_WIN2] = MeshBuilder::GenerateQuad("win menu",Color(1,1,1),2.f);
	meshList[GEO_WIN2]->textureID = LoadTGA("Image//win2.tga");

	meshList[GEO_GAMEOVER] = MeshBuilder::GenerateQuad("game over screen",Color(1,1,1),2.f);
	meshList[GEO_GAMEOVER]->textureID = LoadTGA("Image//losescreen.tga");

	bLightEnabled = false;
}
예제 #21
0
GLUSvoid terminate(GLUSvoid)
{
	glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, 0);

	if (g_texture[0])
	{
		glDeleteTextures(1, &g_texture[0]);

		g_texture[0] = 0;
	}

	glBindTexture(GL_TEXTURE_CUBE_MAP, 0);

	if (g_texture[1])
	{
		glDeleteTextures(1, &g_texture[1]);

		g_texture[1] = 0;
	}

	glBindTexture(GL_TEXTURE_2D, 0);

	if (g_texture[2])
	{
		glDeleteTextures(1, &g_texture[2]);

		g_texture[2] = 0;
	}

	//

	glBindBuffer(GL_ARRAY_BUFFER, 0);

	if (g_verticesModelVBO)
	{
		glDeleteBuffers(1, &g_verticesModelVBO);

		g_verticesModelVBO = 0;
	}

	if (g_normalsModelVBO)
	{
		glDeleteBuffers(1, &g_normalsModelVBO);

		g_normalsModelVBO = 0;
	}

	if (g_verticesBackgroundVBO)
	{
		glDeleteBuffers(1, &g_verticesBackgroundVBO);

		g_verticesBackgroundVBO = 0;
	}

	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

	if (g_indicesBackgroundVBO)
	{
		glDeleteBuffers(1, &g_indicesBackgroundVBO);

		g_indicesBackgroundVBO = 0;
	}

	glBindVertexArray(0);

	if (g_modelVAO)
	{
		glDeleteVertexArrays(1, &g_modelVAO);

		g_modelVAO = 0;
	}

	if (g_backgroundVAO)
	{
		glDeleteVertexArrays(1, &g_backgroundVAO);

		g_backgroundVAO = 0;
	}

	if (g_fullscreenVAO)
	{
		glDeleteVertexArrays(1, &g_fullscreenVAO);

		g_fullscreenVAO = 0;
	}

	glUseProgram(0);

	glusDestroyProgram(&g_modelProgram);

	glusDestroyProgram(&g_backgroundProgram);

	glusDestroyProgram(&g_fullscreenProgram);

	//

	glBindTexture(GL_TEXTURE_2D, 0);

	if (g_fullscreenTexture)
	{
		glDeleteTextures(1, &g_fullscreenTexture);

		g_fullscreenTexture = 0;
	}

	glBindRenderbuffer(GL_RENDERBUFFER, 0);

	if (g_fullscreenDepthRenderbuffer)
	{
		glDeleteRenderbuffers(1, &g_fullscreenDepthRenderbuffer);

		g_fullscreenDepthRenderbuffer = 0;
	}

	glBindFramebuffer(GL_FRAMEBUFFER, 0);

	if (g_fullscreenFBO)
	{
		glDeleteFramebuffers(1, &g_fullscreenFBO);

		g_fullscreenFBO = 0;
	}
}
예제 #22
0
    virtual void startup()
    {
        static const char * vs_source[] =
        {
            "#version 410 core                                                                  \n"
            "                                                                                   \n"
            "void main(void)                                                                    \n"
            "{                                                                                  \n"
            "    const vec4 vertices[] = vec4[](vec4( 0.25, -0.25, 0.5, 1.0),                   \n"
            "                                   vec4(-0.25, -0.25, 0.5, 1.0),                   \n"
            "                                   vec4( 0.25,  0.25, 0.5, 1.0));                  \n"
            "                                                                                   \n"
            "    gl_Position = vertices[gl_VertexID];                                           \n"
            "}                                                                                  \n"
        };

        static const char * tcs_source[] =
        {
            "#version 410 core                                                                  \n"
            "                                                                                   \n"
            "layout (vertices = 3) out;                                                         \n"
            "                                                                                   \n"
            "void main(void)                                                                    \n"
            "{                                                                                  \n"
            "    if (gl_InvocationID == 0)                                                      \n"
            "    {                                                                              \n"
            "        gl_TessLevelInner[0] = 5.0;                                                \n"
            "        gl_TessLevelOuter[0] = 5.0;                                                \n"
            "        gl_TessLevelOuter[1] = 5.0;                                                \n"
            "        gl_TessLevelOuter[2] = 5.0;                                                \n"
            "    }                                                                              \n"
            "    gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;      \n"
            "}                                                                                  \n"
        };

        static const char * tes_source[] =
        {
            "#version 410 core                                                                  \n"
            "                                                                                   \n"
            "layout (triangles, equal_spacing, cw) in;                                          \n"
            "                                                                                   \n"
            "void main(void)                                                                    \n"
            "{                                                                                  \n"
            "    gl_Position = (gl_TessCoord.x * gl_in[0].gl_Position) +                        \n"
            "                  (gl_TessCoord.y * gl_in[1].gl_Position) +                        \n"
            "                  (gl_TessCoord.z * gl_in[2].gl_Position);                         \n"
            "}                                                                                  \n"
        };

        static const char * gs_source[] =
        {
            "#version 410 core                                                                  \n"
            "                                                                                   \n"
            "layout (triangles) in;                                                             \n"
            "layout (points, max_vertices = 3) out;                                             \n"
            "                                                                                   \n"
            "void main(void)                                                                    \n"
            "{                                                                                  \n"
            "    int i;                                                                         \n"
            "                                                                                   \n"
            "    for (i = 0; i < gl_in.length(); i++)                                           \n"
            "    {                                                                              \n"
            "        gl_Position = gl_in[i].gl_Position;                                        \n"
            "        EmitVertex();                                                              \n"
            "    }                                                                              \n"
            "}                                                                                  \n"
        };

        static const char * fs_source[] =
        {
            "#version 410 core                                                 \n"
            "                                                                  \n"
            "out vec4 color;                                                   \n"
            "                                                                  \n"
            "void main(void)                                                   \n"
            "{                                                                 \n"
            "    color = vec4(0.0, 0.8, 1.0, 1.0);                             \n"
            "}                                                                 \n"
        };

        program = glCreateProgram();
        GLuint vs = glCreateShader(GL_VERTEX_SHADER);
        glShaderSource(vs, 1, vs_source, NULL);
        glCompileShader(vs);

        GLuint tcs = glCreateShader(GL_TESS_CONTROL_SHADER);
        glShaderSource(tcs, 1, tcs_source, NULL);
        glCompileShader(tcs);

        GLuint tes = glCreateShader(GL_TESS_EVALUATION_SHADER);
        glShaderSource(tes, 1, tes_source, NULL);
        glCompileShader(tes);

        GLuint gs = glCreateShader(GL_GEOMETRY_SHADER);
        glShaderSource(gs, 1, gs_source, NULL);
        glCompileShader(gs);

        GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(fs, 1, fs_source, NULL);
        glCompileShader(fs);

        glAttachShader(program, vs);
        glAttachShader(program, tcs);
        glAttachShader(program, tes);
        glAttachShader(program, gs);
        glAttachShader(program, fs);

        glLinkProgram(program);

        glDeleteShader(vs);
        glDeleteShader(tcs);
        glDeleteShader(tes);
        glDeleteShader(gs);
        glDeleteShader(fs);

        glGenVertexArrays(1, &vao);
        glBindVertexArray(vao);
    }
예제 #23
0
파일: triplanar.cpp 프로젝트: dormon/FitGL
int main(int /*argc*/, char ** /*argv*/) {
	BaseApp app;
	ProgramObject programEnv, program;

	auto mainWindow = app.getMainWindow();

	PerspectiveCamera cam;
	OrbitManipulator manipulator(&cam);
	manipulator.setupCallbacks(app);
	
	GLuint diffuseTextureTop;
	GLuint diffuseTextureSide;
	GLuint diffuseTextureDown;

	GLuint vao;
	GLuint vaoEmpty;
	GLuint vbo;

	int32_t sphereSizeX = 20;
	int32_t sphereSizeY = 20;

	app.addInitCallback([&]() {
		std::string prefix = app.getResourceDir() + "Shaders/Tutorial/";
		auto vs = compileShader(GL_VERTEX_SHADER,
			"#version 450\n",
			Loader::text(prefix + "triplanar.vp"));
		auto fs = compileShader(GL_FRAGMENT_SHADER,
			"#version 450\n",
			Loader::text(prefix + "lighting.vp"),
			Loader::text(prefix + "triplanar.fp"));
		program = createProgram(vs, fs);
		
		std::string texPrefix = app.getResourceDir() + "Textures/Tutorial/";
		diffuseTextureTop = Loader::texture(texPrefix + "grass.png");
		diffuseTextureSide = Loader::texture(texPrefix + "dirt.jpg");
		diffuseTextureDown = Loader::texture(texPrefix + "rock.jpg");

		glCreateBuffers(1, &vbo);
		const uint32_t floatsPerVertex = 6;
		const uint32_t vertiesPerFace = 6;
		float*vertices = new float[sphereSizeX*sphereSizeY*vertiesPerFace*floatsPerVertex];
		for (int32_t y = 0; y<sphereSizeY; ++y) {
			for (int32_t x = 0; x<sphereSizeX; ++x) {
				for (uint32_t k = 0; k<vertiesPerFace; ++k) {
					const int32_t xOffset[] = { 0,1,0,0,1,1 };
					const int32_t yOffset[] = { 0,0,1,1,0,1 };
					float u = (float)(x + xOffset[k]) / sphereSizeX;
					float v = (float)(y + yOffset[k]) / sphereSizeY;
					float xAngle = -u*glm::two_pi<float>();
					float yAngle = v*glm::pi<float>();
					uint32_t faceId = y*sphereSizeX + x;
					uint32_t faceVertex = faceId*vertiesPerFace + k;
					vertices[faceVertex*floatsPerVertex + 0] = glm::cos(xAngle)*glm::sin(yAngle);
					vertices[faceVertex*floatsPerVertex + 1] = -glm::cos(yAngle);
					vertices[faceVertex*floatsPerVertex + 2] = glm::sin(xAngle)*glm::sin(yAngle);
					vertices[faceVertex*floatsPerVertex + 3] = 1;
					vertices[faceVertex*floatsPerVertex + 4] = u;
					vertices[faceVertex*floatsPerVertex + 5] = v;
				}
			}
		}
		glNamedBufferData(vbo, sizeof(float)*sphereSizeX*sphereSizeY*vertiesPerFace*floatsPerVertex, vertices, GL_STATIC_DRAW);
		delete[]vertices;

		glCreateVertexArrays(1, &vao);
		glEnableVertexArrayAttrib(vao, 0); 
		glVertexArrayAttribFormat(vao, 0, 4, GL_FLOAT, 0, 0); 
		glVertexArrayVertexBuffer(vao, 0, vbo, 0, sizeof(float)*floatsPerVertex);
		glEnableVertexArrayAttrib(vao, 1);
		glVertexArrayAttribFormat(vao, 1, 2, GL_FLOAT, 0, 0);
		glVertexArrayVertexBuffer(vao, 1, vbo, sizeof(float) * 4, sizeof(float)*floatsPerVertex);
		
		glClearColor(0, 0, 0, 1);
		glDisable(GL_CULL_FACE);
		glEnable(GL_DEPTH_TEST);
		glDepthFunc(GL_LEQUAL);
		glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
	});

	app.addResizeCallback([&](int w, int h) {
		glViewport(0, 0, w, h);
		cam.setAspect(float(w) / float(h));
	});

	app.addDrawCallback([&]() {
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		program.use();
		glBindTextureUnit(0, diffuseTextureTop);
		glBindTextureUnit(1, diffuseTextureSide);
		glBindTextureUnit(2, diffuseTextureDown);

		program.setMatrix4fv("p", value_ptr(cam.getProjection()));
		program.setMatrix4fv("v", value_ptr(cam.getView()));

		glBindVertexArray(vao);
		glDrawArrays(GL_TRIANGLES, 0, sphereSizeX*sphereSizeY * 6);
		glBindVertexArray(0);
	});
	return app.run();
}
예제 #24
0
void OpenGL41::setVertexAttributeArrayConfiguration(VertexAttributeArrayConfigurationObject configuration)
{
    glBindVertexArray(GLuint(uintptr_t(configuration)));
    CARBON_CHECK_OPENGL_ERROR(glBindVertexArray);
}
예제 #25
0
int main () {
	GLFWwindow* window = NULL;
	const GLubyte* renderer;
	const GLubyte* version;
	GLuint vao;
	GLuint vbo;
	GLuint colours_vbo;

	/* geometry to use. these are 3 xyz points (9 floats total) to make a triangle
	*/
	GLfloat points[] = {
		 0.0f,	0.5f,	0.0f,
		 0.5f, -0.5f,	0.0f,
		-0.5f, -0.5f,	0.0f,
		0.00f,	0.8f,	0.0f,
		 -0.5f, -0.2f,	0.0f,
		0.5f, -0.2f,	0.0f

	};

		GLfloat colours[] = {
		1.0f, 1.0f,  0.0f,  //yellow rgb(255,255,0)
		1.0f, 1.0f,  0.0f,
		1.0f, 1.0f,  0.0f,
		1.0f, 0.0f,  0.0f, //red rgb(255,0,0)
		1.0f, 0.0f,  0.0f,
		1.0f, 0.0f,  0.0f,
	};
	/* these are the strings of code for the shaders
	the vertex shader positions each vertex point */
	const char* vertex_shader =
	"#version 400\n"
	"layout(location = 0) in vec3 vertex_position;"
    "layout(location = 1) in vec3 vertex_colour;"
    "out vec3 color;"
	"uniform mat4 matrix;"
	"void main () {"
	"  color = vertex_colour;"
	"	gl_Position=matrix * vec4(vertex_position, 1.0);"
	"}";
	/* the fragment shader colours each fragment (pixel-sized area of the
	triangle) */
	const char* fragment_shader =
	"#version 400\n"
	"in vec3 color;"
	"out vec4 frag_colour;"
	"void main () {"
	"	frag_colour = vec4 (color, 1.0);"
	"}";
	/* GL shader objects for vertex and fragment shader [components] */
	GLuint vs, fs;
	/* GL shader programme object [combined, to link] */
	GLuint shader_programme;

	/* start GL context and O/S window using the GLFW helper library */
	if (!glfwInit ()) {
		fprintf (stderr, "ERROR: could not start GLFW3\n");
		return 1;
	} 

	/* change to 3.2 if on Apple OS X */
	glfwWindowHint (GLFW_CONTEXT_VERSION_MAJOR, 4);
	glfwWindowHint (GLFW_CONTEXT_VERSION_MINOR, 0);
	glfwWindowHint (GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
	glfwWindowHint (GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

	window = glfwCreateWindow (
		640, 480, "Hello Triangle", NULL, NULL
	);
	if (!window) {
		fprintf (stderr, "ERROR: could not open window with GLFW3\n");
		glfwTerminate();
		return 1;
	}
	glfwMakeContextCurrent (window);
	/* start GLEW extension handler */
	glewExperimental = GL_TRUE;
	glewInit ();

	/* get version info */
	renderer = glGetString (GL_RENDERER); /* get renderer string */
	version = glGetString (GL_VERSION); /* version as a string */
	printf ("Renderer: %s\n", renderer);
	printf ("OpenGL version supported %s\n", version);

	/* tell GL to only draw onto a pixel if the shape is closer to the viewer */
	glEnable (GL_DEPTH_TEST); /* enable depth-testing */
	glDepthFunc (GL_LESS);/*depth-testing interprets a smaller value as "closer"*/

	/* a vertex buffer object (VBO) is created here. this stores an array of data
	on the graphics adapter's memory. in our case - the vertex points */
	glGenBuffers (1, &vbo);
	glBindBuffer (GL_ARRAY_BUFFER, vbo);
	glBufferData (GL_ARRAY_BUFFER, 9 * sizeof (GLfloat), points, GL_STATIC_DRAW);
	

	glGenBuffers (1, &colours_vbo);
    glBindBuffer (GL_ARRAY_BUFFER, colours_vbo);
    glBufferData (GL_ARRAY_BUFFER, sizeof (colours), colours, GL_STATIC_DRAW);
	/* the vertex array object (VAO) is a little descriptor that defines which
	data from vertex buffer objects should be used as input variables to vertex
	shaders. in our case - use our only VBO, and say 'every three floats is a 
	variable' */
	glGenVertexArrays (1, &vao);
	glBindVertexArray (vao);
	glEnableVertexAttribArray (0);
	glBindBuffer (GL_ARRAY_BUFFER, vbo);
	glVertexAttribPointer (0, 3, GL_FLOAT, GL_FALSE, 0, NULL);

	glEnableVertexAttribArray (1);  //enable 
	glBindBuffer (GL_ARRAY_BUFFER, colours_vbo);
	glVertexAttribPointer (1, 3, GL_FLOAT, GL_FALSE, 0, NULL);



	
	/* here we copy the shader strings into GL shaders, and compile them. we then
	create an executable shader 'program' and attach both of the compiled shaders.
	we link this, which matches the outputs of the vertex shader to the inputs of
	the fragment shader, etc. and it is then ready to use */
	vs = glCreateShader (GL_VERTEX_SHADER);
	glShaderSource (vs, 1, &vertex_shader, NULL);
	glCompileShader (vs);

	fs = glCreateShader (GL_FRAGMENT_SHADER);
	glShaderSource (fs, 1, &fragment_shader, NULL);
	glCompileShader (fs);
	shader_programme = glCreateProgram ();
	
	glAttachShader (shader_programme, fs);
	glAttachShader (shader_programme, vs);
	glLinkProgram (shader_programme);



double theta=180;

GLfloat matrix[] = {
0.5f,0.0f,0.0f,0.00f,
0.0f,0.5f,0.0f,0.00f,
0.0f,0.0f,0.5f,0.00f,
0.25f,0.5f,0.75f,1.0f,
}; 

int matrix_location = glGetUniformLocation (shader_programme, "matrix");
	

	
	while (!glfwWindowShouldClose (window)) {
		glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

		
		glUseProgram (shader_programme);
		glBindVertexArray (vao);

		glDrawArrays (GL_TRIANGLES, 0, 3);
		glDrawArrays (GL_TRIANGLES, 3, 6);
		
		// update other events like input handling 
		glfwPollEvents ();
		if (GLFW_PRESS == glfwGetKey (window, GLFW_KEY_ESCAPE)) {
			glfwSetWindowShouldClose (window, 1);
		}

		
		 if (GLFW_PRESS == glfwGetKey (window, GLFW_KEY_U)) { //return to normal
		 matrix[0] += 0.015f;
		matrix[5] += 0.005f;
		 }

		 if (GLFW_PRESS == glfwGetKey (window, GLFW_KEY_J)) { //return to normal
		 matrix[0] -= 0.015f;
		matrix[5] -= 0.005f;
		 }

		 //uniformed scaling make smaller
		 if (GLFW_PRESS == glfwGetKey (window, GLFW_KEY_D)) { //return to normal
		 matrix[0] -= 0.005f;
		 matrix[5] -= 0.005f;
		  }
		
		 //uniformed scaling bigger
		 if (GLFW_PRESS == glfwGetKey (window, GLFW_KEY_E)) { //return to normal
		 matrix[0] += 0.005f;
		 matrix[5] += 0.005f;
		 matrix[10] += 0.005f;
		 }

		 //non-uniform scaling
		 if (GLFW_PRESS == glfwGetKey (window, GLFW_KEY_X)) { //return to normal
		 
		 matrix[5] = cos(theta);
		 matrix[6] = sin(theta);
		 matrix[9] = -sin(theta);
		 matrix[10] =cos(theta);
		 theta+=0.025;
		}

		//rotation around Y axis
		if (GLFW_PRESS == glfwGetKey (window, GLFW_KEY_Y)) { //return to normal
		 matrix[0] = cos(theta);
		 matrix[2] = sin(theta);
		 matrix[8] = -sin(theta);
		 matrix[10] =cos(theta);
		 theta+=0.025;
		}

		//rotation around Z axis
		if (GLFW_PRESS == glfwGetKey (window, GLFW_KEY_Z)) { //return to normal
		 matrix[0] = cos(theta);
		 matrix[1] = -sin(theta);
		 matrix[4] = sin(theta);
		 matrix[5] = cos(theta);
		 theta+=0.025;
		}

		//combined transformations
		 if (GLFW_PRESS == glfwGetKey (window, GLFW_KEY_C)) {
		 matrix[0] += 0.005f;
		 matrix[5] += 0.005f;
		 matrix[10] +=0.005f;
		 matrix[12] += 0.025f;
		}

		if (GLFW_PRESS == glfwGetKey (window, GLFW_KEY_V)) {
		 matrix[0] -= 0.005f;
		 matrix[5] -= 0.005f;
		 matrix[10] -=0.005f;
		 matrix[12] -= 0.025f;
		}

		// X left
		if (GLFW_PRESS == glfwGetKey (window, GLFW_KEY_LEFT)) {
				matrix[12] -= 0.025f;
			}

			//X Right
		if (GLFW_PRESS == glfwGetKey (window, GLFW_KEY_RIGHT)) {
				matrix[12] += 0.025f;
			}

			//Y Down
		if (GLFW_PRESS == glfwGetKey (window, GLFW_KEY_DOWN)) {
				matrix[13] -= 0.025f;
			}


		//Y UP
		if (GLFW_PRESS == glfwGetKey (window, GLFW_KEY_UP)) {
				matrix[13] += 0.025f;
			}


		glUniformMatrix4fv (matrix_location, 1, GL_FALSE, matrix); //control triangle seperately
        
		// draw points 0-3 from the currently bound VAO with current in-use shader
		

		// put the stuff we've been drawing onto the display
		glfwSwapBuffers (window);
	}
	
	/* close GL context and any other GLFW resources */
	glfwTerminate();
	return 0;
}
예제 #26
0
void RenderableStars::update(const UpdateData& data) {
    if (_dataIsDirty) {
        const int value = _colorOption;
        LDEBUG("Regenerating data");

        createDataSlice(ColorOption(value));

        int size = static_cast<int>(_slicedData.size());

        if (_vao == 0) {
            glGenVertexArrays(1, &_vao);
            LDEBUG("Generating Vertex Array id '" << _vao << "'");
        }
        if (_vbo == 0) {
            glGenBuffers(1, &_vbo);
            LDEBUG("Generating Vertex Buffer Object id '" << _vbo << "'");
        }
        glBindVertexArray(_vao);
        glBindBuffer(GL_ARRAY_BUFFER, _vbo);
        glBufferData(GL_ARRAY_BUFFER,
            size*sizeof(GLfloat),
            &_slicedData[0],
            GL_STATIC_DRAW);

        GLint positionAttrib = _program->attributeLocation("in_position");
        GLint brightnessDataAttrib = _program->attributeLocation("in_brightness");

        const size_t nStars = _fullData.size() / _nValuesPerStar;
        const size_t nValues = _slicedData.size() / nStars;

        GLsizei stride = static_cast<GLsizei>(sizeof(GLfloat) * nValues);

        glEnableVertexAttribArray(positionAttrib);
        glEnableVertexAttribArray(brightnessDataAttrib);
        const int colorOption = _colorOption;
        switch (colorOption) {
        case ColorOption::Color:
            glVertexAttribPointer(positionAttrib, 4, GL_FLOAT, GL_FALSE, stride,
                reinterpret_cast<void*>(offsetof(ColorVBOLayout, position)));
            glVertexAttribPointer(brightnessDataAttrib, 3, GL_FLOAT, GL_FALSE, stride,
                reinterpret_cast<void*>(offsetof(ColorVBOLayout, bvColor)));
            
            break;
        case ColorOption::Velocity:
            {
                glVertexAttribPointer(positionAttrib, 4, GL_FLOAT, GL_FALSE, stride,
                    reinterpret_cast<void*>(offsetof(VelocityVBOLayout, position)));
                glVertexAttribPointer(brightnessDataAttrib, 3, GL_FLOAT, GL_FALSE, stride,
                    reinterpret_cast<void*>(offsetof(VelocityVBOLayout, bvColor)));

                GLint velocityAttrib = _program->attributeLocation("in_velocity");
                glEnableVertexAttribArray(velocityAttrib);
                glVertexAttribPointer(velocityAttrib, 3, GL_FLOAT, GL_TRUE, stride,
                    reinterpret_cast<void*>(offsetof(VelocityVBOLayout, vx)));

                break;
            }
        case ColorOption::Speed:
            {
                glVertexAttribPointer(positionAttrib, 4, GL_FLOAT, GL_FALSE, stride,
                    reinterpret_cast<void*>(offsetof(SpeedVBOLayout, position)));
                glVertexAttribPointer(brightnessDataAttrib, 3, GL_FLOAT, GL_FALSE, stride,
                    reinterpret_cast<void*>(offsetof(SpeedVBOLayout, bvColor)));

                GLint speedAttrib = _program->attributeLocation("in_speed");
                glEnableVertexAttribArray(speedAttrib);
                glVertexAttribPointer(speedAttrib, 1, GL_FLOAT, GL_TRUE, stride,
                    reinterpret_cast<void*>(offsetof(SpeedVBOLayout, speed)));

            }
        }

        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glBindVertexArray(0);

        _dataIsDirty = false;
    }    

    if (_pointSpreadFunctionTextureIsDirty) {
        LDEBUG("Reloading Point Spread Function texture");
        _pointSpreadFunctionTexture = nullptr;
        if (_pointSpreadFunctionTexturePath.value() != "") {
            _pointSpreadFunctionTexture = std::move(ghoul::io::TextureReader::ref().loadTexture(absPath(_pointSpreadFunctionTexturePath)));
            
            if (_pointSpreadFunctionTexture) {
                LDEBUG("Loaded texture from '" << absPath(_pointSpreadFunctionTexturePath) << "'");
                _pointSpreadFunctionTexture->uploadTexture();
            }
            _pointSpreadFunctionTexture->setFilter(ghoul::opengl::Texture::FilterMode::AnisotropicMipMap);

            delete _psfTextureFile;
            _psfTextureFile = new ghoul::filesystem::File(_pointSpreadFunctionTexturePath);
            _psfTextureFile->setCallback([&](const ghoul::filesystem::File&) { _pointSpreadFunctionTextureIsDirty = true; });
        }
        _pointSpreadFunctionTextureIsDirty = false;
    }

    if (_colorTextureIsDirty) {
        LDEBUG("Reloading Color Texture");
        _colorTexture = nullptr;
        if (_colorTexturePath.value() != "") {
            _colorTexture = std::move(ghoul::io::TextureReader::ref().loadTexture(absPath(_colorTexturePath)));
            if (_colorTexture) {
                LDEBUG("Loaded texture from '" << absPath(_colorTexturePath) << "'");
                _colorTexture->uploadTexture();
            }

            delete _colorTextureFile;
            _colorTextureFile = new ghoul::filesystem::File(_colorTexturePath);
            _colorTextureFile->setCallback([&](const ghoul::filesystem::File&) { _colorTextureIsDirty = true; });
        }
        _colorTextureIsDirty = false;
    }
}
예제 #27
0
void RenderUtils::InitVAO() {
   //Method to initialise a vertex array object
  GLuint VertexArrayID;
  glGenVertexArrays(1, &VertexArrayID);
  glBindVertexArray(VertexArrayID);  
}
int main()
{
    // glfw: initialize and configure
    // ------------------------------
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    //glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // uncomment this statement to fix compilation on OS X

    // glfw window creation
    // --------------------
    GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
    if (window == NULL)
    {
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

    // glad: load all OpenGL function pointers
    // ---------------------------------------
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }

    // build and compile our shader zprogram
    // ------------------------------------
    Shader ourShader("5.2.transform.vs", "5.2.transform.fs");

    // set up vertex data (and buffer(s)) and configure vertex attributes
    // ------------------------------------------------------------------
    float vertices[] = {
        // positions           // texture coords
         0.5f,  0.5f, 0.0f,    1.0f, 1.0f, // top right
         0.5f, -0.5f, 0.0f,    1.0f, 0.0f, // bottom right
        -0.5f, -0.5f, 0.0f,    0.0f, 0.0f, // bottom left
        -0.5f,  0.5f, 0.0f,    0.0f, 1.0f  // top left 
    };
    unsigned int indices[] = {
        0, 1, 3, // first triangle
        1, 2, 3  // second triangle
    };
    unsigned int VBO, VAO, EBO;
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    glGenBuffers(1, &EBO);

    glBindVertexArray(VAO);

    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

    // position attribute
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);
    // texture coord attribute
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
    glEnableVertexAttribArray(1);


    // load and create a texture 
    // -------------------------
    unsigned int texture1, texture2;
    // texture 1
    // ---------
    glGenTextures(1, &texture1);
    glBindTexture(GL_TEXTURE_2D, texture1);
    // set the texture wrapping parameters
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    // set texture filtering parameters
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    // load image, create texture and generate mipmaps
    int width, height, nrChannels;
    stbi_set_flip_vertically_on_load(true); // tell stb_image.h to flip loaded texture's on the y-axis.
    unsigned char *data = stbi_load(FileSystem::getPath("resources/textures/container.jpg").c_str(), &width, &height, &nrChannels, 0);
    if (data)
    {
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
        glGenerateMipmap(GL_TEXTURE_2D);
    }
    else
    {
        std::cout << "Failed to load texture" << std::endl;
    }
    stbi_image_free(data);
    // texture 2
    // ---------
    glGenTextures(1, &texture2);
    glBindTexture(GL_TEXTURE_2D, texture2);
    // set the texture wrapping parameters
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);	
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    // set texture filtering parameters
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    // load image, create texture and generate mipmaps
    data = stbi_load(FileSystem::getPath("resources/textures/awesomeface.png").c_str(), &width, &height, &nrChannels, 0);
    if (data)
    {
        // note that the awesomeface.png has transparency and thus an alpha channel, so make sure to tell OpenGL the data type is of GL_RGBA
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
        glGenerateMipmap(GL_TEXTURE_2D);
    }
    else
    {
        std::cout << "Failed to load texture" << std::endl;
    }
    stbi_image_free(data);

    // tell opengl for each sampler to which texture unit it belongs to (only has to be done once)
    // -------------------------------------------------------------------------------------------
    ourShader.use();
    ourShader.setInt("texture1", 0);
    ourShader.setInt("texture2", 1);


    // render loop
    // -----------
    while (!glfwWindowShouldClose(window))
    {
        // input
        // -----
        processInput(window);

        // render
        // ------
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        // bind textures on corresponding texture units
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, texture1);
        glActiveTexture(GL_TEXTURE1);
        glBindTexture(GL_TEXTURE_2D, texture2);


        glm::mat4 transform;
        // first container
        // ---------------
        transform = glm::translate(transform, glm::vec3(0.5f, -0.5f, 0.0f));
        transform = glm::rotate(transform, (float)glfwGetTime(), glm::vec3(0.0f, 0.0f, 1.0f));
        // get their uniform location and set matrix (using glm::value_ptr)
        unsigned int transformLoc = glGetUniformLocation(ourShader.ID, "transform");
        glUniformMatrix4fv(transformLoc, 1, GL_FALSE, glm::value_ptr(transform));

        // with the uniform matrix set, draw the first container
        glBindVertexArray(VAO);
        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

        // second transformation
        // ---------------------
        transform = glm::mat4(); // reset it to an identity matrix
        transform = glm::translate(transform, glm::vec3(-0.5f, 0.5f, 0.0f));
        float scaleAmount = sin(glfwGetTime());
        transform = glm::scale(transform, glm::vec3(scaleAmount, scaleAmount, scaleAmount));
        glUniformMatrix4fv(transformLoc, 1, GL_FALSE, &transform[0][0]); // this time take the matrix value array's first element as its memory pointer value

        // now with the uniform matrix being replaced with new transformations, draw it again.
        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

        // glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
        // -------------------------------------------------------------------------------
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    // optional: de-allocate all resources once they've outlived their purpose:
    // ------------------------------------------------------------------------
    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &VBO);
    glDeleteBuffers(1, &EBO);

    // glfw: terminate, clearing all previously allocated GLFW resources.
    // ------------------------------------------------------------------
    glfwTerminate();
    return 0;
}
예제 #29
0
/* Page 41 */
static bool
test_bindvertexarray()
{
	glBindVertexArray(200);
	return piglit_check_gl_error(GL_INVALID_OPERATION);
}
예제 #30
0
int main(int argc, const char * argv[]) {
    const int WIDTH = 800;
    const int HEIGHT = 600;
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
    
    
    glfwSetErrorCallback(glfwErrorCallback);

    GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", nullptr, nullptr);
    if (window == nullptr)
    {
        printf("Failed to create GLFW window");
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    
    // GLEW负责管理每个平台上应该调用哪个函数指针,所以在调用openGL之前,先初始化它
    glewExperimental = GL_TRUE;
    if (glewInit() != GLEW_OK)
    {
        std::cerr << "Failed to initialize GLEW" << std::endl;
        return -1;
    }
    // Define the viewport dimensions
    int width, height;
    glfwGetFramebufferSize(window, &width, &height);
    glViewport(0, 0, width, height);

    glfwSetKeyCallback(window, key_callback);
    
    // Build and compile our shader program
    // Vertex shader
    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
    glCompileShader(vertexShader);
    // Check for compile time errors
    GLint success;
    GLchar infoLog[512];
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
        std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
    }
    // Fragment shader
    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
    glCompileShader(fragmentShader);
    // Check for compile time errors
    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
        std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
    }
    // Link shaders
    GLuint shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram);
    // Check for linking errors
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
    if (!success) {
        glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
        std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
    }
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);
    
    
    // Set up vertex data (and buffer(s)) and attribute pointers
    GLfloat vertices[] = {
        0.5f,  0.5f, 0.0f,  // Top Right
        0.5f, -0.5f, 0.0f,  // Bottom Right
        -0.5f, -0.5f, 0.0f, // bottom left
    };
    
    GLfloat vertices2[] = {
        0.8f,  0.5f, 0.0f,  // Top Right
        0.8f, -0.5f, 0.0f,  // Bottom Right
        -0.2f, -0.5f, 0.0f, // bottom left
    };

    GLuint VBO, VAO, VBO2, VAO2;
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    
    glGenVertexArrays(2, &VAO2);
    glGenBuffers(2, &VBO2);
    
    // Bind the Vertex Array Object first, then bind and set vertex buffer(s) and attribute pointer(s).
    glBindVertexArray(VAO);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0);
    glEnableVertexAttribArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0); // Note that this is allowed, the call to glVertexAttribPointer registered VBO as the currently bound vertex buffer object so afterwards we can safely unbind
    glBindVertexArray(0); // Unbind VAO (it's always a good thing to unbind any buffer/array to prevent strange bugs), remember: do NOT unbind the EBO, keep it bound to this VAO
    

    glBindVertexArray(VAO2);
    glBindBuffer(GL_ARRAY_BUFFER, VBO2);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices2), vertices2, GL_STATIC_DRAW);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0);
    glEnableVertexAttribArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0); // Note that this is allowed, the call to glVertexAttribPointer registered VBO as the currently bound vertex buffer object so afterwards we can safely unbind
    glBindVertexArray(0); // Unbind VAO (it's always a good thing to unbind any buffer/array to prevent strange bugs), remember: do NOT unbind the EBO, keep it bound to this VAO
    
    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

    while(!glfwWindowShouldClose(window))
    {
        glfwPollEvents();
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);
        
        // Draw our first triangle
        glUseProgram(shaderProgram);
        glBindVertexArray(VAO);
        glDrawArrays(GL_TRIANGLES, 0, 3);
        glBindVertexArray(0);
        
        glBindVertexArray(VAO2);
        glDrawArrays(GL_TRIANGLES, 0, 3);
        glBindVertexArray(0);
        
        glfwSwapBuffers(window);
    }
    
    // Properly de-allocate all resources once they've outlived their purpose
    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &VBO);
    
    // Properly de-allocate all resources once they've outlived their purpose
    glDeleteVertexArrays(1, &VAO2);
    glDeleteBuffers(1, &VBO2);
    
    glfwTerminate();

    return 0;
}