VBO에서 사용자 정의 삼각형, 어떻게 내가 원하는 것은 사용자 정의 방식으로 특정 VBO 버퍼를 읽는 것입니다 일반적으로

Question

렌더링하기

GLuint vbo; 
glGenBuffers(1, &vbo); 
glBindBuffer(GL_ARRAY_BUFFER, vbo); 
glBufferData(GL_ARRAY_BUFFER, size, 0, GL_DYNAMIC_DRAW); 
glBindBuffer(GL_ARRAY_BUFFER, 0); 

그리고 내가 내 렌더링 기능에서 원하는를 sizeof (트라이앵글) (다음 요소)로 보폭을 위해 건너보다는 삼각형의 세 꼭지점을 렌더링하는 것입니다 : 내가 VBO를 생성하는 방법이다. 그래서 나는 glVertexPointer를 A, B, C 점의 3 위치에 맞 춥니 다. 단지, 내가 "glVertexPointer는"단지 포인터 위치를 변경하는 것이 하나 개의 삼각형, 걸음마다 하나의 포인트라고 생각립니다 난 단지뿐만 아니라 삼각형 ONT 하나 개의 색상을 원하는, 그래서 내가 하나 glColorPointer

glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo); 

glVertexPointer(3, GL_FLOAT, sizeof(Triangle), 0); 
glVertexPointer(3, GL_FLOAT, sizeof(Triangle), (void*)12); 
glVertexPointer(3, GL_FLOAT, sizeof(Triangle), (void*)24); 

glEnableClientState(GL_COLOR_ARRAY); 
glColorPointer(3, GL_FLOAT, sizeof(Triangle), (void*)(sizeof(CD_FLOAT)*13)); 

glDrawArrays(GL_TRIANGLES, 0, numTriangles); 
glDisableClientState(GL_COLOR_ARRAY); 

이 함수의 결과를 사용하고 있습니다 따라서 세 번째 삼각형 만 그려집니다.

1. Triangle1 : 난 정말 내가 가진 3 개 삼각형의 무승부 버퍼의 독서를 할 수있는 방법을 알고 싶어 무엇

   들 a 비; 기음; 색깔; 스트랩 :

2. Triangle2 : a; 비; 기음; 색깔; STRIDE
3. Triangle3 : a; 비; 기음; 색깔;

Answer 1

고정 기능 OpenGL에서 원하는 기능을 수행 할 수 없습니다.

당신이 할 수있는 베스트 색상 속성 정보를 귀하의 운동 학적 상태를 분할 중복입니다 :

class Vertex { 
public: 
    CD_FLOAT3 pos; 
    CD_FLOAT3 color; 
}; 

class State { 
public: 
    CD_FLOAT3 direction; 
    CD_FLOAT velocity; 
}; 

const unsigned int NumTris = ...; 
std::vector<State> states(NumTris); 
std::vector<Vertex> verts(NumTris * 3); 

PopulateAndBindVBO(); 

glVertexPointer(3, GL_FLOAT, sizeof(Vertex), 0); 
glColorPointer(3, GL_FLOAT, sizeof(Vertex), sizeof(CD_FLOAT3)); 
glDrawArrays(GL_TRIANGLES, 0, NumTris);  

당신 하지만 삼각형에 당신의 Triangle 구조체의 배열을 분할하는 지오메트리 쉐이더를 사용할 수 있습니다

#include <GL/glew.h> 
#include <GL/freeglut.h> 
#include <iostream> 
#include <vector> 
#include <cstddef> 
using namespace std; 

#include <glm/glm.hpp> 
using namespace glm; 

struct Program 
{ 
    static GLuint Load(const char* vert, const char* geom, const char* frag) 
    { 
     GLuint prog = glCreateProgram(); 
     if(vert) AttachShader(prog, GL_VERTEX_SHADER, vert); 
     if(geom) AttachShader(prog, GL_GEOMETRY_SHADER, geom); 
     if(frag) AttachShader(prog, GL_FRAGMENT_SHADER, frag); 
     glLinkProgram(prog); 
     CheckStatus(prog); 
     return prog; 
    } 

private: 
    static void CheckStatus(GLuint obj) 
    { 
     GLint status = GL_FALSE; 
     if(glIsShader(obj)) glGetShaderiv(obj, GL_COMPILE_STATUS, &status); 
     if(glIsProgram(obj)) glGetProgramiv(obj, GL_LINK_STATUS, &status); 
     if(status == GL_TRUE) return; 
     GLchar log[ 1 << 15 ] = { 0 }; 
     if(glIsShader(obj)) glGetShaderInfoLog(obj, sizeof(log), NULL, log); 
     if(glIsProgram(obj)) glGetProgramInfoLog(obj, sizeof(log), NULL, log); 
     std::cerr << log << std::endl; 
     exit(-1); 
    } 

    static void AttachShader(GLuint program, GLenum type, const char* src) 
    { 
     GLuint shader = glCreateShader(type); 
     glShaderSource(shader, 1, &src, NULL); 
     glCompileShader(shader); 
     CheckStatus(shader); 
     glAttachShader(program, shader); 
     glDeleteShader(shader); 
    } 
}; 

#define GLSL(version, shader) "#version " #version "\n" #shader 

struct Triangle 
{ 
    glm::vec3 a; 
    glm::vec3 b; 
    glm::vec3 c; 
    glm::vec3 color; 

    glm::vec3 direction; 
    GLfloat velocity; 
}; 


const char* vert = GLSL 
(
    330 core, 
    layout (location = 0) in vec3 A; 
    layout (location = 1) in vec3 B; 
    layout (location = 2) in vec3 C; 
    layout (location = 3) in vec3 Color; 

    out VertToGeom 
    { 
     vec3 A; 
     vec3 B; 
     vec3 C; 
     vec3 Color; 
    } outData; 

    void main() 
    { 
     outData.A = A; 
     outData.B = B; 
     outData.C = C; 
     outData.Color = Color; 
    } 
); 

const char* geom = GLSL 
(
    330 core, 

    in VertToGeom 
    { 
     vec3 A; 
     vec3 B; 
     vec3 C; 
     vec3 Color; 
    } inData[]; 

    out GeomToFrag 
    { 
     vec3 Color; 
    } outData; 

    layout (points) in; 
    layout (triangle_strip, max_vertices = 3) out; 
    void main() 
    { 
     gl_Position.xyz = inData[ 0 ].A; 
     outData.Color = inData[ 0 ].Color; 
     EmitVertex(); 
     gl_Position.xyz = inData[ 0 ].B; 
     outData.Color = inData[ 0 ].Color; 
     EmitVertex(); 
     gl_Position.xyz = inData[ 0 ].C; 
     outData.Color = inData[ 0 ].Color; 
     EmitVertex(); 
     EndPrimitive(); 
    } 
); 

const char* frag = GLSL 
(
    330 core, 
    in GeomToFrag 
    { 
     vec3 Color; 
    } inData; 

    void main() 
    { 
     gl_FragColor = vec4(inData.Color, 1.0); 
    } 
); 

GLuint vbo = 0; 
void display() 
{ 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

    static GLuint prog = Program::Load(vert, geom, frag); 
    glUseProgram(prog); 

    vector<Triangle> tris(2); 
    tris[0].a = glm::vec3(0, 0, 0); 
    tris[0].b = glm::vec3(1, 0, 0); 
    tris[0].c = glm::vec3(1, 1, 0); 
    tris[0].color = glm::vec3(1, 0, 0); 
    tris[1].a = glm::vec3(0, 0, 0); 
    tris[1].b = glm::vec3(-1, 0, 0); 
    tris[1].c = glm::vec3(-1, -1, 0); 
    tris[1].color = glm::vec3(0, 1, 0); 

    glBindBuffer(GL_ARRAY_BUFFER, vbo); 
    glBufferData(GL_ARRAY_BUFFER, sizeof(Triangle) * tris.size(), &tris[0], GL_STREAM_DRAW); 

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Triangle), (void*)(sizeof(glm::vec3) * 0)); 
    glEnableVertexAttribArray(0); 
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Triangle), (void*)(sizeof(glm::vec3) * 1)); 
    glEnableVertexAttribArray(1); 
    glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(Triangle), (void*)(sizeof(glm::vec3) * 2)); 
    glEnableVertexAttribArray(2); 
    glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, sizeof(Triangle), (void*)(sizeof(glm::vec3) * 3)); 
    glEnableVertexAttribArray(3); 

    glDrawArrays(GL_POINTS, 0, tris.size()); 

    glutSwapBuffers(); 
} 

int main(int argc, char **argv) 
{ 
    glutInit(&argc, argv); 
    glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); 
    glutInitContextVersion(3, 3); 
    glutInitContextProfile(GLUT_CORE_PROFILE); 
    glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE); 
    glutInitWindowSize(600, 600); 
    glutCreateWindow("GLUT"); 

    glewExperimental = GL_TRUE; 
    glewInit(); 

    GLuint vao = 0; 
    glGenVertexArrays(1, &vao); 
    glBindVertexArray(vao); 

    glGenBuffers(1, &vbo); 

    glutDisplayFunc(display); 
    glutMainLoop(); 
    return 0; 
} 

Answer 2

당신은 https://www.opengl.org/sdk/docs/man/html/glVertexAttribPointer.xhtml

"glVertexAttribPointer"을 시도 할 수 있습니다

나는이 같은 데이터를 저장할 수 있다고 생각 :

struct vertex 
{ 
    //posision 
    float x; 
    float y; 
    float z; 
    //color 
    float r; 
    float g; 
    float b; 
} 

GLuint buffer; 
static const vertex vertices[]={....}; 
glGenBuffers(1,&buffer); 
glBindBuffer(GL_ARRAY_BUFFER,buffer); 
glBufferData(GL_ARRAY_BUFFER,sizeof(vertices),vertices,GL_STATIC_DRAW); 

//set up two vertex attributes---first positions 
glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,sizeof(vertex),(void*)offsetof(vertex,x)); 
glEnableVertexAttribArray(0); 
//now colors 
glVertexAttribPointer(1,3,GL_FLOAT,GL_FALSE,sizeof(vertex),(void*)offsetof(vertex,r)); 
glEnableVertexAttribArray(1);