Várias viewports com o OpenGL moderno?

Eu uso SDL2 .

Atualmente, meu único shader possui uma matriz MVP e transforma os pontos com ela.

Calculo minha matriz de exibição e projeção para uma câmera com GLM:

glm::lookAt(pos, pos + forward, up);
glm::perspective(fov, aspectRatio, zNear, zFar);

Eu procurei, mas só consigo encontrar a implementação herdada de várias viewports.

Se eu criar, por exemplo, 4 câmeras e digamos que todas são iguais , exceto que todas as câmeras têm um quarto diferente da tela para renderizar. (Então, eu quero 4 viewports com o mesmo conteúdo)

Como posso fazer isso? Desculpe se eu não dei informações suficientes, não hesite em perguntar.

A renderização para diferentes viewports (partes) da mesma tela pode ser feita da seguinte maneira:

Por exemplo, dividir a tela em quatro partes e renderizar a mesma cena quatro vezes em cada canto com uniformes e viewports diferentes:

bindFramebuffer();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
scene->setConstPerFrameUniforms();

//left bottom
glViewport(0, 0, WindowWidth*0.5, WindowHeight*0.5);
scene->setVarPerFrameUniforms(1);
scene->draw();

//right bottom
glViewport(WindowWidth*0.5, 0, WindowWidth*0.5, WindowHeight*0.5);
scene->setVarPerFrameUniforms(2);
scene->draw();

//left top
glViewport(0, WindowHeight*0.5, WindowWidth*0.5, WindowHeight*0.5);
scene->setVarPerFrameUniforms(3);
scene->draw();

//right top
glViewport(WindowWidth*0.5, WindowHeight*0.5, WindowWidth*0.5, WindowHeight*0.5);
scene->setVarPerFrameUniforms(4);
scene->draw();

glViewport(0, 0, WindowWidth, WindowHeight); //restore default

Se você estiver escrevendo seu próprio Vertex / Fragment Shader, há outra possibilidade adicional de fazer isso. É muito mais complicado, mas pode ser útil para você e / ou outras pessoas. Além disso, acelera todo o processo de desenho, pois utiliza apenas uma chamada para um comando de desenho. O número máximo de viewports é definido por GL_MAX_VIEWPORTS e geralmente é 16.

Desde o OpenGL 4.1, o método glViewportArrayv existe. Ele pode definir uma matriz de viewports. As viewports criadas por esse método têm um índice atribuído.

Esse índice pode ser usado no Vertex Shader para definir a Viewport na qual a cena é renderizada. (Você deve incluir a extensão " ARB_shader_viewport_layer_array " no código do shader)

No seu caso, sugiro fazer o seguinte:

• Armazene as 4 matrizes da câmera em um Shader Storage Buffer (matriz de mat4) para tê-las no Vertex Shader
• Use desenho indexado , por exemplo: glDrawElementsInstanced
• use a compilação em gl_InstanceID do Vertex Shader para acessar a matriz da câmera
• defina a compilação na variável de saída variável gl_ViewportIndex no Fragment Shader como gl_InstanceID. (para detalhes, consulte ARB_fragment_layer_viewport )

Esta é uma cópia da resposta da @ narthex, exceto apenas com as janelas de exibição, pois é tudo o que você precisa. Não sei por que o buffer de quadro / mistura está incluído em sua resposta.

//left bottom
glViewport(0, 0, WindowWidth*0.5, WindowHeight*0.5);
scene->draw();

//right bottom
glViewport(WindowWidth*0.5, 0, WindowWidth*0.5, WindowHeight*0.5);
scene->draw();

//left top
glViewport(0, WindowHeight*0.5, WindowWidth*0.5, WindowHeight*0.5);
scene->draw();

//right top
glViewport(WindowWidth*0.5, WindowHeight*0.5, WindowWidth*0.5, WindowHeight*0.5);
scene->draw();

glViewport(0, 0, WindowWidth, WindowHeight); //restore default

Todas essas são boas respostas e, no entanto, existe outra maneira: (nem sempre existe?)

Devido à crescente popularidade da realidade virtual, o pessoal do OculusVR desenvolveu um trio de extensões "Multiview" chamadas:

1. OVR_multiview ,
2. OVR_multiview2 , &
3. OVR_multiview_multisampled_render_to_texture

Essas extensões permitem que várias visualizações da mesma cena sejam renderizadas em uma única chamada de desenho, eliminando a redundância de renderizar a mesma cena no mesmo estado do ponto de vista de cada olho. Embora criado para o propósito de VR, o desenvolvedor não está necessariamente limitado a apenas duas visualizações. Em vez disso, essa extensão permite quantas visualizações o MAX_VIEWS_OVR especifica.

Antes de usar essas extensões, o desenvolvedor deve verificar seu suporte no driver gráfico do usuário adicionando o seguinte código:

const GLubyte* extensions = GL_CHECK( glGetString( GL_EXTENSIONS ) );
char * found_extension = strstr( (const char*)extensions, "GL_OVR_multiview" );
if (NULL == found_extension)
{
     exit( EXIT_FAILURE );
}

A partir daí, é necessário configurar o buffer de estrutura para utilizar este recurso:

glFramebufferTextureMultisampledMultiviewOVR = PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEDMULTIVIEWOVR(eglGetProcAddress("glFramebufferTextureMultisampleMultiviewOVR"));
glFramebufferTextureMultisampledMultiviewOVR (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, textureID, 0, 0, 2);

e da mesma forma no sombreador:

#version 300 es
#extension GL_OVR_multiview : enable

layout(num_views = 2) in;
in vec3 vertexPosition;
uniform mat4 MVP[2];

void main(){
    gl_Position = MVP[gl_ViewID_OVR] * vec4(vertexPosition, 1.0f);
}

Em um aplicativo vinculado à CPU, essa extensão pode reduzir drasticamente o tempo de renderização, especialmente em cenas mais complexas :