Dart DocumentationthreePerspectiveCamera

PerspectiveCamera class

@author mr.doob / http://mrdoob.com/ @author greggman / http://games.greggman.com/ @author zz85 / http://www.lab4games.net/zz85/blog

Ported to Dart from JS by: @author rob silverton / http://www.unwrong.com/

class PerspectiveCamera extends Camera {

 double fov;
 double aspect;

 double _fullWidth;
 double _fullHeight;
 double _x;
 double _y;
 double _width;
 double _height;


 PerspectiveCamera( [this.fov = 50.0, this.aspect = 1.0, near = 0.1, far = 2000.0] )
   : super(near, far){

   updateProjectionMatrix();
 }

 /**
  * Uses Focal Length (in mm) to estimate and set FOV
  * 35mm (fullframe) camera is used if frame size is not specified;
  * Formula based on http://www.bobatkins.com/photography/technical/field_of_view.html
  */

 void setLens( double focalLength, double frameSize ) {
   frameSize = frameSize != null ? frameSize : 43.25; // 36x24mm

   fov = 2.0 * Math.atan( frameSize / ( focalLength * 2.0 ) );
   fov = 180.0 / Math.PI * fov;

   updateProjectionMatrix();
 }


 /**
  * Sets an offset in a larger frustum. This is useful for multi-window or
  * multi-monitor/multi-machine setups.
  *
  * For example, if you have 3x2 monitors and each monitor is 1920x1080 and
  * the monitors are in grid like this
  *
  *   +---+---+---+
  *   | A | B | C |
  *   +---+---+---+
  *   | D | E | F |
  *   +---+---+---+
  *
  * then for each monitor you would call it like this
  *
  *   var w = 1920;
  *   var h = 1080;
  *   var fullWidth = w * 3;
  *   var fullHeight = h * 2;
  *
  *   --A--
  *   camera.setOffset( fullWidth, fullHeight, w * 0, h * 0, w, h );
  *   --B--
  *   camera.setOffset( fullWidth, fullHeight, w * 1, h * 0, w, h );
  *   --C--
  *   camera.setOffset( fullWidth, fullHeight, w * 2, h * 0, w, h );
  *   --D--
  *   camera.setOffset( fullWidth, fullHeight, w * 0, h * 1, w, h );
  *   --E--
  *   camera.setOffset( fullWidth, fullHeight, w * 1, h * 1, w, h );
  *   --F--
  *   camera.setOffset( fullWidth, fullHeight, w * 2, h * 1, w, h );
  *
  *   Note there is no reason monitors have to be the same size or in a grid.
  */

 void setViewOffset( double fullWidth, double fullHeight, double x, double y, double width, double height ) {
   _fullWidth = fullWidth;
   _fullHeight = fullHeight;
   _x = x;
   _y = y;
   _width = width;
   _height = height;

   updateProjectionMatrix();
 }


 void updateProjectionMatrix() {
   if ( _fullWidth != null ) {
     double aspect = _fullWidth / _fullHeight;
     double top = Math.tan( fov * Math.PI / 360.0 ) * near;
     double bottom = -top;
     double left = aspect * bottom;
     double right = aspect * top;
     double width = ( right - left ).abs();
     double height = ( top - bottom ).abs();

     setFrustumMatrix(projectionMatrix,
       left + _x * width / _fullWidth,
       left + ( _x + width ) * width / _fullWidth,
       top - ( _y + height ) * height / _fullHeight,
       top - _y * height / _fullHeight,
       near,
       far );
   } else {
     projectionMatrix = makePerspectiveMatrix(fov * (Math.PI / 180), aspect, near, far);
   }
 }
}

Extends

Object3D > Camera > PerspectiveCamera

Constructors

new PerspectiveCamera([double fov = 50.0, double aspect = 1.0, near = 0.1, far = 2000.0]) #

Creates a new Object instance.

Object instances have no meaningful state, and are only useful through their identity. An Object instance is equal to itself only.

docs inherited from Object
PerspectiveCamera( [this.fov = 50.0, this.aspect = 1.0, near = 0.1, far = 2000.0] )
 : super(near, far){

 updateProjectionMatrix();
}

Properties

double aspect #

double aspect

num boundRadius #

inherited from Object3D
num boundRadius

num boundRadiusScale #

inherited from Object3D
num boundRadius, boundRadiusScale

bool castShadow #

inherited from Object3D
bool visible = false, castShadow = false

List children #

inherited from Object3D
List children

var customDepthMaterial #

inherited from Object3D
var customDepthMaterial

bool doubleSided #

inherited from Object3D
bool _dynamic, doubleSided

String eulerOrder #

inherited from Object3D
String eulerOrder

double far #

inherited from Camera
double far

bool flipSided #

inherited from Object3D
bool _dynamic, doubleSided, flipSided

double fov #

double fov

bool frustumCulled #

inherited from Object3D
bool visible = false, castShadow = false, receiveShadow = false, frustumCulled = false

int id #

inherited from Object3D
int id

bool isDynamic #

inherited from Object3D
bool get isDynamic => _dynamic;
set isDynamic(bool flag) => _dynamic = flag;

Matrix4 matrix #

inherited from Object3D
Matrix4 matrix

bool matrixAutoUpdate #

inherited from Object3D
bool matrixAutoUpdate = false

Matrix4 matrixRotationWorld #

inherited from Object3D
Matrix4 matrix, matrixWorld, matrixRotationWorld

Matrix4 matrixWorld #

inherited from Object3D
Matrix4 matrix, matrixWorld

Matrix4 matrixWorldInverse #

inherited from Camera
Matrix4 matrixWorldInverse

bool matrixWorldNeedsUpdate #

inherited from Object3D
bool matrixAutoUpdate = false, matrixWorldNeedsUpdate = false

String name #

inherited from Object3D
String name

double near #

inherited from Camera
double near

Object3D parent #

inherited from Object3D
Object3D parent

Vector3 position #

inherited from Object3D
Vector3 up, position

Matrix4 projectionMatrix #

inherited from Camera
Matrix4 projectionMatrix

Matrix4 projectionMatrixInverse #

inherited from Camera
Matrix4 projectionMatrixInverse

Map properties #

inherited from Object3D
Map properties

var quaternion #

inherited from Object3D
var quaternion

bool receiveShadow #

inherited from Object3D
bool visible = false, castShadow = false, receiveShadow = false

int renderDepth #

inherited from Object3D
int renderDepth

Vector3 rotation #

inherited from Object3D
Vector3 up, position, rotation

bool rotationAutoUpdate #

inherited from Object3D
bool _dynamic, doubleSided, flipSided, rotationAutoUpdate

Vector3 scale #

inherited from Object3D
Vector3 up, position, rotation, scale

Vector3 up #

inherited from Object3D
Vector3 up

bool useQuaternion #

inherited from Object3D
bool useQuaternion

bool visible #

inherited from Object3D
bool visible = false

Operators

dynamic operator [](String key) #

inherited from Object3D
operator [] (String key) => _data[key];

dynamic operator []=(String key, value) #

inherited from Object3D
operator []= (String key, value) => _data[key] = value;

Methods

void add(Object3D object) #

inherited from Object3D
void add( Object3D object ) {
 if ( object == this ) {
   print( 'THREE.Object3D.add: An object can\'t be added as a child of itself.' );
   return;
 }


 if ( object.parent != null ) {
   object.parent.remove( object );
 }

 object.parent = this;
 children.add( object );

 // add to scene
 Object3D scene = this;

 while ( scene.parent != null ) {
   scene = scene.parent;
 }

 if ( scene is Scene ) {
   scene.addObject( object );
 }

}

void applyMatrix(Matrix4 matrix) #

inherited from Object3D
void applyMatrix ( Matrix4 matrix ) {
 this.matrix = matrix * this.matrix;

 this.scale = getScaleFromMatrix( this.matrix );

 Matrix4 mat = extractRotation(new Matrix4.identity(), this.matrix );
 this.rotation = calcEulerFromRotationMatrix( mat, this.eulerOrder );

 this.position = this.matrix.getTranslation();
}

dynamic clone() #

inherited from Object3D
clone() {

 // TODO

}

Object3D getChildByName(String name, bool doRecurse) #

inherited from Object3D
Object3D getChildByName( String name, bool doRecurse ) {
 int c;
 int cl = children.length;
 Object3D child, recurseResult;

 children.forEach((child){

   if ( child.name == name ) {
     return child;
   }

   if ( doRecurse ) {
     recurseResult = child.getChildByName( name, doRecurse );

     if ( recurseResult != null ) {
       return recurseResult;
     }
   }
 });

 return null;
}

dynamic localToWorld(Vector3 vector) #

inherited from Object3D
localToWorld(Vector3 vector) => vector.applyProjection(matrixWorld);

void lookAt(Vector3 vector) #

inherited from Camera
void lookAt(Vector3 vector ) {
 // TODO: Add hierarchy support.

 makeLookAt(matrix, position, vector, up);

 if ( rotationAutoUpdate ) {
   rotation = calcEulerFromRotationMatrix( matrix, eulerOrder );
 }
}

void remove(Object3D object) #

inherited from Object3D
void remove( Object3D object ) {

 int index = children.indexOf( object );

 if ( index != - 1 ){

   object.parent = null;
   children.removeAt(index);

   // remove from scene
   Object3D scene = this;

   while ( scene.parent != null ) {
     scene = scene.parent;
   }

   if (scene is Scene ) {
     scene.removeObject( object );
   }
 }
}

void setLens(double focalLength, double frameSize) #

Uses Focal Length (in mm) to estimate and set FOV 35mm (fullframe) camera is used if frame size is not specified; Formula based on http://www.bobatkins.com/photography/technical/fieldofview.html

void setLens( double focalLength, double frameSize ) {
 frameSize = frameSize != null ? frameSize : 43.25; // 36x24mm

 fov = 2.0 * Math.atan( frameSize / ( focalLength * 2.0 ) );
 fov = 180.0 / Math.PI * fov;

 updateProjectionMatrix();
}

void setViewOffset(double fullWidth, double fullHeight, double x, double y, double width, double height) #

Sets an offset in a larger frustum. This is useful for multi-window or multi-monitor/multi-machine setups.

For example, if you have 3x2 monitors and each monitor is 1920x1080 and the monitors are in grid like this

+---+---+---+ | A | B | C | +---+---+---+ | D | E | F | +---+---+---+

then for each monitor you would call it like this

var w = 1920; var h = 1080; var fullWidth = w * 3; var fullHeight = h * 2;

--A-- camera.setOffset( fullWidth, fullHeight, w * 0, h * 0, w, h ); --B-- camera.setOffset( fullWidth, fullHeight, w * 1, h * 0, w, h ); --C-- camera.setOffset( fullWidth, fullHeight, w * 2, h * 0, w, h ); --D-- camera.setOffset( fullWidth, fullHeight, w * 0, h * 1, w, h ); --E-- camera.setOffset( fullWidth, fullHeight, w * 1, h * 1, w, h ); --F-- camera.setOffset( fullWidth, fullHeight, w * 2, h * 1, w, h );

Note there is no reason monitors have to be the same size or in a grid.

void setViewOffset( double fullWidth, double fullHeight, double x, double y, double width, double height ) {
 _fullWidth = fullWidth;
 _fullHeight = fullHeight;
 _x = x;
 _y = y;
 _width = width;
 _height = height;

 updateProjectionMatrix();
}

void translate(num distance, Vector3 axis) #

inherited from Object3D
void translate( num distance, Vector3 axis ) {
 matrix.rotate3( axis );
 axis.normalize();
 position.add( axis.scale( distance ) );
}

void translateX(num distance) #

inherited from Object3D
void translateX( num distance ) => translate( distance, _vector.setValues( 1.0, 0.0, 0.0 ) );

void translateY(num distance) #

inherited from Object3D
void translateY( num distance ) => translate( distance, _vector.setValues( 0.0, 1.0, 0.0 ) );

void translateZ(num distance) #

inherited from Object3D
void translateZ( num distance ) => translate( distance, _vector.setValues( 0.0, 0.0, 1.0 ) );

void updateMatrix() #

inherited from Object3D
void updateMatrix() {

 if ( useQuaternion ) {
   setRotationFromQuaternion( matrix, quaternion );
 } else {
   setRotationFromEuler( matrix, rotation, eulerOrder );
 }

 matrix.setTranslation( position );

 if ( scale.x != 1.0 || scale.y != 1.0 || scale.z != 1.0 ) {
   matrix.scale( scale );
   boundRadiusScale = Math.max( scale.x, Math.max( scale.y, scale.z ) );
 }

 matrixWorldNeedsUpdate = true;
}

void updateMatrixWorld({bool force: false}) #

inherited from Object3D
void updateMatrixWorld( {bool force: false} ) {

if (matrixAutoUpdate) updateMatrix();

 // update matrixWorld
 if ( matrixWorldNeedsUpdate || force ) {
   if ( parent != null ) {
     matrixWorld = parent.matrixWorld * matrix;
   } else {
     matrixWorld = matrix.clone();
   }

   matrixWorldNeedsUpdate = false;

   force = true;
 }

 // update children
 children.forEach((c) => c.updateMatrixWorld( force: force ) );

}

void updateProjectionMatrix() #

void updateProjectionMatrix() {
 if ( _fullWidth != null ) {
   double aspect = _fullWidth / _fullHeight;
   double top = Math.tan( fov * Math.PI / 360.0 ) * near;
   double bottom = -top;
   double left = aspect * bottom;
   double right = aspect * top;
   double width = ( right - left ).abs();
   double height = ( top - bottom ).abs();

   setFrustumMatrix(projectionMatrix,
     left + _x * width / _fullWidth,
     left + ( _x + width ) * width / _fullWidth,
     top - ( _y + height ) * height / _fullHeight,
     top - _y * height / _fullHeight,
     near,
     far );
 } else {
   projectionMatrix = makePerspectiveMatrix(fov * (Math.PI / 180), aspect, near, far);
 }
}

dynamic worldToLocal(Vector3 vector) #

inherited from Object3D
worldToLocal(Vector3 vector) {
 Matrix4 m = this.matrixWorld.clone();
 m.invert();
 m.transform3( vector );
}