Утечки памяти SDL, OpenGL / Графика / Форум / Программирование игр / GameDev.ru

Здравствуйте.

Создал клас для создания, удаления и перемещения прямоугольных поверхностей в OpenGL. Касс использую как динамический массив, то есть создаю с помощью new некоторое количество прямоугольных поверхностей, когда они становятся не нужны, удаляю их с помощью delete. Заметил что каждый раз при создании поверхностей память выделяется, но после удаления класса, память не освобождается. Пытался отыскать утечки с помощью valgrind, но результата не получил. В самом классе malloc встречается только один раз и сразу же я освобождаю занятую память. В общем не могу понять что не так.

Вот мой класс, гляньте кто-нибудь, может увидите то что не вижу я.

LocationImage.h

+ Показать

− Скрыть

#include <GL/gl.h>
#include <GL/glext.h>
#include <string>
#include <iostream>
#include <vector>
#include <math.h>
#include <SDL/SDL.h>
#include <SDL/SDL_ttf.h>
#include <SDL/SDL_image.h>
#include <SDL/SDL_net.h>

#include "textfile.h"

class LocationImage
{
private:
    PFNGLCREATESHADERPROC glCreateShader;
    PFNGLSHADERSOURCEPROC glShaderSource;
    PFNGLCOMPILESHADERPROC glCompileShader;
    PFNGLCREATEPROGRAMPROC glCreateProgram;
    PFNGLATTACHSHADERPROC glAttachShader;
    PFNGLLINKPROGRAMPROC glLinkProgram;
    PFNGLUSEPROGRAMPROC glUseProgram;
    PFNGLGENVERTEXARRAYSPROC glGenVertexArrays;
    PFNGLBINDVERTEXARRAYPROC glBindVertexArray;
    PFNGLGENBUFFERSPROC glGenBuffers;
    PFNGLBINDBUFFERPROC glBindBuffer;
    PFNGLBUFFERDATAPROC glBufferData;
    PFNGLGETATTRIBLOCATIONPROC glGetAttribLocation;
    PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer;
    PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray;
    PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation;
    PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv;
    PFNGLACTIVETEXTUREPROC glActiveTexture;
    PFNGLUNIFORM1IPROC glUniform1i;
    PFNGLDELETEBUFFERSPROC glDeleteBuffers;
    PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays;
    PFNGLDELETEPROGRAMPROC glDeleteProgram;
    PFNGLGETSHADERIVPROC glGetShaderiv;
    PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog;
    GLuint shaderProgram, vertexShader, fragmentShader;
    GLuint meshVAO, meshVBO[3];
    GLuint colorTexture;
    GLuint textureLocation, positionLocation, texcoordLocation, worldMatrixLocation;
    std::vector<float> vertices;
    std::vector<float> texcoord;
    std::vector<int> indeces;
    float X, Y;
    float projectionMatrix[16], cameraMatrix[16], modelMatrix[16];
public:
    LocationImage();
    ~LocationImage();
    void Init(std::string image, float xbegin, float ybegin, float xend, float yend);
    void Load(const char * fileName, int sizeMap);
    void Render();
    void NewModelMatrix(float x, float y);
    void NewModelMatrixMove(float x, float y);
private:
    bool InvertSDLImage(int pitch, int height, void* image_pixels);
    bool TargetSDLLoadSurface(GLenum target, SDL_Surface *surface);
    void Matrix4Ortho(float * M, float left, float right, float bottom, float top, float zNear, float zFar);
    void Matrix4Rotation(float * M, float x, float y, float z);
    void Matrix4Translation(float *M, float x, float y, float z);
    void Matrix4Mul(float *M, float * A, float * B);
};

LocationImage.cpp

+ Показать

− Скрыть

#include "LocationImage.h"

LocationImage::LocationImage()
{
}

LocationImage::~LocationImage()
{
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
  glBindBuffer(GL_ARRAY_BUFFER, 0);
  // удаляем VBO
  glDeleteBuffers(3, meshVBO);
  // далаем текущий VAO неактивным
  glBindVertexArray(0);
  // удаляем VAO
  glDeleteVertexArrays(1, &meshVAO);
  indeces.clear();
  glUseProgram(0);
  glDeleteProgram(shaderProgram);
  glBindTexture(GL_TEXTURE_2D, 0);
}

bool LocationImage::InvertSDLImage(int pitch, int height, void* image_pixels)
{
  int index;
  void* temp_row;
  int height_div_2;

  temp_row = (void *)malloc(pitch);
  if(NULL == temp_row)
  {
    SDL_SetError("Not enough memory for image inversion");
    return false;
  }
  //if height is odd, don't need to swap middle row
  height_div_2 = (int) (height * .5);
  for(index = 0; index < height_div_2; index++)   {
    //uses string.h
    memcpy((Uint8 *)temp_row,
      (Uint8 *)(image_pixels) +
      pitch * index,
      pitch);

    memcpy(
      (Uint8 *)(image_pixels) +
      pitch * index,
      (Uint8 *)(image_pixels) +
      pitch * (height - index-1),
      pitch);
    memcpy(
      (Uint8 *)(image_pixels) +
      pitch * (height - index-1),
      temp_row,
      pitch);
  }
  free(temp_row);
  return true;
}

bool LocationImage::TargetSDLLoadSurface(GLenum target, SDL_Surface *surface)
{
  if (!surface)
    return false;

  GLenum texture_format;

  switch (surface->format->BytesPerPixel) //chanels
  {
  case 4: //RGBA
    if (surface->format->Rmask == 0x000000ff)
      texture_format = GL_RGBA;
    else
      texture_format = GL_BGRA;
    break;
  case 3: //RGB
    if (surface->format->Rmask == 0x000000ff)
      texture_format = GL_RGB;
    else
      texture_format = GL_BGR;
    break;
  case 2: //RG
    texture_format = GL_LUMINANCE_ALPHA;
    break;
  case 1: //R
    texture_format = GL_LUMINANCE;
    break;
  }
if (InvertSDLImage(surface->pitch, surface->h, surface->pixels))
{
    glGenTextures(1, &colorTexture);
    glBindTexture(GL_TEXTURE_2D, colorTexture);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexImage2D(target, 0, GL_RGBA, surface->w, surface->h, 0, texture_format, GL_UNSIGNED_BYTE, surface->pixels);
}
  else
      return false;

  return true;
}

void LocationImage::Matrix4Ortho(float *M, float left, float right, float bottom, float top, float zNear, float zFar)
{
    const float tx = - (right + left) / (right - left),
    ty = - (top + bottom) / (top - bottom),
    tz = - (zFar + zNear) / (zFar - zNear);

    M[ 0] = 2 / (right - left); M[ 1] =  0; M[ 2] =  0; M[ 3] =  tx;
  M[ 4] = 0;          M[ 5] =  2 / (top - bottom); M[ 6] =  0; M[ 7] =  ty;
  M[ 8] = 0;          M[ 9] =  0; M[10] =  -2 / (zFar - zNear); M[11] =  tz;
  M[12] = 0;          M[13] =  0; M[14] = 0; M[15] =  1;
}

void LocationImage::Matrix4Rotation(float * M, float x, float y, float z)
{
    const float A = cosf(x), B = sinf(x), C = cosf(y),
    D = sinf(y), E = cosf(z), F = sinf(z);
    const float AD = A * D, BD = B * D;
    M[ 0] = C * E;
    M[ 1] = -C * F;
    M[ 2] = D;
    M[ 3] = 0;
    M[ 4] = BD * E + A * F;
    M[ 5] = -BD * F + A * E;
    M[ 6] = -B * C;
    M[ 7] = 0;
    M[ 8] = -AD * E + B * F;
    M[ 9] = AD * F + B * E;
    M[10] = A * C;
    M[11] = 0;
    M[12] = 0;
    M[13] = 0;
    M[14] = 0;
    M[15] = 1;
}

void LocationImage::Matrix4Translation(float *M, float x, float y, float z)
{
    M[ 0] = 1; M[ 1] = 0; M[ 2] = 0; M[ 3] = x;
    M[ 4] = 0; M[ 5] = 1; M[ 6] = 0; M[ 7] = y;
    M[ 8] = 0; M[ 9] = 0; M[10] = 1; M[11] = z;
    M[12] = 0; M[13] = 0; M[14] = 0; M[15] = 1;
}

void LocationImage::Matrix4Mul(float *M, float * A, float * B)
{
    M[ 0] = A[ 0] * B[ 0] + A[ 1] * B[ 4] + A[ 2] * B[ 8] + A[ 3] * B[12];
    M[ 1] = A[ 0] * B[ 1] + A[ 1] * B[ 5] + A[ 2] * B[ 9] + A[ 3] * B[13];
    M[ 2] = A[ 0] * B[ 2] + A[ 1] * B[ 6] + A[ 2] * B[10] + A[ 3] * B[14];
    M[ 3] = A[ 0] * B[ 3] + A[ 1] * B[ 7] + A[ 2] * B[11] + A[ 3] * B[15];
    M[ 4] = A[ 4] * B[ 0] + A[ 5] * B[ 4] + A[ 6] * B[ 8] + A[ 7] * B[12];
    M[ 5] = A[ 4] * B[ 1] + A[ 5] * B[ 5] + A[ 6] * B[ 9] + A[ 7] * B[13];
    M[ 6] = A[ 4] * B[ 2] + A[ 5] * B[ 6] + A[ 6] * B[10] + A[ 7] * B[14];
    M[ 7] = A[ 4] * B[ 3] + A[ 5] * B[ 7] + A[ 6] * B[11] + A[ 7] * B[15];
    M[ 8] = A[ 8] * B[ 0] + A[ 9] * B[ 4] + A[10] * B[ 8] + A[11] * B[12];
    M[ 9] = A[ 8] * B[ 1] + A[ 9] * B[ 5] + A[10] * B[ 9] + A[11] * B[13];
    M[10] = A[ 8] * B[ 2] + A[ 9] * B[ 6] + A[10] * B[10] + A[11] * B[14];
    M[11] = A[ 8] * B[ 3] + A[ 9] * B[ 7] + A[10] * B[11] + A[11] * B[15];
    M[12] = A[12] * B[ 0] + A[13] * B[ 4] + A[14] * B[ 8] + A[15] * B[12];
    M[13] = A[12] * B[ 1] + A[13] * B[ 5] + A[14] * B[ 9] + A[15] * B[13];
    M[14] = A[12] * B[ 2] + A[13] * B[ 6] + A[14] * B[10] + A[15] * B[14];
    M[15] = A[12] * B[ 3] + A[13] * B[ 7] + A[14] * B[11] + A[15] * B[15];
}


void LocationImage::Init(std::string image, float xbegin, float ybegin, float xend, float yend)
{
    glCreateShader = (PFNGLCREATESHADERPROC) SDL_GL_GetProcAddress("glCreateShader");
    glShaderSource = (PFNGLSHADERSOURCEPROC) SDL_GL_GetProcAddress("glShaderSource");
    glCompileShader = (PFNGLCOMPILESHADERPROC) SDL_GL_GetProcAddress("glCompileShader");
    glCreateProgram = (PFNGLCREATEPROGRAMPROC) SDL_GL_GetProcAddress("glCreateProgram");
    glAttachShader = (PFNGLATTACHSHADERPROC) SDL_GL_GetProcAddress("glAttachShader");
    glLinkProgram = (PFNGLLINKPROGRAMPROC) SDL_GL_GetProcAddress("glLinkProgram");
    glUseProgram = (PFNGLUSEPROGRAMPROC) SDL_GL_GetProcAddress("glUseProgram");
    glGenVertexArrays =(PFNGLGENVERTEXARRAYSPROC) SDL_GL_GetProcAddress("glGenVertexArrays");
    glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC) SDL_GL_GetProcAddress("glBindVertexArray");
    glGenBuffers = (PFNGLGENBUFFERSPROC) SDL_GL_GetProcAddress("glGenBuffers");
    glBindBuffer = (PFNGLBINDBUFFERPROC) SDL_GL_GetProcAddress("glBindBuffer");
    glBufferData = (PFNGLBUFFERDATAPROC) SDL_GL_GetProcAddress("glBufferData");
    glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC) SDL_GL_GetProcAddress("glGetAttribLocation");
    glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC) SDL_GL_GetProcAddress("glVertexAttribPointer");
    glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC) SDL_GL_GetProcAddress("glEnableVertexAttribArray");
    glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC) SDL_GL_GetProcAddress("glGetUniformLocation");
    glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC) SDL_GL_GetProcAddress("glUniformMatrix4fv");
    glActiveTexture = (PFNGLACTIVETEXTUREPROC) SDL_GL_GetProcAddress("glActiveTexture");
    glUniform1i = (PFNGLUNIFORM1IPROC) SDL_GL_GetProcAddress("glUniform1i");
    glDeleteBuffers = (PFNGLDELETEBUFFERSPROC) SDL_GL_GetProcAddress("glDeleteBuffers");
    glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC) SDL_GL_GetProcAddress("glDeleteVertexArrays");
    glDeleteProgram = (PFNGLDELETEPROGRAMPROC) SDL_GL_GetProcAddress("glDeleteProgram");
    glGetShaderiv = (PFNGLGETSHADERIVPROC) SDL_GL_GetProcAddress("glGetShaderiv");
    glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC) SDL_GL_GetProcAddress("glGetShaderInfoLog");

  SDL_VideoInfo* info = (SDL_VideoInfo*)SDL_GetVideoInfo();
  glViewport(0,0,(GLsizei) info->current_w, (GLsizei) info->current_h);

  X = 0;
  Y = 0;

  SDL_Surface * img = IMG_Load(image.c_str());
  TargetSDLLoadSurface(GL_TEXTURE_2D, img);

    shaderProgram  = glCreateProgram();
    vertexShader   = glCreateShader(GL_VERTEX_SHADER);
    fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    char *vs = NULL,*fs = NULL;
    vs = textFileRead("shaders/vert/locationimage.vert");
    fs = textFileRead("shaders/frag/locationimage.frag");
    // Передаём шейдерам их исходный код
    glShaderSource(vertexShader, 1, &vs,NULL);
    glShaderSource(fragmentShader, 1, &fs,NULL);
    glCompileShader(vertexShader);
    glCompileShader(fragmentShader);
    free(vs);free(fs);
    // присоединим загруженные шейдеры к шейдерной программе
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    // сборка шейдерной программы из прикрепленных шейдеров
    glLinkProgram(shaderProgram);
    // сделаем шейдерную программу активной
    glUseProgram(shaderProgram);

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

    textureLocation = glGetUniformLocation(shaderProgram, "ColorTexture");
    glUniform1i(textureLocation, 0);

    Matrix4Ortho(projectionMatrix, -100, 100, -100, 100, -100, 100);

    float ModelTranslationMatrix[16];
    float ModelRotationMatrix[16];
    Matrix4Translation(ModelTranslationMatrix, 0.0, 0.0, 0.0);
    Matrix4Rotation(ModelRotationMatrix, 0.0, 0.0, 0.0);
    Matrix4Mul(modelMatrix, ModelTranslationMatrix, ModelRotationMatrix);

    float cameraTranslate[16];
    float cameraRotate[16];
    Matrix4Translation(cameraTranslate, 0.0, 0.0, 0.0);
    Matrix4Rotation(cameraRotate, 0.0, 0.0, 0.0);
    Matrix4Mul(cameraMatrix, cameraRotate, cameraTranslate);

    worldMatrixLocation = glGetUniformLocation(shaderProgram, "worldMatrix");

    int ind = 0;

    float left_bottom_x = xbegin;
    float right_bottom_x = xend;
    float right_top_x = xend;
    float left_top_x = xbegin;

    float left_bottom_y = ybegin;
    float right_bottom_y = ybegin;
    float right_top_y = yend;
    float left_top_y = yend;


    vertices.push_back(left_bottom_x);
    vertices.push_back(left_bottom_y);
    vertices.push_back(right_bottom_x);
    vertices.push_back(right_bottom_y);
    vertices.push_back(right_top_x);
    vertices.push_back(right_top_y);
    vertices.push_back(left_top_x);
    vertices.push_back(left_top_y);


    texcoord.push_back(0.0);
    texcoord.push_back(1.0);
    texcoord.push_back(1.0);
    texcoord.push_back(1.0);
    texcoord.push_back(1.0);
    texcoord.push_back(0.0);
    texcoord.push_back(0.0);
    texcoord.push_back(0.0);

    indeces.push_back(ind);
    ind++;
    indeces.push_back(ind);
    ind++;
    indeces.push_back(ind);
    ind++;
    indeces.push_back(ind);
    ind++;

    glGenVertexArrays(1, &meshVAO);
    // сделаем VAO активным
    glBindVertexArray(meshVAO);
    // создадим 3 VBO для данных куба - координаты вершин, текстурные координат и индексный буфер
    glGenBuffers(3, meshVBO);
    // получим индекс вершинного атрибута 'position' из шейдерной программы
    positionLocation = glGetAttribLocation(shaderProgram, "Vertex");
    // начинаем работу с буфером для координат вершин куба
    glBindBuffer(GL_ARRAY_BUFFER, meshVBO[0]);
    // поместим в буфер координаты вершин куба
    glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(float), &vertices.front(), GL_STATIC_DRAW);
    // укажем параметры вершинного атрибута для текущего активного VBO
    glVertexAttribPointer(positionLocation, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), 0);
    // разрешим использование вершинного атрибута
    glEnableVertexAttribArray(positionLocation);

    // получим индекс вершинного атрибута 'texcoord' из шейдерной программы
    texcoordLocation = glGetAttribLocation(shaderProgram, "TexCoord");
    // начинаем работу с буфером для текстурных координат куба
    glBindBuffer(GL_ARRAY_BUFFER, meshVBO[1]);
    // поместим в буфер текстурные координаты куба
    glBufferData(GL_ARRAY_BUFFER, texcoord.size() * sizeof(float), &texcoord.front(), GL_STATIC_DRAW);
    // укажем параметры вершинного атрибута для текущего активного VBO
    glVertexAttribPointer(texcoordLocation, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), 0);
    // разрешим использование вершинного атрибута
    glEnableVertexAttribArray(texcoordLocation);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, meshVBO[2]);
    // поместим в буфер индексы вершин
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, indeces.size() * sizeof(int), &indeces.front(), GL_STATIC_DRAW);
    glBindVertexArray(0);
    glBindTexture(GL_TEXTURE_2D, 0);

    vertices.clear();
    texcoord.clear();
    SDL_FreeSurface(img);
}

void LocationImage::NewModelMatrix(float x, float y)
{
    float ModelTranslationMatrix[16];
    float ModelRotationMatrix[16];
    X += x;
    Y += y;
    Matrix4Translation(ModelTranslationMatrix, X, Y, 0.0);
    Matrix4Rotation(ModelRotationMatrix, 0.0, 0.0, 0.0);
    Matrix4Mul(modelMatrix, ModelTranslationMatrix, ModelRotationMatrix);
}

void LocationImage::NewModelMatrixMove(float x, float y)
{
    float ModelTranslationMatrix[16];
    float ModelRotationMatrix[16];
    Matrix4Translation(ModelTranslationMatrix, x, y, 0.0);
    Matrix4Rotation(ModelRotationMatrix, 0.0, 0.0, 0.0);
    Matrix4Mul(modelMatrix, ModelTranslationMatrix, ModelRotationMatrix);
}

void LocationImage::Render()
{
    glBindTexture(GL_TEXTURE_2D, colorTexture);
    glUseProgram(shaderProgram);
    float newMatrix[16];
    float worldMatrix[16];
    Matrix4Mul(newMatrix, projectionMatrix, modelMatrix);
    Matrix4Mul(worldMatrix, cameraMatrix, newMatrix);
    glUniformMatrix4fv(worldMatrixLocation, 1, GL_TRUE, worldMatrix);
    glBindVertexArray(meshVAO);
  glDrawElements(GL_QUADS, indeces.size(), GL_UNSIGNED_INT, NULL);
  glBindTexture(GL_TEXTURE_2D, 0);
}

Думаю проблема где-то в методе Init()

Темный
Постоялец

#1
15:08, 9 июня 2014

Вот пример использования класса

+ Показать

− Скрыть

#include <GL/gl.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include "LocationImage.h"

SDL_Surface * Surf_Display;
LocationImage * Fon;

int main()
{

    if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) < 0)
    {
        return 1;
    }
    SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
    if((Surf_Display = SDL_SetVideoMode(1024, 768, 32, SDL_OPENGL)) == NULL)
    {
        return 1;
    }

    float xbegin = -100;
    float ybegin = -100;
    float xend = 100;
    float yend = 100;

    while(1)
    {
        Fon = new LocationImage[1];
        Fon->Init("fon.JPG", xbegin, ybegin, xend, yend);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        Fon->Render();
        SDL_GL_SwapBuffers();
        delete [] Fon;
        SDL_Delay(1000);
    }

    return 0;
}

За каждую секунду расходуется 4МБ памяти=(

Edisoni
Постоялец

#2
15:13, 9 июня 2014

Ты же в цикле постоянно загружаешь в память текстуру зачем?
И ты на одну картинку используешь свой ВБО? Это же бред
И все эти расширения....

Ты напихал все в один класс.
Сделай получение расширений отдельно методом при старте один раз
Для загрузки картинки напиши класс или метод
А классе картинки храни ID текстуры ее координаты

Как минимум запусти так и посмотри уходит память или нет:

#include <GL/gl.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include "LocationImage.h"

SDL_Surface * Surf_Display;
LocationImage * Fon;

int main()
{

    if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) < 0)
    {
        return 1;
    }
    SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
    if((Surf_Display = SDL_SetVideoMode(1024, 768, 32, SDL_OPENGL)) == NULL)
    {
        return 1;
    }

    float xbegin = -100;
    float ybegin = -100;
    float xend = 100;
    float yend = 100;

    Fon = new LocationImage[1];
    Fon->Init("fon.JPG", xbegin, ybegin, xend, yend);

    while(1)
    {
    
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        Fon->Render();
        SDL_GL_SwapBuffers();
    }
    delete [] Fon;

    return 0;
}

Темный
Постоялец

#3
16:36, 9 июня 2014

Это был лишь пример использования класса, а у меня всё происходит по другому. Вот например кликну я мышью в одном месте экрана и в зависимости от места куда я кликнул происходит загрузка какого-то количества прямоугольников. Кликну я в другом месте, удаляются загруженные прямоугольники и создаются новые. В общем количество прямоугольников и какие именно картинки будут на этих прямоугольниках зависит от места куда я кликну и от данных которые приходят с сервера. На одну картинку использую ВБО так как под рукой уже был готовый код, который я использовал в другом проекте, а точнее сказать единственном своём рабочем проекте на SDL+OpenGL и по другому как это сделать я не знаю=(

Приведённый выше код памяти не расходует, но не сгодится.

a10ne
Постоялец

#4
16:53, 9 июня 2014

Нет в SDL утечек, начни облегчать код, удаляй по очереди все места где происходят манипуляции с памятью, пофиг что-то рендерится перестанет, так ты найдешь место где все происходит.

a10ne
Постоялец

#5
16:54, 9 июня 2014

Ну или начни заменять массивы векторами, а сырые указазатели умными, меняй по одному и запускай:)

Темный
Постоялец

#6
17:20, 9 июня 2014

Спасибо за совет, удалось обнаружить кусок кода без которого память не расходуется

SDL_Surface * img = IMG_Load(image.c_str());
TargetSDLLoadSurface(GL_TEXTURE_2D, img);

Я ведь использовал

SDL_FreeSurface(img);

Так почему же память не освобождается? Кто-нибудь знает?

Темный
Постоялец

#7
19:46, 9 июня 2014

Сделал SDL_Surface * img; приватным членом класса и удаление его с помощью SDL_FreeSurface(img); теперь произвожу в деструкторе. Если не использовать TargetSDLLoadSurface(), то память не расходуется. Осталось только понять почему с этим методом она расходуется?

+ Показать

− Скрыть

bool LocationImage::InvertSDLImage(int pitch, int height, void* image_pixels)
{
  int index;
  void* temp_row;
  int height_div_2;

  temp_row = (void *)malloc(pitch);
  if(NULL == temp_row)
  {
    SDL_SetError("Not enough memory for image inversion");
    return false;
  }
  //if height is odd, don't need to swap middle row
  height_div_2 = (int) (height * .5);
  for(index = 0; index < height_div_2; index++)   {
    //uses string.h
    memcpy((Uint8 *)temp_row,
      (Uint8 *)(image_pixels) +
      pitch * index,
      pitch);

    memcpy(
      (Uint8 *)(image_pixels) +
      pitch * index,
      (Uint8 *)(image_pixels) +
      pitch * (height - index-1),
      pitch);
    memcpy(
      (Uint8 *)(image_pixels) +
      pitch * (height - index-1),
      temp_row,
      pitch);
  }
  free(temp_row);
  return true;
}

bool LocationImage::TargetSDLLoadSurface(GLenum target, SDL_Surface *surface)
{
  if (!surface)
    return false;

  GLenum texture_format;

  switch (surface->format->BytesPerPixel) //chanels
  {
  case 4: //RGBA
    if (surface->format->Rmask == 0x000000ff)
      texture_format = GL_RGBA;
    else
      texture_format = GL_BGRA;
    break;
  case 3: //RGB
    if (surface->format->Rmask == 0x000000ff)
      texture_format = GL_RGB;
    else
      texture_format = GL_BGR;
    break;
  case 2: //RG
    texture_format = GL_LUMINANCE_ALPHA;
    break;
  case 1: //R
    texture_format = GL_LUMINANCE;
    break;
  }
if (InvertSDLImage(surface->pitch, surface->h, surface->pixels))
{
    glGenTextures(1, &colorTexture);
    glBindTexture(GL_TEXTURE_2D, colorTexture);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexImage2D(target, 0, GL_RGBA, surface->w, surface->h, 0, texture_format, GL_UNSIGNED_BYTE, surface->pixels);
}
  else
      return false;

  return true;
}

Этими функциями со мною поделился кто-то с этого форума, без них у меня были проблемы с цветами.

=A=L=X=
Постоялец

#8
20:05, 9 июня 2014

Темный
> Если не использовать TargetSDLLoadSurface(), то память не расходуется.

Ошибка в этой функции.

Темный
Постоялец

#9
20:18, 9 июня 2014

Спасибо за подсказку, сам бы я не додумался до этого. Заменил TargetSDLLoadSurface() на

+ Показать

− Скрыть

img = IMG_Load(image.c_str());
  GLenum texture_format;
  switch (img->format->BytesPerPixel) //chanels
  {
  case 4: //RGBA
    if (img->format->Rmask == 0x000000ff)
      texture_format = GL_RGBA;
    else
      texture_format = GL_BGRA;
    break;
  case 3: //RGB
    if (img->format->Rmask == 0x000000ff)
      texture_format = GL_RGB;
    else
      texture_format = GL_BGR;
    break;
  case 2: //RG
    texture_format = GL_LUMINANCE_ALPHA;
    break;
  case 1: //R
    texture_format = GL_LUMINANCE;
    break;
  }
  glGenTextures(1, &colorTexture);
    glBindTexture(GL_TEXTURE_2D, colorTexture);
    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_RGBA, img->w, img->h, 0, texture_format, GL_UNSIGNED_BYTE, img->pixels);