As imagens renderizadas de cima e de baixo usando uma câmera ortográfica não coincidem

Estou usando uma câmera ortográfica para renderizar fatias de um modelo (a fim de voxelizá-lo). Eu renderizo cada fatia de cima e de baixo para determinar o que está dentro de cada fatia.

O modelo que renderizo é uma forma simples de 'T' construída a partir de dois cubos. Os cubos têm as mesmas dimensões e a mesma coordenada Y (altura). Aqui está uma renderização disso no Blender:

Eu renderizo esse modelo uma vez diretamente de cima e uma vez diretamente de baixo. Minha expectativa era que eu obtivesse exatamente a mesma imagem (exceto pelo espelhamento no eixo y). No entanto, quando eu renderizo usando um destino de renderização de resolução muito baixa (25x25), a posição (em pixels) do 'T' é diferente quando renderizada de cima em vez de renderizada de baixo. Veja as figuras 2 e 3. Os blocos rosa não fazem parte da renderização original, mas eu os adicionei para que você possa contar / ver facilmente as diferenças.

Renderizado de cima

Renderizado de baixo

Provavelmente, isso se deve ao que eu li sobre as coordenadas de pixel e texel, que podem estar inclinadas para o canto superior esquerdo, como visto na câmera. Como estou usando o mesmo vetor 'up' para as duas câmeras, minha inclinação só aparece no eixo x. Eu tentei mudar a posição da câmera e ela é observada, o que eu pensei, deveria ser meio pixel. Tentei mudar uma única câmera e mudar as duas câmeras e, enquanto vejo algum efeito, não consigo obter uma cópia perfeita pixel por pixel das duas câmeras.

Aqui, inicializo a câmera e computo o que acredito ser meio pixel. boundsDimX e boundsDimZ é uma caixa delimitadora ligeiramente ampliada em torno do modelo que eu também uso como largura e altura do volume de visualização da câmera ortográfica.

Matrix projection = Matrix.CreateOrthographic(boundsDimX, boundsDimZ, 0.5f, sliceHeight + 0.5f);
Vector3 halfPixel = new Vector3(boundsDimX / (float)renderTarget.Width, 0, 
    boundsDimY / (float)renderTarget.Height) * 0.5f;

Este é o código em que eu defino a posição da câmera e a aparência da câmera

  // Position camera                      
                if (downwards)
                {
                    float cameraHeight = bounds.Max.Y + 0.501f - (sliceHeight * i);
                    Vector3 cameraPosition = new Vector3
                    (
                        boundsCentre.X, // possibly adjust by half a pixel?
                        cameraHeight,
                        boundsCentre.Z
                    );
                    camera.Position = cameraPosition;
                    camera.LookAt = new Vector3(cameraPosition.X, cameraHeight - 1.0f, cameraPosition.Z);

                }
                else
                {
                    float cameraHeight = bounds.Max.Y - 0.501f - (sliceHeight * i);
                    Vector3 cameraPosition = new Vector3
                    (
                        boundsCentre.X,
                        cameraHeight,
                        boundsCentre.Z
                    );
                    camera.Position = cameraPosition;
                    camera.LookAt = new Vector3(cameraPosition.X, cameraHeight + 1.0f, cameraPosition.Z);
                }

Pergunta principal Agora que você já viu todos os problemas e códigos, pode adivinhar. Minha pergunta principal é Como alinhar as duas câmeras para que cada uma renderize exatamente a mesma imagem (espelhada ao longo do eixo Y)?

Essa é uma visão diferente sobre o problema apresentado, o que pode ajudar a evitar completamente as questões de diferenças de rasterização

Você considerou manter tudo no lugar, mas dimensionar o Y do modelo (cubos) em '-1' ao longo do plano de seção? Então você terá tudo exatamente igual, exceto os objetos que estão sendo virados de cabeça para baixo - o que significa que você obterá os lados negativos para o seu objetivo. É claro que você também precisará '-1' dos normais e polígonos voltados para as direções.