0

私はGLFW（静的リンクライブラリ- glfw.lib）を使用GLEWしていて、プロジェクトで問題が発生しました。黒いウィンドウを開き、呼び出しとメインループを含む
最も単純なGLFWプログラム（glfwInit()、、glfwOpenWindow()...、 ）を作成します。のみ、それからそれはOKを実行します。ただし、ロードシェーダーのクラス（ 、 ）を追加すると（クラスに特別なものはなく、静的変数も静的メソッドもまだインスタンスが作成されていないため、2つのファイルをVisual Studioワークスペースウィンドウにドラッグアンドドロップするだけです） 、次に再構築し、を押します。VisualStudioのメッセージを表示してで中断します。しかし、私がそれに変更した場合、それは問題ありません。glewInit()glewInit()glfwSwapBuffers()cshader.hcshader.cppF5sfs.exe has triggered a breakpoint.msvcr110d.dll!_CrtIsValidHeapPointer(const void * pUserData) Line 2036 C++Release

私のコールスタックは次のとおりです。 

msvcr110d.dll!_CrtIsValidHeapPointer(const void * pUserData) Line 2036  C++
msvcr110d.dll!_free_dbg_nolock(void * pUserData, int nBlockUse) Line 1322   C++
msvcr110d.dll!_free_dbg(void * pUserData, int nBlockUse) Line 1265  C++
msvcr110d.dll!free(void * pUserData) Line 49    C++
sfs.exe!__glfwPlatformWaitEvents()  Unknown
sfs.exe!__glfwPlatformWaitEvents()  Unknown
sfs.exe!__glfwPlatformOpenWindow()  Unknown
sfs.exe!_glfwOpenWindow()   Unknown
sfs.exe!main(int argc, char * * argv) Line 54   C++

はい、この問題については何も考えていません。クラスインスタンスはまだ作成していません。クラスには、ロードシェーダー、リンクプログラム、使用、リリースシェーダー、均一設定のメソッドしかありません。誰かが私にこれを手伝ってくれる？

更新：私のcshader.hとcshader.cppは： 

// cshader.h
#ifndef __CShader_h__
#define __CShader_h__

#include <iostream>
#include <fstream>
#include <sstream>
#include <GL/gl.h>

class CShader
{
protected:
  GLuint m_FragmentShader;
  GLuint m_VertexShader;
  GLuint m_Program;

  bool readTextFile(const char *name, std::string& text);
  GLuint createShader(const char *name, GLenum type);

public:
  CShader();
  CShader(const char *vertex, const char *fragment);
  ~CShader();

  bool loadVertexShader(const char *vertex);
  bool loadFragmentShader(const char *fragment);
  bool link();
  void use();
  void end();
  GLint getUniformLocation(const char *name);
  GLint getAttribLocation(const char *name);
  void uni4x4Matrix(const char *name, float *matrix);
  void uni1i(const char *name, GLuint value);

  void enableAttrib(const char *name);
  void enableAttrib(GLint attrib);

  void disableAttrib(const char *name);
  void disableAttrib(GLint attrib);
};

#endif /* __CShader_h__ */


// cshader.cpp
#include <gl/glew.h>
#include "cshader.h"

bool CShader::readTextFile(const char *name, std::string& text) {
  std::ifstream in;

  in.open(name, std::ios::in);
  if (in.fail()) {
    std::cout << "CShader::readTextFile(\"" << name << "\") false" << std::endl;
    return false;
  }

  std::ostringstream data;
  data << in.rdbuf();
  text = data.str();
  in.close();

  return true;
}

GLuint CShader::createShader(const char *name, GLenum type) {
  std::string text, shader_type;
  const char *source;
  GLuint shader;

  switch(type) {
  case GL_VERTEX_SHADER:
    shader_type = "GL_VERTEX_SHADER";
    break;

  case GL_FRAGMENT_SHADER:
    shader_type = "GL_FRAGMENT_SHADER";
    break;

  default:
    shader_type = "UNKNOW_SHADER";
  }

  if (!readTextFile(name, text)) return 0;
  source = text.c_str();

  shader = glCreateShader(type);
  glShaderSource(shader, 1, &source, 0);
  glCompileShader(shader);

  GLint is_compiled;
  glGetShaderiv(shader, GL_COMPILE_STATUS, &is_compiled);
  if (GL_FALSE == is_compiled) {
    std::cout << "CShader::createShader(): Compile " << shader_type << " (" << name << ") error:" << std::endl;
    int errLen, errRet;
    glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &errLen);

    char *errMsg = new char[errLen + 1];
    glGetShaderInfoLog(shader, errLen, &errRet, errMsg);
    std::cout << errMsg << std::endl;
    delete [] errMsg;

    glDeleteShader(shader);
    return 0;
  }

  return shader;
}

CShader::CShader() {
  m_FragmentShader = 0;
  m_VertexShader = 0;
  m_Program = 0;
}

CShader::CShader(const char *vertex, const char *fragment) {
  m_FragmentShader = 0;
  m_VertexShader = 0;
  m_Program = 0;

  loadVertexShader(vertex);
  loadFragmentShader(fragment);
}

CShader::~CShader() {
  if (m_Program > 0) {
    glDetachShader(m_Program, m_VertexShader);
    glDetachShader(m_Program, m_FragmentShader);
    glDeleteProgram(m_Program);
  }

  if (m_VertexShader > 0) glDeleteShader(m_VertexShader);
  if (m_FragmentShader > 0) glDeleteShader(m_FragmentShader);
}

bool CShader::loadVertexShader(const char *vertex) {
  if (m_VertexShader > 0) glDeleteShader(m_VertexShader);

  m_VertexShader = createShader(vertex, GL_VERTEX_SHADER);
  return (m_VertexShader > 0) ? (true) : (false);
}

bool CShader::loadFragmentShader(const char *fragment) {
  if (m_FragmentShader > 0) glDeleteShader(m_FragmentShader);

  m_FragmentShader = createShader(fragment, GL_FRAGMENT_SHADER);
  return (m_FragmentShader > 0) ? (true) : (false);
}

bool CShader::link() {
  if (m_VertexShader <= 0 || m_FragmentShader <= 0) return false;
  if (m_Program > 0) {
    std::cout << "Program have already linked!" << std::endl;
    return false;
  }

  m_Program = glCreateProgram();
  glAttachShader(m_Program, m_VertexShader);
  glAttachShader(m_Program, m_FragmentShader);
  glLinkProgram(m_Program);

  GLint is_Linked;
  glGetProgramiv(m_Program, GL_LINK_STATUS, &is_Linked);
  if (GL_FALSE == is_Linked) {
    std::cout << "CShader::link() got error:" << std::endl;

    int errLen, errRet;
    glGetProgramiv(m_Program, GL_INFO_LOG_LENGTH, &errLen);

    char * errMsg = new char[errLen + 1];
    glGetProgramInfoLog(m_Program, errLen, &errRet, errMsg);
    std::cout << errMsg << std::endl;
    delete [] errMsg;

    glDetachShader(m_Program, m_VertexShader);
    glDetachShader(m_Program, m_FragmentShader);
    glDeleteProgram(m_Program);
    m_Program = 0;
    return false;
  }

  return true;
}

void CShader::use() {
  if (m_Program <= 0) {
    std::cout << "CShader::use(): Program not ready!" << std::endl;
    return;
  }

  glUseProgram(m_Program);
}

void CShader::end() {
  glUseProgram(0);
}

GLint CShader::getUniformLocation(const char *name) {
  if (m_Program <= 0) return -1;
  return glGetUniformLocation(m_Program, name);
}

GLint CShader::getAttribLocation(const char *name) {
  if (m_Program <= 0) return -1;
  return glGetAttribLocation(m_Program, name);
}

void CShader::uni4x4Matrix(const char *name, float *matrix) {
  GLint matLoc = getUniformLocation(name);
  if (matLoc >= 0) {
    glUniformMatrix4fv(matLoc, 1, GL_FALSE, matrix);
  } else {
    std::cout << "CShader::uni4x4Matrix(): " << name << " uniform not found!" << std::endl;
  }
}

void CShader::uni1i(const char *name, GLuint value) {
  GLint matLoc = getUniformLocation(name);
  if (matLoc >= 0) {
    glUniform1i(matLoc, value);
  } else {
    std::cout << "CShader::uni1i(): " << name << " uniform not found!" << std::endl;
  }
}

void CShader::enableAttrib(const char *name) {
  GLint attribLoc = getAttribLocation(name);
  if (attribLoc < 0) {
    std::cout << "CShader::enableAttrib(): " << name << " attrib not found!" << std::endl;
  } else {
    enableAttrib(attribLoc);
  }
}

void CShader::enableAttrib(GLint attrib) {
  glEnableVertexAttribArray(attrib);
}

void CShader::disableAttrib(const char *name) {
  GLint attribLoc = getAttribLocation(name);
  if (attribLoc < 0) {
    std::cout << "CShader::disableAttrib(): " << name << " attrib not found!" << std::endl;
  } else {
    disableAttrib(attribLoc);
  }
}

void CShader::disableAttrib(GLint attrib) {
  glDisableVertexAttribArray(attrib);
}

main.cpp：

#include <iostream>
#include <gl/glew.h>
#include "cshader.h"

#include <gl/glfw.h>

#pragma comment(lib, "glfw.lib")
#pragma comment(lib, "opengl32.lib")
#pragma comment(lib, "glew32.lib")

using namespace std;


void GLFWCALL reshape(int w, int h)
{
}

void display()
{

}

bool init()
{

    return true;
}

int main(int argc, char *argv[])
{
    if (glfwInit() != GL_TRUE) {
        cout << "glfwInit() return false!" << endl;
        cin.get();
        return -1;
    }

    glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, GL_TRUE);
    if(glfwOpenWindow(640, 480, 0, 0, 0, 0, 16, 1, GLFW_WINDOW) != GL_TRUE) {
        cout << "Open window fail!" << endl;
        glfwTerminate();
        return -1;
    }

    if (glewInit() != GLEW_OK) {
        cout << "load opengl functions failed!" << endl;
        glfwTerminate();
        return -1;
    }

    glfwSetWindowTitle("Shadow from scratch...");
    if (!init()) {
        cout << "init() return false!" << endl;
        glfwTerminate();
        return -1;
    }

    glfwSetWindowSizeCallback(&reshape);
    reshape(640, 480);

    bool running = true;
    while (running) {
        display();
        glfwSwapBuffers();

        running = !glfwGetKey(GLFW_KEY_ESC) && glfwGetWindowParam(GLFW_OPENED);
    }

    glfwTerminate();
    return 0;
}

更新2： OpenGL拡張機能をロードするように変更しglLoadGenましたが、問題はまだここにあります...

4

1 に答える 1

0

同じ問題が発生しましたが、次の警告を解決することで機能するようになりました。 マクロの再定義を防ぐ方法 うまくいくことを願っています。

于 2013-04-04T04:42:30.200 に答える