void VertexFormatBinder::Activate(NvSharedVBOGL* pInstanceDataStream) { // Activate the instancing data by binding the instance data stream and setting // up all of the offsets into each of the attributes intptr_t pBufferStart = pInstanceDataStream->GetDynamicOffset(); glBindBuffer(GL_ARRAY_BUFFER, pInstanceDataStream->GetBuffer()); AttribSet::iterator attribIt = m_instanceAttributes.begin(); AttribSet::const_iterator attribEnd = m_instanceAttributes.end(); for (; attribIt != attribEnd; ++attribIt) { const InstanceAttribDesc& desc = attribIt->second; glEnableVertexAttribArray(desc.m_attribIndex); // We have to use an appropriate version of the glVertexAttribPointer family of methods // depending on the type of data and how it will be used in the shader switch (desc.m_usage) { case GL_FLOAT: glVertexAttribPointer(desc.m_attribIndex, desc.m_size, desc.m_type, desc.m_normalized, m_stride, (GLvoid*)(pBufferStart + desc.m_offset)); break; case GL_INT: glVertexAttribIPointer(desc.m_attribIndex, desc.m_size, desc.m_type, m_stride, (GLvoid*)(pBufferStart + desc.m_offset)); break; case GL_DOUBLE: glVertexAttribLPointer(desc.m_attribIndex, desc.m_size, desc.m_type, m_stride, (GLvoid*)(pBufferStart + desc.m_offset)); break; } glVertexAttribDivisor(desc.m_attribIndex, desc.m_divisor); } }
bool initVertexArray() { glGenVertexArrays(1, &VertexArrayName); glBindVertexArray(VertexArrayName); glBindBuffer(GL_ARRAY_BUFFER, BufferName[buffer::VERTEX]); glVertexAttribPointer(semantic::attr::POSITION + 0, 2, GL_FLOAT, GL_FALSE, sizeof(glf::vertex_v2fc4d), BUFFER_OFFSET(0)); glVertexAttribPointer(semantic::attr::POSITION + 1, 2, GL_FLOAT, GL_FALSE, sizeof(glf::vertex_v2fc4d), BUFFER_OFFSET(0)); glVertexAttribLPointer(semantic::attr::COLOR, 4, GL_DOUBLE, sizeof(glf::vertex_v2fc4d), BUFFER_OFFSET(sizeof(glm::vec2))); //glVertexAttribLPointer(semantic::attr::COLOR, 4, GL_DOUBLE, sizeof(glf::vertex_v2fc4d), BUFFER_OFFSET(sizeof(glm::vec2))); glBindBuffer(GL_ARRAY_BUFFER, 0); glEnableVertexAttribArray(semantic::attr::POSITION + 0); glEnableVertexAttribArray(semantic::attr::POSITION + 1); glEnableVertexAttribArray(semantic::attr::COLOR); glBindVertexArray(0); /* std::vector<glf::vertexattrib> Valid(16); Valid[semantic::attr::POSITION + 0] = glf::vertexattrib(GL_TRUE, 2, sizeof(glf::vertex_v2fc4d), GL_FLOAT, GL_FALSE, GL_FALSE, GL_FALSE, 0, NULL); Valid[semantic::attr::POSITION + 1] = glf::vertexattrib(GL_TRUE, 2, sizeof(glf::vertex_v2fc4d), GL_FLOAT, GL_FALSE, GL_FALSE, GL_FALSE, 0, NULL); Valid[semantic::attr::COLOR] = glf::vertexattrib(GL_TRUE, 4, sizeof(glf::vertex_v2fc4d), GL_DOUBLE, GL_FALSE, GL_FALSE, GL_FALSE, 0, BUFFER_OFFSET(sizeof(glm::vec2))); // TODO //glf::validateVAO(VertexArrayName, Valid); */ return true; }
//! glVertexAttribLPointer wrapper. May throw. inline void vertexAttribLPointer(GLuint const index, GLint const size, GLenum const type, GLsizei const stride, GLvoid const* pointer) { glVertexAttribLPointer(index, size, type, stride, pointer); checkError("glVertexAttribLPointer"); }
void VertexAttribLPointer( const GLuint Index, const GLint Size, const EType::Value Type, const GLsizei Stride, const GLvoid* const Pointer) { glVertexAttribLPointer(Index, Size, Type, Stride, Pointer); }
inline void VL_glVertexAttribLPointer(GLuint name, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) { if(glVertexAttribLPointer) glVertexAttribLPointer(name, size, type, stride, pointer); else if(glVertexAttribLPointerEXT) glVertexAttribLPointerEXT(name, size, type, stride, pointer); else VL_UNSUPPORTED_FUNC(); }
void rglVertexAttribLPointer( GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) { #if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) glVertexAttribLPointer(index, size, type, stride, pointer); #endif }
bool initVertexArray() { glGenVertexArrays(1, &VertexArrayName); glBindVertexArray(VertexArrayName); glBindBuffer(GL_ARRAY_BUFFER, BufferName[buffer::F64]); glVertexAttribLPointer(semantic::attr::POSITION, 3, GL_DOUBLE, sizeof(glm::dvec3), BUFFER_OFFSET(0)); glBindBuffer(GL_ARRAY_BUFFER, 0); glEnableVertexAttribArray(semantic::attr::POSITION); glBindVertexArray(0); return this->checkError("initVertexArray"); }
void VertexAttributeBindingImplementation_Legacy::finish(const VertexAttributeBinding * binding) const { assert(bindingData(binding) != nullptr); vao(binding)->bind(); void * offset = nullptr; if (vbo(binding)) { vbo(binding)->bind(GL_ARRAY_BUFFER); const auto offset64 = static_cast<GLuint64>(bindingData(binding)->baseoffset + bindingData(binding)->format.relativeoffset); offset = reinterpret_cast<void *>(offset64); } else { Buffer::unbind(GL_ARRAY_BUFFER); } const GLint attribute = attributeIndex(binding); switch (bindingData(binding)->format.method) { case Format::Method::I: glVertexAttribIPointer(attribute, bindingData(binding)->format.size, bindingData(binding)->format.type , bindingData(binding)->stride, offset); break; case Format::Method::L: glVertexAttribLPointer(attribute, bindingData(binding)->format.size, bindingData(binding)->format.type , bindingData(binding)->stride, offset); break; default: glVertexAttribPointer(attribute, bindingData(binding)->format.size, bindingData(binding)->format.type , bindingData(binding)->format.normalized, bindingData(binding)->stride, offset); } }
// Not supported in ES void AddVertexLPointer(GLint index, GLint count, GLenum type, GLint stride, void * offset) { GL_CHECK(glEnableVertexAttribArray(index)); GL_CHECK(glVertexAttribLPointer(index, count, type, stride, offset)); }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL41_nglVertexAttribLPointerBO(JNIEnv *env, jclass clazz, jint index, jint size, jint type, jint stride, jlong pointer_buffer_offset, jlong function_pointer) { const GLvoid *pointer_address = (const GLvoid *)(intptr_t)offsetToPointer(pointer_buffer_offset); glVertexAttribLPointerPROC glVertexAttribLPointer = (glVertexAttribLPointerPROC)((intptr_t)function_pointer); glVertexAttribLPointer(index, size, type, stride, pointer_address); }
static bool test_vertex_attribs() { bool pass = true; GLuint data = 0; /* "The error INVALID_OPERATION is generated by ... , or VertexAttribPointer * if <type> is UNSIGNED_INT_10F_11F_11F_REV and <size> is not 3. */ glVertexAttribPointer(0, 3, GL_UNSIGNED_INT_10F_11F_11F_REV, GL_FALSE, 0, (GLvoid *)0); TEST("VertexAttribPointer-ok", GL_NO_ERROR); glVertexAttribPointer(0, 2, GL_UNSIGNED_INT_10F_11F_11F_REV, GL_FALSE, 0, (GLvoid *)0); TEST("VertexAttribPointer-badsize", GL_INVALID_OPERATION); glVertexAttribPointer(0, GL_BGRA, GL_UNSIGNED_INT_10F_11F_11F_REV, GL_FALSE, 0, (GLvoid *)0); TEST("VertexAttribPointer-badsize-bgra", GL_INVALID_OPERATION); /* The error INVALID_ENUM is generated by .., VertexAttribIPointer, * VertexAttribLPointer, ... if <type> is UNSIGNED_INT_10F_11F_11F_REV. */ if (piglit_get_gl_version() >= 30) { glVertexAttribIPointer(0, 3, GL_UNSIGNED_INT_10F_11F_11F_REV, 0, (GLvoid *)0); TEST("VertexAttribIPointer-not-allowed", GL_INVALID_ENUM); } if (piglit_is_extension_supported("GL_ARB_vertex_attrib_64bit")) { glVertexAttribLPointer(0, 3, GL_UNSIGNED_INT_10F_11F_11F_REV, 0, (GLvoid *)0); TEST("VertexAttribLPointer-not-allowed", GL_INVALID_ENUM); } /* The error INVALID_ENUM is generated by ... VertexAttribP4ui, VertexAttribP4uiv * if <type> is UNSIGNED_INT_10F_11F_11F_REV */ glVertexAttribP4ui(0, GL_UNSIGNED_INT_10F_11F_11F_REV, GL_FALSE, 0); TEST("VertexAttribP4ui-not-allowed", GL_INVALID_ENUM); glVertexAttribP4uiv(0, GL_UNSIGNED_INT_10F_11F_11F_REV, GL_FALSE, &data); TEST("VertexAttribP4uiv-not-allowed", GL_INVALID_ENUM); glVertexAttribP1ui(0, GL_UNSIGNED_INT_10F_11F_11F_REV, GL_FALSE, 0); TEST("VertexAttribP1ui-ok", GL_NO_ERROR); glVertexAttribP1uiv(0, GL_UNSIGNED_INT_10F_11F_11F_REV, GL_FALSE, &data); TEST("VertexAttribP1uiv-ok", GL_NO_ERROR); glVertexAttribP2ui(0, GL_UNSIGNED_INT_10F_11F_11F_REV, GL_FALSE, 0); TEST("VertexAttribP2ui-ok", GL_NO_ERROR); glVertexAttribP2uiv(0, GL_UNSIGNED_INT_10F_11F_11F_REV, GL_FALSE, &data); TEST("VertexAttribP2uiv-ok", GL_NO_ERROR); glVertexAttribP3ui(0, GL_UNSIGNED_INT_10F_11F_11F_REV, GL_FALSE, 0); TEST("VertexAttribP3ui-ok", GL_NO_ERROR); glVertexAttribP3uiv(0, GL_UNSIGNED_INT_10F_11F_11F_REV, GL_FALSE, &data); TEST("VertexAttribP3uiv-ok", GL_NO_ERROR); /* Test that normalized = GL_TRUE doesn't spuriously produce an error */ glVertexAttribP3uiv(0, GL_UNSIGNED_INT_10F_11F_11F_REV, GL_TRUE, &data); TEST("VertexAttribP3uiv-normalized-ok", GL_NO_ERROR); return pass; }
void GLState::glsVertexAttribLPointer(const GLuint index, const GLint size, const GLenum type, const GLsizei stride, const GLvoid* pointer) { glVertexAttribLPointer(index, size, type, stride, pointer); ERROR_CHECK; }
void Mesh::vertexAttribPointer(const LongAttribute& attribute) { glEnableVertexAttribArray(attribute.location); attribute.buffer->bind(Buffer::Target::Array); glVertexAttribLPointer(attribute.location, attribute.size, attribute.type, attribute.stride, reinterpret_cast<const GLvoid*>(attribute.offset)); }
void AttributeLPointer(VertexAttribute attrib, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer){ glVertexAttribLPointer(attrib,size,type,stride,pointer); }
void GeometryBatch::setVertices(const std::shared_ptr<Buffer>& vbo, size_t count, const std::vector<VertexElement>& layout) { m_vbo = vbo; m_vertexCount = count; m_vao.bind(); size_t computedStride = computeStride(layout); size_t previousOffset = 0; vbo->bind(GL_ARRAY_BUFFER); for (size_t i = 0; i < layout.size(); ++i) { auto element = layout[i]; size_t offset = element.offset; // if offset is 0 then compute it if (i != 0 && offset == 0) offset = previousOffset + layout[i - 1].numComponents * elementTypeSize(layout[i - 1].type); previousOffset = offset; size_t stride = element.stride; if (stride == 0) stride = computedStride; glEnableVertexAttribArray(i); switch (element.type) { case VertexElementType::Float: glVertexAttribPointer(i, element.numComponents, GL_FLOAT, GL_FALSE, stride, reinterpret_cast<const void*>(offset)); break; case VertexElementType::Double: glVertexAttribLPointer(i, element.numComponents, GL_DOUBLE, stride, reinterpret_cast<const void*>(offset)); case VertexElementType::Byte: glVertexAttribIPointer(i, element.numComponents, GL_BYTE, stride, reinterpret_cast<const void*>(offset)); break; case VertexElementType::UnsignedByte: glVertexAttribIPointer(i, element.numComponents, GL_UNSIGNED_BYTE, stride, reinterpret_cast<const void*>(offset)); break; case VertexElementType::Short: glVertexAttribIPointer(i, element.numComponents, GL_SHORT, stride, reinterpret_cast<const void*>(offset)); break; case VertexElementType::UnsignedShort: glVertexAttribIPointer(i, element.numComponents, GL_UNSIGNED_SHORT, stride, reinterpret_cast<const void*>(offset)); break; case VertexElementType::Int: glVertexAttribIPointer(i, element.numComponents, GL_INT, stride, reinterpret_cast<const void*>(offset)); break; case VertexElementType::UsignedInt: glVertexAttribIPointer(i, element.numComponents, GL_UNSIGNED_INT, stride, reinterpret_cast<const void*>(offset)); break; } } }