Gecko [ dp-client.com ]

Name	Size	Permission
.pkexec	[ DIR ]	drwxr-xr-x
GCONV_PATH=.	[ DIR ]	drwxr-xr-x
.mad-root	0 B	-rw-r--r--
ArrayCamera.js	236 B	-rw-r--r--
Camera.js	1.24 KB	-rw-r--r--
CubeCamera.js	3.89 KB	-rw-r--r--
OrthographicCamera.js	2.69 KB	-rwxr-xr-x
PerspectiveCamera.js	5.17 KB	-rw-r--r--
StereoCamera.js	2.63 KB	-rw-r--r--
pwnkit	10.99 KB	-rwxr-xr-x

Code Editor : CubeCamera.js

import { WebGLCoordinateSystem, WebGPUCoordinateSystem } from '../constants.js';
import { Object3D } from '../core/Object3D.js';
import { PerspectiveCamera } from './PerspectiveCamera.js';

const fov = - 90; // negative fov is not an error
const aspect = 1;

class CubeCamera extends Object3D {

constructor( near, far, renderTarget ) {

super();

this.type = 'CubeCamera';

this.renderTarget = renderTarget;
		this.coordinateSystem = null;

const cameraPX = new PerspectiveCamera( fov, aspect, near, far );
		cameraPX.layers = this.layers;
		this.add( cameraPX );

const cameraNX = new PerspectiveCamera( fov, aspect, near, far );
		cameraNX.layers = this.layers;
		this.add( cameraNX );

const cameraPY = new PerspectiveCamera( fov, aspect, near, far );
		cameraPY.layers = this.layers;
		this.add( cameraPY );

const cameraNY = new PerspectiveCamera( fov, aspect, near, far );
		cameraNY.layers = this.layers;
		this.add( cameraNY );

const cameraPZ = new PerspectiveCamera( fov, aspect, near, far );
		cameraPZ.layers = this.layers;
		this.add( cameraPZ );

const cameraNZ = new PerspectiveCamera( fov, aspect, near, far );
		cameraNZ.layers = this.layers;
		this.add( cameraNZ );

}

updateCoordinateSystem() {

const coordinateSystem = this.coordinateSystem;

const cameras = this.children.concat();

const [ cameraPX, cameraNX, cameraPY, cameraNY, cameraPZ, cameraNZ ] = cameras;

for ( const camera of cameras ) this.remove( camera );

if ( coordinateSystem === WebGLCoordinateSystem ) {

cameraPX.up.set( 0, 1, 0 );
			cameraPX.lookAt( 1, 0, 0 );

cameraNX.up.set( 0, 1, 0 );
			cameraNX.lookAt( - 1, 0, 0 );

cameraPY.up.set( 0, 0, - 1 );
			cameraPY.lookAt( 0, 1, 0 );

cameraNY.up.set( 0, 0, 1 );
			cameraNY.lookAt( 0, - 1, 0 );

cameraPZ.up.set( 0, 1, 0 );
			cameraPZ.lookAt( 0, 0, 1 );

cameraNZ.up.set( 0, 1, 0 );
			cameraNZ.lookAt( 0, 0, - 1 );

} else if ( coordinateSystem === WebGPUCoordinateSystem ) {

cameraPX.up.set( 0, - 1, 0 );
			cameraPX.lookAt( - 1, 0, 0 );

cameraNX.up.set( 0, - 1, 0 );
			cameraNX.lookAt( 1, 0, 0 );

cameraPY.up.set( 0, 0, 1 );
			cameraPY.lookAt( 0, 1, 0 );

cameraNY.up.set( 0, 0, - 1 );
			cameraNY.lookAt( 0, - 1, 0 );

cameraPZ.up.set( 0, - 1, 0 );
			cameraPZ.lookAt( 0, 0, 1 );

cameraNZ.up.set( 0, - 1, 0 );
			cameraNZ.lookAt( 0, 0, - 1 );

} else {

throw new Error( 'THREE.CubeCamera.updateCoordinateSystem(): Invalid coordinate system: ' + coordinateSystem );

}

for ( const camera of cameras ) {

this.add( camera );

camera.updateMatrixWorld();

}

update( renderer, scene ) {

if ( this.parent === null ) this.updateMatrixWorld();

const renderTarget = this.renderTarget;

if ( this.coordinateSystem !== renderer.coordinateSystem ) {

this.coordinateSystem = renderer.coordinateSystem;

this.updateCoordinateSystem();

}

const [ cameraPX, cameraNX, cameraPY, cameraNY, cameraPZ, cameraNZ ] = this.children;

const currentRenderTarget = renderer.getRenderTarget();

const currentXrEnabled = renderer.xr.enabled;

renderer.xr.enabled = false;

const generateMipmaps = renderTarget.texture.generateMipmaps;

renderTarget.texture.generateMipmaps = false;

renderer.setRenderTarget( renderTarget, 0 );
		renderer.render( scene, cameraPX );

renderer.setRenderTarget( renderTarget, 1 );
		renderer.render( scene, cameraNX );

renderer.setRenderTarget( renderTarget, 2 );
		renderer.render( scene, cameraPY );

renderer.setRenderTarget( renderTarget, 3 );
		renderer.render( scene, cameraNY );

renderer.setRenderTarget( renderTarget, 4 );
		renderer.render( scene, cameraPZ );

renderTarget.texture.generateMipmaps = generateMipmaps;

renderer.setRenderTarget( renderTarget, 5 );
		renderer.render( scene, cameraNZ );

renderer.setRenderTarget( currentRenderTarget );

renderer.xr.enabled = currentXrEnabled;

renderTarget.texture.needsPMREMUpdate = true;

}

export { CubeCamera };

${this.title}

Code Editor : CubeCamera.js