spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

void TextClass::RenderBuffer ()
{
    // Bind the vertex array object that stored all the information about the vertex and index buffers.
    OpenGL->glBindVertexArray(m_vertexArrayId);

    // Render the vertex buffer using the index buffer.
    glDrawElements(GL_QUADS, m_indexCount, GL_UNSIGNED_INT, 0);
    return;
}

C-/C++-Quelltext

bool TextClass::CreateText ()
{
    //local
    float width = this->PosX;
    Windowsize* wz = Input->GetWindowsize ();

    for (unsigned int i = 0; i < Text.size(); i++)
    {
        char Symbol;
        TextModel* Model;

        Symbol = Text[i];
        for (unsigned int z = 0; z < TextUVdata.size(); z++)
        {
            if (Symbol == TextUVdata[z]->symbol)
            {
                Model = new TextModel;
                Model->Symbol = Symbol;

                //Point 1
                Model->x[0] = width;
                Model->y[0] = this->PosY;
                Model->z[0] = this->PosZ + TextUVdata[z]->hight * wz->Pixel_in_float_height;
                Model->u[0] = TextUVdata[z]->x;
                Model->v[0] = TextUVdata[z]->y + TextUVdata[z]->h;
                //Point 2
                Model->x[1] = width;
                Model->y[1] = this->PosY;
                Model->z[1] = this->PosZ;
                Model->u[1] = TextUVdata[z]->x;
                Model->v[1] = TextUVdata[z]->y;
                //Point 3
                Model->x[2] = width + TextUVdata[z]->width * wz->Pixel_in_float_width;
                Model->y[2] = this->PosY;
                Model->z[2] = this->PosZ;
                Model->u[2] = TextUVdata[z]->x + TextUVdata[z]->w;
                Model->v[2] = TextUVdata[z]->y;
                //Point 4
                Model->x[3] = width + TextUVdata[z]->width * wz->Pixel_in_float_width;
                Model->y[3] = this->PosY;
                Model->z[3] = this->PosZ + TextUVdata[z]->hight * wz->Pixel_in_float_height;
                Model->u[3] = TextUVdata[z]->x + TextUVdata[z]->w;
                Model->v[3] = TextUVdata[z]->y + TextUVdata[z]->h;
                

                //Set new width
                width = width + TextUVdata[z]->width * wz->Pixel_in_float_height;
            }
        }
        Textmodel.push_back(Model);
    }
    return true;
}

C-/C++-Quelltext

bool TextClass::CreateBuffer ()
{
    VertexType* vertices;
    unsigned int* indices;

    int m_vertexCount = this->Textmodel.size () *4;
    this->m_indexCount = this->Textmodel.size () *4;

    // Create the vertex array.
    vertices = new VertexType[m_vertexCount];
    if(!vertices)
    {
        return false;
    }

    // Create the index array.
    indices = new unsigned int[m_indexCount];
    if(!indices)
    {
        return false;
    }

    // Load the vertex array and index array with data.
    unsigned int c = 0;
    int t = 0;
    while (c < this->Textmodel.size ())
    {
        for (int z = 0; z < 4; z++)
        {
            vertices[t].x  = Textmodel[c]->x[z];
            vertices[t].y  = Textmodel[c]->y[z];
            vertices[t].z  = Textmodel[c]->z[z];
            vertices[t].tu = Textmodel[c]->u[z];
            vertices[t].tv = Textmodel[c]->u[z];
            vertices[t].nx = 0;
            vertices[t].ny = 1;
            vertices[t].nz = 0;

            indices[t] = t;
            t = t + 1;
        }
        c = c + 1;
    }

    // Allocate an OpenGL vertex array object.
    OpenGL->glGenVertexArrays(1, &m_vertexArrayId);

    // Bind the vertex array object to store all the buffers and vertex attributes we create here.
    OpenGL->glBindVertexArray(m_vertexArrayId);

    // Generate an ID for the vertex buffer.
    OpenGL->glGenBuffers(1, &m_vertexBufferId);

    // Bind the vertex buffer and load the vertex (position, texture, and normal) data into the vertex buffer.
    OpenGL->glBindBuffer(GL_ARRAY_BUFFER, m_vertexBufferId);
    OpenGL->glBufferData(GL_ARRAY_BUFFER, m_vertexCount * sizeof(VertexType), vertices, GL_STATIC_DRAW);

    // Enable the three vertex array attributes.
    OpenGL->glEnableVertexAttribArray(0);  // Vertex position.
    OpenGL->glEnableVertexAttribArray(1);  // Texture coordinates.
    OpenGL->glEnableVertexAttribArray(2);  // Normals.

    // Specify the location and format of the position portion of the vertex buffer.
    OpenGL->glBindBuffer(GL_ARRAY_BUFFER, m_vertexBufferId);
    OpenGL->glVertexAttribPointer(0, 3, GL_FLOAT, false, sizeof(VertexType), 0);

    // Specify the location and format of the texture coordinate portion of the vertex buffer.
    OpenGL->glBindBuffer(GL_ARRAY_BUFFER, m_vertexBufferId);
    OpenGL->glVertexAttribPointer(1, 2, GL_FLOAT, false, sizeof(VertexType), (unsigned char*)NULL + (3 * sizeof(float)));

    // Specify the location and format of the normal vector portion of the vertex buffer.
    OpenGL->glBindBuffer(GL_ARRAY_BUFFER, m_vertexBufferId);
    OpenGL->glVertexAttribPointer(2, 3, GL_FLOAT, false, sizeof(VertexType), (unsigned char*)NULL + (5 * sizeof(float)));

    // Generate an ID for the index buffer.
    OpenGL->glGenBuffers(1, &m_indexBufferId);

    // Bind the index buffer and load the index data into it.
    OpenGL->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBufferId);
    OpenGL->glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_indexCount* sizeof(unsigned int), indices, GL_STATIC_DRAW);
    
    // Now that the buffers have been loaded we can release the array data.
    delete [] vertices;
    vertices = 0;

    delete [] indices;
    indices = 0;

    return true;
}

C-/C++-Quelltext

void TextClass::Render (float* worldmatrix)
{
    TextureUnit->Render (worldmatrix, ShaderLight, Unit);
    RenderBuffer ();
    return;
}

C-/C++-Quelltext

void TextClass::RenderBuffer ()
{
    // Bind the vertex array object that stored all the information about the vertex and index buffers.
    OpenGL->glBindVertexArray(m_vertexArrayId);

    // Render the vertex buffer using the index buffer.
    glDrawElements(GL_QUADS, m_indexCount, GL_UNSIGNED_INT, 0);
    return;
}

C-/C++-Quelltext

void TextClass::ShutdownBuffers()
{
    // Disable the two vertex array attributes.
    this->OpenGL->glDisableVertexAttribArray(0);
    this->OpenGL->glDisableVertexAttribArray(1);
    
    // Release the vertex buffer.
    this->OpenGL->glBindBuffer(GL_ARRAY_BUFFER, 0);
    this->OpenGL->glDeleteBuffers(1, &m_vertexBufferId);

    // Release the index buffer.
    this->OpenGL->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    this->OpenGL->glDeleteBuffers(1, &m_indexBufferId);

    // Release the vertex array object.
    this->OpenGL->glBindVertexArray(0);
    this->OpenGL->glDeleteVertexArrays(1, &m_vertexArrayId);

    return;
}

C-/C++-Quelltext

bool TextureClass::LoadTarga(OpenGLClass* OpenGL, char* filename, unsigned int textureUnit, bool wrap)
{
    int error, width, height, bpp, imageSize;
    FILE* filePtr;
    unsigned int count;
    TargaHeader targaFileHeader;
    unsigned char* targaImage;


    // Open the targa file for reading in binary.
    error = fopen_s(&filePtr, filename, "rb");
    if(error != 0)
    {
        return false;
    }

    // Read in the file header.
    count = fread(&targaFileHeader, sizeof(TargaHeader), 1, filePtr);
    if(count != 1)
    {
        return false;
    }

    // Get the important information from the header.
    width = (int)targaFileHeader.width;
    height = (int)targaFileHeader.height;
    bpp = (int)targaFileHeader.bpp;

    // Check that it is 32 bit and not 24 bit.
    if(bpp != 32)
    {
        return false;
    }

    // Calculate the size of the 32 bit image data.
    if (bpp == 32)
    {
        imageSize = width * height * 4;
    }

    // Allocate memory for the targa image data.
    targaImage = new unsigned char[imageSize];
    if(!targaImage)
    {
        return false;
    }

    // Read in the targa image data.
    count = fread(targaImage, 1, imageSize, filePtr);
    if(count != imageSize)
    {
        return false;
    }
    
    // Close the file.
    error = fclose(filePtr);
    if(error != 0)
    {
        return false;
    }


    // Set the unique texture unit in which to store the data.
    OpenGL->glActiveTexture(GL_TEXTURE0 + textureUnit);

    // Generate an ID for the texture.
    glGenTextures(1, &m_textureID);

    // Bind the texture as a 2D texture.
    glBindTexture(GL_TEXTURE_2D, m_textureID);

    // Load the image data into the texture unit.
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, targaImage);


    // Set the texture color to either wrap around or clamp to the edge.
    if(wrap)
    {
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    }
    else
    {
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
    }

    // Set the texture filtering.
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

    // Generate mipmaps for the texture.
    OpenGL->glGenerateMipmap(GL_TEXTURE_2D);

    // Release the targa image data.
    delete [] targaImage;
    targaImage = 0;

    // Set that the texture is loaded.
    loaded = true;

    return true;
}

C-/C++-Quelltext

bool GraphicsClass::Render()
{
    float worldMatrix[16];
    float viewMatrix[16];
    float projectionMatrix[16];

    float lightDirection[3];
    float diffuseLightColor[4];
    float ambientLight[4];

    // Clear the buffers to begin the scene.
    m_OpenGL->BeginScene(0.0f, 0.0f, 0.0f, 1.0f);

    // Generate the view matrix based on the camera's position.
    m_Camera->Render();

    // Get the world, view, and projection matrices from the opengl and camera objects.
    m_OpenGL->GetWorldMatrix(worldMatrix);
    m_Camera->GetViewMatrix(viewMatrix);
    m_OpenGL->GetProjectionMatrix(projectionMatrix);

    // Get the light properties.
    m_Light->GetDirection(lightDirection);
    m_Light->GetDiffuseColor(diffuseLightColor);
    m_Light->GetAmbientLight(ambientLight);
    
    // Set the light shader as the current shader program and set the matrices that it will use for rendering.
    m_TextureUnit->SetNewShaderInformation(m_LightShader, m_ColorShader, m_OpenGL, worldMatrix, viewMatrix, projectionMatrix, lightDirection, diffuseLightColor, ambientLight);

    //Render Game Models and other Stuff
    m_Game->Render (worldMatrix);

    // Present the rendered scene to the screen.
    m_OpenGL->EndScene();

    return true;
}

C-/C++-Quelltext

void TextureUnitClass::Render(float* worldMatrix, unsigned int Shader, unsigned int TextureUnit)
{
    switch (Shader)
    {
    case ShaderLight:
        {
            LightShaderPointer->SetShader(OpenGL);
            LightShaderPointer->SetShaderParameters(this->OpenGL, worldMatrix, this->viewMatrix, this->projectionMatrix, TextureUnit,
                                                    this->lightDirection, this->diffuseLightColor, this->ambientLight);
            break;
        }
    case ShaderColor:
        {
            ColorShaderPointer->SetShader(OpenGL);
            ColorShaderPointer->SetShaderParameters(this->OpenGL, worldMatrix, this->viewMatrix, this->projectionMatrix);
            break;
        }
    }
    return;
}

C-/C++-Quelltext

bool LightShaderClass::InitializeShader(char* vsFilename, char* fsFilename, OpenGLClass* OpenGL, HWND hwnd)
{
    const char* vertexShaderBuffer;
    const char* fragmentShaderBuffer;
    int status;


    // Load the vertex shader source file into a text buffer.
    vertexShaderBuffer = LoadShaderSourceFile(vsFilename);
    if(!vertexShaderBuffer)
    {
        return false;
    }

    // Load the fragment shader source file into a text buffer.
    fragmentShaderBuffer = LoadShaderSourceFile(fsFilename);
    if(!fragmentShaderBuffer)
    {
        return false;
    }

    // Create a vertex and fragment shader object.
    m_vertexShader = OpenGL->glCreateShader(GL_VERTEX_SHADER);
    m_fragmentShader = OpenGL->glCreateShader(GL_FRAGMENT_SHADER);

    // Copy the shader source code strings into the vertex and fragment shader objects.
    OpenGL->glShaderSource(m_vertexShader, 1, &vertexShaderBuffer, NULL);
    OpenGL->glShaderSource(m_fragmentShader, 1, &fragmentShaderBuffer, NULL);

    // Release the vertex and fragment shader buffers.
    delete [] vertexShaderBuffer;
    vertexShaderBuffer = 0;
    
    delete [] fragmentShaderBuffer;
    fragmentShaderBuffer = 0;

    // Compile the shaders.
    OpenGL->glCompileShader(m_vertexShader);
    OpenGL->glCompileShader(m_fragmentShader);

    // Check to see if the vertex shader compiled successfully.
    OpenGL->glGetShaderiv(m_vertexShader, GL_COMPILE_STATUS, &status);
    if(status != 1)
    {
        // If it did not compile then write the syntax error message out to a text file for review.
        OutputShaderErrorMessage(OpenGL, hwnd, m_vertexShader, vsFilename);
        return false;
    }

    // Check to see if the fragment shader compiled successfully.
    OpenGL->glGetShaderiv(m_fragmentShader, GL_COMPILE_STATUS, &status);
    if(status != 1)
    {
        // If it did not compile then write the syntax error message out to a text file for review.
        OutputShaderErrorMessage(OpenGL, hwnd, m_fragmentShader, fsFilename);
        return false;
    }

    // Create a shader program object.
    m_shaderProgram = OpenGL->glCreateProgram();

    // Attach the vertex and fragment shader to the program object.
    OpenGL->glAttachShader(m_shaderProgram, m_vertexShader);
    OpenGL->glAttachShader(m_shaderProgram, m_fragmentShader);

    // Bind the shader input variables.
    OpenGL->glBindAttribLocation(m_shaderProgram, 0, "inputPosition");
    OpenGL->glBindAttribLocation(m_shaderProgram, 1, "inputTexCoord");
    OpenGL->glBindAttribLocation(m_shaderProgram, 2, "inputNormal");

    // Link the shader program.
    OpenGL->glLinkProgram(m_shaderProgram);

    // Check the status of the link.
    OpenGL->glGetProgramiv(m_shaderProgram, GL_LINK_STATUS, &status);
    if(status != 1)
    {
        // If it did not link then write the syntax error message out to a text file for review.
        OutputLinkerErrorMessage(OpenGL, hwnd, m_shaderProgram);
        return false;
    }

    return true;
}