2014-06-17 3 views
-1

"Android C++ 게임 개발 시작"책을 읽었습니다. 현재 5 장에서 책의 코드는 웹 사이트에서 다운로드 할 수 있습니다. 당신은 색상이 잘못 볼 수OpenGl Es 텍스처 색상이 올바르지 않습니다.

http://i193.photobucket.com/albums/z127/johto760/error-1.png

, 내가 가지 기대 : 텍스처를 렌더링 할 때

나는 나의 문제없이 장 4 개까지 책을 따라 가지고 있지만, 올 5 장,이 수 이 같은 :

http://i193.photobucket.com/albums/z127/johto760/somewhatexpected.png

에도 RGB가, 내가 이미지 TGA 파일을 사용하고 반전 두 번째 일인치 일요일부터 해결책을 찾고 있었는데 오늘 화요일입니다.

 SampleTask.cpp 
     namespace { 
      float verts[] = {-0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 
       -0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f}; 

      unsigned short indices[] = {0, 2, 1, 2, 3, 1}; 

     } 

     SampleTask::SampleTask(Framework::Renderer* renderer, 
       const unsigned int priority) : 
       Framework::Task(priority), m_state(RUNNING), m_renderer(renderer), m_readBytes(
         0), m_TGABuffer(NULL), m_file("test.tga"), m_fileLength(0) { 

      m_renderable.SetGeometry(&m_geometry); 
      m_renderable.SetShader(&m_textureShader); 
     } 

     SampleTask::~SampleTask() { 
      m_renderer->RemoveRenderable(&m_renderable); 
      m_renderer->RemoveTexture(&m_texture); 
      m_renderer->RemoveShader(&m_textureShader); 

      if (m_TGABuffer) { 
       delete[] static_cast<char*>(m_TGABuffer); 
       m_TGABuffer = 0; 
      } 
     } 

     bool SampleTask::Start() { 
      Framework::Geometry* pGeometry = m_renderable.GetGeometry(); 
      pGeometry->SetName("quad"); 
      pGeometry->SetVertexBuffer(verts); 
      pGeometry->SetNumVertices(4); 
      pGeometry->SetIndexBuffer(indices); 
      pGeometry->SetNumIndices(6); 

      pGeometry->SetNumVertexPositionElements(3); 
      pGeometry->SetNumTexCoordsElements(2); 
      pGeometry->SetVertexStride(sizeof(float) * 5); 

      bool success = false; 
      if (m_file.Open()) { 
       m_fileLength = m_file.Length(); 

       m_TGABuffer = new char[m_fileLength]; 

       m_state = LOADING_FILE; 
       success = true; 
      } 

      return success; 
     } 

     void SampleTask::Stop() { 
      m_renderer->RemoveRenderable(&m_renderable); 
     } 

     void SampleTask::Update() { 
      switch (m_state) { 

      case (LOADING_FILE): { 
       void* currentDataPos = static_cast<char*>(m_TGABuffer) 
         + (sizeof(char) * m_readBytes); 

       size_t bytesRead = 0; 
       m_file.Read(currentDataPos, 512 * 1024, bytesRead); 
       m_readBytes += bytesRead; 
       if (m_readBytes == m_fileLength) { 

        m_state = CREATE_TEXTURE; 
       } 
      } 
       break; 

      case (CREATE_TEXTURE): { 
       Framework::TGAFile tgaFile(m_TGABuffer); 

       Framework::Texture::Header textureHeader; 
       textureHeader.m_width = tgaFile.GetWidth(); 
       textureHeader.m_height = tgaFile.GetHeight(); 

       textureHeader.m_bytesPerPixel = 4; 

       textureHeader.m_dataSize = textureHeader.m_width 
         * textureHeader.m_height * textureHeader.m_bytesPerPixel; 

       m_texture.SetData(textureHeader, tgaFile.GetImageData()); 

       m_textureShader.SetTexture(&m_texture); 

       m_renderer->AddTexture(&m_texture); 

       m_renderer->AddShader(&m_textureShader); 

       m_renderer->AddRenderable(&m_renderable); 

       m_state = RUNNING; 

      } 
       break; 
      }; 
     } 

Renderer.cpp 
    void Renderer::Update() { 
     if (m_initialized) { 

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

      for (RenderableVectorIterator iter = m_renderables.begin(); 
        iter != m_renderables.end(); iter++) { 
       Renderable* pRenderable = *iter; 
       if (pRenderable) { 
        Draw(pRenderable); 
       } 
      } 
      eglSwapBuffers(m_display, m_surface); 
     } 
    } 

    void Renderer::Init() { 

     // initialize OpenGL ES and EGL 

     /* 
     * Here specify the attributes of the desired configuration. 
     * Below, we select an EGLConfig with at least 8 bits per color 
     * component compatible with on-screen windows 
     */ 
     const EGLint attribs[] = { 
     EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, 
     EGL_SURFACE_TYPE, EGL_WINDOW_BIT, 
     EGL_BLUE_SIZE, 8, 
     EGL_GREEN_SIZE, 8, 
     EGL_RED_SIZE, 8, 
     EGL_NONE }; 

     EGLint format; 
     EGLint numConfigs; 
     EGLConfig config; 

     m_display = eglGetDisplay(EGL_DEFAULT_DISPLAY); 

     eglInitialize(m_display, NULL, NULL); 

     /* Here, the application chooses the configuration it desires. In this 
     * sample, we have a very simplified selection process, where we pick 
     * the first EGLConfig that matches our criteria */ 
     eglChooseConfig(m_display, attribs, &config, 1, &numConfigs); 

     /* EGL_NATIVE_VISUAL_ID is an attribute of the EGLConfig that is 
     * guaranteed to be accepted by ANativeWindow_setBuffersGeometry(). 
     * As soon as we picked a EGLConfig, we can safely reconfigure the 
     * ANativeWindow buffers to match, using EGL_NATIVE_VISUAL_ID. */ 
     eglGetConfigAttrib(m_display, config, EGL_NATIVE_VISUAL_ID, &format); 

     ANativeWindow_setBuffersGeometry(m_state->window, 0, 0, format); 

     m_surface = eglCreateWindowSurface(m_display, config, m_state->window, 
     NULL); 

     EGLint contextAttribs[] = { 
     EGL_CONTEXT_CLIENT_VERSION, 2, 
     EGL_NONE }; 
     m_context = eglCreateContext(m_display, config, NULL, contextAttribs); 

     eglMakeCurrent(m_display, m_surface, m_surface, m_context); 

     eglQuerySurface(m_display, m_surface, EGL_WIDTH, &m_width); 
     eglQuerySurface(m_display, m_surface, EGL_HEIGHT, &m_height); 

     for (TextureVectorIterator iter = m_textures.begin(); 
       iter != m_textures.end(); ++iter) { 
      Texture* pCurrent = *iter; 
      pCurrent->Init(); 
     } 

     for (ShaderVectorIterator iter = m_shaders.begin(); iter != m_shaders.end(); 
       ++iter) { 
      Shader* pCurrent = *iter; 
      pCurrent->Link(); 
     } 

     m_initialized = true; 

    } 

    void Renderer::Draw(Renderable* renderable) { 
     assert(renderable); 
     if (renderable) { 
      Geometry* geometry = renderable->GetGeometry(); 
      Shader* shader = renderable->GetShader(); 

      assert(geometry && shader); 
      if (geometry && shader) { 
       shader->Setup(*renderable); 

       glDrawElements(GL_TRIANGLES, geometry->GetNumIndices(), 
       GL_UNSIGNED_SHORT, geometry->GetIndexBuffer()); 
      } 
     } 
    } 

Texture.cpp 
    void Texture::Init() { 
     GLint packBits = 4; 
     GLint internalFormat = GL_RGBA; 
     GLenum format = GL_RGBA; 
     switch (m_header.m_bytesPerPixel) { 
     case 1: { 
      packBits = 1; 
      internalFormat = GL_ALPHA; 
      format = GL_ALPHA; 
     } 
      break; 
     }; 

     glGenTextures(1, &m_id); 

     glBindTexture(GL_TEXTURE_2D, m_id); 

     glPixelStorei(GL_UNPACK_ALIGNMENT, packBits); 

     glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, m_header.m_width, 
       m_header.m_height, 0, format, GL_UNSIGNED_BYTE, m_imageData); 
    } 

TextureShader.cpp 
    m_vertexShaderCode = 
    "attribute vec4 a_vPosition;  \n" 
    "attribute vec2 a_texCoord;   \n" 
    "varying vec2 v_texCoord;   \n" 
    "void main(){      \n" 
    " gl_Position = a_vPosition;  \n" 
    " v_texCoord = a_texCoord;  \n" 
    "}         \n"; 

m_fragmentShaderCode = 
    "precision highp float;        \n" 
    "varying vec2 v_texCoord;        \n" 
    "uniform sampler2D s_texture;       \n" 
    "void main(){           \n" 
    " gl_FragColor = texture2D(s_texture, v_texCoord); \n" 
    "}              \n"; 

0 :

는 여기에 내가 일하고 있어요 관련 코드입니다

답변

0

무엇이 잘못되었는지 찾아 냈습니다.

나는 책의 웹 사이트에서 헤더와 cpp 파일을 사용하기로 결정했다. 그런 다음 하나씩 코드의 내 자신의 버전에서 각 cpp 파일을 복사하여 붙여 넣었다. 그 코드는 "계산 오류"로 판명되었다. TGA 파일의 이미지 사이즈.

내 오류 코드입니다 : 대신 내가 18 바이트 뭔가 생각이다를 sizeof TGAHeader 클래스를 계산해야 할 때

m_imageData = static_cast<void*>(static_cast<char*>(data) + sizeof(m_header)); 

내가 sizeof의 "m_header"변수를 계산했다, 그래서 그래서 같은 TGAHeader 변경됨 m_header는 :

m_imageData = static_cast<void*>(static_cast<char*>(data) + sizeof(TGAHeader)); 

이제 색상이 정확, 또한 GL_BGR_EXT하는 GL_RGB에서 포맷을 변경하고 (GL)의 버퍼에 입력 할 때의 색을 바꾸도록, GL_RGB로 내부 형식을 유지 .