cPy.cModel module

class JType(value)

Bases: Enum

Flags and types for snapping joints.

AxialMask = 255

Vertical = 256

Horizontal = 512

Free = 1024

Tile = 2048

TypeMask = 61440

Type1 = 4096

Type2 = 8192

Type3 = 16384

Type4 = 32768

IsConnector = 65536

IsPlug = 131072

KeepDirection = 262144

ManualRotate = 524288

AutoFlipX = 1048576

AutoFlipY = 2097152

AutoFlipZ = 4194304

class VolMarker

Bases: object

mark pints in space, used for inter-volume segmental selection

Empty: bool

Activated: bool

T: cMat4

Ti: cMat4

Initial: any

Clear()

Check(pos: cVec3) → bool

Mark(pos: cVec3)

SetupMatrix(src: any)

class ABOcTree

Bases: object

Axis-Aligned Box Octree for fast spatial lookups of volume cells.

Depth: int

Levels: any

Update(VO: any)

AddDirtyCell(Level: int, tz: any, AB: any)

Clear()

class SpOcTree

Bases: object

Spatial Octree implementation for raycasting.

L0: any

Center: cVec3

Side: float

NeedFreeze: bool

Root: any

Temp: any

AddCell(vo: any, vc: any)

AddSmoothedVO(vo: any)

Create(Smoothed: bool = True, Anyway: bool = False)

Clear()

void CreateForVO(VORenderQueue& RQ);

PrepareToScan()

Scan(Start: cVec3, Dir: cVec3, Len: float, res: any) → bool

static ScanAll(Start: cVec3, Dir: cVec3, Len: float, res: any, Sharp: bool = True) → bool

static CreateAll(Smoothed: bool = True)

static CreateVO(VO: any)

static RestoreAll()

static ClearAll()

class VolumeColorizer

Bases: object

Helper class to handle volumetric color rendering and layer management.

cells: any

SingleLayer: int

AddCell(vc: any)

RenderToVolume(vo: any, MT: cMat4)

static RenderAllVolumes(Layer: int)

static GetColorDebt(vo: any, L: int) → any

static FinishColorDebts()

class VolumeObject

Bases: BaseClass

One layer without hierarchy in the SculptRoom.

Represents volume object. Volume object may be in volume or surface

representations depends on bool InSurfaceRepresentation().

In volume mode voxels are modified and then mesh is generated.

In surface mode mesh is modified then voxels are generated.

The transform matrix of volume corresponds to latest selected instance in VoxTree.

There may be multiple references from VoxTree to the same VolumeObject.

VolumeObject is voxel/surface object not placed in tree. VoxTreeBranch is the object reference.

All active VoxelObject’s are kept as linear set in VTree array.

RootVTree consists of hiererchial set of references of objects from this array.

Each VolumeObject contains complete information about geometry in local space.

Correct transform matrices are kept in VoxTreeBranch that refers this VolumeObject.

Transform matrices in VolumeObject correspond to non-instanced VoxTree element.

If object is instance transform matrix in VolumeObject is

different form VoxTreeBranch transform.

see VoxTreeBranch

linkedToRetopoObj: bool

topologyLockedByLinkedObject: bool

SpaceID: int

Unique ID of the volume, same as VoxTreeBranch::SpaceID.

LoadTimeSpaceID: int

SpaceName: cStr

CacheName: cStr

Cache reference.

Ghost: bool

cache() → str

boolean_root: any

GetGlobalSummaryCut(p: cVec3, root: any = None) → float

GetSummaryCutExcept(p: cVec3, except_vo: VolumeObject, root: any = None, density: float = None) → cVec3

CuttingOperation: int

0 - none, 1 - subtract, 2 - intersect, 3 - add

FlipFaces: bool

BooleansDisabled: bool

Subd: any

CurrentSubdLevel: int

DestroySubdLevels() → bool

volumetricalGettter: any

linkedObjects: any

NGObjectIdx: int

AverageEdgeLengthInPen: float = 0.0

BackBufferTextureID: int = 573

BackBufferDepthID: int = 574

BBSizeX: int = -1

BBSizeY: int = -1

RenderStamp: any = 4

static int VoxThreshold; // without implementation

LightColor: cVec4 = 1.0000 1.0000 1.0000 1.0000

LightScatter: float = 0.0

GloballyAllowVoxelColoring: bool = False

Value:

#00000000

GloballyIntentVoxelColoring: bool = False

Value:

#00000000

LightColor2: cVec4 = 1.0000 1.0000 1.0000 1.0000

111 for external light, rgb for panorama.

IsExternalLight: float = 0.0

1 for external light, 0 for panorama.

AllowBB: bool = True

WholeDirty: bool = True

Incremental: bool = False

AllowProgress: bool = False

IgnoreDropUndo: bool = False

NoVoxMerge: bool = False

InvisibleMode: bool = True

GlobalSortTriangles: bool = False

static SetCur(tb: any, Fast: bool = False, keepsym: bool = False, flash: bool = True)

static WarnIfSurface(HasCancel: bool) → bool

OldColor: any

Color to be restored when volume will be turned back to surface mode.

ScaleChange: float

How scale is changed when passed to proxy mode.

VolumeExtrusion: float

bkCells: any

VoxOcTree: ABOcTree

Represents OcTree structure for fast finding of volume cells.

LocalAABB: any

PickFarPlane: float

< AABB in local space

PickNearPlane: float

< far plane position in picked radius

PickAvgPlane: float

< closest plane position in picked radius

PickPlane: float

< average plane position in picked radius

PickListDirty: int

< plane position of picked center

LastDrawn: any

Border: int

< last drawn bound box of cells centers in local space

MinCell: any

< border for dencity falloff in voxel objects, usually is 4

MaxCell: any

< min for bound box of cell indices, x,y,z

Transform: cMat4

< max for bound box of cell indices, x,y,z

TransformInv: cMat4

< transform from local to global space

Visible: bool

< transform from global to local space

InCache: bool

< better refer visibility from VoxTreeBranch

SurfaceColorChanged: bool

< is in cache state

RawObjTris: int

RawInSurfaceRepresentation: int

CurCacheMethod: int

LastPolycount: int

ScaleFactor: float

Environment: VolumeObject

< scale factor, it is like simplified transform from local to global space. If you need to get some distance approx in local space, divide it on ScaleFactor

HiddenVolume: VolumeObject

IdxAllocator: any

Allows to allocate / free global indices for mesh represented by MeshInVCell.

TempRef: VolumeObject

CellsChanged: bool

HasLeakyPos: bool

CompletelyRebuilt: bool

HasTransparency: bool

< this is for undo, it indicates that structure of volume changed drastically, almost no correstondence between old and new

RenderJustFacture: bool

< for render - nood to sort triangles or not

SomethingNewSelected: bool = False

Joints: any

Joints of all merged objects

BackupJoints: any

AddJoint(J: any, GlobalTransform: cMat4)

Add joint to volume, GlobalTransform is transform matrix for model in world space

AddAllJoints()

Add all joints registered in VoxelSculptTool

Color: int

ApproxColor: int

ApproxSpec: int

< bot baking of approximate shader color

ApproxMet: int

Est: any

PbrEst: any

< estimate hader approximately

Shader: any

SetTransform(M: cMat4, symm: bool)

TransformPt(P: cVec3)

TransformScalar(P: float)

TransformVec(P: cVec3)

TransformNrm(P: cVec3)

TransformPtInv(P: cVec3)

TransformVecInv(P: cVec3)

TransformNrmInv(P: cVec3)

TransformScalarInv(P: float)

CheckIfUseCUDA(Radius: float) → bool

GenerateCavity()

GenerateCavity2()

DiscardCavity()

UsesLayer(L: int) → bool

FlipNormals()

LastWorkPoint: cVec3

SubCellSize: int

DefCellSize: int

DefCellShift: int

NumBackups: int

SurfaceChanged: bool

NeedOcTreeRefine: bool

SimpleStampMode: bool

HideMode: bool

InSurfaceRepresentation: bool

RenderOrder: any

OrderDir: cVec3

GetCell(t: any, Create: bool, CreateBackup: bool = False, Multithreaded: bool = True) → any

GetBackup(x: int, y: int, z: int) → any

CreateBackup(x: int, y: int, z: int) → any

MoveToBackup(x: int, y: int, z: int) → any

DetachModifiers()

ClearBackups()

CreateCellsNearCells()

Clear(KeepCache: bool = False)

ClearWithUndo()

static ClearLeakyPos()

RestoreColors()

TotalSmooth(Times: int = 1)

DeleteCell(x: int, y: int, z: int)

CalcCellsAABB()

CalcCellsAABBTransformed(by_tree: bool = True) → any

EstimateObjectColor()

CreateEstimateStructures()

ClearEstimateStructures()

static ClearAllEstimateStructures()

GetObjectColor(pos: cVec3, Specular: int, spop: int, met: int, Normal: cVec3, srs: any = None, Cavity: float = 0, PixSize: float = 0) → cVec4

static EstimateAllObjectsColor()

EnsureHiddenVolumeExists()

GetAverageVoxelNormalInSphere(Center: cVec3, Radius: float) → cVec3

Create shape in volume using getter and StartPoint recursively. All points are in local space

GetAverageVoxelNormalAndPosInSphere(Center: cVec3, Radius: float, nrmSampling: float = 1.0, posSampling: float = 1.0, FromBackup: bool = True, Preferred: cVec3 = cPy.cTypes.cVec3.Zero) → cVec3

UpdateVixelNormalsInLocalTrajectory(pts: any)

UpdateVixelNormalsAndAveragePositionsInLocalTrajectory(pts: any)

CreateFuncShapeCUDA(fn: any, Pos: cVec3, Where: any, Subtract: int, Additive: bool = False, ComplexCheck: bool = False, UseTemp: bool = False, Extrusion: int = 0)

Creates the arbitrary volxels shape

Parameters:

• fn – the callback that defines the shape. Gets position of the point returns the value 0..1 to be set as voxel value

• Subtract (int) – Subtract = 0: add, 1:subtract, 255: replace

• UseTemp (bool) – set true if you want modify the cell afterward, all passed values will be kept in temp location and placed into the cell after the whole operation will be completed.

CreateFuncShapeWeighted(fn: any, Pos: cVec3, Where: any, Subtract: bool, Additive: bool = False)

ApplySurfChange(fn: any, Pos: cVec3, Where: any, Reader: any = None, SmDeg: float = 0)

CreateSphere(Pos: cVec3, Radius: float, Subtract: bool, Additive: bool = False)

CreateSphereSegment(Start: cVec3, End: cVec3, RadiusS: float, RadiusE: float, Subtract: int, Additive: bool = False)

CopySphereSegment(Start: cVec3, End: cVec3, RadiusS: float, RadiusE: float)

TransferCells(x: int, y: int, z: int) → any

TransferSphereSegment(Dest: VolumeObject, Start: cVec3, End: cVec3, RadiusS: float, RadiusE: float)

TransferSphereSegmentSymm(Hide: bool, Start: cVec3, End: cVec3, RadiusS: float, RadiusE: float)

CreateSphereSegmentSymm(Start: cVec3, End: cVec3, RadiusS: float, RadiusE: float, Subtract: int, Additive: bool = False)

CopySphereSegmentSymm(Start: cVec3, End: cVec3, RadiusS: float, RadiusE: float, Subtract: bool)

CreateSegment(Start: cVec3, NS: cVec3, AspectS: float, End: cVec3, NE: cVec3, AspectE: float, R1: float, R2: float, ExtraLayerWidth: float, Subtract: bool)

CreateSegmentSymm(Start: cVec3, NS: cVec3, AspectS: float, End: cVec3, NE: cVec3, AspectE: float, R1: float, R2: float, ExtraLayerWidth: float, Subtract: bool, DoubleSided: bool = False, PlaneLimit: bool = False)

void CreateLimSegment(Vector3D Start,Vector3D NS,float AspectS,Vector3D End,Vector3D NE,float AspectE,float R1,float R2,cPlane PL,float ExtraLayerWidth,bool Subtract); // implementation not found

PerformSmoothing(Pos: cVec3, Radius: float, AddValue: float = 0, AddMode: int = 0)

void CreateLimSegmentSymm(Vector3D Start,Vector3D NS,float AspectS,Vector3D End,Vector3D NE,float AspectE,float R1,float R2,cPlane PL,float ExtraLayerWidth,bool Subtract,bool DoubleSided=false); // implementation not found

PerformSmoothingCUDA(Pos: cVec3, Radius: float, AddValue: float = 0, AddMode: int = 0)

PerformSmoothingSymm(Pos: cVec3, Radius: float, AddValue: float = 0, AddMode: int = 0)

PerformPinchVox(Pos1: cVec3, Radius1: float, N1: cVec3, Pos2: cVec3, Radius2: float, N2: cVec3, Degree: float, Shift: cVec3)

PerformPinchVoxSymm(Pos1: cVec3, Radius1: float, N1: cVec3, Pos2: cVec3, Radius2: float, N2: cVec3, Degree: float, Shift: cVec3)

GrowSurface(Start: cVec3, NStart: cVec3, StartD: float, End: cVec3, NEnd: cVec3, EndD: float, R1: float, R2: float, Subtract: bool, UsePen: bool, UseTemp: bool)

GrowSurfaceSymm(Start: cVec3, NStart: cVec3, StartD: float, End: cVec3, NEnd: cVec3, EndD: float, R1: float, R2: float, Subtract: bool, UsePen: bool, UseTemp: bool)

ApplyPlane(Start: cVec3, N: cVec3, Radius: float, disp: float)

ApplyPlaneSymm(Start: cVec3, N: cVec3, Radius: float, disp: float)

AddCellTriangulation(cx: int, cy: int, cz: int) → any

void DrawPressStroke(Vector3D Start,Vector3D End,Vector3D NStart,Vector3D NEnd,float R1,float R2,float Pressure,bool Subtract); // implementation not found

AddCellTriangulation2(cx: int, cy: int, cz: int) → any

AddGlobalCellQuads(cx: int, cy: int, cz: int, vc: any, TC: any)

AddGlobalCellTriangulation(cx: int, cy: int, cz: int, vc: any, TC: any, M: cMat4)

AddGlobalCellTriangulation3(cx: int, cy: int, cz: int, vc: any, TC: any, M: cMat4)

AddIndexedCellTriangulation(cx: int, cy: int, cz: int) → any

void AddGlobalCellTriangulationG(int cx, int cy, int cz, VolumeCell* vc, TriangulationContext* TC, const Matrix4D& M, cList_int * CellPos = NULL); // implementation not found

AddIndexedCellTriangulation2(cx: int, cy: int, cz: int) → any

CreateFuncShapeInCell(cx: int, cy: int, cz: int) → any

CreateFuncShapeInCellW(cx: int, cy: int, cz: int) → any

CreateFuncShapeInCellUsingTemp(x: int, y: int, z: int) → any

MakeSmoothingInCell(cx: int, cy: int, cz: int) → any

MakeSmoothingInCell3(cx: int, cy: int, cz: int) → any

MakeSmoothingInCell2(cx: int, cy: int, cz: int) → any

MakePinchInCell(cx: int, cy: int, cz: int) → any

GrowDensityInCell2(cx: int, cy: int, cz: int) → any

VolumeCell* GrowSurfaceInCell(int cx,int cy,int cz); // implementation not found

GrowDensityInCell(cx: int, cy: int, cz: int) → any

CutHullInCell(cx: int, cy: int, cz: int) → any

ClearAllTemp()

static ClearAllTempForAll()

MarkDirtyCell(cx: int, cy: int, cz: int, onlymesh: bool = False, MultiThread: bool = False)

GetInterpValueThrough(Pos: cVec3, Backup: bool = False) → float

GetVolumetricValue(Pos: cVec3) → float

GetCutByParents(Pos: cVec3, max_density: float = None, except_vo: VolumeObject = None) → float

GetSummaryCut(Pos: cVec3, max_density: float = None, except_vo: VolumeObject = None) → float

GetInterpLSumm(dst: any, pos: cVec3, con: any, TempStorage: any)

static float GetCut(Vector3D Pos, float* max_density, VolumeObject* except); // implementation not found

GetFastNormal(p: cVec3, normalize: bool = True) → cVec3

GetInterpNormalThrough(Pos: cVec3, dst: float) → cVec3

GetInterpColorThrough(Pos: cVec3, Specular: int = None, me: int = None, Normal: cVec3 = None, srs: any = None) → int

GetInterpColorThroughLayered(Pos: cVec3, Info: any, N1: cVec3, srs: any = None, PixSize: float = 0)

GetOcclusionThrough(Pos: cVec3, dst: float) → float

GetCavity(Pos: cVec3, dst: float) → float

GetInterpNormalSmThrough(Pos: cVec3, dst: float) → cVec3

GetInterpEdgeValue(Pos: cVec3, Cash: any) → float

GetInterpValueSm(Pos: cVec3) → float

GetInterpValueSmNThrough(Pos: cVec3, N: cVec3) → float

GetInterpValueSmThrough(Pos: cVec3) → float

GetCInterpValue(Pos: cVec3, Backup: bool, Cash: any) → float

GetPreciseValue(x: int, y: int, z: int, Cash: any, Backup: bool = False) → any

GetPreciseValueRef(x: int, y: int, z: int, Cash: any) → any

SetPreciseValue(x: int, y: int, z: int, V: any, Cash: any)

GetInterpNormal(Pos: cVec3, Backup: bool = False) → cVec3

GetInterpPreciseNormal(Pos: cVec3, Dist: float) → cVec3

GetInterpEdgeNormal(Pos: cVec3, Backup: bool = False) → cVec3

GetInterpNormal2(Pos: cVec3, Backup: bool = False) → cVec3

UpdateMeshRect(cx: int, cy: int, cz: int, mc: any)

UpdateFilling()

CreateWholeMesh()

UpdateMesh(NoCuda: bool = False)

static Render(IncludingPMS: bool = False, IncludingRtp: bool = False, ShadowOnly: bool = False)

DrawPickPlane(invonly: bool = False)

ScanRay(Orig: cVec3, Dir: cVec3, Length: float) → bool

OcScanRay(Orig: cVec3, Dir: cVec3, Length: float, Quick: bool = False) → bool

ScanCells(Orig: cVec3, Dir: cVec3, Length: float) → bool

ScanCellsGrad(Orig: cVec3, Dir: cVec3, Length: float) → bool

ScanCellsGradSmart(Orig: cVec3, Dir: cVec3, Length: float, sm: bool) → bool

ScanCellsGradSm(Orig: cVec3, Dir: cVec3, Length: float) → bool

Pick(Res: cVec3, pic: any, OnlyPosition: bool = False) → bool

SnapToVolume(pos: cVec3, dir: cVec3) → cVec3

StoreLayerToFile(y: float, Name: str)

void ApplyToPickPool(Vector3D Pos,float Radius,fnGetSurfDisp4* fn,fnGetSurfDisp2* Reader,float SmDeg); // implementation not found

Restore(BS: any, TryToFind: bool = False, CacheName: str = None)

StoreGlobalIds(VO: VolumeObject, BS: any)

RestoreGlobalIds(VO: VolumeObject, BS: any)

MergePMS(PMS: any, Scale: float)

ApplyHoleRect(Dest: VolumeObject = None, SplitBorder: float = 0, EraseOld: bool = True, Additive: bool = False)

ApplyFilledRect(Start: cVec3, N: cVec3, Symm: cMat4, neg: bool = False)

ApplyFilledRectSymm(Start: cVec3, N: cVec3, neg: bool = False)

EnsureNativeIfInVoxels()

ApplyMeshChange(Forced: bool = False)

ApplyMeshChangeAB(Forced: bool = False)

DetectPureGeometry() → int

VoxelizePureGeometry(Manually: bool, AsShell: bool, tovox: bool = True, suggestedpoly: int = 0)

GetPolycount() → int

DetectRealVoxels() → bool

GetAverageEdgeLength(inGlobalSpace: bool) → float

GetDimensionsInBasis(x: cVec3 = cPy.cTypes.cVec3.AxisX, y: cVec3 = cPy.cTypes.cVec3.AxisY, z: cVec3 = cPy.cTypes.cVec3.AxisZ) → any

MergeWithGivenPolycount(PolyCount: int, dest: VolumeObject, undo: bool, shelldepth: float = 0) → float

MergeAdaptively(PolyCount: int, dest: VolumeObject) → float

UpdateLayersFromVolumetricColor(vc: any, tm: cMat4)

ApplySimplifiedMeshChange(Subtract: int)

ApplyMeshChangeOnTheFly()

ProcessMeshChange()

ApplyMeshChangeSimple()

ApplyMeshChangeRough()

ApplySurfaceDistortion(P: cVec3, R: float, Dist: float, Method: int)

ShrinkSurface(Pos1: cVec3, Radius1: float, Pos2: cVec3, Radius2: float, Dist: float)

ApplySurfaceDistortionSymm(P: cVec3, R: float, Dist: float, Method: int = 0)

ShrinkSurfaceSymm(Pos1: cVec3, Radius1: float, Pos2: cVec3, Radius2: float, Dist: float)

SetSurfClay(Pos: cVec3, Radius: float, D: float)

SetSurfPlane2(Pos: cVec3, Radius: float, Dir: cVec3, Softness: float)

SetSurfPlaneSymm(Pos: cVec3, Radius: float, D: float = 0, Dir: cVec3 = cPy.cTypes.cVec3.Zero, SmDegree: float = 0)

StrongSmooth(Pos: cVec3, Radius: float, SmDegree: float, SmType: int)

MoveSurfaceSymm(Start: cVec3, Radius: float, Dist: cVec3, Additive: bool)

WrapCell(cx: int, cy: int, cz: int)

WrapCell2(cx: int, cy: int, cz: int, AdditionalSource: VolumeObject)

GrowDencity()

SetEmplty()

Symmetry()

CleanSurface()

LegacyFix()

Decompose(MinCluster: int, DelSize: int)

DeleteHidden()

< Separate loose parts

Decimate()

DecimateEx(Degree: float, Undo: bool, rk: float) → bool

Shell()

Bevel()

< Global operators

RemoveSelfIntersections()

CloseHolesFastAndGood(weld: bool, maxcontour: int = 100000) → any

if maxcontour == 0 it just returns (HolesCount,MaxHole)

CloseSurfHoles(interp: bool = True, type: int = 0, Accuracy: float = 0.22, MaxContourLength: int = 10000000)

EstimateHoles(MaxHole: int, MinHole: int, NHoles: int)

RenderAO(RenderPMS: bool = False)

DelUnused()

HideInRadius(Pos: cVec3, Radius: float, Hide: bool)

HideInRadiusSymm(Pos: cVec3, Radius: float, Hide: bool)

MarkFreezeInSurfMode(Pos: cVec3, Radius: float, Pos1: cVec3, Radius1: float, Inv: bool, Degree: float, Degree1: float, Additive: bool)

MarkFreezeInSurfModeSymm(Pos: cVec3, Radius: float, Pos1: cVec3, Radius1: float, Inv: bool, Degree: float, Degree1: float, Additive: bool)

SmoothFreezeInSurfMode(Pos: cVec3, Radius: float, Degree: float)

SmoothPoseInSurfMode(Pos: cVec3, Radius: float, Degree: float)

ExpandFreezeInSurfMode(Pos: cVec3, Radius: float, inv: bool)

SmoothColorInSurfMode(Pos: cVec3, Radius: float, Degree: float, count: int = 1)

SmoothColorInVoxelMode(Pos: cVec3, Radius: float, Degree: float, count: int = 1)

SmoothCavityInSurfMode(count: int, SharpDegree: float, SmoothDegree: float)

SmoothFreezeInSurfModeSymm(Pos: cVec3, Radius: float, Degree: float)

static SmoothFreezeInPaintRoom(Pos: cVec3, Radius: float, Degree: float)

InvertSurfFreeze()

static InvertPoseSelection()

static ApplyPoseSelection() → bool

UpdateDirtyPoseSelection()

ConvertPoseSelectionToFreeze()

UnfreezeSurf()

AllocVox(Filler: any) → any

FreeVox(vc: any)

AllocCell() → any

FreeCell(vc: any)

CreateSegSelection(P1: cVec3, P2: cVec3, EyeDir: cVec3, PP: any, LSP: cMat4, Mode: int, SubMode: int) → cVec3

CreateRectSelection(EyeDir: cVec3, PP: any, LSP: cMat4, Mode: int, SubMode: int, FreezeOnly: bool, WeightMod: float = 1.0) → cVec3

CreateSegSelectionSymm(P1: cVec3, P2: cVec3, EyeDir: cVec3, PP: any, LSP: cMat4, Mode: int, SubMode: int) → cVec3

CreateRectSelectionSymm(EyeDir: cVec3, PP: any, LSP: cMat4, Mode: int, SubMode: int, FreezeOnly: bool, WeightMod: float = 1.0) → cVec3

GetMainAxis(UseFreeze: bool, InvFreeze: bool, UseSymm: bool, RefPoint: cVec3) → cMat4

GetSelBasis(UseFreeze: bool, InvFreeze: bool, UseSymm: bool, RefPoint: cVec3) → cMat4

ExtrudeSurfInRect(EyeDir: cVec3, Dist: float, AvgNormal: int)

ExtrudeSurfInRectSymm(EyeDir: cVec3, Dist: float)

ClearSegSelection(PP: any, Remesh: bool = False, Undo: bool = False)

ApplyPenSelection(P: cVec3, R: float, Mode: bool, Transparency: float)

ApplyPenSelectionSymm(P: cVec3, R: float, Mode: bool, Transparency: float)

PrintMemUsageReport()

CopyTo(Dest: VolumeObject, Undo: bool = True)

MergeToOtherVO(VO: VolumeObject, Sub: int = False)

MergeToThisVO(ExtraTransform: cMat4, ClearThis: bool, NoUndo: bool = False)

ExtrudeVO(Value: float, Sub: int = 0, Clr: bool = False, forcevox: bool = False)

CreateShell(Value: float)

MakeHull(L: int)

MergeHullToOtherVO(VO: VolumeObject, In: float, Out: float, ReScale: bool)

RemoveConnectedParts(pt: cVec3, remBB: any, MaxRadius: float)

Remove parts, connected to nearest point

ToSTL(OnlyThis: bool, BS: any, SingleM: cMat4 = cPy.cTypes.cMat4.Identity, OnlySel: bool = False) → bool

Throw to cMeshContainer.

For example

|         cMeshContainer  mc;
|         this->ToRawMesh( true, true, &mc, Matrix4D::Identity, false );

odo Note unobvious params.

GetVoTNB(T: cVec3, N: cVec3, B: cVec3, R: bool)

RestoreFromBackup()

Flip(x: bool, y: bool, z: bool)

MakeUniform(global_space: bool)

ExportRawVoxels(File: str, bits: int, CreateHeader: bool, color: bool, gloss: bool, layers: bool)

ImportRawVoxels(File: str, offset: int, bits: int, Lx: int, Ly: int, Lz: int, Scale: float)

EstimateInitialParameters(File: str, offset: int, bits: int, Lx: int, Ly: int, Lz: int) → bool

static ExportRawVoxelsWithDialog()

static ImportRawVoxelsWithDialog()

SplitInTwo(InsertInTree: bool, EraseOld: bool, subtree: bool = False, changetool: bool = True) → VolumeObject

HideVoxRect(Hide: bool)

UnhideAllVoxels()

SeparateHidden()

ToCache()

FromCache()

FromCacheEx()

ApplySketchToCell(x: int, y: int, z: int) → any

CreateSketch(num_steps: int = 2, Softness: float = 0)

Barelief(Org: cVec3, Dir: cVec3, Coef: float, FreeEdges: bool = False, Tapering: float = 0, KeepScale: bool = False, Undo: bool = True, ExDensity: float = 1.0, KeepBottom: bool = False)

LegacyBarelief(Org: cVec3, Dir: cVec3, Coef: float, FreeEdges: bool = False, Tapering: float = 0, KeepScale: bool = False, Undo: bool = True, ExDensity: float = 1.0, KeepBottom: bool = False)

RemoveUndercuts(Start: cVec3, Dir: cVec3, Tapering: float, KeepBottom: bool = False)

DirectionalNormalsSmoothing(LocalDir: cVec3, divirvence: float)

CutUnderPlane(Start: cVec3, Dir: cVec3)

RemoveInvisibles()

ToSurfMode(ask: bool = False)

ToVoxMode()

SurfSmoothAll()

SmoothOpenEdgesDialog()

SmoothOpenEdges(times: int)

SurfIdeal()

CloseInnerHoles()

RemoveIndexedStructure()

CreateIndexedStructure()

CreateIndexedStructure2()

< fills GlobalVertIndices for every cell, assigns global index for each vertex

CreateAdjacent()

< fills GlobalVertIndices for every cell, assigns global index for each vertex, the difference is that this function makes job basing on coordinates of vertices

MergeRegularMesh(mc: any, Inv: bool)

CreateGlobalVoxAABB(AB: any, Subtrct: bool)

SubdivBkCellsIfNeed()

SubdivAllCells()

FixVCLayersErrors(vc: any)

PerformVolumeCSG(Fiels: any, gen: any)

SurfaceRectCut(T: cMat4, symidx: int = 1)

SurfaceRectCloseHole(T: cMat4)

SurfaceRectMakeHole(T: cMat4)

BooleanMerge(bm: any, sub: int)

SurfaceRectCut2(Field: any, ProjField: any)

SurfaceRectCloseHole2(Field: any)

SurfaceRectMakeHole2(Field: any)

CheckLinearFit()

RemoveUnusedVerts()

static RemoveUnusedVertsForAllVolumes()

ReorderCells(Undo: bool = True, Subcells: bool = True)

CheckGlobals()

ChecAttr()

OptimizeTables()

CheckDupIds()

OptimizeIndicesUsage()

Reproject(InDistance: float, OutDistance: float, method: int, reprojectcolor: bool)

CalculateAllNormals()

CalcSquare() → float

static EnsurePaintLayer()

static AutoPaintInVolume(operation: str) → bool

static AutoRectInVolume(operation: str) → bool

SplitByCurve(cu: any, Thickness: float = 0, method: int = 0, make_shape: bool = False)

SplitRich(cu: any)

MakeBevelOverCurve(cu: any)

GetClosestCell(pt: cVec3, Global: bool) → cVec3

SurfSubdiv(calcGraph: any, layers: bool = True, scale: bool = True, linear: bool = False)

StepDown(skipChanges: bool = False)

ClearSubdLevels()

TestMultiresolution(message: str = None) → bool

CheckIfMultiresolutionUsed() → bool

TopologyLocked() → bool

CollapseBooleans()

class SmoothParams

Bases: BaseClass

SmoothingDegree: float

Tangent: bool

Relaxation: bool

KeepSharpEdges: bool

KeepOpenEdges: bool

InvertFreeze: bool

class VolumeCell

Bases: object

Contains voxel values.

Each volume / surface object consists of cells. In case of voxels all cells has same width

in space - 8 voxels, array of voxels is 9x9x9 - last, 9’s is from right neighbour cell.

In voxel mode you are operating with voxels, surface will be generated by voxels using marshing cubes.

In case of surface there is no voxel data (polygons / layers / colors) are kept in VolumeCellAttrib.

Destroy()

Destroy2()

Attr: any

Represents cell’s polygonal surface. If it is nullptr, there are no faces in the cell.

Owner: VolumeObject

BackupDropTick: int

Cells before this change. Undo will get to this state when applied.

Backup: VolumeCell

Temp: any

Values: any

Pointer to voxels array 9x9x9. Voxel values itself, <=32767 - empty space, >=32768 - filled space.n For details, it may be zero if all voxels are the same. In this case SameValue contains this same value. Surface is determined by the value 32767 using marching cubes.

Layers: any

SameValue: any

If cell is completely filled or empty and Values == nullptr the value is used as cell filler.

boolean_hash: float

RenderStamp: any

Nx: any

< cell is locked for changes, rather used for temporary purposes

AllocAttributes()

< usually = 9, Cell is (Nx * Nx * Nx)

FreeAttributes()

TryToFreeAttributes()

Compact(FreeCell: bool = True, Multithread: bool = False)

Compact8()

Explicit(WhatTodo: int = 3, Multithreaded: bool = False)

< param WhatTodo 1 - allocate, 2 - fill, 3 - all

CalcABC()

UpdateRect(RStamp: int)

FreeVolLayers()

GetVolumetricLayer(LayerID: int, type: int, create: bool) → any

class VolumeCellAttrib

Bases: object

Main brick in voxel / surface structure.

It contains polygonal geometry, color layers if given cell of the surface

pointer to this structure kept in VolumeCell.

RctX: int

RctY: int

RctW: int

RctH: int

VertsAB: any

Verts: any

Vertices of the mesh in the cell. Of course, same vertex may be present in neighbour cells and sometimes you need to identify that 2 vertices from different cells represent single global index. There are two ways. Using Status field in MCVertex that represents edge status. It has global index for every vertex in cell.

BackupVerts: any

LeakyPos: any

BackupIds: any

Verticies and indicies before this change. Undo will get to this state when applied.

OldVerts: any

Positions / normals of vertices before entering surface mode.

Indices: any

Indices of mesh in the cell. They refer vertices in this cell. Each three indices represent triangle.

TempVerts: any

GlobalVertIndices: cList_DWORD

GlobalVertIndices are references of global vertices indices. GlobalVertIndices corresponds to vertex list Verts. Each vertex in Verts corresponds to item in GlobalVertIndices. If GlobalVertIndices is empty - there are no global indexation in the mesh. Each value is DWORD. Highest bit (0x80000000) is set up if the vertex is on the edge of the cell. The global index itself is GlobalVertIndices[i]&0x7FFFFFFFFF

Layers: any

CurLayerInvisible: bool = False

CurLayerDepthMod: float = 1.0

UseLayerScale: bool = False

InvisLayerWarning: bool = False

SetVertexPos(index: int, newpos: cVec3, inlayers: bool = False)

IncVertexPos(index: int, add: cVec3, inlayers: bool = False)

EnsureLayerExists()

RemoveLayer(LayerID: int)

CompactArray<TexturedVertex> TVerts;//textured vertices

Insertlayer(LayerID: int, MandatoryDepth: bool = False) → any

GetLayer(LayerID: int) → any

AddVertexToLayers(pv1: int, pv2: int, pv3: int, u: float, v: float)

AddDefaultVertexToLayers()

UpdateLayersSumm(vo: VolumeObject)

UpdateLayersSumm2()

FreeLayers()

ValidateColor(vl: any)

DrewDbgTri(idx: int, m: cMat4, Color: int = 0, coef: float = 0.9)

DrawDbg(m: cMat4 = cPy.cTypes.cMat4.Identity, Color: int = 0, coef: float = 0.9)

GetVertexColor(p: int) → int

Temp4D: cVec4

Dirty: any

For tracking persistent data.