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.
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()
print dimension["cl"], dimension["ct"], dimension["cr"], dimension["cb"]
#(left, top, right, bottom)
Key cl: | The first visible left pixel position. |
---|---|
Key ct: | The first visible top pixel position. |
Key cr: | The first visible right pixel position. |
Key cb: | The first visible bottom pixel position. |
Return type: | dict{cl: int, ct: int, cr: int, cb: int} |
The dimension in pixels of the render lines. The render lines show what part of the view is included in the rendered picture:
position = bv.GetSafeFrame()
print position["cl"], position["ct"], position["cr"], position["cb"]
#(left, top, right, bottom)
Key cl: | The first visible left pixel position. |
---|---|
Key ct: | The first visible top pixel position. |
Key cr: | The first visible right pixel position. |
Key cb: | The first visible bottom pixel position. |
Return type: | dict{cl: int, cl: int, cr: int, cb: int} |
Retrieves the parameters for the current projection. See Ocamera.h for projection types. The following is the code used internally to project points:
CAMDIST = 0.05
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==c4d.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==c4d.Pmilitary or projection==c4d.Pfrog or projection==c4d.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==c4d.Pmilitary or projection==c4d.Pfrog or projection==c4d.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==c4d.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{offset: Vector, scale: Vector, scale_z: Vector} |
---|---|
Returns: | The dimension, is never None. |
Returns the camera matrix, i.e. the global object matrix of the current camera object.
Return type: | Matrix |
---|---|
Returns: | The camera matrix. |
Returns the inverse of the camera matrix. Equivalent to GetMg(), but faster.
Return type: | Matrix |
---|---|
Returns: | The inverted camera matrix. |
Returns the projection used by the view. See Ocamera.h for values.
Return type: | int |
---|---|
Returns: | The projection type. |
Returns True if the point is within the boundary returned by GetFrame(). The point coordinates must be in screen space.
Parameters: |
|
---|---|
Return type: |
bool |
Returns: |
True if the point is inside, otherwise False. |
Returns True if the point is visible in the view according to the current projection. The point must be in camera space.
Parameters: | y (Vector) – Y coordinate |
---|---|
Return type: | bool |
Returns: | True if the point is visible, otherwise False. |
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 |
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.
Parameters: | p (Vector) – A point in world space. |
---|---|
Return type: | Vector |
Returns: | The point in screen space. |
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.
Parameters: | p (Vector) – A point in world space. |
---|---|
Return type: | Vector |
Returns: | The point in screen space. |
World to camera conversion. Converts p from world space to camera space and returns the result.
Parameters: | p (Vector) – A point in world space. |
---|---|
Return type: | Vector |
Returns: | The point in camera space. |
Camera to world conversion. Converts p from camera space to world space and returns the result.
Parameters: | p (Vector) – A point in camera space. |
---|---|
Return type: | Vector |
Returns: | The point in world space. |
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.
Parameters: | p (Vector) – A point in screen space. |
---|---|
Return type: | Vector |
Returns: | The point in camera space. |
Camera to screen conversion. Converts p from camera space to screen space (pixels relative to the view) and returns the result.
Parameters: |
|
---|---|
Return type: | |
Returns: |
A point in screen space. |
World to camera vector conversion. Converts the world vector v to camera space and returns the result.
Parameters: | v (Vector) – A vector in world space. |
---|---|
Return type: | Vector |
Returns: | The vector in camera space. |
Camera to world vector conversion. Converts the camera vector v to world space and returns the result.
Parameters: | v (Vector) – A vector in camera space. |
---|---|
Return type: | Vector |
Returns: | The vector in world space. |
New in version R13.058.
Returns the size in world units for a single pixel at the given Z-depth z.
Parameters: |
|
---|---|
Return type: |
float |
Returns: |
The size in world untis. |
New in version R13.058.
Returns the size in pixels for a single world unit at the given Z-depth z.
Parameters: |
|
---|---|
Return type: |
float |
Returns: |
The size in pixels. |
New in version R13.058.
Returns the size in world units for a single pixel at screen space vector p.
Parameters: |
|
---|---|
Return type: |
float |
Returns: |
Size in world units. |
New in version R13.058.
Returns the size in screen space pixels for a single world unit at world position p.
Parameters: |
|
---|---|
Return type: |
float |
Returns: |
Size in screen space pixels. |
Tests the face with center p and normal n for backface culling.
Parameters: | |
---|---|
Return type: | |
Returns: |
True if the face should be visible, otherwise False. |
Indicates if the view has Z near clipping.
Return type: | bool |
---|---|
Returns: | True if the view has Z clipping near, otherwise False. |
Returns the near clipping of Z sensitive view.
Return type: | float |
---|---|
Returns: | Near clipping distance. |
Indicates if the view has Z far clipping.
Return type: | bool |
---|---|
Returns: | True if the view has Z clipping far, otherwise False. |
Returns the far clipping of Z sensitive view.
Return type: | float |
---|---|
Returns: | Far clipping distance. |
New in version R13.058.
Calculates the nearest point on the line defined by p and v for a given mouse coordinate.
Parameters: | |
---|---|
Return type: |
tuple(Vector, float, int) |
Returns: |
The nearest point on the line, the distance from p scaled by the length of v (offset = distance to p / length of v) and an error code:
|
New in version R13.058.
Calculates the nearest point on the plane defined by p and v for a given mouse coordinate.
Parameters: | |
---|---|
Return type: |
tuple(Vector, int) |
Returns: |
The nearest point on the plane and an error code:
|