Class KX_Camera

Tests the given sphere against the view frustum.

Parameters:

• centre (list [x, y, z]) - The centre of the sphere (in world coordinates.)
• radius (float) - the radius of the sphere

Returns:

INSIDE, OUTSIDE or INTERSECT

Example:

       import GameLogic
       co = GameLogic.getCurrentController()
       cam = co.owner
       
       # A sphere of radius 4.0 located at [x, y, z] = [1.0, 1.0, 1.0]
       if (cam.sphereInsideFrustum([1.0, 1.0, 1.0], 4) != cam.OUTSIDE):
               # Sphere is inside frustum !
               # Do something useful !
       else:
               # Sphere is outside frustum

Tests the given box against the view frustum.

Example:

       import GameLogic
       co = GameLogic.getCurrentController()
       cam = co.owner
       
       # Box to test...
       box = []
       box.append([-1.0, -1.0, -1.0])
       box.append([-1.0, -1.0,  1.0])
       box.append([-1.0,  1.0, -1.0])
       box.append([-1.0,  1.0,  1.0])
       box.append([ 1.0, -1.0, -1.0])
       box.append([ 1.0, -1.0,  1.0])
       box.append([ 1.0,  1.0, -1.0])
       box.append([ 1.0,  1.0,  1.0])
       
       if (cam.boxInsideFrustum(box) != cam.OUTSIDE):
               # Box is inside/intersects frustum !
               # Do something useful !
       else:
               # Box is outside the frustum !

Parameters:

• box (list) - Eight (8) corner points of the box (in world coordinates.)

Returns:

INSIDE, OUTSIDE or INTERSECT

Tests the given point against the view frustum.

Example:

       import GameLogic
       co = GameLogic.getCurrentController()
       cam = co.owner

       # Test point [0.0, 0.0, 0.0]
       if (cam.pointInsideFrustum([0.0, 0.0, 0.0])):
               # Point is inside frustum !
               # Do something useful !
       else:
               # Box is outside the frustum !

Parameters:

• point ([x, y, z]) - The point to test (in world coordinates.)

Returns: boolean

True if the given point is inside this camera's viewing frustum.

Returns the camera-to-world transform.

Returns: matrix (4x4 list)

the camera-to-world transform matrix.

Returns the world-to-camera transform.

This returns the inverse matrix of getCameraToWorld().

Returns: matrix (4x4 list)

the world-to-camera transform matrix.

Returns the camera's projection matrix.

Returns: matrix (4x4 list)

the camera's projection matrix.

Sets the camera's projection matrix.

You should use normalised device coordinates for the clipping planes: left = -1.0, right = 1.0, top = 1.0, bottom = -1.0, near = cam.near, far = cam.far

Example:

       import GameLogic

       def Scale(matrix, size):
               for y in range(4):
                       for x in range(4):
                               matrix[y][x] = matrix[y][x] * size[y]
               return matrix
       
       # Generate a perspective projection matrix
       def Perspective(cam):
               return [[cam.near, 0.0     ,  0.0                                  ,  0.0                                      ],
                       [0.0     , cam.near,  0.0                                  ,  0.0                                      ],
                       [0.0     , 0.0     , -(cam.far+cam.near)/(cam.far-cam.near), -2.0*cam.far*cam.near/(cam.far - cam.near)],
                       [0.0     , 0.0     , -1.0                                  ,  0.0                                      ]]
       
       # Generate an orthographic projection matrix
       # You will need to scale the camera
       def Orthographic(cam):
               return [[1.0/cam.scaling[0], 0.0               ,  0.0                   ,  0.0                                  ],
                       [0.0               , 1.0/cam.scaling[1],  0.0                   ,  0.0                                  ],
                       [0.0               , 0.0               , -2.0/(cam.far-cam.near), -(cam.far+cam.near)/(cam.far-cam.near)],
                       [0.0               , 0.0               ,  0.0                   ,  1.0                                  ]]
       
       # Generate an isometric projection matrix
       def Isometric(cam):
               return Scale([[0.707, 0.0  , 0.707, 0.0],
                             [0.408, 0.816,-0.408, 0.0],
                             [0.0  , 0.0  , 0.0  , 0.0],
                             [0.0  , 0.0  , 0.0  , 1.0]],
                             [1.0/cam.scaling[0], 1.0/cam.scaling[1], 1.0/cam.scaling[2], 1.0])
       
       co = GameLogic.getCurrentController()
       cam = co.owner
       cam.setProjectionMatrix(Perspective(cam)))

Parameters:

• matrix (4x4 matrix.) - The new projection matrix for this camera.

Use this camera to draw a viewport on the screen (for split screen games or overlay scenes). The viewport region is defined with setViewport.

Parameters:

• viewport (bool) - the new viewport status

Sets the region of this viewport on the screen in pixels.

Use Rasterizer.getWindowHeight Rasterizer.getWindowWidth to calculate values relative to the entire display.

Parameters:

• top (int)
• bottom (int)
• right (int)
• left (int)

Gets the position of an object projected on screen space.

Example: # For an object in the middle of the screen, coord = [0.5,0.5] coord = camera.getScreenPosition(object)

Parameters:

• arg - KX_GameObject, object name or list [x, y, z]

Returns: list [x, y]

the object's position in screen coordinates.

Gets the vector from the camera position in the screen coordinate direction.

Example: # Gets the vector of the camera front direction: m_vect = camera.getScreenVect(0.5,0.5)

Parameters:

• y (float)
• x (float)

Returns: 3d vector

the vector from a screen coordinate.

Look towards a screen coordinate (x,y) and find first object hit within dist that matches prop. The ray is similar to KX_GameObject->rayCastTo.

Example: # Gets an object with a property "wall" in front of the camera within a distance of 100: target = camera.getScreenRay(0.5,0.5,100,"wall")

Parameters:

• dist (float) - max distance to look (can be negative => look behind); 0 or omitted => detect up to other
• property (string) - property name that object must have; can be omitted => detect any object
• y (float)
• x (float)

Returns: KX_GameObject

the first object hit or None if no object or object does not match prop

camera_to_world

Type:

4x4 Matrix [[float]]

modelview_matrix

Type:

4x4 Matrix [[float]]

world_to_camera

Type:

4x4 Matrix [[float]]