opengl-4

I've been working on a game engine and recently got to the point where I could easily create a Camera class to manage a view matrix (or allow an easy switch to another). I know conceptually what it must do, but where I'm having trouble is figuring out how to rotate about the local origin (for the view matrix, it would be the same as the translation matrix that is multiplied into a rotation matrix). I know that in direct mode, you would glTranslatef(x, y, z); //move back to origin glRotatef(angle, x_rot, y_rot, z_rot); //turn using a quaternion glTranslatef(-x, -y, -z); //move back to original

Question OpenGL 4.4, C++11 Do I have the power to use indices in an element_array_buffer from 0 for each attribute, by setting vertex attributes to both the element_array_buffer, and array_buffer? Data Layout VAO Buffer(array_buffer) PositionFloat * n TextureFloat * n NormalFloat * n Buffer(element_array_buffer) PositionIndex * 1 TextureIndex * 1 NormalIndex * 1 Data Use //gen glBindVertexArray(VAO); glBindBuffer(array_buffer, vbo); glBufferData(array_buffer, size(vertices), data(vertices), access(vertices)); glVertexAttribPointer(POSITIONS, 3, float, offset(0)); glVertexAttribPointer(UVS, 2,

When created, do VAOs track just VBO indices (via glBindVertexBuffer ), or also which VBO names are bound to those indices? If I specify a binding index of, say, 0 using glVertexAttribBinding during VAO creation, can I bind a different VBO to index 0 just prior to a draw call and have it use the contents of that VBO, or will it always use whatever VBO was bound to index 0 at the time the VAO was created? I ask because a lot of examples I find precede calls to glVertexAttribFormat and glVertexAttribBinding with a call to glBindVertexBuffer , which should not be necessary if the VAO tracks only

I work with OpenGL4.X .Recently I read this Apple OpenGLES2 doc where it is stated that using interleaved attribute arrays improves performance on IOS mobile devices and is the recommended way (instead of using blocks of attributes). For those who didn't understand what I mean here is an example: Block of attributes in a single attribute array: float vertices[]{ //Triangle vertices: v0x , v0y , v0z , v1x , v1y , v1z , v2x , v2y , v2z , //Triangle UVs: uv0s , uv0t , uv1s , uv1t , uv2s , uv2t , //Triangle Normals: n0x , n0y , n0z , n1x , n1y , n1z , n2x , n2y , n2z } Interleaved attribute array:

OpenGL has array textures , denoted in shaders by specific sampler types: sampler2DArray array_texture; But GLSL also allows samplers to be aggregated into arrays: sampler2D array_of_textures[10]; Are these two features related to each other? How are they different? Let's understand the distinction by analogy. Samplers in GLSL are like pointers in C++; they reference some other object of a given type. So consider the following C++ code: int* pi; std::array<int, 5>* pai; std::array<int*, 5> api; pi is a pointer to a single object of type int (let's ignore the fact that technically it could be a