How to change camera projection to othographic/orthogonal?

[agGitHub]

Hi,

The projection is a perspective projection. I wonder how to change the camera projection to othographic/orthogonal.

Thanks for your help.

[ThomasGorisse]

Hi,
Please use the discussion section for this.
What's your goal exactly for using orthographic projection?

[agGitHub]

I need this feature in order to be able to have clean views when I have a 3D reconstruction of a flat/house/home. For example, if I have a room seen from the top, I want to see only the floor, I don't want to see the walls because of the perspective effect. Thanks a lot.

[agGitHub]

Hi. Any update on this topic? Would be really great to have a camera with orthogonal projection. See for example the three.js OrthoraphicCamera object: https://threejs.org/docs/#api/en/cameras/OrthographicCamera

Would be really great to have the same in Sceneform or a trick to make the camera orthographic. Thanks.

[ThomasGorisse]

Hi,
Could you please ask directly on the Filament repo and link the issue here?

[ThomasGorisse]

Answer here: google/filament#4948

[agGitHub]

It doesn't answer the question. Indeed, I see a setProjection method in the filament version of the objet Camera, but I don't see an equivalent in the Sceneform version of the Camera objet. How to set the projection to orthogonal in Sceneform? Thanks.

[grassydragon]

There is a method for setting the matrix data, however, you may need to use reflection to access it: https://github.com/SceneView/sceneform-android/blob/master/core/src/main/java/com/google/ar/sceneform/Camera.java#L358

Sceneform doesn't support the orthogonal projection explicitly because in AR the camera projection matrix must match the device camera parameters (be perspective and have the same fields of view).

[agGitHub]

There is a method for setting the matrix data, however, you may need to use reflection to access it: https://github.com/SceneView/sceneform-android/blob/master/core/src/main/java/com/google/ar/sceneform/Camera.java#L358

Thanks. I never used the concept of reflection, and I don't know what to set in setProjectionMatrix(Matrix matrix) as you recommend. May you give more details?

Note that I use Sceneform alone in a 3D viewer, not in AR.

Thanks for your help.

[ThomasGorisse]

If you are on a 3D only (no AR usage), try this:

sceneView.getRenderer().getCamera().setProjection(Camera.Projection.ORTHO, double left, double right, double bottom, double top, double near, double far);

[agGitHub]

Thanks for your answer.

I do :

camera = scene.getCamera(); // Note that it is a Sceneform Camera object, not a Filament Camera.
camera.setSelectable(false);
camera.setFarClipPlane(100f);

double near = camera.getNearClipPlane();
double far = camera.getFarClipPlane();
sceneView.getRenderer().getCamera().setProjection(com.google.android.filament.Camera.Projection.ORTHO, -1, 1, -1, 1, near, far); // Note that we use here a filament Camera object ; does it have effect on my Sceneform Camera ?

But it doesn't seem to work as it changes nothing to the 3D view.

Any idea ?

Thanks for your help.

[ThomasGorisse]

Sorry about that, I forgot that the camera projection is updated each frame also outside of an AR usage here:

sceneform-android/core/src/main/java/com/google/ar/sceneform/rendering/Renderer.java

Lines 321 to 332 in 65d6e6e

	if (cameraProvider != null) {
	final float[] projectionMatrixData = cameraProvider.getProjectionMatrix().data;
	for (int i = 0; i < 16; ++i) {
	cameraProjectionMatrix[i] = projectionMatrixData[i];
	}
	camera.setModelMatrix(cameraProvider.getWorldModelMatrix().data);
	camera.setCustomProjection(
	cameraProjectionMatrix,
	cameraProvider.getNearClipPlane(),
	cameraProvider.getFarClipPlane());

So in your case, your setProjection() call is bypassed by the renderer setCustomProjection() repeated call.
That's something we will care about in sceneview-android but if you are using sceneform-android, your only solution might be to call sceneView.getRenderer().getCamera().setProjection(com.google.android.filament.Camera.Projection.ORTHO, -1, 1, -1, 1, near, far); inside the onUpdate() which is called every frame (not the cleanest way obviously)

[agGitHub]

Thanks. I just tried to execute the code at each frame. Tried at the beginning or and of the onUpdate() loop but changes nothing unfortunately. Any clue how to solve this problem ? Thanks.

[Norlandz]

With the help from AI (opus 4.5), i managed to get it working in a hacky way.

Android. Java 11.

    implementation "com.gorisse.thomas.sceneform:sceneform:1.23.0"
    // Sceneform 1.23.0 uses embedded Filament v1.21.1 

Below are AI generated solution, worked for me.

public class EngineerX3dModelFragment extends Fragment {
    private CameraProjectionHelper cameraProjectionHelper;
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        cameraProjectionHelper = new CameraProjectionHelper(binding.sceneView);
    }

    private void setupSnapshotControls() {
        // Toggle Orthographic/Perspective projection
        binding.btnToggleProjection.setOnClickListener(v -> {
            boolean isOrtho = cameraProjectionHelper.toggle();
            binding.btnToggleProjection.setText(isOrtho ? "📐 Persp" : "📐 Ortho");
            log("Projection: " + (isOrtho ? "ORTHOGRAPHIC" : "PERSPECTIVE"));
        });
    }

import android.util.Log;

import com.google.ar.sceneform.FrameTime;
import com.google.ar.sceneform.Scene;
import com.google.ar.sceneform.SceneView;
import com.google.ar.sceneform.math.Matrix;

import java.lang.reflect.Method;

/**
 * Camera Projection Helper - Switches between Perspective and Orthographic.
 * 
 * Uses reflection to access Sceneform Camera's internal methods:
 * - setProjectionMatrix(Matrix) for setting orthographic projection
 * - refreshProjectionMatrix() for restoring perspective projection
 */
public class CameraProjectionHelper {
    private static final String TAG = "CamProj";

    private final SceneView sceneView;
    private boolean isOrthographic = false;
    
    // Orthographic settings
    private double orthoHeight = 2.5;
    
    private final Scene.OnUpdateListener updateListener;
    private int frameCount = 0;
    
    // Reflection cache
    private Method setProjectionMatrixMethod = null;
    private Method refreshProjectionMatrixMethod = null;
    private boolean reflectionFailed = false;

    public CameraProjectionHelper(SceneView sceneView) {
        this.sceneView = sceneView;
        this.updateListener = this::onSceneUpdate;
        sceneView.getScene().addOnUpdateListener(this.updateListener);
        
        initReflection();
        
        Log.d(TAG, "Initialized. setProjectionMatrix: " + (setProjectionMatrixMethod != null) +
              ", refreshProjectionMatrix: " + (refreshProjectionMatrixMethod != null));
    }
    
    private void initReflection() {
        try {
            Class<?> cameraClass = com.google.ar.sceneform.Camera.class;
            
            for (Method m : cameraClass.getDeclaredMethods()) {
                if (m.getName().equals("setProjectionMatrix") && m.getParameterCount() == 1) {
                    m.setAccessible(true);
                    setProjectionMatrixMethod = m;
                    Log.d(TAG, "Found setProjectionMatrix");
                }
                if (m.getName().equals("refreshProjectionMatrix") && m.getParameterCount() == 0) {
                    m.setAccessible(true);
                    refreshProjectionMatrixMethod = m;
                    Log.d(TAG, "Found refreshProjectionMatrix");
                }
            }
            
        } catch (Exception e) {
            Log.e(TAG, "Reflection init failed: " + e.getMessage());
            reflectionFailed = true;
        }
    }
    
    public boolean toggle() {
        isOrthographic = !isOrthographic;
        Log.d(TAG, "=== TOGGLE === Now: " + (isOrthographic ? "ORTHO" : "PERSP"));
        
        if (isOrthographic) {
            applyOrthoProjection();
        } else {
            restorePerspectiveProjection();
        }
        
        return isOrthographic;
    }

    public void setOrthographicMode(boolean enable) {
        if (this.isOrthographic != enable) {
            this.isOrthographic = enable;
            if (enable) {
                applyOrthoProjection();
            } else {
                restorePerspectiveProjection();
            }
        }
    }

    public boolean isOrthographic() {
        return isOrthographic;
    }

    public void setOrthoHeight(double height) {
        this.orthoHeight = height;
        if (isOrthographic) applyOrthoProjection();
    }

    private void onSceneUpdate(FrameTime frameTime) {
        frameCount++;
        
        // Keep enforcing ortho projection every frame (Sceneform fights us)
        if (isOrthographic) {
            applyOrthoProjection();
        }
        
        // Debug every 120 frames
        if (frameCount % 120 == 0) {
            debugLogProjection();
        }
    }

    private void applyOrthoProjection() {
        if (reflectionFailed || setProjectionMatrixMethod == null) return;
        
        com.google.ar.sceneform.Camera camera = sceneView.getScene().getCamera();
        if (camera == null) return;
        
        int width = sceneView.getWidth();
        int height = sceneView.getHeight();
        if (width <= 0 || height <= 0) return;
        
        double aspect = (double) width / (double) height;
        double near = camera.getNearClipPlane();
        double far = camera.getFarClipPlane();
        
        double halfH = orthoHeight / 2.0;
        double halfW = halfH * aspect;
        
        float[] orthoData = buildOrthoMatrix(-halfW, halfW, -halfH, halfH, near, far);
        
        try {
            Matrix orthoMatrix = new Matrix();
            orthoMatrix.set(orthoData);
            setProjectionMatrixMethod.invoke(camera, orthoMatrix);
            
            if (frameCount % 60 == 0) {
                Log.d(TAG, "[ORTHO] Applied. halfW=" + String.format("%.2f", halfW) + 
                      " halfH=" + String.format("%.2f", halfH));
            }
        } catch (Exception e) {
            Log.e(TAG, "setProjectionMatrix failed: " + e.getMessage());
        }
    }
    
    private void restorePerspectiveProjection() {
        com.google.ar.sceneform.Camera camera = sceneView.getScene().getCamera();
        if (camera == null) return;
        
        // Method 1: Call refreshProjectionMatrix via reflection
        if (refreshProjectionMatrixMethod != null) {
            try {
                refreshProjectionMatrixMethod.invoke(camera);
                Log.d(TAG, "[PERSP] Restored via refreshProjectionMatrix");
                return;
            } catch (Exception e) {
                Log.e(TAG, "refreshProjectionMatrix failed: " + e.getMessage());
            }
        }
        
        // Method 2: Fallback - manually build perspective matrix
        Log.d(TAG, "[PERSP] Using fallback perspective matrix");
        
        int width = sceneView.getWidth();
        int height = sceneView.getHeight();
        if (width <= 0 || height <= 0) return;
        
        float aspect = (float) width / (float) height;
        float fov = camera.getVerticalFovDegrees();
        float near = camera.getNearClipPlane();
        float far = camera.getFarClipPlane();
        
        float[] perspData = buildPerspectiveMatrix(fov, aspect, near, far);
        
        try {
            Matrix perspMatrix = new Matrix();
            perspMatrix.set(perspData);
            setProjectionMatrixMethod.invoke(camera, perspMatrix);
            Log.d(TAG, "[PERSP] Applied fallback. fov=" + fov + " aspect=" + aspect);
        } catch (Exception e) {
            Log.e(TAG, "Fallback perspective failed: " + e.getMessage());
        }
    }
    
    /**
     * Build orthographic projection matrix (column-major).
     */
    private float[] buildOrthoMatrix(double left, double right, double bottom, double top, double near, double far) {
        double rml = right - left;
        double tmb = top - bottom;
        double fmn = far - near;
        
        float[] m = new float[16];
        m[0] = (float)(2.0 / rml);
        m[5] = (float)(2.0 / tmb);
        m[10] = (float)(-2.0 / fmn);
        m[12] = (float)(-(right + left) / rml);
        m[13] = (float)(-(top + bottom) / tmb);
        m[14] = (float)(-(far + near) / fmn);
        m[15] = 1.0f;
        
        return m;
    }
    
    /**
     * Build perspective projection matrix (column-major).
     * Matches Sceneform's setPerspective implementation.
     */
    private float[] buildPerspectiveMatrix(float verticalFovDegrees, float aspect, float near, float far) {
        double fovRadians = Math.toRadians(verticalFovDegrees);
        float top = (float)(Math.tan(fovRadians * 0.5) * near);
        float bottom = -top;
        float right = top * aspect;
        float left = -right;
        
        float reciprocalWidth = 1.0f / (right - left);
        float reciprocalHeight = 1.0f / (top - bottom);
        float reciprocalDepth = 1.0f / (far - near);
        
        float[] m = new float[16];
        
        m[0] = 2.0f * near * reciprocalWidth;
        m[5] = 2.0f * near * reciprocalHeight;
        m[8] = (right + left) * reciprocalWidth;
        m[9] = (top + bottom) * reciprocalHeight;
        m[10] = -(far + near) * reciprocalDepth;
        m[11] = -1.0f;
        m[14] = -2.0f * far * near * reciprocalDepth;
        
        return m;
    }
    
    private void debugLogProjection() {
        try {
            com.google.android.filament.Camera filamentCamera = 
                sceneView.getRenderer().getFilamentView().getCamera();
            if (filamentCamera != null) {
                double[] proj = filamentCamera.getProjectionMatrix(null);
                Log.d(TAG, "[DEBUG] Frame " + frameCount + 
                      " | Mode: " + (isOrthographic ? "ORTHO" : "PERSP") +
                      " | proj[0]=" + String.format("%.4f", proj[0]) +
                      " | proj[5]=" + String.format("%.4f", proj[5]) +
                      " | proj[10]=" + String.format("%.4f", proj[10]));
            }
        } catch (Exception e) {
            // Ignore
        }
    }
    
    public void destroy() {
        try {
            sceneView.getScene().removeOnUpdateListener(this.updateListener);
        } catch (Exception e) {
            Log.e(TAG, "Error removing listener", e);
        }
    }
}

Technical Report: Implementing Orthographic Projection in Sceneform

1. Objective

Enable runtime switching between Perspective and Orthographic camera projection modes within a Sceneform (Android) application.

2. Technical Context & Prerequisites

• Technology Stack: Android, Sceneform 1.16+ (wrapping Google Filament 1.4.x+).
• Architecture: Sceneform exposes a high-level Scene Graph API (Scene, Node, Camera) that abstracts the lower-level Filament renderer.
• The Conflict: Sceneform was architected primarily for Augmented Reality (AR). In AR, the virtual camera's projection matrix must rigidly match the physical device camera's lens characteristics to ensure virtual objects "stick" to the real world. Consequently, Sceneform actively resists external changes to the projection matrix to maintain tracking consistency.

3. The Journey: Traps, Failures, and Diagnoses

Attempt 1: Direct Filament API (The "Obvious" Way)

Approach: Access the underlying Filament Camera and set the projection directly.

sceneView.getRenderer().getFilamentView().getCamera().setProjection(Projection.ORTHO, ...);

• Result: Failure. The view remains Perspective or flickers briefly.
• Diagnosis: Deep debugging revealed that Sceneform's Renderer.render() loop runs after user code. It takes the projectionMatrix from its own high-level Camera node and forcefully pushes it to the Filament camera every single frame, effectively overwriting any manual changes we made.

Attempt 2: The OnUpdateListener (The "Fight Back" Way)

Approach: Hook into Scene.OnUpdateListener to re-apply the Orthographic projection every frame, attempting to "win" the race condition against Sceneform's renderer.

// Inside onUpdate(FrameTime)
filamentCamera.setProjection(Projection.ORTHO, ...);

• Result: Partial Success / Unstable.
• Diagnosis: Logs showed the matrix value changing, but visual results were inconsistent. Furthermore, Sceneform has internal flags indicating whether matrices are "dirty" or need updating, which we were bypassing, leading to undefined behavior.

Attempt 3: The setCustomProjection Discovery

Approach: Use filamentCamera.setCustomProjection() instead of setProjection().

• Result: Worked for entering Orthographic mode, but failed to return to Perspective.
• Diagnosis: Once we overrode the projection loop with a custom matrix, Sceneform's internal state machine for the camera became desynchronized. It no longer knew how to restore the original Perspective matrix because its internal "refresh" triggers were disabled.

4. The Root Cause Analysis

The source of truth is not the Filament camera, but the com.google.ar.sceneform.Camera class.

1. State Ownership: The Sceneform Camera class maintains a private projectionMatrix field.
2. Update Logic: The Renderer reads this specific field every frame to update the GPU.
3. The Trap: The method responsible for rebuilding the standard Perspective matrix (refreshProjectionMatrix()) is private. It is only automatically called during layout changes (e.g., screen rotation).
4. The Lockout: When we want to switch back to Perspective at runtime without resizing the screen, there is no public API to tell Sceneform, "Please recalculate your perspective matrix now."

5. The Solution: Reflection & Persistence

To solve this properly, we must manipulate Sceneform's internal state directly, making it believe it is responsible for the Orthographic matrix.

Key Components

1. Reflection: We use Java Reflection to access two hidden methods in com.google.ar.sceneform.Camera:
   • void setProjectionMatrix(Matrix matrix): Allows us to inject our own custom 4x4 Orthographic matrix into Sceneform's "source of truth".
   • void refreshProjectionMatrix(): Allows us to force Sceneform to recalculate the standard Perspective matrix based on its FOV/Aspect Ratio settings.
2. Per-Frame Enforcement: We utilize Scene.OnUpdateListener. Since Sceneform or ARCore (if active) may attempt to reset the camera state, we re-inject our Orthographic matrix every frame while in Orthographic mode to guarantee stability.

The Algorithm

To Enter Orthographic Mode:

1. Calculate a standard OpenGL Orthographic Projection Matrix (Column-Major).
2. Inside onUpdate(FrameTime):
   • Use Reflection to invoke camera.setProjectionMatrix(orthoMatrix).
3. Result: Sceneform sees the updated matrix in its own field and passes it downstream to Filament naturally. The rendering is stable.

To Enter Perspective Mode:

1. Stop the per-frame overwrite loop.
2. Use Reflection to invoke camera.refreshProjectionMatrix().
3. Result: Sceneform looks at its verticalFov, nearClip, farClip, and aspectRatio fields, rebuilds the standard Perspective matrix, and stores it. The view returns to normal 3D perspective.

6. Implementation Guide for Future Developers

If you need to reproduce this solution or explain it to an AI assistant, provide these specific instructions:

1. Do not rely on Filament APIs alone: Direct calls to filamentCamera.setProjection will be overwritten by Sceneform's update loop.
2. Use Reflection on Sceneform Camera: You must access the private methods of com.google.ar.sceneform.Camera to make the changes "stick".
3. Required Methods:
   • getDeclaredMethod("setProjectionMatrix", Matrix.class)
   • getDeclaredMethod("refreshProjectionMatrix")
4. Enforce Loop: Use scene.addOnUpdateListener to set the Orthographic matrix continuously while that mode is active.
5. Restore via Refresh: Rely on refreshProjectionMatrix() to cleanly restore Perspective mode without manually calculating perspective math.

Why is this "Hacky"?

We are using Reflection to access private APIs (setAccessible(true)). This bypasses the library's public contract.

• Constraint: Sceneform is archived and no longer actively maintained by Google.
• Justification: This is the only robust way to achieve this specific functionality (runtime projection switching) without forking the entire Sceneform library or migrating the entire rendering stack to raw Filament (a massive refactor). Given the constraints, this is the optimal engineering decision.