`c4d.BaseView` – a BaseView class¶

BaseView represents an editor view. It cannot be instantiated. In most cases the sub-class BaseDraw is used. It adds functions for drawing into the view.

See the dbasedraw.h description file for container IDs.

class c4d.BaseView¶

BaseView.GetFrame()
BaseView.GetSafeFrame()
BaseView.GetViewParameter()
BaseView.GetMg()
BaseView.GetMi()
BaseView.GetProjection()
BaseView.TestPoint()
BaseView.TestPointZ()
BaseView.TestClipping3D()

BaseView.WS()
BaseView.SW()
BaseView.WC()
BaseView.CW()
BaseView.SC()
BaseView.CS()
BaseView.WC_V()
BaseView.CW_V()

BaseView.BackfaceCulling()
BaseView.ZSensitive()
BaseView.ZSensitiveNearClipping()

SuperClass¶

BaseList2D

SubClass¶

BaseDraw

Methods¶

BaseView.GetFrame()¶

The dimension in pixels of the view window. The coordinates are relative to the upper left corner of the view, and specify visible pixels. (I.e. the border isn’t included.):

dimension = bv.GetFrame()
#dimension["cl"], dimension["ct"], dimension["cr"], dimension["cb"]
#(left, top, right, bottom)

Return type:	dict of int
Returns:	The dimension, is never `None`.

BaseView.GetSafeFrame()¶

The position in pixels of the render lines. The render lines show what part of the view is included in the rendered picture:

position = bv.GetSafeFrame()
#position["from"], position["to"], position["horizontal"]

Key from:

The position of the leftmost/top render line in pixels.

Key to:

The position of the rightmost/bottom render line in pixels.

Key horizontal:

A number to describe how the render lines are oriented.

`SAFEFRAME_NONE`	No render lines used (`from == to == 0`).
`SAFEFRAME_VERTICAL`	The render lines are vertical.
`SAFEFRAME_HORIZONTAL`	The render lines are horizontal.

Return type:	dict of int
Returns:	The dimension, is never `None`.

BaseView.GetViewParameter()¶

Retrieves the parameters for the current projection. See Ocamera.h for projection types. The following is the code used internally to project points:

#Pmilitary, Pfrog, Pgentleman, Pprojection are defined in Ocamera.h

def WorldToCamera(p, camera_matrix):
    return p*(~inverse_camera_matrix)


def CameraToWorld(p, camera_matrix):
    return p*camera_matrix


def CameraToScreen(pp):
    p = c4d.Vector(pp)
    if projection==Pperspective:
        nz = 1.0/CAMDIST if p.z<=00 else 1.0/(p.z + CAMDIST)
        p.x = p.x*scale.x*nz+off.x
        p.y = p.y*scale.y*nz+off.y
        return p

    p.x = (p.x*scale.x)+off.x
    p.y = (p.y*scale.y)+off.y

    if projection==Pmilitary or projection==Pfrog or projection==Pgentleman:
        p.x += p.z*scale.x*sclaez.x
        p.y -= p.z*scale.y*scalez.y
    return p


def ScreenToCamera(pp):
    p = c4d.Vector(pp)
    if projection==Pmilitary or projection==Pfrog or projection==Pgentleman:
        p.x -= p.z*scale.x*scalez.x
        p.y += p.z*scale.y*scalez.y

    p.x = (p.x-off.x)/scale.x
    p.y = (p.y-off.y)/scale.y

    if projection==Pperspective:
        nz = p.z + CAMDIST
        p.x *= nz
        p.y *= nz
    return p

For non-axometric projection here’s the code how to calculate off/scale:

def InitView(camera, xres, yres, pix_x, pix_y):

    opm = camera.GetMg()
    data = camera.GetDataInstance()
    project = data.GetInt(CAMERA_PROJECTION, Pperspective)

    if projection!=Pperspective and projection!=Pparallel:
        opm.v1 = Vector(1.0,0.0,0.0)
        opm.v2 = Vector(0.0,1.0,0.0)
        opm.v3 = Vector(0.0,0.0,1.0)

    off.x = xres*0.5
    off.y = yres*0.5

    if b_ab == Pperspective:
        ap = data.GetFloat(CAMERAOBJECT_APERTURE, 36.0)
        scale.x = data.GetFloat(CAMERA_FOCUS, 36.0) / ap * xres
    else:
        scale.x = xres/1024.0*data.GetFloat(CAMERA_ZOOM,1.0)

    scale.y = -scale.x*pix_x/pix_y
    # ... calculated here


#example how to use GetViewParameter
params = bv.GetViewParameter()
#params["offset"], params["scale"], params["scale_z"]

Key params:	The center of the view in screen space.
Key scale:	For perspective mode: the size of the view plane in pixels. For axonometric modes: the number of pixels per meter.
Key scale_z:	The different Z scale for the X and Y axes in axonometric projections.

Return type:	dict of `Vector`
Returns:	The dimension, is never `None`.

BaseView.GetMg()¶

Returns the camera matrix, i.e. the global object matrix of the current camera object.

Return type:	`Matrix`
Returns:	The camera matrix.

BaseView.GetMi()¶

Returns the inverse of the camera matrix. Equivalent to ~GetMg, but faster.

Return type:	`Matrix`
Returns:	The inverted camera matrix.

BaseView.GetProjection()¶

Returns the projection used by the view. See Ocamera.h for values.

Return type:	int
Returns:	The projection type.

BaseView.TestPoint(x, y)¶

Returns True if the point is within the boundary returned by GetFrame(). The point coordinates must be in screen space.

Parameters:	x (int) – X coordinate y (int) – Y coordinate
Return type:	bool
Returns:	`True` if the point is inside, otherwise `False`.

BaseView.TestPointZ(z)¶

Returns True if the point is visible in the view according to the current projection. The point must be in camera space.

Parameter:	y (`Vector`) – Y coordinate
Return type:	bool
Returns:	`True` if the point is visible, otherwise `False`.

BaseView.TestClipping3D(mp, rad, mg)¶

Tests if a bounding box is visible in the view according to the current projection. The box is defined by these eight corner coordinates:

p = ( )
p.append(c4d.Vector(mp.x + rad.x, mp.y + rad.y, mp.z + rad.z) * mg)
p.append(c4d.Vector(mp.x + rad.x, mp.y + rad.y, mp.z - rad.z) * mg)
p.append(c4d.Vector(mp.x + rad.x, mp.y - rad.y, mp.z + rad.z) * mg)
p.append(c4d.Vector(mp.x + rad.x, mp.y - rad.y, mp.z - rad.z) * mg)
p.append(c4d.Vector(mp.x - rad.x, mp.y + rad.y, mp.z + rad.z) * mg)
p.append(c4d.Vector(mp.x - rad.x, mp.y + rad.y, mp.z - rad.z) * mg)
p.append(c4d.Vector(mp.x - rad.x, mp.y - rad.y, mp.z + rad.z) * mg)
p.append(c4d.Vector(mp.x - rad.x, mp.y - rad.y, mp.z - rad.z) * mg)

#example
result = bv.TestClipping3D(mp, rad, mg)
#result["visible"], result["clip2d"], result["clipz"]

Key visible:	`True` if the box is visible at all, otherwise `False`.
Key clip2d:	Is `True` if the box needs 2D clipping, i.e. if any part of it is outside of the view boundaries. Otherwise `False`.
Key clipz:	Is assigned `True` if the box needs Z clipping, i.e. if any part of it is too close to or behind the camera. Otherwise `False`.
Return type:	dict of bool:
Returns:	The result

BaseView.WS(p)¶

World to screen conversion. Converts p from world space to screen space (pixels relative to the view), and returns the conversion. The orthogonal distance to the world point is stored in world units in the Z axis of the result.

Parameter:	p (`Vector`) – A point in world space.
Return type:	`Vector`
Returns:	The point in screen space.

BaseView.SW(p)¶

Screen to world conversion. Converts p from screen space (pixels relative to the view) to world space. The X and Y coordinates of the point are given in screen space; the Z coordinate is the orthogonal distance in world units to the point from the view plane. The result of the conversion is returned.

Parameter:	p (`Vector`) – A point in world space.
Return type:	`Vector`
Returns:	The point in screen space.

BaseView.WC(p)¶

World to camera conversion. Converts p from world space to camera space and returns the result.

Parameter:	p (`Vector`) – A point in world space.
Return type:	`Vector`
Returns:	The point in camera space.

BaseView.CW(p)¶

Camera to world conversion. Converts p from camera space to world space and returns the result.

Parameter:	p (`Vector`) – A point in camera space.
Return type:	`Vector`
Returns:	The point in world space.

BaseView.SC(p)¶

Screen to camera conversion. Converts p from screen space (pixels relative to the view) to camera space and returns the result. The X and Y coordinates of the point are given in screen space; the Z coordinate is the orthogonal distance in world units to the point from the view plane.

Parameter:	p (`Vector`) – A point in screen space.
Return type:	`Vector`
Returns:	The point in camera space.

BaseView.CS(p, z_inverse)¶

Camera to screen conversion. Converts p from camera space to screen space (pixels relative to the view) and returns the result.

Parameters:	p (`Vector`) – A point in camera space. z_inverse (bool) – If `True` the Z coordinate of the converted point is inverted. This is used by the Z-buffer.
Return type:	`Vector`
Returns:	A point in screen space.

BaseView.WC_V(v)¶

World to camera vector conversion. Converts the world vector v to camera space and returns the result.

Parameter:	v (`Vector`) – A vector in world space.
Return type:	`Vector`
Returns:	The vector in camera space.

BaseView.CW_V(v)¶

Camera to world vector conversion. Converts the camera vector v to world space and returns the result.

Parameter:	v (`Vector`) – A vector in camera space.
Return type:	`Vector`
Returns:	The vector in world space.

BaseView.BackfaceCulling(n, p)¶

Tests the face with center p and normal n for backface culling.

Parameters:	n (`Vector`) – The face normal. p (`Vector`) – The face center.
Return type:	`Vector`
Returns:	`True` if the face should be visible, otherwise `False`.

BaseView.ZSensitive(n, p)¶

Indicates if the view has Z clipping.

Return type:	bool
Returns:	`True` if the view has Z clipping, otherwise `False`.

BaseView.ZSensitiveNearClipping(n, p)¶

Returns the near clipping of Z sensitive view.

Return type:	float
Returns:	Near clipping distance.

`c4d.BaseView` – a BaseView class¶

SuperClass¶

SubClass¶

Methods¶

Table Of Contents

This Page

Navigation

c4d.BaseView – a BaseView class¶

SuperClass¶

SubClass¶

Methods¶

Table Of Contents

This Page

Quick search

Navigation

`c4d.BaseView` – a BaseView class¶