3DCoat Core API
The 3DCoat API documentation.
Loading...
Searching...
No Matches
CoreAPI.h
1#pragma once
2#include <stdafx.h>
3#ifdef PYBIND11_DEF
4#include <Python.h>
5#include <pybind11/pybind11.h>
6#include <pybind11/numpy.h>
7#endif
8
9
21class ItemsTree;
22class ItemsFolder;
23class ClusteredMesh;
24
25#ifndef PY_PARSER
26#ifdef PYBIND11_DEF
27
28#define PY_BYTE_ARRAY pybind11::array_t<unsigned char, pybind11::array::c_style>
29#define PY_WORD_ARRAY pybind11::array_t<WORD, pybind11::array::c_style>
30#define PY_DWORD_ARRAY pybind11::array_t<dword, pybind11::array::c_style>
31#define PY_INT_ARRAY pybind11::array_t<int, pybind11::array::c_style>
32#define PY_FLOAT_ARRAY pybind11::array_t<float, pybind11::array::c_style>
33#define PY_DOUBLE_ARRAY pybind11::array_t<double, pybind11::array::c_style>
34
35#endif
36#endif
37
38#pragma pack(push, 1)
43namespace coat {
44 class Model;
45 class Volume;
47 typedef comms::cVec4 vec4;
48
50 typedef comms::cVec3 vec3;
51
53 typedef comms::cVec3i vec3i;
54
56 typedef comms::cVec2 vec2;
57
59 typedef comms::cMat4 mat4;
60
62 typedef comms::cMat3 mat3;
63
64 typedef comms::cMath math;
65
67 typedef comms::cStr str;
68
70 template <class X> using list = comms::cList<X>;
71
73 typedef comms::cRect rect;
74
75 typedef comms::cQuat quat;
76
77 typedef comms::cRotation rotation;
78
79 typedef comms::cAngles angles;
80
81 // axis-aligned bound box
82 typedef comms::cBounds boundbox;
83
96 };
97 class prim;
98
99
104 void start_main_menu(const char* id);
105
111 void menu_item(const char* id);
112
118 bool menu_submenu(const char* id);
119
123 void menu_exit();
124
129
137 void menu_hotkey(const char* id, int Shift, int Ctrl, int Alt);
138
145 bool iconic_submenu(const char* id, int size);
146
152
158
164
169 bool is_ppp();
170
175 bool is_proxy();
176
182
188
194 bool IsInRoom(const char* name);
195
201 bool RoomExists(const char* name);
202
208 bool CheckIfExists(const char* path);
209
210
216
217
222 bool is_mv();
223
228 bool is_ptex();
229
234
240 void show_space_panel(const char* Subset, int NumColumns);
241
247
253
258 void menu_insert_extensions(const char* id);
259
264
270
275 void SetAutoSnapDefaults(bool value);
276
282 bool menu_property(const char* id);
283
288 void tools_section(const char* id);
289
294 void tools_item(const char* id);
295
300 void page_suffix(const char* suffix);
301
306 void default_tool(const char* tool);
307
312 bool IsDebug();
313
318
322 void menu_sort();
323
329
335 bool IsInTool(const char* ToolID);
336
342
348
354
360
366 int GetCurrentToolSubmode(const char* id);
367
372 void tools_comment(const char* id);
373
378 bool doc_mode();
379
384
390
391
397
401 class APICALL Mesh {
402 protected:
403 friend class Model;
404 static std::vector<std::pair<comms::cMeshContainer*, int>> allocated_meshes;
405 comms::cMeshContainer* allocate();
406 void inc_ref(comms::cMeshContainer* m);
407 void dec_ref(comms::cMeshContainer* m);
408
409 comms::cMeshContainer* MeshData;
410 list<int> raw_start;
411 int raw_count;
412 void validate_raws();
413 public:
414 Mesh();
415 ~Mesh();
416
417 Mesh(const Mesh& m);
418 Mesh(const Model& m);
419 Mesh& operator = (const Mesh& m);
420 Mesh& operator = (const Model& m);
421 Mesh MakeCopy();
422
428 bool Read(const char* name);
429
435 bool Write(const char* name);
436
441 bool valid() const;
442
447 comms::cMeshContainer* geometry();
448
449 comms::cMeshContainer* geometry() const;
450
454 void clear();
455
460 Mesh& operator +=(const Mesh& m);
461
466 Mesh& operator +=(const Model& m);
467
473 void addTransformed(const Mesh& m, const mat4& t);
474
479 void boolean(const Mesh& m, BoolOpType op);
480
485 void transform(const mat4& transform);
486
492 void rotateToXYAxis(const vec3& axisX, const vec3& axisY);
493
499 void rotateToYZAxis(const vec3& axisY, const vec3& axisZ);
500
506 void rotateToZXAxis(const vec3& axisZ, const vec3& axisX);
507
512 int vertsCount() const;
513
518 int vertsUvCount() const;
519
524 int vertsNormalCount() const;
525
531
537 vec3 getVertex(int idx) const;
538
544 void setVertex(int idx, const vec3& v);
545
551 int createNewVertex(const vec3& position);
552
558 vec2 getVertexUV(int idx) const;
559
565 void setVertexUV(int idx, const vec2& v);
566
573
579 vec3 getVertexNormal(int idx) const ;
580
586 void setVertexNormal(int idx, const vec3& v);
587
592
597
603 int getFaceVertsCount(int face);
604
610 int getFaceUvVertsCount(int face);
611
618 int getFaceVertex(int faceIndex, int faceVertexIndex);
619
625 std::vector<int> getFaceVerts(int face);
626 void getFaceVerts(int face, list<int>& vertices);
627
633 void setFaceVerts(int face, const std::vector<int>& vertices);
634 void setFaceVerts(int face, const list<int>& vertices);
635
642 int getFaceUvVertex(int faceIndex, int faceVertexIndex);
643
650 void setFaceUvVertex(int faceIndex, int faceVertexIndex, int uvVertexIndex);
651
658 int getFaceNormalVertex(int faceIndex, int faceVertexIndex);
659
666 void setFaceNormalVertex(int faceIndex, int faceVertexIndex, int normalVertexIndex);
667
673 std::vector<int> getFaceUvVerts(int face);
674 void getFaceUvVerts(int face, list<int>& vertices);
675
681 int getFaceObject(int faceIndex);
682
688 void setFaceObject(int faceIndex, int objectIndex);
689
695 int getFaceMaterial(int faceIndex);
696
702 void setFaceMaterial(int faceIndex, int materialIndex);
703
709
715 std::string getObjectName(int idx);
716
722 void setObjectName(int idx, const std::string& name);
723
729 int addObject(const char* name);
730
735 void removeObject(int idx);
736
741 void unifyAllObjects(const std::string& name = "");
742
748
754 int addMaterial(const char* name);
755
760 void removeMaterial(int idx);
761
767 std::string getMaterialName(int idx);
768
774 void setMaterialName(int idx, const std::string& name);
775
782 std::string getMaterialTexture(int idx, int texture_layer);
783
790 void setMaterialTexture(int idx, int texture_layer, const std::string& texture_path);
791
798 void fromVolume(Volume& v, bool with_subtree = false, bool all_selected = false);
799
807 void fromReducedVolume(Volume& v, float reduction_percent, bool with_subtree = false, bool all_selected = false);
808
816 void fromVolumeWithMaxPolycount(Volume& v, int max_polycount, bool with_subtree = false, bool all_selected = false);
817
824 void toVolume(Volume& v, const mat4& transform = mat4::Identity, BoolOpType op = BOOL_MERGE);
825
831 void insertInVolume(Volume& v, const mat4& transform = mat4::Identity);
832
838 void addToVolume(Volume& v, const mat4& transform = mat4::Identity);
839
845 void subtractFromVolume(Volume& v, const mat4& transform = mat4::Identity);
846
852 void intersectWithVolume(Volume& v, const mat4& transform = mat4::Identity);
853
858
863
868 void reduceToPolycount(int destination_triangles_count);
869
874
880 void booleanOp(Mesh& With, BoolOpType op);
881
886 std::vector<vec3> getMeshVertices();
887
892 std::vector<vec3> getMeshNormals();
893
898 std::vector<vec2> getMeshUVs();
899
904 void setMeshVertices(const std::vector<vec3>& positions);
905
910 void setMeshNormals(const std::vector<vec3>& normals);
911
916 void setMeshUVs(const std::vector<vec2>& uvs);
917
925 void setMeshFaces(const std::vector<int>& faces);
926
931 void addMeshVertices(const std::vector<vec3>& positions);
932
937 void addMeshNormals(const std::vector<vec3>& normals);
938
943 void addMeshUVs(const std::vector<vec2>& uvs);
944
952 void addMeshFaces(const std::vector<int>& faces);
953
958
963
968
973
978 void removeFaces(const std::vector<int>& faces);
979
984
989
994
1000 int addObject(const std::string& name);
1001
1007 int addMaterial(const std::string& name);
1008
1013
1018
1023
1029 void cutByPlane(const vec3& start, const vec3& NormalDirection);
1030
1039 void cutByDistortedPlane(const vec3& start, const vec3& NormalDirection, float noise_degree, float noise_scale, int seed = 0);
1040
1048 void distortByPerlinNoise(float noise_degree, float noise_scale, bool anisotropic = false, int seed = 0);
1049
1054 std::vector<Mesh> splitDisconnectedParts();
1055
1062 void symmetry(const vec3& start, const vec3& NormalDirection, bool resultInQuads);
1063
1068 std::vector<comms::cPlane> autodetectSymmetryPlanes();
1069
1074 void weld(float minimal_relative_distance = 0.0001f);
1075
1080 boundbox getBounds() const;
1081
1086 float getVolume() const;
1087
1094 float getOpenSurfaceVolume(const vec3& start, const vec3& dir) const;
1095
1100 float getSquare() const;
1101
1107 float getFaceSquare(int face);
1108
1114 float getFaceUVSquare(int face);
1115
1122
1129 void relax(float degree, bool tangent, float crease_angle = 180);
1130
1145 static Mesh box(const vec3& center = vec3::Zero, const vec3& size = vec3::One, const vec3& xAxis =vec3::Zero, const vec3& yAxis = vec3::Zero, const vec3& zAxis = vec3::Zero, float detail_size = 1, float fillet = 0.0f, int nx=0, int ny=0, int nz=0);
1146
1154 static Mesh sphere(const vec3& center = vec3::Zero, float radius = 1.0f, float detail_size = 1);
1155
1168 static Mesh cylinder(const vec3& center = vec3::Zero, float radius = 1, float height = 2, float detail_size = 1, int slices = 0, int caps = 0, int rings = 0, float fillet = 0);
1169
1179 static Mesh cone(const vec3& center = vec3::Zero, float radius = 1, float height = 2, float detail_size = 1, const vec3& topAxis = vec3::AxisY);
1180
1192 static Mesh plane(const vec3& center = vec3::Zero, float sizeX = 2, float sizeY = 2, int divisionsX = 2, int divisionsY = 2, const vec3& xAxis = vec3::AxisX, const vec3& yAxis = vec3::AxisY);
1193
1205 static Mesh hexagonal_plane(const vec3& center = vec3::Zero, float sizeX = 2, float sizeY = 2, int divisionsX = 2, int divisionsY = 2, const vec3& xAxis = vec3::AxisX, const vec3& yAxis = vec3::AxisY);
1206
1219 static Mesh text(const char* string, const char* font = "tahoma", float height = 10.0f, const vec3 & center = vec3::Zero, const vec3& text_direction = vec3::AxisX, const vec3& text_normal = vec3::AxisY, float thickness = 1, int align = 1);
1220
1231 void createVDM(int side, const char* path_to_exr, const vec3& center = vec3::Zero, float radius = 1, const vec3& up = vec3::AxisZ, const vec3& x = vec3::AxisX, const vec3& y = vec3::AxisY);
1232
1239 void shell(float thickness_out, float thickness_in, int divisions = 1);
1240
1247 std::vector<int> extrudeOpenEdges(float distance, vec3 direction = vec3::Zero);
1248
1254 std::vector<int> expandOpenEdges(float distance);
1255
1260 std::vector<int> getOpenEdges();
1261
1267 float getLengthAlongDirection(const vec3& dir) const;
1268
1274
1275
1276 protected:
1277 void setMesh(const comms::cMeshContainer& mesh) {
1278 if (MeshData) {
1279 MeshData->Clear();
1280 MeshData->Copy(mesh);
1281 }
1282 else {
1283 MeshData = new comms::cMeshContainer(mesh);
1284 inc_ref(MeshData);
1285 }
1286 }
1287 friend class prim;
1288 };
1289
1293 class APICALL Image : public comms::cImage {
1294 public:
1295 Image();
1296 Image(const Image& im);
1302 bool Read(const char* name);
1303
1309 bool Write(const char* name);
1310
1316 bool FromTexture(int texture_id);
1317
1323#ifdef PYBIND11_DEF
1336 int Paste(PY_BYTE_ARRAY src_data, int pasteLeft = 0, int pasteTop = 0, int cropLeft = 0, int cropTop = 0, int cropRight = 0, int cropBottom = 0, bool flipY = false);
1337
1342 size_t Pointer();
1343
1349 bool FromArray(PY_BYTE_ARRAY src_data);
1350 bool FromArray(PY_DWORD_ARRAY src_data);
1351 bool FromArray(PY_FLOAT_ARRAY src_data);
1352
1353 pybind11::buffer_info _py_buffer_info();
1354#endif
1355 };
1356
1357 class Volume;
1358
1359 class APICALL symm {
1360 public:
1366 static symm& enable(bool _enable = true);
1367
1368 static bool enabled();
1369
1374 static symm& disable();
1375
1383 static symm& xyz(bool x, bool y, bool z);
1384
1389 static bool is_xyz();
1390
1395 static bool& x();
1396
1401 static bool& y();
1402
1407 static bool& z();
1408
1416 static symm& axial(int n, bool extraMirror = false, bool stepSymmetry = false);
1417
1422 static bool is_axial();
1423
1428 static int& axialOrder();
1429
1434 static bool& extraMirror();
1435
1440 static bool& stepSymmetry();
1448 static symm& axialMirror(int n, bool extraMirror = false, bool stepSymmetry = false);
1449
1454 static bool isAxialMirror();
1455
1466 static symm& translation(int numX, float stepX, int numY, float stepY, int numZ, float stepZ);
1467
1472 static bool is_translation();
1473
1478 static int& numX();
1479
1484 static float& stepX();
1485
1490 static int& numY();
1491
1496 static float& stepY();
1497
1502 static int& numZ();
1503
1508 static float& stepZ();
1509
1515
1521
1526 static symm& toGeneral();
1527
1533 static symm& set_start(const vec3& pos);
1534
1539 static vec3& start();
1540
1546 static symm& set_end(const vec3& pos);
1547
1552 static vec3& end();
1553
1559 static symm& showSymmetryPlane(bool show = true);
1560
1566 static symm& setCustomSymetryTransforms(list<mat4>& symmetryTransforms);
1567#ifdef PYBIND11_DEF
1573 static symm& setCustomSymetryTransforms(pybind11::list& symmetryTransforms);
1574#endif
1575
1580 static bool isCustomSymmetry();
1581
1586 static symm& getCurrentTransforms(list<mat4>& symmetryTransforms);
1587
1592 static std::vector<mat4> getCurrentTransforms();
1593
1599
1604 static std::vector<comms::cPlane> getCurrentPlanes();
1605 };
1609 class APICALL SceneElement {
1610 protected:
1611 ItemsTree* el;
1612 VoxTreeBranch* tb() const;
1613 OneCurveObject* cu() const;
1614 friend class Scene;
1615 friend class Curve;
1616 friend class Volume;
1617 public:
1618 SceneElement();
1619 SceneElement(VolumeObject* vo);
1620 SceneElement(ItemsTree* c);
1621 SceneElement(const SceneElement& other);
1622
1623 ~SceneElement();
1624
1625 const bool operator==(const SceneElement& other) const;
1626 const bool operator!=(const SceneElement& other) const;
1627
1633
1638 int childCount() const;
1639
1645 SceneElement child(int index) const ;
1646
1651 bool isSculptObject() const;
1652
1657 bool isCurve() const;
1658
1664 const SceneElement& setTransform(const mat4& Transform) const ;
1665
1671 const SceneElement& transform(const mat4& Transform) const ;
1672
1677 const SceneElement& density(float density_value) const;
1678
1684 const SceneElement& transform_single(const mat4& Transform) const;
1685
1691
1696 const SceneElement& clear() const ;
1697
1702 const char* name() const;
1703
1708 const char* getLinkedFile() const;
1709
1714 void setLinkedFile(const char* file_path) const;
1715
1721 const SceneElement& rename(const char* name) const;
1722
1728 SceneElement addChild(const char* name) const;
1729
1735 SceneElement findInSubtree(const char* name) const;
1736
1742 bool iterateSubtree(const std::function<bool(SceneElement)>& fn) const;
1743#ifdef PYBIND11_DEF
1756 bool iterateSubtree(const pybind11::object& fn) const;
1757#endif
1758
1764 bool iterateVisibleSubtree(const std::function<bool(SceneElement)>& fn) const;
1765#ifdef PYBIND11_DEF
1778 bool iterateVisibleSubtree(const pybind11::object& fn) const;
1779#endif
1780
1786 void mergeSubtree(bool booleanMerge = false) const;
1787
1793 void mergeTo(const SceneElement& dest, BoolOpType op);
1794
1801
1805 void removeSubtree() const;
1806
1811 void removeSubtreeItem(int index) const;
1812
1816 void remove() const;
1817
1823
1829
1834 void changeParent(SceneElement newParent) const;
1835
1841 bool isParentOf(SceneElement child) const;
1842
1847 bool& visible() const;
1848
1853 void setVisibility(bool visible) const;
1854
1859 bool ghost() const;
1860
1865 void setGhost(bool ghost) const;
1866
1872
1877 void setReferenceColor(const vec4& color);
1878
1881
1883 void select() const;
1884
1886 void selectOne() const;
1887
1889 void unselectAll() const;
1890
1892 bool selected();
1893
1896
1898 std::vector<SceneElement> collectSelected();
1899 };
1900
1902 public:
1903 VolumeCache();
1904 tri_DWORD CellID;
1905 VolumeCell* pCell;
1906 };
1907
1911 class APICALL Volume {
1912 protected:
1913 VoxTreeBranch* tb;
1914 VolumeObject* Obj;
1915 friend class SceneElement;
1916 public:
1917 Volume();
1918 Volume(VoxTreeBranch* tb);
1919 Volume(VolumeObject* vo);
1920 Volume(const Volume& vol);
1925 bool valid() const;
1926
1931 bool isSurface() const;
1932
1937 bool isVoxelized() const;
1938
1943
1947 void toVoxels();
1948
1953 static void enableVoxelsColoring(bool enable = true);
1954
1958 static void color(DWORD CL);
1959
1967 static void color(float r, float g, float b, float a);
1968
1975 static void color(float r, float g, float b);
1976
1982 static void color(const char* colorid);
1983
1988 static void gloss(float value);
1989
1994 static void roughness(float value);
1995
2000 static void metal(float value);
2001
2008 void mergeMesh(Mesh& mesh, const mat4& transform = mat4::Identity, BoolOpType op = BOOL_MERGE);
2009
2015 void insertMesh(Mesh& mesh, const mat4& transform = mat4::Identity);
2016
2022 void addMesh(Mesh& mesh, const mat4& transform = mat4::Identity);
2023
2029 void subtractMesh(Mesh& mesh, const mat4& transform = mat4::Identity);
2030
2036 void intersectWithMesh(Mesh& mesh, const mat4& transform = mat4::Identity);
2037
2044 void mergeMeshWithTexture(Mesh& mesh, const mat4& transform = mat4::Identity, BoolOpType op = BOOL_MERGE);
2045
2057 Volume& makeVoxelFigure(std::function<float(vec3)> densityFunction, const list<vec3>& growCenters, bool Subtract = false, bool useTempLocation = false, bool overHidden = false, bool useColor = false);
2058
2068 float getExactDencity(int x, int y, int z, bool fromBackup, VolumeCache& cache_ref);
2069
2076 float getInterpolatedValue(const vec3& pos, bool fromBackup);
2077
2083 void scanCells(const std::function<void(VolumeCell* vc)>& fn, bool multithreaded = false);
2084
2090 void scanCells(const std::function<void(VolumeCellAttrib* vc)>& fn, bool multithreaded = false);
2091
2097 void scanCells(const std::function<void(VolumeCellAttrib* vc, const tri_DWORD& T)>& fn, bool multithreaded = false);
2098
2104 void scanCells(const std::function<void(VolumeCell* vc, const tri_DWORD& T)>& fn, bool multithreaded = false);
2105
2111 void scanTriangles(const std::function<void(const MCVertex& v1, const MCVertex& v2, const MCVertex& v3)>& fn, bool multithreaded = false);
2112
2118 void scanTriangles(const std::function<void(const Vector3D& v1, const Vector3D& v2, const Vector3D& v3)>& fn, bool multithreaded = false);
2119
2125
2130 float getVolume();
2131
2136 float getSquare();
2137
2143
2149
2154 VoxTreeBranch* tree();
2155
2160 VolumeObject* vo();
2161
2171 VolumeCell* cell(int cx, int cy, int cz, bool create, bool backup);
2172
2182 VolumeCellAttrib* attributes(int cx, int cy, int cz, bool create, bool backup);
2183
2190 void dirty(int cx, int cy, int cz);
2191
2196 void setOpacity(float Opacity);
2197
2204 void relaxGpu(const vec3& center, float Radius, float degree);
2205
2210 void relaxVoxels(int count);
2211
2218 void relaxSurface(float degree, bool tangent = false, bool keep_sharp_boolean_edges = false);
2219
2224 void relaxOpenEdges(int nTimes);
2225
2231
2235 void clear();
2236
2241
2246 void assignShader(const char* shaderName);
2247
2248 void setBoolShaderProperty(const char* property, bool value);
2249 void setFloatShaderProperty(const char* property, float value);
2250 void setColorShaderProperty(const char* property, DWORD value);
2251
2257 void removeFacesByWeight(std::function<float(const vec3&)> weight);
2258
2263 void closeHoles(int maxSize);
2264
2270
2279 static void setMoldingParams(const vec3& direction, float tapering_angle = 0, float undercuts_density = 1.0f, float decimation_limit_millions = 10, bool perform_subtraction = true);
2280
2285
2290 void basRelief(const vec3& start_point = vec3::Zero);
2291
2296
2303 static void setMoldingBox(float width, float length, float thickness);
2304
2309 static void setMoldingBorder(float width = 0);
2310
2315
2320
2325
2330
2336
2342
2348
2354
2359
2364 void assignLiveBooleans(int operation);
2365
2370 };
2371
2372 inline coat::VolumeCache::VolumeCache() {
2373 pCell = nullptr;
2374 CellID.V1 = CellID.V2 = CellID.V3 = 100000;
2375 }
2376
2377 class APICALL settings {
2378 public:
2384 static bool valueExists(const char* ID);
2385
2391 static bool getBool(const char* ID);
2392
2398 static std::string getString(const char* ID);
2399
2405 static float getFloat(const char* ID);
2406
2412 static int getInt(const char* ID);
2413
2420 static bool setBool(const char* ID, bool value);
2421
2428 static bool setString(const char* ID, const char* value);
2429
2436 static bool setFloat(const char* ID, float value);
2437
2444 static bool setInt(const char* ID, int value);
2445
2449 static void saveSettings();
2450
2461 static void resetSettings(bool ResetGeneralSettings = true, bool ResetHiddenSet = true, bool ResetHotkeys = true, bool RestNavigation = true, bool ResetPresets = true, bool ResetTheme = true, bool ResetWindows = true);
2462
2467 static std::vector<std::string> listAllSettings();
2468
2473 static void pressButton(const char* button_name);
2474 };
2475
2479 class APICALL Scene {
2480 public:
2485 static void clearScene(bool askUser = false);
2491
2497
2503
2510 static int getLayer(const char* name, bool addIfNotExists = true);
2511
2517 static const char* getLayerName(int LayerID);
2518
2524 static void setLayerName(int LayerID, const char* name);
2525
2531 static int getLayerBlending(int LayerID);
2532
2538 static void setLayerBlending(int LayerID, int mode);
2539
2544 static int getCurrentLayer();
2545
2550 static void setCurrentLayer(int LayerID);
2551
2555 static void mergeVisibleLayers();
2556
2561 static void mergeLayerDown(int LayerID);
2562
2567 static void applyLayerBlending(int LayerID);
2568
2573 static void invalidateLayer(int LayerID);
2574
2579 static void setActiveLayer(int LayerID);
2580
2585 static void removeLayer(int LayerID);
2586
2592 static bool layerIsEmpty(int layerID);
2593
2597 static void removeEmptyLayers();
2598
2602 static bool layerVisible(int LayerID);
2603
2608 static void setLayerVisibility(int LayerID, bool Visible);
2609
2615 static void setLayerColorOpacity(int LayerID, float Opacity);
2616
2622 static void setLayerDepthOpacity(int LayerID, float Opacity);
2623
2629 static void setLayerMetalnessOpacity(int LayerID, float Opacity);
2630
2636 static void setLayerGlossOpacity(int LayerID, float Opacity);
2637
2643 static int assignLayerMask(int LayerID);
2644
2649 static void removeLayerMask(int LayerID);
2650
2655 static void extractMaskAsLayer(int LayerID);
2656
2662 static void setMaskForTheLayer(int LayerID, int MaskLayerID);
2663
2669 static void enableLayerMask(int LayerID, bool enable);
2670
2676 static bool isLayerMaskEnabled(int LayerID);
2677
2682 static void invertLayerMask(int LayerID);
2683
2689 static int getLayerMaskLayer(int LayerID);
2690
2695 static void disableLayerMask(int LayerID);
2696
2701 static void enableLayerMask(int LayerID);
2702
2708 static bool maskEnabled(int LayerID);
2709
2714 static void setClippingLayer(int LayerID);
2715
2720 static void disableClippingLayer(int LayerID);
2721
2722
2727 static int PaintObjectsCount();
2728
2734
2739 static int PaintUVSetsCount();
2740
2745 static void RemovePaintObject(int idx);
2746
2751 static void RemovePaintMaterial(int idx);
2752
2757 static void RemoveUVSet(int idx);
2758
2764 static const char* PaintObjectName(int idx);
2765
2771 static const char* PaintMaterialName(int idx);
2772
2778 static const char* PaintUVSetName(int idx);
2779
2785 static SceneElement importMesh(const char* filename, const mat4& transform = mat4::Identity);
2786
2791 static void ScaleSceneVisually(float scale);
2792
2797 static void ScaleSceneUnits(float scale);
2798
2803 static float GetSceneScale();
2804
2809 static const char* GetSceneUnits();
2810
2816 static bool setSceneUnits(const char* units);
2817
2823
2828 static void setSceneShift(const vec3& shift);
2829
2834 static std::vector<std::string> getAvailableUnits();
2835
2841 static bool convertSceneUnits(const char* destination_unit_name);
2842 };
2843
2844 class APICALL RenderRoom {
2845 public:
2849 static void toRenderRoom();
2850
2854 static void restartRendering();
2855
2861 static void setCustomRenderSize(int width, int height);
2862
2867 static void setRenderResult(const char* filename);
2868
2872 static void renderFrame();
2873
2878 static void enableRealtimeRendering(bool enable);
2879
2885
2890 static void setExposure(float exposure);
2891
2896 static float getExposure();
2897
2902 static void setEnvironmentLight(float envlight);
2903
2908 static float getEnvironmentLight();
2909
2914 static void setDOFDegree(float degree);
2915
2920 static float getDOFDegree();
2921
2926 static int getLightsCount();
2927
2932 static int addLight();
2933
2938 static void removeLight(int idx);
2939
2943 static void removeAllLights();
2944
2950 static void setLightDirection(int idx, const vec3& dir);
2951
2957 static vec3 getLightDirection(int idx);
2958
2964 static void setLightScattering(int idx, float scattering);
2965
2971 static float getLightScattering(int idx);
2972
2978 static void setLightColor(int idx, const vec3& color = vec3::One);
2979
2985 static vec3 getLightColor(int idx);
2986
2992 static void setLightIntensity(int idx, float intensity);
2993
2999 static float getLightIntensity(int idx);
3000
3005 static void setRaysPerFrame(int count);
3006
3011 static int getRaysPerFrame();
3012
3017 static void setAA(bool AA);
3018
3023 static bool getAA();
3024
3025 };
3026
3027 class APICALL Curve:public SceneElement {
3028 OneCurveObject* cu;
3029 bool allocated;
3030 friend class SceneElement;
3031 void validate();
3032 public:
3037 ~Curve();
3038
3043 Curve(OneCurveObject* ob);
3044
3050 Curve& operator = (SceneElement& el);
3051
3057
3063 OneSelPoint* point(int idx);
3064
3070 void removePoints(int index, int count);
3071
3076 OneCurveObject* curve();
3077
3083
3089 OneSelPoint* renderPoint(int idx);
3090
3096
3101 bool& closed();
3102
3109 void add(const Vector3D& p, const Vector3D& normal, float Radius);
3110
3117 void addSharp(const Vector3D& p, const Vector3D& normal, float Radius);
3118
3125 void addSmooth(const Vector3D& p, const Vector3D& normal, float Radius);
3126
3135 void add(const Vector3D& p, const Vector3D& normal, const Vector3D& inTangent, const Vector3D& outTangent, float Radius);
3136
3144 void add(const Vector3D& p, const Vector3D& normal, const Vector3D& inOutTangent, float Radius);
3145
3151 void tubeToMesh(Mesh& mesh, bool hemisphere);
3152
3161 void fill(Mesh& mesh, float thickness, float relax_count = 0, float details_level = 1, float extrusion = 0);
3162 };
3163
3168 class APICALL SphericalCollision {
3169 list<vec4> spheres;
3170 uni_hash<int, tri_int> cells;
3171 float unit;
3172 public:
3174
3179 SphericalCollision(float cellsize);
3180
3182
3187 void setUnit(float u);
3188
3192 void clear();
3193
3200 int addSphere(const vec3& p, float radius);
3201
3208 vec3 collides(const vec3& p, float radius);
3209
3215 vec4 sphere(int idx);
3216 };
3217
3221 class APICALL ui {
3222 public:
3233 static bool cmd(const char* id, std::function<void()> process_in_modal_dialog = 0);
3234#ifdef PYBIND11_DEF
3249 static bool cmd(const char* id, pybind11::object fn = pybind11::none());
3250#endif
3257 static bool wait(const char* id, float max_seconds);
3258
3264 static bool presentInUI(const char* id);
3265
3271 static void highlight(const char* id, float milliseconds);
3272
3278 static void enablePenChannel(int i, bool enabled);
3279
3285 static bool isEnabledPenChannel(int i);
3286
3293 static bool setSliderValue(const char* id, float value);
3294
3300 static float getSliderValue(const char* id);
3301
3308 static bool setEditBoxValue(const char* id, const char* value);
3309
3316 static bool setEditBoxValue(const char* id, int value);
3317
3324 static bool setEditBoxValue(const char* id, float value);
3325
3332 static bool getEditBoxValue(const char* id, str& result);
3333 static const char* getEditBoxValue(const char* id);
3334
3338 static void apply();
3339
3347 static void setFileForFileDialog(const char* filename);
3348
3354 static bool getBoolField(const char* id);
3355
3362 static bool setBoolValue(const char* id, bool value);
3363
3368 static const char* currentRoom();
3369
3375 static bool isInRoom(const char* name);
3376
3382 static void toRoom(const char* name, bool Force = false);
3383
3388 static int roomsCount();
3389
3395 static const char* roomName(int index);
3396
3402 static const char* roomID(int index);
3403
3408 static void toolParam(BaseClass* B);
3409
3414 static void removeToolParam(BaseClass* B = nullptr);
3415
3421 static const char* getOption(const char* id);
3422
3429 static bool setOption(const char* id, const char* value);
3430 static bool setOption(const char* id, bool value);
3431 static bool setOption(const char* id, float value);
3432
3437 static void hideDontShowAgainMessage(const char* id);
3438
3444 static void showInfoMessage(const char* infoID, int milliseconds);
3445
3454 static void insertInMenu(const char* Menu, const char* ID_in_menu, const char* script_path);
3455
3468 static void insertInToolset(const char* roomID, const char* section, const char* toolID, const char* script_path = "");
3469
3474 static void removeCommandFromMenu(const char* ID_in_menu);
3475
3481 static bool checkIfMenuItemInserted(const char* ID_in_menu);
3482
3483#ifdef PYBIND11_DEF
3492 static void addExtension(const char* roomID, const char* section, pybind11::object& obj);
3493#endif
3499 static bool checkIfExtensionPresent(const char* extension_ID);
3500
3506 static void addTranslation(const char* id, const char* text);
3507
3513 static const std::string getIdTranslation(const char* id);
3514
3519 static const std::string getCurrentLanguage();
3520
3525 static void switchToLanguage(const char* language);
3526
3531 static float scale();
3532
3539 static std::string inputString(const char* text, int min_length = 0);
3540
3546 static int inputInt(int initial_value);
3547
3553 static float inputFloat(float initial_value);
3554 };
3555
3556 class APICALL Camera
3557 {
3558 public:
3563 static void rotateToGradually(const vec3& destination_dir);
3564
3570
3575 static vec3 getUp();
3576
3581 static vec3 getRight();
3582
3587 static bool isOrtho();
3588
3593 static void setOrtho(bool ortho);
3594
3599 static vec3 getPivot();
3600
3605 static void setPivot(const vec3& pivot);
3606
3612
3618 static vec3 getWorldToScreenSpace(const vec3& world_pos);
3619
3625 static vec3 getScreenToWorldSpace(const vec3& screen_pos);
3626
3635 static void setCamera(const vec3& position, const vec3& lookAt, float fovY, const vec3& up = vec3::Zero);
3636 };
3637
3641 class APICALL dialog {
3642#ifndef DOXYGEN_SHOULD_SKIP_THIS
3643 bool _modal;
3644 bool _topright;
3645 str _buttons;
3646 std::function<void()> _process;
3647 std::function<void(int)> _press;
3648 int _width;
3649 int _icon;
3650 bool _undoWorks;
3651 bool _dontshowagain;
3652 BaseClass* _bc;
3653 str _text;
3654 str _caption;
3655 bool _transparentbg;
3656 BaseWidget* _widget;
3657#endif //DOXYGEN_SHOULD_SKIP_THIS
3658 public:
3659 dialog();
3665 dialog& text(const char* id);
3666
3672 dialog& caption(const char* id);
3673
3679 dialog& width(int w);
3680
3686
3692
3698 dialog& buttons(const char* list);
3699
3705
3711
3717
3723
3729
3735
3741
3747
3753
3759
3765
3772#ifdef PYBIND11_DEF
3778 dialog& params(pybind11::object params);
3779
3785 dialog& process(pybind11::object callback);
3786#endif
3792 dialog& process(std::function<void()> process);
3793
3799 dialog& onPress(std::function<void(int)> press);
3800#ifdef PYBIND11_DEF
3811 dialog& onPress(pybind11::object press);
3812#endif
3813
3818 int show();
3819
3820 dialog& widget(BaseWidget* w);
3821 };
3822
3826 class APICALL resource {
3827 ItemsFolder* folder;
3828 public:
3835 resource(const char* id);
3836
3841 static std::vector<std::string> listAllResourcesTypes();
3842
3847 std::vector<std::string> listFolders();
3848
3853 std::string currentFolder();
3854
3860
3865 std::string rootPath();
3866
3871 std::vector<std::string> supportedExtensions();
3872
3877 void setCurrentFolder(const char* folder);
3878
3883 void createFolder(const char* folderName);
3884
3889 void removeFolder(const char* folderName);
3890
3895 std::vector<std::string> listCurrentFolderItems();
3896
3901 void addItem(const char* itemPath);
3902
3907 void removeItem(const char* itemName);
3908
3913 void selectItem(const char* itemName);
3914
3920 void moveItemToFolder(const char* itemName, const char* destFolderName);
3921
3926 std::string getCurrentItem();
3927 };
3928
3932 class APICALL io {
3933 public:
3938 static const char* installPath();
3939
3944 static const char* dataPath();
3945
3951 static const char* documents(const char* path);
3952
3959 static bool fileExists(const char* path);
3960
3966 static void copyFile(const char* src, const char* dest);
3967
3973 static void copyFolder(const char* src, const char* dest);
3974
3980 static void removeFile(const char* filename);
3981
3986 static void removeFolder(const char* folder);
3987
3994 static std::string toFullPathInDataFolder(const char* path);
3995 static void toFullPathInDataFolder(str* path);
3996
4003 static std::string toFullPathInInstallFolder(const char* path);
4004 static void toFullPathInInstallFolder(str* path);
4005
4011 static std::string convertToWritablePath(const char* path);
4012 static void convertToWritablePath(str* path);
4013
4020 static std::string convertToWritablePathIfFileExists(const char* path);
4021 static void convertToWritablePathIfFileExists(str* path);
4022
4028 static std::string getExtension(const char* filepath);
4029
4035 static std::string getFileName(const char* filepath);
4036
4042 static std::string getFilePath(const char* filepath);
4043
4049 static std::string getFileNameWithoutExtension(const char* filepath);
4050
4057 static std::string strFromFile(const char* filename);
4058
4064 static void strToFile(const char* text, const char* filename);
4065
4071 static size_t getFileSize(const char* filename);
4072
4077 static vec2 cursorPos();
4078
4084
4090
4095 static rect workArea();
4096
4103 static void progressBar(float stage, float max_stage, const char* message);
4104
4111 static void progressBarInWindowHeader(float stage, float max_stage, const char* message);
4112
4118 static void setWindowTitle(const char* text, float seconds);
4119
4124 static void step(int count = 1);
4125
4131 static void exec(const char* command, const char* arguments = nullptr);
4132
4139 static const char* execAndWait(const char* command, const char* arguments = nullptr);
4140
4141
4146 static void updateCoatPyi(const char* folderOrFile);
4147
4155 static void ListFiles(const char* folder, const char* mask, coat::list<coat::str>& result, bool recursive = true);
4156
4164 static std::vector<std::string> ListFiles(const char* folder, const char* mask, bool recursive = true);
4165
4171 static void ListFolders(const char* startFolder, coat::list<coat::str>& result);
4172
4178 static std::vector<std::string> ListFolders(const char* startFolder);
4179
4184 static const char* supportedImagesFormats();
4185
4190 static const char* supportedMeshesFormats();
4191
4198 static bool openFileDialog(const char* extensions, str& fileName);
4199 static std::string openFileDialog(const char* extensions);
4200
4207 static bool openFilesDialog(const char* extensions, list<str>& fileNames);
4208
4214 static std::vector<std::string> openFilesDialog(const char* extensions);
4215
4222 static bool saveFileDialog(const char* extensions, str& fileName);
4223 static std::string saveFileDialog(const char* extensions);
4224
4228 static const char* currentSceneFilepath();
4229
4234 static void pipInstall(const char* requirements);
4235 static void pipUninstall(const char* requirements);
4236
4241 static std::string pythonPath();
4242
4246 static void showPythonConsole();
4247
4252 static void executeScript(const char* path);
4253
4254
4259 static void installRequirements(const char* path_to_requirements_txt);
4260#ifdef PYBIND11_DEF
4267 static std::string toJson(const pybind11::object& obj, const char* filename = "");
4268
4274 static void fromJsonFile(pybind11::object& obj, const char* filename);
4275
4281 static void restoreObjectFormJsonString(pybind11::object& obj, const char* data);
4282#endif
4283
4291 static void createRedistributablePackageFromFolder(const char* folder, const char* package_name, const char* excluded_folders_names = "", const char* excluded_extensions = "");
4292
4298 static void download(const char* url, std::function<void(const char*, const char*)> report_success);
4299
4305
4314 static void post_request(const char* url, const char* data, const char* headers, const std::function<void(const char*)>& report_success = nullptr, const std::function<void(const char*)>& report_error = nullptr);
4315
4323 static void get_request(const char* url, const char* headers, const std::function<void(const char*)>& report_success = nullptr, const std::function<void(const char*)>& report_error = nullptr);
4324
4329 static std::vector<std::string> listBlenderInstallFolders();
4330
4339 static void saveScreenshot(const char* filename, int x = 0, int y = 0, int width = 0, int height = 0);
4340
4341 static void removeBackground(const char* image1, const char* image2, const char* result);
4342 };
4343
4344 class APICALL utils {
4345 public:
4351 static vec4 dwordToVec4(unsigned int d);
4352
4358 static unsigned vec4ToDword(const vec4& v);
4359
4364 static void randomize(int seed);
4365
4370 static float random01();
4371
4378 static float random(float min, float max);
4379
4385
4392 static vec3 perlin3d(vec3 p, float seed = 0);
4393
4400 static float perlin(vec3 p, float seed = 0);
4401
4408 static const char* getEnumValueByIndex(const char* enumID, int index);
4409
4416 static int getEnumValue(const char* enumID, const char* key);
4417
4424 static int getEnumValueIndex(const char* enumID, const char* key);
4425
4431 static int getEnumValuesCount(const char* enumID);
4432
4437 static void clearEnum(const char* enumID);
4438
4445 static void addEnumValue(const char* enumID, const char* key, int value = - 1);
4446
4450 static void quit();
4451
4455 static void testSuccessful();
4456
4461 static void testFailed(const char* message);
4462
4467 static void signal(const char* message);
4468
4473 static std::vector<std::string>& last_signals();
4474
4479 static float getFPS();
4480
4485 static float getFrameTimeMs();
4486
4491 static bool inRenderProcess();
4492
4498 static void set(const char* key, const char* value);
4499
4505 static const char* get(const char* key);
4506 };
4507
4511 class APICALL uv {
4512 public:
4517 static int uvSetsCount();
4518
4523 static void setUnwrapIslandsDistance(float distance);
4524
4530
4535 static int currentUvSet();
4536
4542 static int islandsCount(int uv_set);
4543
4550 static Mesh islandToMesh(int uv_set, int island_index);
4551
4558 static Mesh islandToMeshInSpace(int uv_set, int island_index);
4559
4566 static std::vector<int> getIslandVertexMapping(int uv_set, int island_index);
4567
4574 static std::vector<int> getIslandBorder(int uv_set, int island_index);
4575
4584 static std::vector<int> getBorderBetweenIslands(int uv_set1, int island_index1, int uv_set2, int island_index2);
4585
4593 static vec2 getIslandVertexUv(int uv_set, int island_index, int vertex_index);
4594
4603 static Mesh flattenSingleIsland(const Mesh& mesh, int method, bool optimize_rotation = true, bool scale_to_geometry = true);
4604
4611 static void meshToIsland(const Mesh& mesh, int uv_set, int island_index);
4612
4619 static void pack(int uv_set, bool rotate, bool shuffle);
4620
4625 static void unwrap(int uv_set);
4626
4632 static void toAbf(int uv_set, int island_index);
4633
4639 static void toLscm(int uv_set, int island_index);
4640
4646 static void toGu(int uv_set, int island_index);
4647
4653 static void toPlanar(int uv_set, int island_index);
4654
4660 static void toStripe(int uv_set, int island_index);
4661
4668 static void toUvSet(int uv_set, int island_index, int destination_uv_set);
4669
4675
4681
4686 static std::vector<int> getSeams();
4687
4693 static void addSeam(DWORDS2 start_vertex_index, int end_vertex_index);
4694
4700 static void removeSeam(int start_vertex_index, int end_vertex_index);
4701
4706 static std::vector<int> getSharpEdges();
4707
4713 static void addSharpEdge(int start_vertex_index, int end_vertex_index);
4714
4720 static void removeSharpEdge(int start_vertex_index, int end_vertex_index);
4721
4725 static void unwrapUnassigned();
4726
4730 static void applyUVSet();
4731 };
4732
4733
4738 {
4739 Uniform_Scaling = 0,
4740 Axial_Normal = 1,
4741 Axial_X = 2,
4742 Axial_Y = 3,
4743 Axial_Z = 4,
4744 Radial_Normal = 5,
4745 Radial_X = 6,
4746 Radial_Y = 7,
4747 Radial_Z = 8
4748 };
4754 class APICALL Model {
4755 protected:
4756 friend class Mesh;
4757 ClusteredMesh* _mesh;
4758 bool _from_retopo;
4759 bool _from_uv;
4760 ClusteredMesh& _mctx();
4761 ClusteredMesh* _pmctx() const;
4762 static void inc_ref(ClusteredMesh* m);
4763 static void dec_ref(ClusteredMesh* m);
4764 static bool has_ref(ClusteredMesh* m);
4765 static ClusteredMesh* allocate();
4766 static ClusteredMesh* allocate(ClusteredMesh* src);
4767 static std::vector<std::pair<ClusteredMesh*, int>> allocated_meshes;
4768 public:
4773
4778 Model(const Model& source);
4779
4784 Model(const Mesh& source);
4785
4791 Model & operator=(const Model& source);
4792
4793 Model & operator=(const Mesh& source);
4794
4795 Model & operator += (const Model& source);
4796
4797 Model & operator += (const Mesh& source);
4798
4805
4810
4815
4821
4827
4832 static Model fromUv();
4833
4842 void displayOptions(bool showWireframe = true, bool showColored = true, bool showSeams = true, bool showSharpEdges = true, bool smoothView = false);
4843
4849
4855
4860 void setCurrentObject(int index);
4861
4867 const char* getObjectName(int group_index);
4868
4872 void removeObject(int group_index);
4873
4879 void setObjectName(int index, const char* name);
4880
4886 void setObjectVisibility(int index, bool visible);
4887
4893 bool getObjectVisibility(int index);
4894
4900 int addObject(const char* name);
4901
4907 int addMaterial(const char* name);
4908
4913
4920
4926 void setObjectReferenceColor(int group_index, vec4 color);
4927
4932 void selectedToObject(int group_index);
4933
4939
4945
4951
4960 void addTransformed(const Mesh& mesh, const mat4& Transform = mat4::Identity, BoolOpType b = BOOL_MERGE, bool select = false, bool snap_to_existing = false);
4961
4967 Mesh getObjectMesh(int group_index);
4968
4975 void setObjectMesh(int group_index, Mesh& mesh, const mat4& transform = mat4::Identity);
4976
4985 int duplicateObject(int group_index, const char* name = nullptr, const mat4& transform = mat4::Identity, bool select = false);
4986
4992 std::string generateName(const char* base);
4993
4998 void clearObjectMesh(int group_index);
4999
5003 void clear();
5004
5008 void dropUndo();
5009
5014 std::vector<int> getSelectedFaces();
5015 void getSelectedFaces(list<int>& faces);
5016
5021 void setSelectedFaces(std::vector<int>& faces);
5022 void setSelectedFaces(list<int>& faces);
5023
5028 void selectFace(int face);
5029
5034 void selectObject(int group_index, bool add_to_selected = true);
5035
5041 std::vector<int> getObjectFaces(int group_index);
5042 void getObjectFaces(int group_index, list<int>& faces);
5043
5049 bool isFaceSelected(int face);
5050
5055
5060
5065
5070
5075
5080
5085 std::vector<int> getSelectedEdges();
5086 void getSelectedEdges(list<int>& edges);
5087
5092 void setSelectedEdges(std::vector<int>& edges);
5093 void setSelectedEdges(list<int>& edges);
5094
5100 void selectEdge(int vertex1, int vertex2);
5101
5108 bool isEdgeSelected(int vertex1, int vertex2);
5109
5114
5119 std::vector<int> getSelectedVertices();
5120 void getSelectedVertices(list<int>& vertices);
5121
5126 std::vector<float> getSelectedVerticesWeights();
5127
5133 void setSelectedVertices(const std::vector<int>& vertices, const std::vector<float>& weights);
5134 void setSelectedVertices(const list<int>& vertices, const list<float>& weights);
5135
5141 void selectVertex(int vertex, float weight = 1.0f);
5142
5148 bool isVertexSelected(int vertex);
5149
5154
5160
5166
5172
5177 void removeFace(int face);
5178
5185 int createNewFace(int Group, int UVSet);
5186
5192 int getFaceVertsCount(int face);
5193
5200 int getFaceVertex(int face, int vertex_index);
5201
5207 std::vector<int> getFaceVerts(int face);
5208 void getFaceVerts(int face, list<int>& vertices);
5209
5215 void setFaceVerts(int face, const std::vector<int>& vertices);
5216 void setFaceVerts(int face, const list<int>& vertices);
5217
5223 bool getFaceVisibility(int face);
5224
5230 void setFaceVisibility(int face, bool visibility);
5231
5237 float getFaceSquare(int face);
5238
5244 float getFaceUVSquare(int face);
5245
5252
5258 int getFaceObject(int face);
5259
5265 void setFaceObject(int face, int group);
5266
5272 int getFaceMaterial(int face);
5273
5279 void setFaceMaterial(int face, int uv_set);
5280
5286 int getFaceUvVertsCount(int face);
5287
5294 int getFaceUvVertex(int face, int vertex_index);
5295
5301 std::vector<int> getFaceUvVerts(int face);
5302 void getFaceUvVerts(int face, list<int>& vertices);
5303
5309 void setFaceUvVerts(int face, const std::vector<int>& vertices);
5310 void setFaceUvVerts(int face, const list<int>& vertices);
5311
5317 vec3 getVertex(int vertex);
5318
5324 void setVertex(int vertex, const vec3& position);
5325
5331 int createNewVertex(const vec3& position);
5332
5338 vec2 getVertexUV(int uv_vertex);
5339
5345 void setVertexUV(int uv_vertex, const vec2& uv);
5346
5353
5360
5365 void updateNormals(bool for_snapping = true);
5366
5371
5375 void cleanup();
5376
5382 std::vector<int> getVertsNearVertex(int vertex);
5383 void getVertsNearVertex(int vertex, list<int>& vertices);
5384
5390 std::vector<int> getFacesNearVertex(int vertex);
5391 void getFacesNearVertex(int vertex, list<int>& faces);
5392
5398 std::vector<int> getFaceNeighbors(int face);
5399 void getFaceNeighbors(int face, list<int>& faces);
5400
5407 std::vector<int> getFacesNearEdge(int vertex1, int vertex2);
5408 void getFacesNearEdge(int vertex1, int vertex2, list<int>& faces);
5409
5416 bool isOpenEdge(int vertex1, int vertex2);
5417
5424 bool isSharpEdge(int vertex1, int vertex2);
5425
5432 void setEdgeSharpness(int vertex1, int vertex2, bool sharp);
5433
5440 bool isSeam(int vertex1, int vertex2);
5441
5448 void setEdgeSeam(int vertex1, int vertex2, bool seam);
5449
5455 void collapseEdge(int vertex1, int vertex2);
5456
5462 int islandsCount(int uv_set);
5463
5470 Mesh islandToMesh(int uv_set, int island_index);
5471
5478 Mesh islandToMeshInSpace(int uv_set, int island_index);
5479
5486 std::vector<int> getIslandVertexMapping(int uv_set, int island_index);
5487
5494 std::vector<int> getIslandBorder(int uv_set, int island_index);
5495
5504 std::vector<int> getBorderBetweenIslands(int uv_set1, int island_index1, int uv_set2, int island_index2);
5505
5513 vec2 getIslandVertexUv(int uv_set, int island_index, int vertex_index);
5514
5523 static Mesh flattenSingleIsland(const Mesh& mesh, int method, bool optimize_rotation = true, bool scale_to_geometry = true);
5524
5531 void meshToIsland(const Mesh& mesh, int uv_set, int island_index);
5532
5539 void pack(int uv_set, bool rotate, bool shuffle);
5540
5545 void unwrap(int uv_set);
5546
5552 void toAbf(int uv_set, int island_index);
5553
5559 void toLscm(int uv_set, int island_index);
5560
5566 void toGu(int uv_set, int island_index);
5567
5573 void toPlanar(int uv_set, int island_index);
5574
5580 void toStripe(int uv_set, int island_index);
5581
5586
5591 void moveSelectedFacesAlongFacesNormals(float displacement);
5592
5597 void moveSelectedFacesAlongVertexNormals(float displacement);
5598
5603 void subdivideSelectedFaces(bool apply_catmull_clark = false);
5604
5609 void subdivide(bool apply_catmull_clark = true);
5610
5616 void transformSelected(const mat4& transform, bool apply_symmetry);
5617
5622 void scaleSelectedFacesClusters(float scale, ClusterScale method = Uniform_Scaling);
5623
5629
5635 void bevelOverSelectedEdges(float size, int segments = 1, bool OldVariant = false);
5636
5644 int splitEdge(int vertex1, int vertex2, float position);
5645
5652 bool connect(int vertex1, int vertex2);
5653
5660 bool checkConnectivity(int vertex1, int vertex2);
5661
5666
5671
5675 void inset(float distance);
5676
5681 void shell();
5682
5687 void intrude();
5688
5693
5699 void selectPath(int vertex1, int vertex2);
5700
5706 std::vector<int> getPath(int vertex1, int vertex2);
5707
5708 };
5709 class APICALL logger {
5710 FILE* out;
5711 void* tempTimer;
5712 str filename;
5713 str _accum;
5714 int precission;
5715 void append(const char*);
5716 void close();
5717
5718 public:
5724
5729 logger(const char* filename);
5730
5731
5732 ~logger();
5736 void open();
5737
5742
5748 logger& directTo(const char* filename);
5749
5755
5760 logger& operator << (const char*);
5761
5766 logger& operator << (str&);
5767
5772 logger& operator << (const wchar_t*);
5773
5778 logger& operator << (int);
5779
5784 logger& operator << (float);
5785
5790 logger& operator << (double);
5791
5796 logger& operator << (const vec2&);
5797
5802 logger& operator << (const vec3&);
5803
5808 logger& operator << (const vec4&);
5809
5814 logger& operator << (BaseClass*);
5815
5822 logger& format(const char* format, ...);
5823
5829
5835
5841
5847
5853
5858 logger& floatPrecission(int signs = 2);
5859 };
5860}
5861
5862
5863#include "CorePrimAPI.h"
5864#pragma pack(pop)
5865
5866#ifdef COMMS_OPENGL
5867#include <ui.h>
5868#include <ui_definition.h>
5869#define EXPORT(x) \
5870 static int Main();\
5871 __defineui(xxx) {\
5872 ui_element(#x, Main);\
5873 } static
5874#define EXPORT_COMMAND(x) \
5875 static void x();\
5876 __defineui(x) {\
5877 ui_element(#x, x);\
5878 } static void x()
5879#define EXPORT_EXTENSION(x) __defineui(___##x)
5880void executeCoreScript(const char* filename, bool build, bool clean);
5881#endif //COMMS_OPENGL
Use this class for build a class for UI or serialization. see class_reg.h for details about the class...
Definition BaseClass.h:91
Definition CoreAPI.h:3557
static vec3 getWorldToScreenSpace(const vec3 &world_pos)
convert the world position to the screen position
static vec3 getScreenToWorldSpace(const vec3 &screen_pos)
convert the screen position to the world position
static void rotateToGradually(const vec3 &destination_dir)
align the camera along the view
static vec3 getPivot()
get the camera pivot position
static bool isOrtho()
return true if the camera is in the ortho mode
static void setPivot(const vec3 &pivot)
set the camera pivot position
static vec3 getForward()
get the forward direction
static vec3 getRight()
get the camera right direction
static void setOrtho(bool ortho)
switch the camera to the ortho or perspective mode
static vec3 getUp()
get the camera up direction
static void setCamera(const vec3 &position, const vec3 &lookAt, float fovY, const vec3 &up=vec3::Zero)
static vec3 getPosition()
get the camera position
Definition CoreAPI.h:3027
void add(const Vector3D &p, const Vector3D &normal, float Radius)
add the point to the curve without the direct options the tangents
int pointsCount()
get the base points cout in the curve
void removePoints(int index, int count)
remove the points out of the curve base points list
OneCurveObject * curve()
get the low-level ObjeCurveObject pointer
void add(const Vector3D &p, const Vector3D &normal, const Vector3D &inOutTangent, float Radius)
add the point with the opposite tangents
void add(const Vector3D &p, const Vector3D &normal, const Vector3D &inTangent, const Vector3D &outTangent, float Radius)
add the point with two independent tangents.
Curve(OneCurveObject *ob)
create Curve based on low-level object OneCurveObject
void addSmooth(const Vector3D &p, const Vector3D &normal, float Radius)
add the smooth B-spline-like point to the curve
void addSharp(const Vector3D &p, const Vector3D &normal, float Radius)
add the sharp point to the curve
OneSelPoint * point(int idx)
get the base point pointer
bool & closed()
returns the reference to the closed state of the curve to get or set the value
Curve()
the default constructor, creates the curve without insertion into the scene, it is good for the tempo...
Curve(SceneElement &el)
create the curve object based on the SceneElement, it is valid only is scene element is curve
int renderPointsCount()
returns the visual points count. Visual points used to render the curve in the viewport as set of str...
void updatePoints()
update the visual points if need. Use this function if you cahnge the curve. Change the multiple para...
void tubeToMesh(Mesh &mesh, bool hemisphere)
create the solid tube around the curve using the points radius
void fill(Mesh &mesh, float thickness, float relax_count=0, float details_level=1, float extrusion=0)
Create the curved surface around the curve.
OneSelPoint * renderPoint(int idx)
returns the visual point reference
The image references. Look the cImage for the list of allowed operations.
Definition CoreAPI.h:1293
int ToTexture()
Create texture from image.
bool Read(const char *name)
Read the image from the file.
bool Write(const char *name)
Write the image to file.
bool FromTexture(int texture_id)
Get image from texture.
The mesh reference.
Definition CoreAPI.h:401
void subtractFromVolume(Volume &v, const mat4 &transform=mat4::Identity)
boolean subtraction of the mesh from the volume
std::vector< vec2 > getMeshUVs()
get the list of all UV vertices of the mesh
int facesCount()
returns the faces amount
std::vector< vec3 > getMeshVertices()
get the list of all positional vertices of the mesh
void setMaterialTexture(int idx, int texture_layer, const std::string &texture_path)
set the texture layer filename of the material
void shell(float thickness_out, float thickness_in, int divisions=1)
add some thickness to the mesh (intrude a bit)
float getOpenSurfaceVolume(const vec3 &start, const vec3 &dir) const
calculate the volume even if the mesh is not closed, in this case we define plane that limits the int...
void addMeshUVs(const std::vector< vec2 > &uvs)
add the list of all UV vertices for the mesh
void reduceToPolycount(int destination_triangles_count)
reduce the mesh to the given polycount, mesh will be triangulated
void removeObject(int idx)
remove object from the mesh
void distortByPerlinNoise(float noise_degree, float noise_scale, bool anisotropic=false, int seed=0)
distort the mesh by the Perlin noise
void setMeshFaces(const std::vector< int > &faces)
set the complete list of faces for the mesh
std::string getMaterialName(int idx)
get the name of the material
static Mesh cone(const vec3 &center=vec3::Zero, float radius=1, float height=2, float detail_size=1, const vec3 &topAxis=vec3::AxisY)
create the cone mesh
void fromVolume(Volume &v, bool with_subtree=false, bool all_selected=false)
extract the mesh from the volume
void rotateToYZAxis(const vec3 &axisY, const vec3 &axisZ)
rotate the mesh so that Y axis will be aligned with axisY, Z axis will be aligned with axisZ
std::vector< int > getOpenEdges()
get the list of open edges
void addToVolume(Volume &v, const mat4 &transform=mat4::Identity)
boolean add to volume
vec3 getCenterMass() const
calculate the center mass of the mesh
vec3 getFaceNormal(int face)
get the face normal
void weld(float minimal_relative_distance=0.0001f)
weld the mesh, remove all vertices that are closer than minimal_relative_distance*mesh_bound_box_diag...
std::string getMaterialTexture(int idx, int texture_layer)
get the texture name of the material
void clearVerts()
clear all positional vertices of the mesh
void rotateToXYAxis(const vec3 &axisX, const vec3 &axisY)
rotate the mesh so that X axis will be aligned with axisX, Y axis will be aligned with axisY
int createNewVertex(const vec3 &position)
create the positional vertex
void setMaterialName(int idx, const std::string &name)
set material name
int getFaceVertex(int faceIndex, int faceVertexIndex)
get the positional vertex index over the face
void addMeshNormals(const std::vector< vec3 > &normals)
add the list of all normal vertices for the mesh
void clearUvVerts()
clear all uv vertices of the mesh
std::vector< int > getFaceVerts(int face)
get the list of UV vertex indices over the face, pay attention UV vertices are not same as position v...
void clearFaces()
clear all faces of the mesh
void removeMaterial(int idx)
remove the material (and corresponding faces) from the mesh
vec3 getVertex(int idx) const
get the vertex coordinate
static Mesh cylinder(const vec3 &center=vec3::Zero, float radius=1, float height=2, float detail_size=1, int slices=0, int caps=0, int rings=0, float fillet=0)
create the cylinder mesh
static Mesh plane(const vec3 &center=vec3::Zero, float sizeX=2, float sizeY=2, int divisionsX=2, int divisionsY=2, const vec3 &xAxis=vec3::AxisX, const vec3 &yAxis=vec3::AxisY)
create the single-side plane mesh, the faces normals are put toward the vec3.Cross(xAxis,...
int vertsCount() const
returns the amount of verts in the mesh
void addTransformed(const Mesh &m, const mat4 &t)
concatenate the transformed mesh with the current one
void calcNormals()
re-calculate normals over the mesh
void toVolume(Volume &v, const mat4 &transform=mat4::Identity, BoolOpType op=BOOL_MERGE)
merge this mesh to the volume object
void intersectWithVolume(Volume &v, const mat4 &transform=mat4::Identity)
boolean intersection of the mesh with the volume
void fromReducedVolume(Volume &v, float reduction_percent, bool with_subtree=false, bool all_selected=false)
extract the mesh from the volume and reduce it by the given percent
void setVertexNormal(int idx, const vec3 &v)
set the normal of the vertex, pay attention position verts and normal verts are different,...
void fromVolumeWithMaxPolycount(Volume &v, int max_polycount, bool with_subtree=false, bool all_selected=false)
extract the mesh from the volume and reduce to the given polycount
vec2 getVertexUV(int idx) const
get the UV coordinate of the vertex, pay attention position verts and UV verts are different,...
int getFaceVertsCount(int face)
get the amount of vertices over the face
float getVolume() const
get the volume of the mesh
void addMeshVertices(const std::vector< vec3 > &positions)
add the list of all positional vertices for the mesh
int getFaceNormalVertex(int faceIndex, int faceVertexIndex)
get the normal vertex index over the face
std::vector< comms::cPlane > autodetectSymmetryPlanes()
Detect the symmetry planes of the mesh.
void transform(const mat4 &transform)
transform the mesh
void boolean(const Mesh &m, BoolOpType op)
boolean operation
void calcNormalsIgnoreSharpEdges()
re-calculate normals over the mesh, ignore the sharp edges
void clearObject()
clear all objects
void setFaceMaterial(int faceIndex, int materialIndex)
set the material index over the face, see the getMaterialsCount(), getMaterialName()
int addObject(const char *name)
add new object to the mesh
float getFaceSquare(int face)
get the squareof the face
void addMeshFaces(const std::vector< int > &faces)
add the list of faces for the mesh, pay attention, all vertex indices are global over the whole mesh!
void setFaceObject(int faceIndex, int objectIndex)
set the object index for the face, see the getObjectsCount(), getObjectName()
int getFaceUvVertsCount(int face)
get the amount of UV vertices over the face
void rotateToZXAxis(const vec3 &axisZ, const vec3 &axisX)
rotate the mesh so that Z axis will be aligned with axisZ, X axis will be aligned with axisX
void removeUnusedFaces()
remove all faces that contain zero vertices
int getFaceObject(int faceIndex)
get the object index over the face, see the getObjectsCount(), getObjectName()
int getMaterialsCount()
get the materials count in the mesh
void fromRetopo()
take the whole mesh from the retopo room
void setVertexUV(int idx, const vec2 &v)
set the UV coordinate of the vertex, pay attention position verts and UV verts are different,...
void insertInVolume(Volume &v, const mat4 &transform=mat4::Identity)
insert without boolean operation, if the volume is not in surface mode (volumetric) the boolean ADD w...
float getLengthAlongDirection(const vec3 &dir) const
get the mesh size along some axis
bool valid() const
Check if mesh is valid.
void clearMaterials()
clear all materials
int getObjectsCount()
returns the objects count in the mesh
int createNewUvVertex(const vec2 &uv)
create new UV vertex to be used for faces
void booleanOp(Mesh &With, BoolOpType op)
Perform the boolean operation with the given mesh.
void fromPaintRoom()
get the mesh from the paint room
void setFaceNormalVertex(int faceIndex, int faceVertexIndex, int normalVertexIndex)
set the normal vertex index over the face
void setMeshNormals(const std::vector< vec3 > &normals)
set the list of all normal vertices for the mesh
boundbox getBounds() const
get the mesh bound box
int addMaterial(const char *name)
add new material to the mesh
void relax(float degree, bool tangent, float crease_angle=180)
relax the mesh, keep the vertices count
void setFaceVerts(int face, const std::vector< int > &vertices)
set the list of positional vertex indices over the face
std::string getObjectName(int idx)
get the name of the object
void unifyAllObjects(const std::string &name="")
unify all objects in the mesh, i.e. make one object
void removeUnusedVerts()
remove all unused vertices
void setObjectName(int idx, const std::string &name)
set object name
vec3 getVertexNormal(int idx) const
get the normal of the vertex, pay attention position verts and normal verts are different,...
int getFaceUvVertex(int faceIndex, int faceVertexIndex)
get the UV vertex index over the face
bool Read(const char *name)
Load the mesh from the file.
void cutByDistortedPlane(const vec3 &start, const vec3 &NormalDirection, float noise_degree, float noise_scale, int seed=0)
Cut off the mesh by the distorted plane (using the Perlin noise), the result is stored in the current...
void clearNormals()
clear all normal vertices of the mesh
static Mesh hexagonal_plane(const vec3 &center=vec3::Zero, float sizeX=2, float sizeY=2, int divisionsX=2, int divisionsY=2, const vec3 &xAxis=vec3::AxisX, const vec3 &yAxis=vec3::AxisY)
create the single-side triangular plane mesh that consists mostly of quasi equally-sided triangles
static Mesh text(const char *string, const char *font="tahoma", float height=10.0f, const vec3 &center=vec3::Zero, const vec3 &text_direction=vec3::AxisX, const vec3 &text_normal=vec3::AxisY, float thickness=1, int align=1)
Create the text mesh.
int vertsNormalCount() const
returns the amount of normal - verts in the mesh
float getFaceUVSquare(int face)
get the face square in UV space
void setVertex(int idx, const vec3 &v)
set the vertex coordinate
void removeFaces(const std::vector< int > &faces)
remove the set of vertices from the mesh
void setMeshVertices(const std::vector< vec3 > &positions)
set the list of all positional vertices for the mesh
void setFaceUvVertex(int faceIndex, int faceVertexIndex, int uvVertexIndex)
set the UV vertex index over the face
float getSquare() const
get square of the mesh
int addObject(const std::string &name)
add the named object
void triangulate()
triangulate the mesh
void cutByPlane(const vec3 &start, const vec3 &NormalDirection)
Cut off the mesh by the plane, the result is stored in the current mesh, the part of the mesh that is...
void clear()
clear the mesh
std::vector< int > expandOpenEdges(float distance)
extrude open edges of the mesh
static Mesh box(const vec3 &center=vec3::Zero, const vec3 &size=vec3::One, const vec3 &xAxis=vec3::Zero, const vec3 &yAxis=vec3::Zero, const vec3 &zAxis=vec3::Zero, float detail_size=1, float fillet=0.0f, int nx=0, int ny=0, int nz=0)
create the box mesh
int getFaceMaterial(int faceIndex)
get the material index over the face, see the getMaterialsCount(), getMaterialName()
void symmetry(const vec3 &start, const vec3 &NormalDirection, bool resultInQuads)
apply symmetry to the mesh
void removeUnusedObjectsAndMaterials()
remove all unused objects and materials
int vertsUvCount() const
returns the amount of UV - verts in the mesh
std::vector< int > extrudeOpenEdges(float distance, vec3 direction=vec3::Zero)
extrude open edges of the mesh
std::vector< int > getFaceUvVerts(int face)
get the list of UV vertices indices over the face
std::vector< vec3 > getMeshNormals()
get the list of all normal vertices of the mesh
comms::cMeshContainer * geometry()
The low-level mesh reference allows to create, operate over individual faces, vertices,...
void setMeshUVs(const std::vector< vec2 > &uvs)
set the list of all UV vertices for the mesh
static Mesh sphere(const vec3 &center=vec3::Zero, float radius=1.0f, float detail_size=1)
create the sphere mesh
void ensureMaterialsAndObjectsExist()
ensure that at least one material and one object exist in the mesh
void createVDM(int side, const char *path_to_exr, const vec3 &center=vec3::Zero, float radius=1, const vec3 &up=vec3::AxisZ, const vec3 &x=vec3::AxisX, const vec3 &y=vec3::AxisY)
Create the vector displacement map from the mesh and save it as EXR file. The mesh is put on plane at...
int addMaterial(const std::string &name)
add the named material
bool Write(const char *name)
Save the mesh to file.
std::vector< Mesh > splitDisconnectedParts()
split the mesh into disconnected parts
The class that corresponds to the retopo/modeling rooms meshes. This is advanced version of the Mesh ...
Definition CoreAPI.h:4754
void setSelectedEdges(std::vector< int > &edges)
set the selected edges list
void relaxSelected()
relax selected vergtices
std::vector< int > getFacesNearEdge(int vertex1, int vertex2)
get the list of faces that are adjacent to the edge
int getFaceVertsCount(int face)
get the vertices count over the face
void setFaceMaterial(int face, int uv_set)
set the UV set for the face
void unselectAllEdges()
unselect all edges
void toGu(int uv_set, int island_index)
unwrap the island using the GU (Globally Uniform) approach
void invertSelectedFacesTopoplogically()
invert selected faces only within the connective area, if some objects has no selected faces,...
int vertsUvCount()
get the uv vertices count
std::vector< int > getIslandVertexMapping(int uv_set, int island_index)
get the mapping from the vertex index in the mesh that was got by islandToMesh to the vertex index in...
void setEdgeSharpness(int vertex1, int vertex2, bool sharp)
set the sharpness state for the edge
void setEdgeSeam(int vertex1, int vertex2, bool seam)
set or clear the seam state for the edge
int getCurrentObject()
get the index of the current group
Mesh getObjectMesh(int group_index)
get the mesh from some retopo group
void setVertexUV(int uv_vertex, const vec2 &uv)
set the UV for the UV vertex
std::vector< int > getFacesNearVertex(int vertex)
get the list of faces that are adjacent to the vertex
vec3 getFaceNormal(int face)
get the face normal
void bevelOverSelectedVertices(float size)
perform the bevel over the selected vertices. As result, new faces will be selected
void inset(float distance)
perform the inset over the selected faces
int getFaceMaterial(int face)
get the UV set index for the face
void dropUndo()
Drop the whole mesh to the undo queue, it is important if you want allow the user to undo your mesh c...
void pack(int uv_set, bool rotate, bool shuffle)
pack the islands in the current uv-set
void toLscm(int uv_set, int island_index)
unwrap the island using the LSCM approach
void removeUnusedMaterials()
remove all unused UV sets (not referred within the mesh)
int duplicateObject(int group_index, const char *name=nullptr, const mat4 &transform=mat4::Identity, bool select=false)
duplicate the object (retopo group)
void setSelectedVertices(const std::vector< int > &vertices, const std::vector< float > &weights)
set the selected vertices list
void unselectAllVertices()
unselect all vertices
void setSelectedFaces(std::vector< int > &faces)
set the selected faces list
int getFaceObject(int face)
get the group index of the face
void scaleSelectedFacesClusters(float scale, ClusterScale method=Uniform_Scaling)
scale each selection cluster separately, to own center mass
int splitEdge(int vertex1, int vertex2, float position)
split existing edge somewhere between vertices.
void toPlanar(int uv_set, int island_index)
unwrap the island using the Planar approach
void subdivideSelectedFaces(bool apply_catmull_clark=false)
subdivide the selected faces
bool isOpenEdge(int vertex1, int vertex2)
check if the edge is open
std::vector< int > getSelectedFaces()
get the list of selected faces
void intrude()
perform the intrude operation over the selected faces. After calling the intrude() you should call th...
void subdivide(bool apply_catmull_clark=true)
subdivide the whole mesh
~Model()
destroy the mesh reference (the mesh itself will not be destroyed if it is the reference to retopo/mo...
Mesh visibleToMesh()
get the visible faces as the Mesh object
std::vector< int > getFaceVerts(int face)
get the list of UV vertex indices over the face, pay attention UV vertices are not same as position v...
void toStripe(int uv_set, int island_index)
try to uwrap the island as the regular stripe
int createNewFace(int Group, int UVSet)
create empty face, you need to call setFaceVertices to set the vertices, setFaceUVVerts to set the UV...
void selectedToEdges()
convert faces/vertices selection to edges selection
void setFaceObject(int face, int group)
set the group index of the face
Mesh islandToMesh(int uv_set, int island_index)
get the mesh that contains the island, xy of each point is the UV coordinate. The mesh contains only ...
Model & operator=(const Model &source)
the assignment operator. No new Mesh allocated! Use MakeCopy if you need to make a copy of the mesh
void moveSelectedFacesAlongVertexNormals(float displacement)
move selected faces along the vertex normals, each vertex displace on the same distance
void selectPath(int vertex1, int vertex2)
select all edges on the path from vertex1 to vertex2 (add to existing edges selection)
bool getFaceVisibility(int face)
get the face visibility
void bevelOverSelectedEdges(float size, int segments=1, bool OldVariant=false)
perform the bevel over the selected edges.
std::vector< int > getVertsNearVertex(int vertex)
get the list of vertices that are adjacent to the vertex
static Mesh flattenSingleIsland(const Mesh &mesh, int method, bool optimize_rotation=true, bool scale_to_geometry=true)
Flatten the mesh that consists of the single island.
int getObjectsCount()
get the retopo groups count
bool isVertexSelected(int vertex)
check if the vertex is selected
Model(const Model &source)
make a reference to the source mesh. No new Mesh allocated! Use MakeCopy if you need to make a copy o...
void selectedToObject(int group_index)
move the selected faces to the group
std::vector< float > getSelectedVerticesWeights()
get the soft selection weights of the selected vertices, 1 is maximum value
int createNewUvVertex(const vec2 &uv)
create new UV vertex to be used for faces
void setObjectMesh(int group_index, Mesh &mesh, const mat4 &transform=mat4::Identity)
replace the retopo layer with mesh
void updateNormals(bool for_snapping=true)
update the vertex normals
Model(const Mesh &source)
construct model from the Mesh object.
void selectObject(int group_index, bool add_to_selected=true)
select all feces in the group
void contractSelection()
contract the faces/vertices/edges selection to the connected geometry
const char * getObjectName(int group_index)
get the retopo group name
int getFaceUvVertex(int face, int vertex_index)
get the UV vertex index over the face
vec3 getVertexNormal(int vertex)
get vertex normal, calculated as average of adjacent faces normals
void setObjectVisibility(int index, bool visible)
set the group visibility
int addMaterial(const char *name)
add the new UV set/Material
void cleanup()
complete cleanul from non-manifolds or other problems, some faces may be removed
vec3 getVertex(int vertex)
get the vertex position in space
bool isSeam(int vertex1, int vertex2)
check if edge is seam
std::vector< int > getFaceNeighbors(int face)
get the list of faces that are adjacent to the face
void setObjectReferenceColor(int group_index, vec4 color)
set the group reference color
void selectedToFaces()
convert edges/vertices selection to faces selection
bool isEdgeSelected(int vertex1, int vertex2)
check if the edge is selected, order of vertices has no matter
void updateTopology()
update the connectivity information, it should be called sometimes if you feel that the connectivity ...
float getFaceUVSquare(int face)
get the face square in UV space
int getFaceUvVertsCount(int face)
get the amount of UV vertices over the face
void setFaceVisibility(int face, bool visibility)
set the face visibility
void meshToIsland(const Mesh &mesh, int uv_set, int island_index)
use the mesh (that was previously got by islandToMesh) to replace the island in the current uv-set
int createNewVertex(const vec3 &position)
create the positional vertex
std::vector< int > getBorderBetweenIslands(int uv_set1, int island_index1, int uv_set2, int island_index2)
get the border between two islands
void addTransformed(const Mesh &mesh, const mat4 &Transform=mat4::Identity, BoolOpType b=BOOL_MERGE, bool select=false, bool snap_to_existing=false)
insert the mesh to the retopo/modeling room, each object of the mesh treated as the new retopo layer
Model & transform(const mat4 &m)
transform the whole Model with the matrix
std::string generateName(const char *base)
generate unique name for the object, it will start as the string in base base
int getFaceVertex(int face, int vertex_index)
get the vertex index over the face
void expandSelection()
expand the faces/vertices/edges selection to the connected geometry
std::vector< int > getSelectedVertices()
get the list of selected vertices
void collapseEdge(int vertex1, int vertex2)
collapse the edge to the middle of the edge
std::vector< int > getPath(int vertex1, int vertex2)
get all vertices on the path from vertex1 to vertex2
void extrudeSelected()
Extrude the selected edges or selected faces without the actual moving of the extruded elements....
void selectedToVertices()
convert faces/edges selection to vertices selection
vec4 getObjectReferenceColor(int group_index)
get the group reference color
void transformSelected(const mat4 &transform, bool apply_symmetry)
apply the transformation to the selected elements
void toAbf(int uv_set, int island_index)
unwrap the island using the ABF approach
void displayOptions(bool showWireframe=true, bool showColored=true, bool showSeams=true, bool showSharpEdges=true, bool smoothView=false)
Set the display options for the retopo/modeling/uv meshes.
void setFaceUvVerts(int face, const std::vector< int > &vertices)
set the UV vertices for the face
void selectEdge(int vertex1, int vertex2)
select the edge by vertex indices (add to selection)
void moveSelectedFacesAlongFacesNormals(float displacement)
move selected faces along the faces normals, trying to keep faces parallel to the original direction
std::vector< int > getIslandBorder(int uv_set, int island_index)
get unsorted list of edges on the border of the island
Mesh islandToMeshInSpace(int uv_set, int island_index)
get the mesh that contains the island, each point is the coordinate in space (not the uv coordinate!...
Mesh getWholeMesh()
get the whole mesh from the retopo room
void setObjectName(int index, const char *name)
rename the group by index
vec2 getIslandVertexUv(int uv_set, int island_index, int vertex_index)
get the uv coordinate of the positional vertex in the island
void clearObjectMesh(int group_index)
remove all faces from the group
void unwrap(int uv_set)
unwrap the current uv-set
bool connect(int vertex1, int vertex2)
split existing edge somewhere between vertices.
bool isSharpEdge(int vertex1, int vertex2)
check if the edge is sharp
static Model fromModeling()
get the reference to the mesh in the modeling room, currently it is the same mesh as in the retopo ro...
bool getObjectVisibility(int index)
get the group visibility
Model()
construct the lowpoly mesh, it is completely independent on retopo/modeling/uv workspace....
void connectSelectedVerts()
connect selected vertices in smart way
bool isFaceSelected(int face)
check if the face selected
std::vector< int > getFaceUvVerts(int face)
get the list of UV vertices indices over the face
Model MakeCopy() const
make a copy of the source mesh. Pay attention, if you taken it from the retopo/uv context,...
void shell()
perform the shell operation over the selected faces. After calling the shell() you should call the mo...
bool checkConnectivity(int vertex1, int vertex2)
check if connecting the two vertices is possible
void clear()
clear the whole mesh
int vertsCount()
get the positional vertices count
int addObject(const char *name)
add new retopo group
void removeObject(int group_index)
remove the group by index
int islandsCount(int uv_set)
get the islands count over the current uv-set
void setFaceVerts(int face, const std::vector< int > &vertices)
set the list of positional vertex indices over the face
void selectVertex(int vertex, float weight=1.0f)
add the vertex to the selection
std::vector< int > getObjectFaces(int group_index)
get the list of faces in the group
int facesCount()
get the faces count
float getFaceSquare(int face)
get the face square
void setCurrentObject(int index)
set the current group index
static Model fromRetopo()
get the reference to the mesh in the retopo room
Mesh selectedToMesh()
get the selected faces as the Mesh object
void unselectAllFaces()
unselect all faces
void selectFace(int face)
select the face by index
std::vector< int > getSelectedEdges()
returns even amount of vertex indices, pairs os start and end vertices of the selected edges
void setVertex(int vertex, const vec3 &position)
set the vertex position in space
static Model fromUv()
get the reference to the mesh in the uv room, pay attention that topology changes to that mesh may le...
vec2 getVertexUV(int uv_vertex)
get the UV coordinates of the UV vertex
void removeFace(int face)
remove the face by index
Definition CoreAPI.h:2844
static void setExposure(float exposure)
set the exposure value for the rendering (in render room)
static void setDOFDegree(float degree)
set the depth of field (DOF) degree
static vec3 getLightColor(int idx)
get the light color for the additional light
static float getLightIntensity(int idx)
get the light intensity for the additional light
static void removeLight(int idx)
remove the additional directional light
static void setLightIntensity(int idx, float intensity)
set the light intensity for the additional light
static void enableRealtimeRendering(bool enable)
enable or disable the realtime rendering
static void setCustomRenderSize(int width, int height)
set the render output width
static int getRaysPerFrame()
get rays per frame for the rendering
static void setRenderResult(const char *filename)
set the render output filename
static void setAA(bool AA)
set the anti-aliasing (AA) rendering state
static vec3 getLightDirection(int idx)
get the direction for the additional light
static void removeAllLights()
remove all additional directional lights
static void restartRendering()
if the realtime render enabled the command will restart the rendering from scratch
static void setLightScattering(int idx, float scattering)
set the light scattering for the additional light
static void setEnvironmentLight(float envlight)
set the brightness of the environment light (spherical environment)
static void setRaysPerFrame(int count)
set rays per frame for the rendering
static void toRenderRoom()
get to the render room to be able to render
static void setLightColor(int idx, const vec3 &color=vec3::One)
set the light color for the additional light
static void setLightDirection(int idx, const vec3 &dir)
set the direction for the additional light
static float getEnvironmentLight()
get the brightness of the environment light (spherical environment)
static bool isRealtimeRenderingEnabled()
get the realtime rendering state
static float getExposure()
get the exposure value for the rendering (in render room)
static float getDOFDegree()
get the depth of field (DOF) degree
static void renderFrame()
render to the output file
static float getLightScattering(int idx)
get the light scattering for the additional light
static int getLightsCount()
get the amount of additional directional lighte
static int addLight()
add the additional directional light
static bool getAA()
get the anti-aliasing (AA) rendering state
The scene element, like sculpt object or curve.
Definition CoreAPI.h:1609
SceneElement duplicate() const
diplicate the item
void selectOne() const
unselect all similar elements and select this one
SceneElement findInSubtree(const char *name) const
find the element in subtree by name
bool iterateVisibleSubtree(const std::function< bool(SceneElement)> &fn) const
iterate over the visible subtree
SceneElement child(int index) const
returns child element by index
mat4 getTransform() const
get the scene element transform
void removeSubtreeItem(int index) const
remove one child from the subtree
bool ghost() const
returs the state of ghosting (if available)
void removeSubtree() const
remove the whole subtree
bool isParentOf(SceneElement child) const
check if the element is parent of another one
const SceneElement & density(float density_value) const
this command useful if you use voxels, it sets the scale for the volume so that there will be density...
void collectSelected(list< SceneElement > &elemList)
Collect the selected elements in the subtree (including this element if selected)
void setVisibility(bool visible) const
set the visibility of the element
int childCount() const
returns the child elements count
const char * name() const
get the element name
void unselectAll() const
unselect all similar objects
const SceneElement & rename(const char *name) const
rename the element
void setGhost(bool ghost) const
sets the ghosting state (if available)
void select() const
add the object to selected
void setLinkedFile(const char *file_path) const
set the linked file path
void changeParent(SceneElement newParent) const
change the parent element for the current one
void setReferenceColor(const vec4 &color)
set the reference color for the element
void mergeSubtree(bool booleanMerge=false) const
merge all subtree volumes into this
vec4 getReferenceColor()
get the reference color for the element
bool & visible() const
returns own visibility state reference. It does not take into account that parent may be invisible.
const SceneElement & transform(const mat4 &Transform) const
Additional transform over the object.
SceneElement duplicateAsInstance() const
create the instance of the object if instancing supported
void copyMergeTo(SceneElement &dest, BoolOpType op)
copy and merge the volume to another one, delete this volume
SceneElement parent() const
get the parent scene graph element
bool iterateSubtree(const std::function< bool(SceneElement)> &fn) const
iterate over the subtree
const char * getLinkedFile() const
get the linked file path
Volume Volume() const
returns the volume object to operate over voxels or surface
bool selected()
Check if the scene element is selected.
const SceneElement & setTransform(const mat4 &Transform) const
Set the transform matrix.
std::vector< SceneElement > collectSelected()
Collect the selected elements in the subtree (including this element if selected)
void mergeTo(const SceneElement &dest, BoolOpType op)
merge the volume to another one, delete this volume
void remove() const
remove this item and all child objects from the scene
bool isSculptObject() const
Check if it is the sculpt object.
bool isCurve() const
Check if the element is curve.
const SceneElement & clear() const
Clear the element content.
const SceneElement & transform_single(const mat4 &Transform) const
Additional transform over the object, not applied to child objects.
SceneElement addChild(const char *name) const
add the child element of the same nature
referes the roots of the scene graph
Definition CoreAPI.h:2479
static void setLayerBlending(int LayerID, int mode)
set the layer blending mode
static void RemoveUVSet(int idx)
Remove the UV-set (texture)
static SceneElement importMesh(const char *filename, const mat4 &transform=mat4::Identity)
import mesh into scene, it is the same as File->Import->Import mesh for vertex painting/reference ....
static void invertLayerMask(int LayerID)
invert the layer mask (if assigned)
static void setActiveLayer(int LayerID)
activate the layer
static const char * getLayerName(int LayerID)
get the layer name
static void mergeVisibleLayers()
merge all visible layers
static bool setSceneUnits(const char *units)
Set the scene units without actual scaling the scene to new units, just name change.
static vec3 getSceneShift()
get the scene shift value, look the Edit->Scale master->X,Y,Z
static void setLayerVisibility(int LayerID, bool Visible)
set the layer visibility
static void setLayerMetalnessOpacity(int LayerID, float Opacity)
set the layer metalness opacity
static int getLayerBlending(int LayerID)
get the layer blending mode
static void setCurrentLayer(int LayerID)
set the current layer
static void RemovePaintObject(int idx)
Remove the paint object.
static void ScaleSceneUnits(float scale)
Keep the scene visial size in scene, but scale the export size.
static float GetSceneScale()
the length of 1 scene unit when you export the scene
static const char * PaintMaterialName(int idx)
Get the reference to the material mane.
static void disableLayerMask(int LayerID)
disable the mask for the layer
static int getLayerMaskLayer(int LayerID)
get the mask identifier assigned to the layer
static void setSceneShift(const vec3 &shift)
set the scene shift value, look the Edit->Scale master->X,Y,Z
static void enableLayerMask(int LayerID)
enable the mask for the layer
static void ScaleSceneVisually(float scale)
Scale the whole scene visually but keep the export size.
static void mergeLayerDown(int LayerID)
merge the layer down
static void removeEmptyLayers()
remove all unused layers
static void setLayerGlossOpacity(int LayerID, float Opacity)
set the layer gloss/roughness opacity
static void extractMaskAsLayer(int LayerID)
If the layer has the mask attached, the mask will be extracted as a new layer and the masking disable...
static bool maskEnabled(int LayerID)
check if the mask is enabled for the layer
static void invalidateLayer(int LayerID)
refresh the layer appearance in scene
static int getCurrentLayer()
get current layer identifier
static void applyLayerBlending(int LayerID)
apply layer blending
static SceneElement current()
returns the current sculpt object
static const char * GetSceneUnits()
get the name of the current scene units
static void setMaskForTheLayer(int LayerID, int MaskLayerID)
set the MaskLayerID to be used as mask for the LayerID. The MaskLayerID will disappear among the laye...
static void enableLayerMask(int LayerID, bool enable)
enable or disable the layer mask
static void RemovePaintMaterial(int idx)
Remove the paint material.
static bool layerIsEmpty(int layerID)
Check if the layer is empty.
static const char * PaintObjectName(int idx)
Get the reference to the object name.
static int PaintUVSetsCount()
Get the paint UV-sets (textures) count.
static void setLayerName(int LayerID, const char *name)
set the layer name
static void clearScene(bool askUser=false)
clear the whole scene
static int assignLayerMask(int LayerID)
assign the mask to the layer if it is not assigned before
static bool convertSceneUnits(const char *destination_unit_name)
Convert the scene units to the new units, the scene scale will be changed, visual size will be kept.
static void setClippingLayer(int LayerID)
set this layer as clipping layer
static void removeLayerMask(int LayerID)
remove the layer mask
static std::vector< std::string > getAvailableUnits()
Get the list of all available units.
static void removeLayer(int LayerID)
remove the layer
static int getLayer(const char *name, bool addIfNotExists=true)
get the Layer ID by name, add the layer if not exists
static SceneElement sculptRoot()
get the root of all sculpt objects
static int PaintMaterialCount()
Get the count of paint materials.
static int PaintObjectsCount()
Get the count of paint objects in scene.
static SceneElement curvesRoot()
get the root of all curves
static bool isLayerMaskEnabled(int LayerID)
check if the mask is enabled for the layer
static const char * PaintUVSetName(int idx)
Get the reference to the UV set name.
static void disableClippingLayer(int LayerID)
disable the clipping layer
static void setLayerColorOpacity(int LayerID, float Opacity)
set the layer opacity
static bool layerVisible(int LayerID)
return the layer visibility
static void setLayerDepthOpacity(int LayerID, float Opacity)
set the layer depth opacity
The class intended to place spheres in space and identify if there are spheres around....
Definition CoreAPI.h:3168
int addSphere(const vec3 &p, float radius)
add the sphere into the space
void setUnit(float u)
set the cell size, the cell space should be empty
SphericalCollision(float cellsize)
create the collision space
void clear()
remove all spheres
vec3 collides(const vec3 &p, float radius)
check if sphere intersects other spheres in the space
vec4 sphere(int idx)
get the sphere parameters by index
Definition CoreAPI.h:1901
The class allows to operate over voxels/surface on the relatively low-level.
Definition CoreAPI.h:1911
static void roughness(float value)
assign the roughness for the voxel operations, it will work only if the color already assigned
void subtractMesh(Mesh &mesh, const mat4 &transform=mat4::Identity)
subtract the mesh from volume (boolean)
void removeFacesByWeight(std::function< float(const vec3 &)> weight)
Remove all faces where all the function returns the value < 0 for all the vertices over the face.
VolumeCell * cell(int cx, int cy, int cz, bool create, bool backup)
get the cell by cell coordinates, each cell is 8*8*8
float getInterpolatedValue(const vec3 &pos, bool fromBackup)
returns interolated voxels density
void scanCells(const std::function< void(VolumeCellAttrib *vc)> &fn, bool multithreaded=false)
run through all volume cells
void clearNoUndo()
Clear quickly, without affecting the Undo queue.
boundbox calcLocalSpaceAABB()
Calculate the Axis - Aligned Bound Box of the object in local space.
void relaxGpu(const vec3 &center, float Radius, float degree)
fast voxel-based relax within the sphere with the gradual falloff. It works only in voxel mode.
void relaxSurface(float degree, bool tangent=false, bool keep_sharp_boolean_edges=false)
relax the object in surface mode
static void gloss(float value)
assign the gloss for the voxel operations, it will work only if the color already assigned
SceneElement generateMoldingTest()
generate the figure that fills the gap between the molding shapes
static void setMoldingParams(const vec3 &direction, float tapering_angle=0, float undercuts_density=1.0f, float decimation_limit_millions=10, bool perform_subtraction=true)
set the parameters for the molding
static void enableVoxelsColoring(bool enable=true)
enable or disable the voxel-based coloring. It is applied wherever possible - merging models,...
float getVolume()
get the volume of this object in world coordinates
Volume & makeVoxelFigure(std::function< float(vec3)> densityFunction, const list< vec3 > &growCenters, bool Subtract=false, bool useTempLocation=false, bool overHidden=false, bool useColor=false)
This function is fast (generally realtime) way to fill the volume with voxels. Voxel Brush Engune com...
SceneElement findMoldingTop()
find the top molding shape (that was previously generated)
void mergeMesh(Mesh &mesh, const mat4 &transform=mat4::Identity, BoolOpType op=BOOL_MERGE)
merge the mesh into scene
void mergeMeshWithTexture(Mesh &mesh, const mat4 &transform=mat4::Identity, BoolOpType op=BOOL_MERGE)
merge the mesh with facture, the volume polygons will be hidden, just the texture will be shown (like...
float getSquare()
reg the square of this object in world coordinates
void toVoxels()
turn to voxels, auto-voxelize
void scanTriangles(const std::function< void(const MCVertex &v1, const MCVertex &v2, const MCVertex &v3)> &fn, bool multithreaded=false)
run through all triangles
void removeUndercuts()
remove undercuts for the current volume
VoxTreeBranch * tree()
returns the low-level object (VoxTreeBranch) for all low-level operations
void intersectWithMesh(Mesh &mesh, const mat4 &transform=mat4::Identity)
intersect the volume with the mesh (boolean)
void curveBasedMolding()
perform the curve-based mold
static void color(float r, float g, float b)
assign the color for the voxel operations
void setOpacity(float Opacity)
set the volume opacity
bool isVoxelized() const
Check if in voxel mode.
void assignShader(const char *shaderName)
set the shader for the Volume
void scanCells(const std::function< void(VolumeCellAttrib *vc, const tri_DWORD &T)> &fn, bool multithreaded=false)
run through all volume cells
void closeHoles(int maxSize)
Close the holes.
void scanCells(const std::function< void(VolumeCell *vc, const tri_DWORD &T)> &fn, bool multithreaded=false)
run through all volume cells
void addMesh(Mesh &mesh, const mat4 &transform=mat4::Identity)
add the mesh to volume (boolean)
VolumeCellAttrib * attributes(int cx, int cy, int cz, bool create, bool backup)
get the cell attributes by cell coordinates, each cell is 8*8*8, generally it is kept as VolumeCell::...
void scanTriangles(const std::function< void(const Vector3D &v1, const Vector3D &v2, const Vector3D &v3)> &fn, bool multithreaded=false)
run through all triangles
void generateMoldingCurves()
generate the automatic molding curves
void removeMoldingShapes()
remove all molding intermediate shapes, tests, etc.
static void color(float r, float g, float b, float a)
assign the color for the voxel operations
void clear()
Clear and pass to the Undo queue.
void relaxOpenEdges(int nTimes)
relax the open edges of the mesh, it is applicable only to the surface mode
void toSurface()
turn to surface mode, the triangles will be tangentially relaxed
static void setMoldingBox(float width, float length, float thickness)
set the molding bound box to be user-defined, not automatic
void assignLiveBooleans(int operation)
Apply the live booleans over the sculpt mesh, it is available for voxels only.
boundbox calcWorldSpaceAABB()
Calculate the Axis - Aligned Bound Box of the object in world space.
int getPolycount()
get the volume triangles count
void dirty(int cx, int cy, int cz)
mark the cell as dirty. This is required if you
static bool checkIfMoldingLicenseAvailable()
check if molding allowed
bool isSurface() const
Check if in surface mode.
void subtractWithoutUndecuts()
subtract the current undercutted object from the preliminary generated molding shapes
static void color(DWORD CL)
set the default color to fill voxels if the voxel coloring enabled
void basRelief(const vec3 &start_point=vec3::Zero)
perform the bas-relief for the current volume
SceneElement findMoldingTest()
find the test molding test shape (that was previously generated)
void relaxVoxels(int count)
relax the whole volume, works only for voxels
bool valid() const
checks if object is valid
void collapseBollTree()
collapse the boolean tree, it is available for this volume
void scanCells(const std::function< void(VolumeCell *vc)> &fn, bool multithreaded=false)
run through all volume cells
float getExactDencity(int x, int y, int z, bool fromBackup, VolumeCache &cache_ref)
returns the exact voxel density in local space at the exact integer location
void insertMesh(Mesh &mesh, const mat4 &transform=mat4::Identity)
insert the mesh into the volume, in case of voxels this is identical to addMesh, in case of surface,...
void automaticMolding()
perform the automatic molding
static void color(const char *colorid)
assign the color for the voxel operations
static void metal(float value)
the metalliclty value for the voxel operations, it will work only if the color already assigned
static void setAutomaticMoldingBox()
set the molding bound box to be automatic
SceneElement findMoldingBottom()
find the bottom molding shape (that was previously generated)
VolumeObject * vo()
returns the low-level object (VolumeObject) for all low-level operations
static void setMoldingBorder(float width=0)
set the molding border around the parting line to fade to the plane, if it is zero,...
SceneElement inScene()
Get the Volume placement in the scene.
the rich dialog. You may customize it, show your custom parameters and custom buttons.
Definition CoreAPI.h:3641
dialog & transparentBackground()
the background will not be faded
dialog & no()
add No button
dialog & process(std::function< void()> process)
pass the function/lambda that will be called each frame. But there is better way - override the Proce...
dialog & dontShowAgainCheckbox()
show the checkbox "Don't show again". If user checks if the dialog will net be shown next time and sh...
dialog & modal()
dialog will be modal. Generally, it is modal by default. Execution will be paused at show() till the ...
dialog & params(BaseClass *params)
The important core feature. BaseClass allows to create the custom controls in the dialog....
dialog & width(int w)
change the default width
dialog & noModal()
dialog will be no modal. Execution will continue after you will call the show()
dialog & onPress(std::function< void(int)> press)
pass the function/lambda that will be called when the button will be pressed. The button index (start...
dialog & undoWorks()
allow undo (CTR-Z) act even in modal dialog
dialog & ok()
add Ok button
dialog & cancel()
add Cancel button
dialog & warn()
add Warning icon
int show()
pass the function/lambda that will be called when the button will be pressed. The button index (start...
dialog & caption(const char *id)
pass the caption of the dialog
dialog & question()
add Question icon
dialog & topRight()
place the dialog at the top-right position of the viewport
dialog & yes()
add Yes button
dialog & buttons(const char *list)
pass the list of buttons for the dialog
dialog & text(const char *id)
pass the header text of the dialog
static bool & fadeDialogsBackground()
returns the reference to the global property - fade modal dialogs background (true) or not (false)
General I/O access.
Definition CoreAPI.h:3932
static vec2 snappedCursorPos()
returns the snapped cursor position
static void showPythonConsole()
Show the python console, clear it and pop up.
static void pipInstall(const char *requirements)
install one or multiple python packages
static std::vector< std::string > openFilesDialog(const char *extensions)
open multiple files dialog
static void ListFiles(const char *folder, const char *mask, coat::list< coat::str > &result, bool recursive=true)
list files in the folder
static std::string strFromFile(const char *filename)
read string from file.
static bool openFilesDialog(const char *extensions, list< str > &fileNames)
open multiple files dialog
static std::string getFileName(const char *filepath)
get the file name from the path
static std::string getExtension(const char *filepath)
get the file extension (without .)
static void createRedistributablePackageFromFolder(const char *folder, const char *package_name, const char *excluded_folders_names="", const char *excluded_extensions="")
Create the 3dcpack file from the folder placed in Documents.
static std::string toFullPathInDataFolder(const char *path)
convert the relative path to full path in documents folder. If the path is full and placed in the ins...
static void step(int count=1)
perform rendering cycles
static void progressBarInWindowHeader(float stage, float max_stage, const char *message)
Show the progress bar only in the 3DCoat's window header.
static void exec(const char *command, const char *arguments=nullptr)
execute command. It may be exe file, URL, batch command
static void executeScript(const char *path)
execute python (.py file) or angelscript (c++ like), or CoreAPI (native C++) script
static void post_request(const char *url, const char *data, const char *headers, const std::function< void(const char *)> &report_success=nullptr, const std::function< void(const char *)> &report_error=nullptr)
send the post request to the url
static const char * supportedImagesFormats()
returns the currently supported mesh export formats
static std::vector< std::string > listBlenderInstallFolders()
list the blender install folders
static void copyFolder(const char *src, const char *dest)
copy the whole folder from src to dest. If the src or dest is relative, it is relative to the documen...
static std::string getFileNameWithoutExtension(const char *filepath)
remove the file extension from the filename
static const char * currentSceneFilepath()
returns the current scene filename, empty if the scene was not saved/opened
static std::string getFilePath(const char *filepath)
get the file path without the filename
static std::vector< std::string > ListFolders(const char *startFolder)
list folders within the folder, non-recursive, just plain list
static void setWindowTitle(const char *text, float seconds)
Override the 3DCoat's window title for some amount of time.
static rect wholeScreen()
get the whole screen rectangle
static bool openFileDialog(const char *extensions, str &fileName)
show the file dialog
static void get_request(const char *url, const char *headers, const std::function< void(const char *)> &report_success=nullptr, const std::function< void(const char *)> &report_error=nullptr)
send the get request to the url
static std::string convertToWritablePath(const char *path)
If the path is relative or points into some file in the install folder, it will be converted to the p...
static void ListFolders(const char *startFolder, coat::list< coat::str > &result)
list folders within the folder, non-recursive, just plain list
static int getDownloadProgress()
returns the overall download progress
static void removeFolder(const char *folder)
remove the folder. If the folder is relative, it is relative to the documents folder....
static void saveScreenshot(const char *filename, int x=0, int y=0, int width=0, int height=0)
save the screenshot to the file
static rect workArea()
get the work area rectangle
static std::vector< std::string > ListFiles(const char *folder, const char *mask, bool recursive=true)
list files in the folder
static std::string pythonPath()
get the python libraries folder
static vec2 cursorPos()
returns the current cursor position
static void copyFile(const char *src, const char *dest)
copy the file from src to dest. If the src or dest is relative, it is relative to the documents folde...
static void installRequirements(const char *path_to_requirements_txt)
Install all the requirements for the python script execution.
static std::string convertToWritablePathIfFileExists(const char *path)
If the path is relative or points into some file in the install folder, it will be converted to the p...
static bool fileExists(const char *path)
check if file exists
static size_t getFileSize(const char *filename)
get the file size
static void download(const char *url, std::function< void(const char *, const char *)> report_success)
download the file from the url
static bool saveFileDialog(const char *extensions, str &fileName)
show the save file dialog
static void updateCoatPyi(const char *folderOrFile)
update the .pyi file for the given folder or py file
static const char * dataPath()
the 3DCoat data path
static void removeFile(const char *filename)
remove the file. If the filename is relative, it is relative to the documents folder....
static const char * execAndWait(const char *command, const char *arguments=nullptr)
execute and wait till finished, the console output will be returned as string
static const char * documents(const char *path)
convert the relative path to the path in documents, if the path is absolute, just return the original...
static const char * installPath()
the 3DCoat installation path
static std::string toFullPathInInstallFolder(const char *path)
convert the relative path to the full path in the install folder. If the path is full,...
static const char * supportedMeshesFormats()
returns the list of supported images formats
static void strToFile(const char *text, const char *filename)
write the string to file
static void progressBar(float stage, float max_stage, const char *message)
Show the progress bar.
Definition CoreAPI.h:5709
void showMessage()
show the accumulated log in the message box
logger & floatPrecission(int signs=2)
set the precission of floating-point output
logger & flush()
save all acumulated text to the file
void open()
open the accumulated log in the default text editor
logger & directTo(const char *filename)
Direct the log output to the file
logger & timestamp()
add the timestamp to the log as the
logger & endTimer()
stop the timer and output the time into the log as amount of microseconds
logger & newline()
start newline in the text file
logger & startTimer()
start the timer to profile some operation
logger()
create the logger object. You may call directTo later and flush the output there. Otherwise,...
str getFullPath()
Returns the absolute path to the log file.
logger(const char *filename)
create the logger object and direct the output there
logger & format(const char *format,...)
send the formatted message
this class represents different resources accessible in UI - alphas, strips, materials,...
Definition CoreAPI.h:3826
std::string getCurrentItem()
returns the current item name (if possible)
void removeItem(const char *itemName)
remove the item from the current folder
std::vector< std::string > listFolders()
list folders of the resource type referred by this object
std::string currentFolderFullPath()
full path (relative to the 3DCoat's documents) to the current folder files
static std::vector< std::string > listAllResourcesTypes()
list all available resources types
void setCurrentFolder(const char *folder)
set the current folder (short name without the full path)
void moveItemToFolder(const char *itemName, const char *destFolderName)
move the item to another folder
void createFolder(const char *folderName)
create the folder and switch there
void selectItem(const char *itemName)
select/activate the item in the current folder
std::vector< std::string > supportedExtensions()
get the list of supported extensions for the resource type referred by this object
void addItem(const char *itemPath)
add the item to the current folder
std::vector< std::string > listCurrentFolderItems()
get the list of all items in the current folder
std::string currentFolder()
get the current folder short name
std::string rootPath()
the root path (relative to the 3DCoat's documents) to the resource type referred by this object
resource(const char *id)
create the reference to some resource type to access it and operate with it
void removeFolder(const char *folderName)
remove the folder and switch to the root folder if this is the current folder
Definition CoreAPI.h:2377
static std::vector< std::string > listAllSettings()
get the list of all available settings
static float getFloat(const char *ID)
get the float value from the settings
static bool setString(const char *ID, const char *value)
set the string value to the settings
static void pressButton(const char *button_name)
triger some action in settings
static void resetSettings(bool ResetGeneralSettings=true, bool ResetHiddenSet=true, bool ResetHotkeys=true, bool RestNavigation=true, bool ResetPresets=true, bool ResetTheme=true, bool ResetWindows=true)
reset all settings to default values, application will restart
static bool getBool(const char *ID)
get the boolen value from the settings
static std::string getString(const char *ID)
get the string value from the settings
static void saveSettings()
save all changed settings
static int getInt(const char *ID)
get the integer value from the settings
static bool setFloat(const char *ID, float value)
set the float value to the settings
static bool setInt(const char *ID, int value)
set the integer value to the settings
static bool valueExists(const char *ID)
returns true if the value in settings exists
static bool setBool(const char *ID, bool value)
set the boolean value to the settings
Definition CoreAPI.h:1359
static std::vector< comms::cPlane > getCurrentPlanes()
Returns all symmetry planes using the current symmetry state.
static symm & translation(int numX, float stepX, int numY, float stepY, int numZ, float stepZ)
Enable the translation symmetry.
static symm & xyz(bool x, bool y, bool z)
Enable the XYZ-mirror symmetry.
static symm & enable(bool _enable=true)
Enable the symmetry.
static vec3 & start()
get the start point reference
static symm & axialMirror(int n, bool extraMirror=false, bool stepSymmetry=false)
Enable the axial mirror symmetry.
static bool & stepSymmetry()
returns the state of step symmetry
static bool & x()
check x symmetry state
static symm & getCurrentTransforms(list< mat4 > &symmetryTransforms)
Returns all transforms using the current symmetry state.
static bool & z()
check z symmetry state
static symm & setCustomSymetryTransforms(list< mat4 > &symmetryTransforms)
enable the custom symmetry, provide the symmetry transfoms
static bool & y()
check y symmetry state
static int & axialOrder()
returns the axial symmetry order if axial or axial mirror symmetry enabled
static std::vector< mat4 > getCurrentTransforms()
Returns all transforms using the current symmetry state.
static symm & getCurrentPlanes(list< comms::cPlane > &planes)
Returns all symmetry planes using the current symmetry state.
static symm & showSymmetryPlane(bool show=true)
Show or hide the symmetry planes.
static float & stepZ()
returns the reference to the z-step if the translational symmetry used
static symm & toGlobalSpace()
set the symmetry to be in global space
static bool & extraMirror()
returns the state of extra mirror, this is valid only tor the axial symmetry
static symm & toLocalSpace()
set the symmetry to be in local space
static int & numY()
returns the reference to the number of the y repeats if the translational symmetry used
static symm & disable()
disable the symmetry
static bool is_axial()
Check if the axial symmetry enabled
static symm & axial(int n, bool extraMirror=false, bool stepSymmetry=false)
Enable the axial symmetry.
static symm & set_start(const vec3 &pos)
set the central point for the symmetry
static int & numX()
returns the reference to the number of the x repeats if the translational symmetry used
static bool is_xyz()
check if the XYZ symmetry enabled
static symm & toGeneral()
set the symmetry to general case
static symm & set_end(const vec3 &pos)
set the end point for the symmetry axis, calling this function enables the general case of the symmet...
static vec3 & end()
the end point reference
static bool isCustomSymmetry()
Check if the custom symmetry used.
static int & numZ()
returns the reference to the number of the z repeats if the translational symmetry used
static float & stepX()
returns the reference to the x-step if the translational symmetry used
static bool is_translation()
Check if the translation symmetry enabled.
static bool isAxialMirror()
Check if the axial mirror symmetry enabled.
static float & stepY()
returns the reference to the y-step if the translational symmetry used
text primitive
Definition CorePrimAPI.h:1735
operate over the Coat's ui
Definition CoreAPI.h:3221
static const char * roomName(int index)
get the room name by index
static void toolParam(BaseClass *B)
show the class B as the part of the tools params panel
static bool checkIfMenuItemInserted(const char *ID_in_menu)
Check if the command inserted somewhere into the menu.
static std::string inputString(const char *text, int min_length=0)
input text under the mouse position
static void toRoom(const char *name, bool Force=false)
switch to the room
static void insertInMenu(const char *Menu, const char *ID_in_menu, const char *script_path)
Insert the scripted command into the main menu.
static void apply()
pess ENTER, acts as Apply usually
static bool setBoolValue(const char *id, bool value)
Set the value for the checkbox in UI.
static void removeToolParam(BaseClass *B=nullptr)
remove the class from the tools params
static int roomsCount()
returns the rooms count
static void setFileForFileDialog(const char *filename)
Set the file for the next file dialog that will be triggered by user. If you will use coat::ui:cmd(....
static void enablePenChannel(int i, bool enabled)
enable or disable the pen channel
static const char * getOption(const char *id)
get the option from preferences
static bool getBoolField(const char *id)
Get the bool field from the checkbox in UI.
static int inputInt(int initial_value)
input the integer value under the mouse position
static const char * roomID(int index)
get the text identifier of the room
static float inputFloat(float initial_value)
inputh the float value under the mouse position
static bool isInRoom(const char *name)
check if we are in the specified room
static bool setEditBoxValue(const char *id, float value)
set the edit box value
static const std::string getIdTranslation(const char *id)
Get the translation for the text identifier.
static bool setEditBoxValue(const char *id, int value)
set the edit box value
static bool isEnabledPenChannel(int i)
check if the pen channel is enabled
static bool cmd(const char *id, std::function< void()> process_in_modal_dialog=0)
execute some action in UI as if you pressed on some control
static bool setSliderValue(const char *id, float value)
Set the value for the the slider (if exists in UI)
static void hideDontShowAgainMessage(const char *id)
Hides the "Don't show again dialog" for the current session (not forever)
static void addTranslation(const char *id, const char *text)
Add the translation for the text identifier.
static void showInfoMessage(const char *infoID, int milliseconds)
Show the floating information message for the some time period.
static const char * currentRoom()
get the current room name
static float getSliderValue(const char *id)
get the value of the slider
static bool wait(const char *id, float max_seconds)
wait till the element id will appear in the UI. The element will not be clicked. The max wait time is...
static bool getEditBoxValue(const char *id, str &result)
get the edit box value
static void removeCommandFromMenu(const char *ID_in_menu)
remove the command from the menu
static void insertInToolset(const char *roomID, const char *section, const char *toolID, const char *script_path="")
Insert the script-based tool into the toolset.
static bool setOption(const char *id, const char *value)
set the value to preferences
static bool checkIfExtensionPresent(const char *extension_ID)
Check if extension named as extension_ID is present in the 3DCoat.
static void switchToLanguage(const char *language)
Switch the layout to the language.
static bool presentInUI(const char *id)
Check if the elemnt present in the UI.
static bool setEditBoxValue(const char *id, const char *value)
set the edit box value
static const std::string getCurrentLanguage()
Get the current language file name (without the XML extension)
static void highlight(const char *id, float milliseconds)
highlight the UI element for a while
static float scale()
returns the scale in comparison to the smallest UI theme
Definition CoreAPI.h:4344
static float getFPS()
get the current FPS
static void set(const char *key, const char *value)
Globally set the value for the key, it is even stored between sessions of the 3DCoat.
static float getFrameTimeMs()
get the frame time in milliseconds
static void testSuccessful()
report that the test was successful. In this case the file "InstallFolder/.installer/test_success....
static void testFailed(const char *message)
report that the test was successful. In this case the file "InstallFolder/.installer/test_failed....
static void clearEnum(const char *enumID)
clear the global strings list.
static int getEnumValueIndex(const char *enumID, const char *key)
get the index of the value in the global strings list. That lists used in dropdown boxes in UI
static bool inRenderProcess()
check if the viewport is in render process in render room
static const char * getEnumValueByIndex(const char *enumID, int index)
get the value from the global strings list by index. That lists used in dropdown boxes in UI
static void quit()
exit the 3DCoat
static vec4 dwordToVec4(unsigned int d)
convert DWORD (unsigned int) to vec4
static unsigned vec4ToDword(const vec4 &v)
convert vec4 to DWORD (unsigned int)
static vec3 randomNormal()
get the normalized random vector
static void addEnumValue(const char *enumID, const char *key, int value=- 1)
add the value to the global strings list.
static float random01()
get the random value 0..1
static const char * get(const char *key)
Get previously stored value by the key.
static float perlin(vec3 p, float seed=0)
generate the perlin noise value
static float random(float min, float max)
get the random value in range
static int getEnumValuesCount(const char *enumID)
get the count of the values in the global strings list. That lists used in dropdown boxes in UI
static void randomize(int seed)
set the random seed for all further random value generation
static void signal(const char *message)
send some message to 3DCoat (usually used for internal purposes)
static int getEnumValue(const char *enumID, const char *key)
get the integer value that corresponds to the string value from the global strings list.
static std::vector< std::string > & last_signals()
get the list of last signals sent to 3DCoat
static vec3 perlin3d(vec3 p, float seed=0)
returns the perlin noise 3d vector
The UV API. The mesh is taken from the current room. If paint or UV rooms is active,...
Definition CoreAPI.h:4511
static void toUvSet(int uv_set, int island_index, int destination_uv_set)
move the island from one uv-set to another one
static std::vector< int > getSeams()
get all seams across the mesh
static Mesh getWholeMesh()
get the whole mesh from the paint/UV/Retopo room - in dependence on current room
static int islandsCount(int uv_set)
get the islands count over the current uv-set
static void toPlanar(int uv_set, int island_index)
unwrap the island using the Planar approach
static void addSeam(DWORDS2 start_vertex_index, int end_vertex_index)
add the seam to the mesh
static void toLscm(int uv_set, int island_index)
unwrap the island using the LSCM approach
static std::vector< int > getIslandVertexMapping(int uv_set, int island_index)
get the mapping from the vertex index in the mesh that was got by islandToMesh to the vertex index in...
static std::vector< int > getIslandBorder(int uv_set, int island_index)
get unsorted list of edges on the border of the island
static Mesh flattenSingleIsland(const Mesh &mesh, int method, bool optimize_rotation=true, bool scale_to_geometry=true)
Flatten the mesh that consists of the single island.
static Mesh selectedToMesh()
get the selected faces as the Mesh object
static void unwrapUnassigned()
re-wrap/extend islands in correspondence to the changed seams and inserted faces. Pay attention,...
static void removeSharpEdge(int start_vertex_index, int end_vertex_index)
remove the sharp edge from the mesh
static Mesh islandToMeshInSpace(int uv_set, int island_index)
get the mesh that contains the island, each point is the coordinate in space (not the uv coordinate!...
static Mesh islandToMesh(int uv_set, int island_index)
get the mesh that contains the island, xy of each point is the UV coordinate. The mesh contains only ...
static void setUnwrapIslandsDistance(float distance)
set the border around the islands when we pack it
static vec2 getIslandVertexUv(int uv_set, int island_index, int vertex_index)
get the uv coordinate of the positional vertex in the island
static void toAbf(int uv_set, int island_index)
unwrap the island using the ABF approach
static void applyUVSet()
apply uv changes to the paint room mesh (if we use uv/paint context)
static int currentUvSet()
get the current uv-set index
static float getUnwrapIslandsDistance()
get the border around the islands when we pack it
static void meshToIsland(const Mesh &mesh, int uv_set, int island_index)
use the mesh (that was previously got by islandToMesh) to replace the island in the current uv-set
static void unwrap(int uv_set)
unwrap the current uv-set
static std::vector< int > getSharpEdges()
get the sharp edges across the mesh
static void addSharpEdge(int start_vertex_index, int end_vertex_index)
add the sharp edge to the mesh
static void removeSeam(int start_vertex_index, int end_vertex_index)
remove the seam from the mesh
static int uvSetsCount()
get the UV-sets count.
static void toGu(int uv_set, int island_index)
unwrap the island using the GU (Globally Uniform) approach
static void toStripe(int uv_set, int island_index)
try to uwrap the island as the regular stripe
static std::vector< int > getBorderBetweenIslands(int uv_set1, int island_index1, int uv_set2, int island_index2)
get the border between two islands
static void pack(int uv_set, bool rotate, bool shuffle)
pack the islands in the current uv-set
The coat namespace used for most 3DCoat API calls except low-level internal structures.
Definition CoreAPI.h:43
bool gltf_support()
gltf export supported
comms::cVec3 vec3
3D - float vector, see the cVec3
Definition CoreAPI.h:50
void menu_separator()
add the separator to the current menu, this command may be called only from the menu making script
BoolOpType
Boolean operations type.
Definition CoreAPI.h:87
@ BOOL_SUBTRACT
boolean subtract
Definition CoreAPI.h:93
@ BOOL_ADD
boolean add
Definition CoreAPI.h:91
@ BOOL_MERGE
just merge, no booleans, it may be used only in surface mode
Definition CoreAPI.h:89
@ BOOL_INTERSECT
boolean intersect
Definition CoreAPI.h:95
bool IsInTool(const char *ToolID)
check if we are in some tool
bool is_new_scene()
is the scene new/empty?
void insert_extensions()
insert extensions into the toolset (may be used only from the toolset.py)
bool UseRecordScript()
check is scripts recording available
bool voxtree_object_picked()
check if the sculpt object is picked in the viewport
int GetCurrentToolSubmode(const char *id)
get the current tool submode (usually for the uv/retopo tools)
void set_space_panel_columns_count(int num)
set the space panel columns count (only for the toolset.py)
void menu_sort()
sort items in the current menu
void menu_item(const char *id)
add the item to the menu, this command may be called only from the menu making script
bool is_surface()
check if the current sculpt object is in surface mode
comms::cVec4 vec4
4D - float vector, see the cVec4
Definition CoreAPI.h:47
void start_main_menu(const char *id)
strat the main menu root items, this command may be called only from the menu making script
bool is_ptex()
check if ptex is used in the current scene
bool ue5_support()
returns if ue5 support enabled
void tools_item(const char *id)
add the item to the tools section (toolset.py)
bool RoomExists(const char *name)
check if the room exists
bool iconic_submenu(const char *id, int size)
start the menu that will be shown on the icon click, like the navigation menu
bool is_mv()
check if mv objects available in scene
void show_space_panel(const char *Subset, int NumColumns)
show the space panel (with limitations if need)
comms::cVec2 vec2
2D - vector, see the cVec2
Definition CoreAPI.h:56
bool voxtree_item_picked()
check if the VoxTree item is picked
comms::cMat4 mat4
4x4 float matrix, see the cMat4
Definition CoreAPI.h:59
void default_tool(const char *tool)
set the default tool for the toolset.py
ClusterScale
the parameters to be used for cluster scaling in Model, scaleSelectedFacesClusters
Definition CoreAPI.h:4738
void tools_section(const char *id)
start the tools section in the toolset.py
bool IsDebug()
is Debug mode (for developers only)
int tex_approach()
returns the texturing approach index (from the Textures menu)
bool doc_mode()
check if script is in auto-documenting mode (legacy)
bool is_medical()
check if the app is medical
void menu_exit()
finish the current submenu, this command may be called only from the menu making script
bool is_multires()
check if the current sculpt object is on some multiresolution level
void SetAutoSnapDefaults(bool value)
set the default value for auto-snapping, usually for the retopo/modeling rooms (in toolset....
void show_rmb_panel()
show the rmb panel
void menu_hotkey(const char *id, int Shift, int Ctrl, int Alt)
set the hotkey for the menu item, this command may be called only from the menu making script
void page_suffix(const char *suffix)
set the additional suffix for the page in the toolset.py
bool IsRecordScript()
is the script recording enabled?
bool empty_space_picked()
check if no object is picked
comms::cRect rect
rect float, see the cRect
Definition CoreAPI.h:73
void start_rmb_panel()
start the RNB panel. This command may be called only from the RMB response making script (curves....
comms::cVec3i vec3i
3D - int vector, see the cVec3i
Definition CoreAPI.h:53
bool is_steam_app()
is it steam app?
bool lock_ui_changes()
check if UI changes locked (for specialized applications, like printing)
comms::cMat3 mat3
3x3 float matrix, see the cMat3
Definition CoreAPI.h:62
bool retopo_object_picked()
the retopo object is picked
bool menu_submenu(const char *id)
add the submenu to the current menu, this command may be called only from the menu making script
bool is_proxy()
check if current sculpt object is in proxy mode
bool IsInRoom(const char *name)
check if you are in some room
bool is_ppp()
chack if there are any ppp objects in scene
comms::cStr str
the string that is compatible with the 3DCoat engine, see the cStr
Definition CoreAPI.h:67
void menu_insert_extensions(const char *id)
insert extension into the main menu (may be called only from the menu making script)
comms::cList< X > list
the array template, see cList
Definition CoreAPI.h:70
void tools_comment(const char *id)
comment in toolset.py for auto-documentation (legacy)
bool menu_property(const char *id)
returns boolean property value
void PureIconic()
enable the radial menu mode for the space panel
bool CheckIfExists(const char *path)
check if the file exists