本文整理汇总了C++中BUFFER_OFFSET函数的典型用法代码示例。如果您正苦于以下问题：C++ BUFFER_OFFSET函数的具体用法？C++ BUFFER_OFFSET怎么用？C++ BUFFER_OFFSET使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了BUFFER_OFFSET函数的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: getMatrix
void OBJWrapper::onDraw(Render& render, const glm::mat4& mvp)
{
glm::mat4 localMatrix = getMatrix();
glm::mat4 totalMatrix = mvp * localMatrix;
for(std::map<std::string, OBJDatas*>::iterator itOBJ = m_objDatas.begin(); itOBJ != m_objDatas.end(); ++itOBJ)
{
OBJDatas* currentDatas = itOBJ->second;
glBindBuffer(GL_ARRAY_BUFFER, currentDatas->vboID);
{
for(std::map<std::string, int>::iterator itSeries = currentDatas->materialSerie.begin(); itSeries != currentDatas->materialSerie.end(); itSeries++)
{
//Draw triangle for each materials series.
int offset = 0;
//Get the material and the shader, then init them.
Material* currentMaterial = currentDatas->mtlWrapper->getMaterial(itSeries->first);
const Shader* shader;
if(!m_material)
{
currentMaterial->enableShader();
currentMaterial->init(render, totalMatrix, localMatrix);
shader = currentMaterial->getShader();
}
else
{
m_material->init(render, totalMatrix, localMatrix);
shader = m_material->getShader();
}
//Send the vector attribute
int stride = 12;
glVertexAttribPointer(glGetAttribLocation(shader->getProgramID(), "vPosition"), 3, GL_FLOAT, false, stride, BUFFER_OFFSET(0));
glVertexAttribPointer(glGetAttribLocation(shader->getProgramID(), "vNormal"), 3, GL_FLOAT, false, stride, BUFFER_OFFSET(currentDatas->vertexPositionLength*4));
//Send the uniform attribute
GLint mvpMatrixHandle = glGetUniformLocation(shader->getProgramID(), "uMVP");
glUniformMatrix4fv(mvpMatrixHandle, 1, false, glm::value_ptr(totalMatrix));
//Draw the triangles.
glDrawArrays(GL_TRIANGLES, offset, itSeries->second);
offset += itSeries->second;
}
}
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
}示例2: Rotate
Rotate(modelViewShadow, 1.0, 0.0, 0.0, rotateModelWithLeftMouse[0]);
Rotate(modelViewShadow, 0.0, 1.0, 0.0, rotateModelWithLeftMouse[1]);
//----------------------------------------------------------------------------------------
Translate(modelViewShadow, facing_VIEW_blocks_01_POSITION[0] * scaleMoveShadows[0],
facing_VIEW_blocks_01_POSITION[1] * scaleMoveShadows[1],
facing_VIEW_blocks_01_POSITION[2] * scaleMoveShadows[2]);
//-------------------------------------------------------
Rotate(modelViewShadow, facing_VIEW_blocks_01_ROTATE[0],
facing_VIEW_blocks_01_ROTATE[1],
facing_VIEW_blocks_01_ROTATE[2],
facing_VIEW_blocks_01_ROTATE[3]);
//-------------------------------------------------------
Scale(modelViewShadow, scaleShadowSize,
scaleShadowSize,
scaleShadowSize);
//------------------------------------------------------------------------------------------------
MultiplyMatrix(mvpMatrix, ProjectionShadow, modelViewShadow);
//---------------------------------------------------------------------------------------------------------------------------------------------------|__DRAW
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 44, BUFFER_OFFSET(0));
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 44, BUFFER_OFFSET(12));
glEnableVertexAttribArray(1);
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 44, BUFFER_OFFSET(24));
glEnableVertexAttribArray(2);
glVertexAttribPointer(3, 2, GL_FLOAT, GL_FALSE, 44, BUFFER_OFFSET(36));
glEnableVertexAttribArray(3);
//--------------------------------------------------------------------------------------------------
glUniformMatrix4fv(UNIFORM_MODELVIEWPROJ_shadow_44bit_Stride, 1, 0, mvpMatrix);
//--------------------------------------------------------------------------------------------------
glDrawElements(GL_TRIANGLES, 60, GL_UNSIGNED_INT, 0);
示例3: LoadShaders
void Ex06_02::InitGL()
{
if (! LoadGL() )
return;
ShaderInfo base_shaders[] = {
{ GL_VERTEX_SHADER, "Shaders/sh06_02.vert" },
{ GL_FRAGMENT_SHADER, "Shaders/sh06_02.frag" },
{ GL_NONE, NULL }
};
base_prog = LoadShaders( base_shaders );
glGenBuffers(1, &quad_vbo);
glBindBuffer(GL_ARRAY_BUFFER, quad_vbo);
static const GLfloat quad_data[] =
{
0.75f, -0.75f,
-0.75f, -0.75f,
-0.75f, 0.75f,
0.75f, 0.75f,
0.0f, 0.0f,
1.0f, 0.0f,
1.0f, 1.0f,
0.0f, 1.0f
};
glBufferData(GL_ARRAY_BUFFER, sizeof(quad_data), quad_data, GL_STATIC_DRAW);
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(8 * sizeof(float)));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glLinkProgram(base_prog);
glGenTextures(1, &tex_checkerboard);
glBindTexture(GL_TEXTURE_2D, tex_checkerboard);
glTexStorage2D(GL_TEXTURE_2D, 4, GL_RGBA8, 8, 8);
// The following is an 8x8 checkerboard pattern using
// GL_RED, GL_UNSIGNED_BYTE data.
static const unsigned char tex_checkerboard_data[] =
{
0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF
};
glTexSubImage2D(GL_TEXTURE_2D,
0,
0, 0,
8, 8,
GL_RED, GL_UNSIGNED_BYTE,
tex_checkerboard_data);
static const GLint swizzles[] = { GL_RED, GL_RED, GL_RED, GL_ONE };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzles);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glGenerateMipmap(GL_TEXTURE_2D);
glGenTextures(1, &tex_color);
glBindTexture(GL_TEXTURE_2D, tex_color);
glTexStorage2D(GL_TEXTURE_2D, 2, GL_RGBA32F, 2, 2);
// The following data represents a 2x2 texture with red,
// green, blue, and yellow texels represented as GL_RGBA,
// GL_FLOAT data.
static const GLfloat tex_color_data[] =
{
// Red texel Green texel
1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f,
// Blue texel Yellow texel
0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f
};
glTexSubImage2D(GL_TEXTURE_2D, // target
0, // First mipmap level
0, 0, // x and y offset
2, 2, // width and height
GL_RGBA, GL_FLOAT, // format and type
tex_color_data); // data
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
//.........这里部分代码省略.........
示例4: init
// OpenGL initialization
void
init()
{
/**
*** Create and initialize buffer objects
**/
glGenBuffers( 4, buffers );
//Vertex buffer for the vertex coordinates
glBindBuffer( GL_ARRAY_BUFFER, buffers[cube_vertices] );
glBufferData( GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW );
glBindBuffer( GL_ARRAY_BUFFER, buffers[cube_vertices_explicit] );
glBufferData( GL_ARRAY_BUFFER, sizeof(cube_vertices_positions), cube_vertices_positions, GL_STATIC_DRAW );
std::cout<< "sizeof(cube_vertices_positions)" << sizeof(cube_vertices_positions) << std::endl;
//Elements buffer for the pointers
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, buffers[cube_indeces] );
glBufferData( GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
glGenVertexArrays(2, VAO);
// Load shaders and use the resulting shader programs
program[0] = InitShader( "./shaders/vshader30_TwoCubes_FullPipe.glsl", "./shaders/fshader30_TwoCubes.glsl" );
program[1] = InitShader( "./shaders/skyboxvertex.glsl", "./shaders/skyboxfragment.glsl" );
//VAO[1] the skybox
glUseProgram( program[1] );
glBindVertexArray(VAO[1]);
glBindBuffer( GL_ARRAY_BUFFER, buffers[cube_vertices_explicit] );
vPosition = glGetAttribLocation( program[1], "vPosition" );
glEnableVertexAttribArray( vPosition );
glVertexAttribPointer( vPosition, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0) );
//done with this packet
glBindVertexArray(0);
glUseProgram(0);
//VAO[0] the Cube
glUseProgram( program[0] );
glBindVertexArray(VAO[0]);
glBindBuffer( GL_ARRAY_BUFFER, buffers[cube_vertices] );
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[cube_indeces]);
vPosition = glGetAttribLocation( program[0], "vPosition" );
glEnableVertexAttribArray( vPosition );
glVertexAttribPointer( vPosition, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0) );
//done with this packet
glBindVertexArray(0);
glUseProgram(0);
//Skybox textures
//Load Skybox Images. 6 images to represent the 6 angles of view. Inside it's own structured Cubemap
skybox.top = glmReadPPM("skybox\\sky-top.ppm", &skybox.topWidth, &skybox.topHeight);
skybox.bottom = glmReadPPM("skybox\\sky-bottom.ppm", &skybox.bottomWidth, &skybox.bottomHeight);
skybox.right = glmReadPPM("skybox\\sky-right.ppm", &skybox.rightWidth, &skybox.rightHeight);
skybox.left = glmReadPPM("skybox\\sky-left.ppm", &skybox.leftWidth, &skybox.leftHeight);
skybox.front = glmReadPPM("skybox\\sky-front.ppm", &skybox.frontWidth, &skybox.frontHeight);
skybox.back = glmReadPPM("skybox\\sky-back.ppm", &skybox.backWidth, &skybox.backHeight);
glActiveTexture(GL_TEXTURE0);
glGenTextures(1, &texture);
int isEnabled=0;
if (glIsEnabled(GL_TEXTURE_CUBE_MAP) == GL_TRUE) {isEnabled = 1;} else {isEnabled = 0;};
std::cout << isEnabled << std::endl;
glEnable(GL_TEXTURE_CUBE_MAP);
if (glIsEnabled(GL_TEXTURE_CUBE_MAP) == GL_TRUE) {isEnabled = 1;} else {isEnabled = 0;};
std::cout << isEnabled << std::endl;
glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
//.........这里部分代码省略.........
示例5: initVertexArray
bool initVertexArray()
{
bool Validated(true);
glGenVertexArrays(1, &VertexArrayName);
glBindVertexArray(VertexArrayName);
glBindBuffer(GL_ARRAY_BUFFER, BufferName[buffer::VERTEX]);
glVertexAttribPointer(semantic::attr::POSITION, 2, GL_FLOAT, GL_FALSE, sizeof(glf::vertex_v2fv2f), BUFFER_OFFSET(0));
glVertexAttribPointer(semantic::attr::TEXCOORD, 2, GL_FLOAT, GL_FALSE, sizeof(glf::vertex_v2fv2f), BUFFER_OFFSET(sizeof(glm::vec2)));
glBindBuffer(GL_ARRAY_BUFFER, 0);
glEnableVertexAttribArray(semantic::attr::POSITION);
glEnableVertexAttribArray(semantic::attr::TEXCOORD);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, BufferName[buffer::ELEMENT]);
glBindVertexArray(0);
return Validated;
}示例6: TAssert
void CRenderingContext::SetBitangentsBuffer(size_t iOffset, size_t iStride)
{
if (m_pShader->m_iBitangentAttribute == ~0)
return;
TAssert(iOffset%4 == 0); // Should be multiples of four because it's offsets in bytes and we're always working with floats or doubles
glEnableVertexAttribArray(m_pShader->m_iBitangentAttribute);
glVertexAttribPointer(m_pShader->m_iBitangentAttribute, 3, GL_FLOAT, false, iStride, BUFFER_OFFSET(iOffset));
}示例7: cos
Sphere::Sphere(Scenegraph *graph,string name)
:Object(graph,name)
{
float theta,phi;
int STACKS=100;
int i,j;
int SLICES = 100;
float PI = 3.14159f;
float cosphi,sinphi,costheta,sintheta;
VertexAttribs v;
/*
*A sphere is drawn using vertices in polar coordinates. Polar coordinates are in terms of the radiu
*, latitude and longitude. STACKS controls how many latitudes, and SLICES controls how many longitudes
* are being used to draw this sphere.
*/
//prepare the vertex data
for (i=0;i<=STACKS;i++)
{
phi = -PI/2 + i*PI/STACKS;
cosphi = cos(phi);
sinphi = sin(phi);
for (j=0;j<=SLICES;j++)
{
theta = 2*j*PI/SLICES;
costheta = cos(theta);
sintheta = sin(theta);
v.position[0] = cosphi*costheta;
v.position[1] = sinphi;
v.position[2] = -cosphi*sintheta;
v.position[3] = 1;
v.normal[0] = cosphi*costheta;
v.normal[1] = sinphi;
v.normal[2] = -cosphi*sintheta;
v.normal[3] = 0;
v.texcoords[0] = theta/(2*PI);
v.texcoords[1] = (phi+0.5f*PI)/PI;
vertexData.push_back(v);
}
}
//now prepare the triangle index list
//this is simple enough. Just imagine drawing each quad in the sphere as two triangles
//triangle 1: (i,j), (i,j+1) and (i+1,j+1)
//triangle 2: (i,j), (i+1,j+1) and (i+1,j)
//It is a good habit to specify all triangles in counter-clockwise order as OpenGL uses by default the order
//to determine front-facing vs. back-facing if culling is enabled
for (i=0;i<STACKS;i++)
{
for (j=0;j<SLICES;j++)
{
triangleIndices.push_back(i*(SLICES+1)+j);
triangleIndices.push_back(i*(SLICES+1)+j+1);
triangleIndices.push_back((i+1)*(SLICES+1)+j+1);
triangleIndices.push_back(i*(SLICES+1)+j);
triangleIndices.push_back((i+1)*(SLICES+1)+j+1);
triangleIndices.push_back((i+1)*(SLICES+1)+j);
}
}
/*
*Bind the VAO as the current VAO, so that all subsequent commands affect it
*/
glBindVertexArray(VAO);
/*
*Allocate the VBO for vertex data and send it to the GPU
*/
glBindBuffer(GL_ARRAY_BUFFER,buffers[VertexBuffer]);
glBufferData(GL_ARRAY_BUFFER,sizeof(VertexAttribs)*vertexData.size(),&vertexData[0],GL_STATIC_DRAW);
/*
*Allocate the VBO for triangle indices and send it to GPU
*/
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[IndexBuffer]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint)*triangleIndices.size(), &triangleIndices[0], GL_STATIC_DRAW);
/*
*Specify all the vertex attribute pointers, i.e. tell OpenGL how to organize data according to attributes rather than vertices
*/
//first enable the correct VBO, since the "current" is the VBO for triangle indices
glBindBuffer(GL_ARRAY_BUFFER,buffers[VertexBuffer]);
//VertexData starts with position, so starting byte is 0
glVertexAttribPointer(vPosition,4,GL_FLOAT,GL_FALSE,sizeof(VertexAttribs),BUFFER_OFFSET(0));
//In VertexData, normal follows the position (4 floats), so start reading normals from 4*sizeof(float)
glVertexAttribPointer(vNormal,4,GL_FLOAT,GL_FALSE,sizeof(VertexAttribs),BUFFER_OFFSET(4*sizeof(float)));
//In VertexData, texture coordinates follow the position and normal (8 floats), so start reading texture coordinates from 8*sizeof(float)
glVertexAttribPointer(vTexCoord,2,GL_FLOAT,GL_FALSE,sizeof(VertexAttribs),BUFFER_OFFSET(8*sizeof(float)));
//.........这里部分代码省略.........
示例8: glGenTextures
bool ProxyTexture::Init(__in const char* vCmdLine[], __in const int iCmdCount,
__in const int iWidth, __in const int iHeight){
if(!NX::Application::Init(vCmdLine, iCmdCount, iWidth, iHeight)){
return false;
}
GLuint ProxyId;
glGenTextures(1, &ProxyId);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_PROXY_TEXTURE_2D, ProxyId);
glTexImage2D(GL_PROXY_TEXTURE_2D, 0, GL_RGBA, 1024, 1024, 0, GL_RGBA, GL_UNSIGNED_BYTE, BUFFER_OFFSET(0));
GLint maxTexWidth;
glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &maxTexWidth);
if(maxTexWidth){
NX::glb_GetLog().logToConsole("create succeed");
}else{
NX::glb_GetLog().logToConsole("create failed");
}
return true;
}示例9: init
// OpenGL initialization
void
init()
{
// Subdivide a tetrahedron into a sphere
tetrahedron( NumTimesToSubdivide );
// Create a vertex array object
GLuint vao;
glGenVertexArrays( 1, &vao );
glBindVertexArray( vao );
// Create and initialize a buffer object
GLuint buffer;
glGenBuffers( 1, &buffer );
glBindBuffer( GL_ARRAY_BUFFER, buffer );
glBufferData( GL_ARRAY_BUFFER, sizeof(points) + sizeof(normals),
NULL, GL_STATIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, sizeof(points), points );
glBufferSubData( GL_ARRAY_BUFFER, sizeof(points),
sizeof(normals), normals );
// Load shaders and use the resulting shader program
GLuint program = InitShader( "vshader_a7.glsl", "fshader_a7.glsl" );
glUseProgram( program );
// set up vertex arrays
GLuint vPosition = glGetAttribLocation( program, "vPosition" );
glEnableVertexAttribArray( vPosition );
glVertexAttribPointer( vPosition, 4, GL_FLOAT, GL_FALSE, 0,
BUFFER_OFFSET(0) );
GLuint vNormal = glGetAttribLocation( program, "vNormal" );
glEnableVertexAttribArray( vNormal );
glVertexAttribPointer( vNormal, 3, GL_FLOAT, GL_FALSE, 0,
BUFFER_OFFSET(sizeof(points)) );
// Initialize shader lighting parameters
point4 light_position( 0.0, 0.0, 2.0, 0.0 );
color4 light_ambient( 0.2, 0.2, 0.2, 1.0 );
color4 light_diffuse( 1.0, 1.0, 1.0, 1.0 );
color4 light_specular( 1.0, 1.0, 1.0, 1.0 );
color4 material_ambient( 1.0, 0.0, 1.0, 1.0 );
color4 material_diffuse( 1.0, 0.8, 0.0, 1.0 );
color4 material_specular( 1.0, 0.0, 1.0, 1.0 );
float material_shininess = 5.0;
color4 ambient_product = light_ambient * material_ambient;
color4 diffuse_product = light_diffuse * material_diffuse;
color4 specular_product = light_specular * material_specular;
glUniform4fv( glGetUniformLocation(program, "AmbientProduct"),
1, ambient_product );
glUniform4fv( glGetUniformLocation(program, "DiffuseProduct"),
1, diffuse_product );
glUniform4fv( glGetUniformLocation(program, "SpecularProduct"),
1, specular_product );
glUniform4fv( glGetUniformLocation(program, "LightPosition"),
1, light_position );
glUniform1f( glGetUniformLocation(program, "Shininess"),
material_shininess );
// Retrieve transformation uniform variable locations
ModelView = glGetUniformLocation( program, "ModelView" );
Projection = glGetUniformLocation( program, "Projection" );
glEnable( GL_DEPTH_TEST );
glClearColor( 1.0, 1.0, 1.0, 1.0 ); /* white background */
}示例10: BUFFER_OFFSET
VertexFormatToAttrOffsetsMap Mesh::createVertexFormatToAttrOffsetsMap() {
VertexFormatToAttrOffsetsMap formatToOffsetMap;
byte* start;
VertexPos vtPos;
start = (byte*)&vtPos;
AttrToOffsetMap mapPos;
mapPos[kPosIndex] = BUFFER_OFFSET((byte*)&(vtPos.position) - start);
formatToOffsetMap[VT_Pos] = mapPos;
VertexPosUV vtPosUV;
start = (byte*)&vtPosUV;
AttrToOffsetMap mapPosUV;
mapPosUV[kPosIndex] = BUFFER_OFFSET((byte*)&(vtPosUV.position) - start);
mapPosUV[kTexCoordIndex] = BUFFER_OFFSET((byte*)&(vtPosUV.texcoord) - start);
formatToOffsetMap[VT_PosUV] = mapPosUV;
VertexPosColor vtPosColor;
start = (byte*)&vtPosColor;
AttrToOffsetMap mapPosColor;
mapPosColor[kPosIndex] = BUFFER_OFFSET((byte*)&(vtPosColor.position) - start);
mapPosColor[kColorIndex] = BUFFER_OFFSET((byte*)&(vtPosColor.color) - start);
formatToOffsetMap[VT_PosColor] = mapPosColor;
VertexPosUVColor vtPosUVColor;
start = (byte*)&vtPosUVColor;
AttrToOffsetMap mapPosUVColor;
mapPosUVColor[kPosIndex] = BUFFER_OFFSET((byte*)&(vtPosUVColor.position) - start);
mapPosUVColor[kTexCoordIndex] = BUFFER_OFFSET((byte*)&(vtPosUVColor.texcoord) - start);
mapPosUVColor[kColorIndex] = BUFFER_OFFSET((byte*)&(vtPosUVColor.color) - start);
formatToOffsetMap[VT_PosUVColor] = mapPosUVColor;
VertexSkinned vtSkinned;
start = (byte*)&vtSkinned;
AttrToOffsetMap mapSkinned;
mapSkinned[kPosIndex] = BUFFER_OFFSET((byte*)&(vtSkinned.position) - start);
mapSkinned[kTexCoordIndex] = BUFFER_OFFSET((byte*)&(vtSkinned.texcoord) - start);
mapSkinned[kColorIndex] = BUFFER_OFFSET((byte*)&(vtSkinned.color) - start);
mapSkinned[kBlendIndicesIndex] = BUFFER_OFFSET((byte*)&(vtSkinned.blendindices) - start);
mapSkinned[kBlendWeightsIndex] = BUFFER_OFFSET((byte*)&(vtSkinned.blendweights) - start);
formatToOffsetMap[VT_Skinned] = mapSkinned;
return formatToOffsetMap;
}示例11: sizeof
void Grid::uploadGeometry()
{
const int ColorOffset = 0;
const int PositionOffset = sizeof( Color4 );
const int TexCoordOffset = sizeof( Color4 ) + sizeof( Point );
const unsigned int POSITION_INDEX = 0;
const unsigned int COLOR0_INDEX = 3;
const unsigned int TEXCOORD_INDEX = 8;
/// Generate and bind vertex array object for the grid
glGenVertexArrays(1, g_vao);
(Logger::Instance()).checkAndReportGLError("Failed to generate Vertex Arrays",'e',4,__LINE__,__FILE__);
glBindVertexArray( g_vao[0] );
(Logger::Instance()).checkAndReportGLError("Failed to bind Vertex Arrays",'e',4,__LINE__,__FILE__);
/// Generate buffer objects for vertices and indices
glGenTextures(1, texName);
(Logger::Instance()).checkAndReportGLError(" failed to gen textures",'e',4,__LINE__,__FILE__);
glBindTexture(GL_TEXTURE_2D, texName[0]);
(Logger::Instance()).checkAndReportGLError(" fail 2d ",'e',4,__LINE__,__FILE__);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
(Logger::Instance()).checkAndReportGLError(" fail wrap s",'e',4,__LINE__,__FILE__);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
(Logger::Instance()).checkAndReportGLError(" fail wrap t",'e',4,__LINE__,__FILE__);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
if(tgaObj.pixelSizeInBytes == 3)
{
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, tgaObj.width,
tgaObj.height, 0, GL_BGR, GL_UNSIGNED_BYTE,
tgaObj.data);
(Logger::Instance()).checkAndReportGLError(" fail image 2d ",'e',4,__LINE__,__FILE__);
}
else
{
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tgaObj.width,
tgaObj.height, 0, GL_BGRA, GL_UNSIGNED_BYTE,
tgaObj.data);
(Logger::Instance()).checkAndReportGLError(" fail image 2d ",'e',4,__LINE__,__FILE__);
}
glGenBuffers( NUM_BUFFERS, vbo );
(Logger::Instance()).checkAndReportGLError("Failed to generate Buffer objects",'e',4,__LINE__,__FILE__);
/// Bind vertex buffer object
glBindBuffer( GL_ARRAY_BUFFER, vbo[VBO] );
(Logger::Instance()).checkAndReportGLError("Failed to bind Vertex Buffer object",'e',4,__LINE__,__FILE__);
glBufferData(
GL_ARRAY_BUFFER,
sizeof(Vertex) * totVertices,
reinterpret_cast<const GLvoid*>( g_VertexArray ),
GL_STATIC_DRAW );
(Logger::Instance()).checkAndReportGLError("Failed to provide Vertex Buffer data",'e',4,__LINE__,__FILE__);
glVertexAttribPointer(
POSITION_INDEX,
3,
GL_FLOAT,
GL_FALSE,
sizeof( Vertex ),
BUFFER_OFFSET( PositionOffset ) );
(Logger::Instance()).checkAndReportGLError("Failed to run glVertexAttribPointer for vertex position",'e',4,__LINE__,__FILE__);
glEnableVertexAttribArray( POSITION_INDEX );
(Logger::Instance()).checkAndReportGLError("Failed to enable VertexAttribArray for vertex position",'e',4,__LINE__,__FILE__);
glVertexAttribPointer(
COLOR0_INDEX,
4,
GL_UNSIGNED_BYTE,
GL_TRUE,
sizeof( Vertex ),
BUFFER_OFFSET( ColorOffset ) );
(Logger::Instance()).checkAndReportGLError("Failed to run glVertexAttribPointer for color",'e',4,__LINE__,__FILE__);
glEnableVertexAttribArray( COLOR0_INDEX );
(Logger::Instance()).checkAndReportGLError("Failed to enable VertexAttribArray for color",'e',4,__LINE__,__FILE__);
glVertexAttribPointer(
TEXCOORD_INDEX,
2,
GL_FLOAT,
GL_FALSE,
sizeof( Vertex ),
BUFFER_OFFSET( TexCoordOffset ) );
(Logger::Instance()).checkAndReportGLError("Failed to run glVertexAttribPointer for TexCoord",'e',4,__LINE__,__FILE__);
glEnableVertexAttribArray( TEXCOORD_INDEX );
(Logger::Instance()).checkAndReportGLError("Failed to enable VertexAttribArray for TexCoord",'e',4,__LINE__,__FILE__);
/// Bind Index buffer object
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, vbo[IBO] );
(Logger::Instance()).checkAndReportGLError("Failed to bind Index Buffer object",'e',4,__LINE__,__FILE__);
glBufferData(
GL_ELEMENT_ARRAY_BUFFER,
sizeof(GLushort) * NUMBER_OF_INDICES,
reinterpret_cast<const GLvoid*>( g_indices ),
GL_STATIC_DRAW );
(Logger::Instance()).checkAndReportGLError("Failed to provide buffer data for indices",'e',4,__LINE__,__FILE__);
}示例12: switch
//.........这里部分代码省略.........
glBindVertexArray( m_VertexArrayObject );
glBindBuffer( GL_ARRAY_BUFFER, m_VertexBufferObject );
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, m_IndexBufferObject );
KIL_MEMSIZE Offset = 0;
KIL_SINT32 PositionOffset = -1;
KIL_SINT32 NormalsOffset = -1;
for( KIL_MEMSIZE Index = 0;
Index < p_VertexAttributes.GetVertexAttributeCount( ); ++Index )
{
KIL_MEMSIZE Dimension = 0;
KIL_MEMSIZE TypeSize = 0;
GLenum Type = GL_INVALID_ENUM;
struct VERTEXATTRIBUTE Attribute =
p_VertexAttributes.GetAttributeAt( Index );
Type = ConvertVertexAttributeToGLenum( Attribute );
TypeSize = ConvertVertexAttributeToSize( Attribute );
Dimension = ConvertVertexAttributeToElementCount( Attribute );
if( Attribute.Intent == VERTEXATTRIBUTE_INTENT_POSITION )
{
PositionOffset = Offset;
}
if( Attribute.Intent == VERTEXATTRIBUTE_INTENT_NORMAL )
{
NormalsOffset = Offset;
}
glVertexAttribPointer( Index, Dimension, Type, GL_FALSE,
m_Stride, BUFFER_OFFSET( Offset ) );
Offset += TypeSize;
glEnableVertexAttribArray( Index );
}
glBufferData( GL_ARRAY_BUFFER, p_VertexCount * m_Stride,
p_pVertices, GL_STATIC_DRAW );
GLenum Error = glGetError( );
if( Error == GL_OUT_OF_MEMORY )
{
this->Destroy( );
return KIL_FAIL;
}
glBufferData( GL_ELEMENT_ARRAY_BUFFER,
p_IndexCount * sizeof( KIL_UINT16 ), p_pIndices, GL_STATIC_DRAW );
Error = glGetError( );
if( Error == GL_OUT_OF_MEMORY )
{
this->Destroy( );
return KIL_FAIL;
}
m_VertexCount = p_VertexCount;
m_IndexCount = p_IndexCount;示例13: printf
//////////////////////////////////////////////////////////////////////
// readback
//
// Code to handle reading back of the FBO data (but with a specified FBO pointer)
//
//////////////////////////////////////////////////////////////////////
bool CheckBackBuffer::readback( GLuint width, GLuint height, GLuint bufObject )
{
bool ret = false;
if (m_bUseFBO) {
if (m_bUsePBO)
{
printf("CheckBackBuffer::readback() FBO->PBO->m_pImageData\n");
// binds the PBO for readback
bindReadback();
// bind FBO buffer (we want to transfer FBO -> PBO)
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, bufObject );
// Now initiate the readback to PBO
glReadPixels(0, 0, width, height, getPixelFormat(), GL_UNSIGNED_BYTE, BUFFER_OFFSET(0));
ret = checkStatus(__FILE__, __LINE__, true);
if (!ret) printf("CheckBackBuffer::readback() FBO->PBO checkStatus = %d\n", ret);
// map - unmap simulates readback without the copy
void *ioMem = glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY_ARB);
memcpy(m_pImageData, ioMem, width*height*m_Bpp);
glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
// release the FBO
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
// release the PBO
unbindReadback();
} else {
printf("CheckBackBuffer::readback() FBO->m_pImageData\n");
// Reading direct to FBO using glReadPixels
glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, bufObject );
ret = checkStatus(__FILE__, __LINE__, true);
if (!ret) printf("CheckBackBuffer::readback::glBindFramebufferEXT() fbo=%d checkStatus = %d\n", bufObject, ret);
glReadBuffer(static_cast<GLenum>(GL_COLOR_ATTACHMENT0_EXT));
ret &= checkStatus(__FILE__, __LINE__, true);
if (!ret) printf("CheckBackBuffer::readback::glReadBuffer() fbo=%d checkStatus = %d\n", bufObject, ret);
glReadPixels(0, 0, width, height, getPixelFormat(), GL_UNSIGNED_BYTE, m_pImageData);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
}
} else {
printf("CheckBackBuffer::readback() PBO->m_pImageData\n");
// read from bufObject (PBO) to system memorys image
glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, bufObject); // Bind the PBO
// map - unmap simulates readback without the copy
void *ioMem = glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY_ARB);
// allocate a buffer so we can flip the image
unsigned char * temp_buf = (unsigned char *)malloc(width*height*m_Bpp);
memcpy( temp_buf, ioMem, width*height*m_Bpp );
// let's flip the image as we copy
for (unsigned int y = 0; y < height; y++) {
memcpy( (void *)&(m_pImageData[(height-y)*width*m_Bpp]), (void *)&(temp_buf[y*width*m_Bpp]), width*m_Bpp);
}
free(temp_buf);
glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
// read from bufObject (PBO) to system memory image
glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0); // unBind the PBO
}
return CHECK_FBO;
}示例14: get_image
static int get_image( mlt_frame a_frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
int error = 0;
// Get the b frame from the stack
mlt_frame b_frame = (mlt_frame) mlt_frame_pop_frame( a_frame );
// Get the transition object
mlt_transition transition = (mlt_transition) mlt_frame_pop_service( a_frame );
// Get the properties of the transition
mlt_properties properties = MLT_TRANSITION_PROPERTIES( transition );
// Get the properties of the a frame
mlt_properties a_props = MLT_FRAME_PROPERTIES( a_frame );
// Get the movit objects
mlt_service service = MLT_TRANSITION_SERVICE( transition );
mlt_service_lock( service );
EffectChain* chain = GlslManager::get_chain( service );
MltInput* a_input = GlslManager::get_input( service );
MltInput* b_input = (MltInput*) mlt_properties_get_data( properties, "movit input B", NULL );
mlt_image_format output_format = *format;
if ( !chain || !a_input ) {
mlt_service_unlock( service );
return 2;
}
// Get the frames' textures
GLuint* texture_id[2] = {0, 0};
*format = mlt_image_glsl_texture;
mlt_frame_get_image( a_frame, (uint8_t**) &texture_id[0], format, width, height, 0 );
a_input->useFBOInput( chain, *texture_id[0] );
*format = mlt_image_glsl_texture;
mlt_frame_get_image( b_frame, (uint8_t**) &texture_id[1], format, width, height, 0 );
b_input->useFBOInput( chain, *texture_id[1] );
// Set resolution to that of the a_frame
*width = mlt_properties_get_int( a_props, "width" );
*height = mlt_properties_get_int( a_props, "height" );
// Setup rendering to an FBO
GlslManager* glsl = GlslManager::get_instance();
glsl_fbo fbo = glsl->get_fbo( *width, *height );
if ( output_format == mlt_image_glsl_texture ) {
glsl_texture texture = glsl->get_texture( *width, *height, GL_RGBA );
glBindFramebuffer( GL_FRAMEBUFFER, fbo->fbo );
check_error();
glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture->texture, 0 );
check_error();
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
check_error();
GlslManager::render( service, chain, fbo->fbo, *width, *height );
glFinish();
check_error();
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
check_error();
*image = (uint8_t*) &texture->texture;
mlt_frame_set_image( a_frame, *image, 0, NULL );
mlt_properties_set_data( properties, "movit.convert", texture, 0,
(mlt_destructor) GlslManager::release_texture, NULL );
*format = output_format;
}
else {
// Use a PBO to hold the data we read back with glReadPixels()
// (Intel/DRI goes into a slow path if we don't read to PBO)
GLenum gl_format = ( output_format == mlt_image_rgb24a || output_format == mlt_image_opengl )?
GL_RGBA : GL_RGB;
int img_size = *width * *height * ( gl_format == GL_RGB? 3 : 4 );
glsl_pbo pbo = glsl->get_pbo( img_size );
glsl_texture texture = glsl->get_texture( *width, *height, gl_format );
if ( fbo && pbo && texture ) {
// Set the FBO
glBindFramebuffer( GL_FRAMEBUFFER, fbo->fbo );
check_error();
glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture->texture, 0 );
check_error();
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
check_error();
GlslManager::render( service, chain, fbo->fbo, *width, *height );
// Read FBO into PBO
glBindBuffer( GL_PIXEL_PACK_BUFFER_ARB, pbo->pbo );
check_error();
glBufferData( GL_PIXEL_PACK_BUFFER_ARB, img_size, NULL, GL_STREAM_READ );
check_error();
glReadPixels( 0, 0, *width, *height, gl_format, GL_UNSIGNED_BYTE, BUFFER_OFFSET(0) );
check_error();
// Copy from PBO
uint8_t* buf = (uint8_t*) glMapBuffer( GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY );
check_error();
//.........这里部分代码省略.........
示例15: memset
//.......................................................................................
void Font::RenderString_ss(float _x, float _y, char *_str, ...)
{
// extract arguments
char buffer[1024];
memset(buffer, 0, 1024);
va_list arglist;
if (!_str)
return;
va_start(arglist, _str);
vsprintf(buffer, _str, arglist);
va_end(arglist);
const uint8_t *p;
float x = -1 + _x * m_sx;
float y = 1 - _y * m_sy;
// Bind texture
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, m_atlasTextureID);
glUniform1i(m_uniformTex, 0);
// Select the font VBO
glBindVertexArray(m_fontVAO);
glEnableVertexAttribArray(m_attributeCoord);
glBindBuffer(GL_ARRAY_BUFFER, m_fontVBO);
glVertexAttribPointer(m_attributeCoord, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
int c = 0;
//memset(m_sTexCoords, 0, sizeof(font_point) * 256);
m_sTexCoords = new font_point[6 * strlen(buffer)];
// Loop through all characters
for (p = (const uint8_t *)buffer; *p; p++)
{
// calculate vertex and texture coordinates
float x2 = x + m_sChars[*p].bl * m_sx;
float y2 = -y - m_sChars[*p].bt * m_sy;
float w = m_sChars[*p].bw * m_sx;
float h = m_sChars[*p].bh * m_sy;
// advance cursor
x += m_sChars[*p].ax * m_sx;
y += m_sChars[*p].ay * m_sy;
// skip empty chars
if (!w || !h)
continue;
m_sTexCoords[c+0].x = x2 + w;
m_sTexCoords[c+0].y = -y2;
m_sTexCoords[c+0].s = m_sChars[*p].tx + m_sChars[*p].bw / m_iTextureWidth;
m_sTexCoords[c+0].t = m_sChars[*p].ty;
m_sTexCoords[c+1].x = x2;
m_sTexCoords[c+1].y = -y2;
m_sTexCoords[c+1].s = m_sChars[*p].tx;
m_sTexCoords[c+1].t = m_sChars[*p].ty;
m_sTexCoords[c+2].x = x2;
m_sTexCoords[c+2].y = -y2 - h;
m_sTexCoords[c+2].s = m_sChars[*p].tx;
m_sTexCoords[c+2].t = m_sChars[*p].ty + m_sChars[*p].bh / m_iTextureHeight;
m_sTexCoords[c+3].x = x2 + w;
m_sTexCoords[c+3].y = -y2;
m_sTexCoords[c+3].s = m_sChars[*p].tx + m_sChars[*p].bw / m_iTextureWidth;
m_sTexCoords[c+3].t = m_sChars[*p].ty;
m_sTexCoords[c+4].x = x2;
m_sTexCoords[c+4].y = -y2 - h;
m_sTexCoords[c+4].s = m_sChars[*p].tx;
m_sTexCoords[c+4].t = m_sChars[*p].ty + m_sChars[*p].bh / m_iTextureHeight;
m_sTexCoords[c+5].x = x2 + w;
m_sTexCoords[c+5].y = -y2 - h;
m_sTexCoords[c+5].s = m_sChars[*p].tx + m_sChars[*p].bw / m_iTextureWidth;
m_sTexCoords[c+5].t = m_sChars[*p].ty + m_sChars[*p].bh / m_iTextureHeight;
c += 6;
}
glBufferData(GL_ARRAY_BUFFER, sizeof(font_point) * c, m_sTexCoords, GL_DYNAMIC_DRAW);
glDrawArrays(GL_TRIANGLES, 0, c);
glDisableVertexAttribArray(m_attributeCoord);
glBindVertexArray(0);
// free memory
delete [] m_sTexCoords;
} // Font::RenderString_ss()