PolygonModifier

Inheritance: java.lang.Object

public class PolygonModifier

पॉलीगॉन को संशोधित करने के यूटिलिटीज़

विधियाँ

विधि	विवरण
applyTransform(Node node, Matrix4 transform)	सभी ज्यामितियों के कंट्रोल पॉइंट्स पर ट्रांसफ़ॉर्म मैट्रिक्स लागू करें
buildTangentBinormal(Mesh mesh)	यह मेष पर टैन्जेंट और बिनॉर्म बनाएगा। सामान्य (Normal) आवश्यक है, यदि मेष पर सामान्य मौजूद नहीं है, तो यह स्थिति से सामान्य डेटा भी बनाएगा।
buildTangentBinormal(Scene scene)	यह सीन के सभी मेषों पर टैन्जेंट और बिनॉर्म बनाएगा। सामान्य आवश्यक है, यदि मेष पर सामान्य मौजूद नहीं है, तो यह स्थिति से सामान्य डेटा भी बनाएगा।
equals(Object arg0)
generateNormal(Mesh mesh)	मेश परिभाषा से सामान्य डेटा उत्पन्न करें
generateUV(Mesh mesh)	दिए गए इनपुट मेष से UV डेटा उत्पन्न करें
generateUV(Mesh mesh, VertexElementNormal normals)	दिए गए इनपुट मेष और निर्दिष्ट सामान्य डेटा से UV डेटा उत्पन्न करें।
getClass()
hashCode()
mergeMesh(Node node)	पूरे नोड को एकल परिवर्तित मेष में बदलें। Vertex तत्व जैसे normal/texture coordinates अभी समर्थित नहीं हैं।
mergeMesh(Scene scene)	पूरे दृश्य को एकल परिवर्तित मेष में बदलें। Vertex तत्व जैसे normal/texture coordinates अभी समर्थित नहीं हैं।
mergeMesh(List nodes)	पूरे नोड को एकल परिवर्तित मेष में बदलें। Vertex तत्व जैसे normal/texture coordinates अभी समर्थित नहीं हैं।
notify()
notifyAll()
scale(Node node, Vector3 scale)	इस नोड में सभी ज्यामितियों को स्केल करें (ट्रांसफ़ॉर्मेशन मैट्रिक्स नहीं, कंट्रोल पॉइंट्स को स्केल करें)।
scale(Scene scene, Vector3 scale)	इस दृश्य में सभी ज्यामितियों को स्केल करें (ट्रांसफ़ॉर्मेशन मैट्रिक्स नहीं, कंट्रोल पॉइंट्स को स्केल करें)।
splitMesh(Mesh mesh, SplitMeshPolicy policy)	मेश को VertexElementMaterial द्वारा उप-मेश में विभाजित करें।
splitMesh(Node node, SplitMeshPolicy policy)	मेश को VertexElementMaterial द्वारा उप-मेश में विभाजित करें।
splitMesh(Node node, SplitMeshPolicy policy, boolean createChildNodes)	मेश को VertexElementMaterial द्वारा उप-मेश में विभाजित करें।
splitMesh(Node node, SplitMeshPolicy policy, boolean createChildNodes, boolean removeOldMesh)	मेश को VertexElementMaterial द्वारा उप-मेश में विभाजित करें।
splitMesh(Scene scene, SplitMeshPolicy policy)	मेश को VertexElementMaterial द्वारा उप-मेश में विभाजित करें।
splitMesh(Scene scene, SplitMeshPolicy policy, boolean removeOldMesh)	मेश को VertexElementMaterial द्वारा उप-मेश में विभाजित करें।
toString()
triangulate(Mesh mesh)	बहुभुज-आधारित मेष को पूर्ण त्रिकोणीय मेष में बदलें।
triangulate(Scene scene)	सभी बहुभुज-आधारित मेषों को पूर्ण त्रिकोणीय मेष में बदलें।
triangulate(List controlPoints)	बहुभुज को त्रिकोणों में बदलें, बहुभुज का क्रम `controlPoints` द्वारा परिभाषित होता है।
triangulate(List controlPoints, int[] polygon)	बहुभुज को त्रिकोणों में बदलें।
triangulate(List controlPoints, List<int[]> polygons)	बहुभुज-आधारित मेष को त्रिकोणों में बदलें।
triangulate(List controlPoints, List<int[]> polygons, boolean generateNormals, Vector3[][] nor_out)	बहुभुज-आधारित मेष को पूर्ण त्रिकोणीय मेष में बदलें।
wait()
wait(long arg0)
wait(long arg0, int arg1)

applyTransform(Node node, Matrix4 transform)

public static void applyTransform(Node node, Matrix4 transform)

सभी ज्यामितियों के कंट्रोल पॉइंट्स पर ट्रांसफ़ॉर्म मैट्रिक्स लागू करें

Parameters:

पैरामीटर	प्रकार	विवरण
node	Node	किस नोड की ज्यामितियों पर दिया गया ट्रांसफ़ॉर्म लागू होगा।
transform	Matrix4	ट्रांसफ़ॉर्मेशन मैट्रिक्स जो कंट्रोल पॉइंट्स पर लागू होगा।

buildTangentBinormal(Mesh mesh)

public static void buildTangentBinormal(Mesh mesh)

यह मेष पर टैंजेंट और बाइनॉर्म बनाता है। Normal आवश्यक है; यदि मेष में Normal मौजूद नहीं है, तो यह स्थिति से Normal डेटा भी बनाता है। UV भी आवश्यक है, यदि कोई UV नहीं मिला तो अपवाद उत्पन्न होगा।

Parameters:

पैरामीटर	प्रकार	विवरण
mesh	Mesh

buildTangentBinormal(Scene scene)

public static void buildTangentBinormal(Scene scene)

यह दृश्य के सभी मेषों पर टैंजेंट और बाइनॉर्म बनाता है। Normal आवश्यक है; यदि मेष में Normal मौजूद नहीं है, तो यह स्थिति से Normal डेटा भी बनाता है। UV भी आवश्यक है; यदि कोई UV परिभाषित नहीं है तो मेष को अनदेखा किया जाएगा।

Parameters:

पैरामीटर	प्रकार	विवरण
scene	Scene

equals(Object arg0)

public boolean equals(Object arg0)

Parameters:

पैरामीटर	प्रकार	विवरण
arg0	java.lang.Object

Returns: boolean

generateNormal(Mesh mesh)

public static VertexElementNormal generateNormal(Mesh mesh)

मेश परिभाषा से सामान्य डेटा उत्पन्न करें

Parameters:

पैरामीटर	प्रकार	विवरण
mesh	Mesh

Returns: VertexElementNormal - VertexElementNormal instance with normal data.

generateUV(Mesh mesh)

public static VertexElementUV generateUV(Mesh mesh)

दिए गए इनपुट मेष से UV डेटा उत्पन्न करें

Parameters:

पैरामीटर	प्रकार	विवरण
mesh	Mesh	इनपुट मेष

Returns: VertexElementUV - Generated UV data

generateUV(Mesh mesh, VertexElementNormal normals)

public static VertexElementUV generateUV(Mesh mesh, VertexElementNormal normals)

दिए गए इनपुट मेष और निर्दिष्ट सामान्य डेटा से UV डेटा उत्पन्न करें।

Parameters:

पैरामीटर	प्रकार	विवरण
mesh	Mesh	इनपुट मेष
normals	VertexElementNormal	Normal डेटा

Returns: VertexElementUV - Generated UV data

getClass()

public final native Class<?> getClass()

Returns: java.lang.Class

hashCode()

public native int hashCode()

Returns: int

mergeMesh(Node node)

public static Mesh mergeMesh(Node node)

पूरे नोड को एकल परिवर्तित मेष में बदलें। Vertex तत्व जैसे normal/texture coordinates अभी समर्थित नहीं हैं।

Parameters:

पैरामीटर	प्रकार	विवरण
node	Node	मर्ज करने के लिए नोड

Returns: Mesh - Merged mesh Example: The following code shows how to merge all objects from nodes into a single mesh.

//Input file may contains multiple objects
          var scene = Scene.fromFile("input.fbx");
          //now merge them into a single mesh
          Mesh merged = PolygonModifier.mergeMesh(scene.getRootNode());
          //then we save it to a file with only one mesh
          var newScene = new Scene(merged);
          newScene.save("test.obj");

mergeMesh(Scene scene)

public static Mesh mergeMesh(Scene scene)

पूरे दृश्य को एकल परिवर्तित मेष में बदलें। Vertex तत्व जैसे normal/texture coordinates अभी समर्थित नहीं हैं।

Parameters:

पैरामीटर	प्रकार	विवरण
scene	Scene	मर्ज करने के लिए दृश्य

Returns: Mesh - The merged mesh Example: The following code shows how to merge all objects from a scene into a single mesh.

//Input file may contains multiple objects
         var scene = Scene.fromFile("input.fbx");
         //now merge them into a single mesh
         Mesh merged = PolygonModifier.mergeMesh(scene);
         //then we save it to a file with only one mesh
         var newScene = new Scene(merged);
         newScene.save("test.obj");

mergeMesh(List nodes)

public static Mesh mergeMesh(List<Node> nodes)

Parameters:

पैरामीटर	प्रकार	विवरण
नोड्स	java.util.List<com.aspose.threed.Node>	मर्ज करने के नोड्स

Returns: Mesh - Merged mesh Example: The following code shows how to merge all objects from nodes into a single mesh.

//Input file may contains multiple objects
         var scene = Scene.fromFile("input.fbx");
         //now merge them into a single mesh
         Mesh merged = PolygonModifier.mergeMesh(scene.getRootNode().getChildNodes());
         //then we save it to a file with only one mesh
         var newScene = new Scene(merged);
         newScene.save("test.obj");

notify()

public final native void notify()

notifyAll()

public final native void notifyAll()

scale(Node node, Vector3 scale)

public static void scale(Node node, Vector3 scale)

इस नोड में सभी ज्यामितियों को स्केल करें (ट्रांसफ़ॉर्मेशन मैट्रिक्स नहीं, कंट्रोल पॉइंट्स को स्केल करें)।

Parameters:

पैरामीटर	प्रकार	विवरण
node	Node	स्केल करने के लिए नोड
	scale	Vector3

//Load a test file for scaling
 		 var scene = Scene.fromFile("input.fbx");
 		 //scale all geometries 10 times.
 		 PolygonModifier.scale(scene.getRootNode(), new Vector3(10, 10, 10));
 		 scene.save("test.obj");
``` |

### scale(Scene scene, Vector3 scale) {#scale-com.aspose.threed.Scene-com.aspose.threed.Vector3-}

public static Scene scale(Scene scene, Vector3 scale)



इस दृश्य में सभी ज्यामितियों को स्केल करें (ट्रांसफ़ॉर्मेशन मैट्रिक्स नहीं, कंट्रोल पॉइंट्स को स्केल करें)।

**Parameters:**
| पैरामीटर | प्रकार | विवरण |
| --- | --- | --- |
| scene | [Scene](../../com.aspose.threed/scene) | स्केल करने के लिए दृश्य |
|  | scale | [Vector3](../../com.aspose.threed/vector3) | स्केल फ़ैक्टर **Example:** निम्नलिखित कोड दर्शाता है कि दृश्य में सभी ज्यामितियों को 10 गुना कैसे स्केल किया जाए। |

//Load a test file for scaling var scene = Scene.fromFile(“input.fbx”); //scale all geometries 10 times. PolygonModifier.scale(scene, new Vector3(10, 10, 10)); scene.save(“test.obj”);


**Returns:**
[Scene](../../com.aspose.threed/scene)
### splitMesh(Mesh mesh, SplitMeshPolicy policy) {#splitMesh-com.aspose.threed.Mesh-com.aspose.threed.SplitMeshPolicy-}

public static Mesh[] splitMesh(Mesh mesh, SplitMeshPolicy policy)



मेश को [VertexElementMaterial](../../com.aspose.threed/vertexelementmaterial) द्वारा उप-मेश में विभाजित करें। प्रत्येक उप-मेश केवल एक सामग्री का उपयोग करेगा। मूल मेष नहीं बदलेगा।

**Parameters:**
| पैरामीटर | प्रकार | विवरण |
| --- | --- | --- |
| mesh | [Mesh](../../com.aspose.threed/mesh) |  |
| policy | [SplitMeshPolicy](../../com.aspose.threed/splitmeshpolicy) |  |

**Returns:**
com.aspose.threed.Mesh[] - नई विभाजित मेष **उदाहरण:** निम्नलिखित कोड दिखाता है कि सामग्री सूचकांकों का उपयोग करके बॉक्स को उप‑मेश में कैसे विभाजित किया जाए।

// Create a mesh of box(A box is composed by 6 planes) Mesh box = (new Box()).toMesh(); // Create a material element on this mesh VertexElementMaterial mat = (VertexElementMaterial)box.createElement(VertexElementType.MATERIAL, MappingMode.POLYGON, ReferenceMode.INDEX); // And specify different material index for each plane mat.setIndices(new int[] { 0, 1, 2, 3, 4, 5 }); // Now split it into 6 sub meshes, we specified 6 different materials on each plane, each plane will become a sub mesh. // We used the CloneData policy, each plane will has the same control point information or control point-based vertex element information. Mesh[] planes = PolygonModifier.splitMesh(box, SplitMeshPolicy.CLONE_DATA);

		// Now split it into 2 sub meshes, first mesh will contains 0/1/2 planes, and second mesh will contains the 3/4/5th planes.
		mat.setIndices(new int[] { 0, 0, 0, 1, 1, 1 });
		// We used the CompactData policy, each plane will has its own control point information or control point-based vertex element information.
		planes = PolygonModifier.splitMesh(box, SplitMeshPolicy.COMPACT_DATA);

### splitMesh(Node node, SplitMeshPolicy policy) {#splitMesh-com.aspose.threed.Node-com.aspose.threed.SplitMeshPolicy-}

public static void splitMesh(Node node, SplitMeshPolicy policy)



सबस्ट्रक्चर को [VertexElementMaterial](../../com.aspose.threed/vertexelementmaterial) द्वारा विभाजित करें। प्रत्येक सब‑मेश केवल एक सामग्री का उपयोग करेगा। एक नोड पर मेष विभाजन करें **उदाहरण:** निम्नलिखित कोड दिखाता है कि सामग्री सूचकांकों का उपयोग करके बॉक्स को उप‑मेश में कैसे विभाजित किया जाए।

		// Now split it into 2 sub meshes, first mesh will contains 0/1/2 planes, and second mesh will contains the 3/4/5th planes.
		mat.setIndices(new int[] { 0, 0, 0, 1, 1, 1 });
		// We used the CompactData policy, each plane will has its own control point information or control point-based vertex element information.
		planes = PolygonModifier.splitMesh(box, SplitMeshPolicy.COMPACT_DATA);


**Parameters:**
| पैरामीटर | प्रकार | विवरण |
| --- | --- | --- |
| node | [Node](../../com.aspose.threed/node) |  |
| policy | [SplitMeshPolicy](../../com.aspose.threed/splitmeshpolicy) |  |

### splitMesh(Node node, SplitMeshPolicy policy, boolean createChildNodes) {#splitMesh-com.aspose.threed.Node-com.aspose.threed.SplitMeshPolicy-boolean-}

public static void splitMesh(Node node, SplitMeshPolicy policy, boolean createChildNodes)



सबस्ट्रक्चर को [VertexElementMaterial](../../com.aspose.threed/vertexelementmaterial) द्वारा विभाजित करें। प्रत्येक सब‑मेश केवल एक सामग्री का उपयोग करेगा। एक नोड पर मेष विभाजन करें

**Parameters:**
| पैरामीटर | प्रकार | विवरण |
| --- | --- | --- |
| node | [Node](../../com.aspose.threed/node) |  |
| policy | [SplitMeshPolicy](../../com.aspose.threed/splitmeshpolicy) |  |
|  | createChildNodes | boolean | प्रत्येक सब‑मेश के लिए चाइल्ड नोड बनाएं। **उदाहरण:** निम्नलिखित कोड दिखाता है कि सामग्री सूचकांकों का उपयोग करके बॉक्स को उप‑मेश में कैसे विभाजित किया जाए। |

		// Now split it into 2 sub meshes, first mesh will contains 0/1/2 planes, and second mesh will contains the 3/4/5th planes.
		mat.setIndices(new int[] { 0, 0, 0, 1, 1, 1 });
		// We used the CompactData policy, each plane will has its own control point information or control point-based vertex element information.
		planes = PolygonModifier.splitMesh(box, SplitMeshPolicy.COMPACT_DATA);


### splitMesh(Node node, SplitMeshPolicy policy, boolean createChildNodes, boolean removeOldMesh) {#splitMesh-com.aspose.threed.Node-com.aspose.threed.SplitMeshPolicy-boolean-boolean-}

public static void splitMesh(Node node, SplitMeshPolicy policy, boolean createChildNodes, boolean removeOldMesh)



सबस्ट्रक्चर को [VertexElementMaterial](../../com.aspose.threed/vertexelementmaterial) द्वारा विभाजित करें। प्रत्येक सब‑मेश केवल एक सामग्री का उपयोग करेगा। एक नोड पर मेष विभाजन करें

**Parameters:**
| पैरामीटर | प्रकार | विवरण |
| --- | --- | --- |
| node | [Node](../../com.aspose.threed/node) |  |
| policy | [SplitMeshPolicy](../../com.aspose.threed/splitmeshpolicy) |  |
| createChildNodes | boolean | प्रत्येक सब‑मेश के लिए चाइल्ड नोड बनाएं। |
|  | removeOldMesh | boolean | विभाजन के बाद पुराना मेष हटाएँ, यदि यह पैरामीटर false है, तो पुराना और नया मेष दोनों मौजूद रहेंगे। **उदाहरण:** निम्नलिखित कोड दिखाता है कि सामग्री सूचकांकों का उपयोग करके बॉक्स को उप‑मेश में कैसे विभाजित किया जाए। |

		// Now split it into 2 sub meshes, first mesh will contains 0/1/2 planes, and second mesh will contains the 3/4/5th planes.
		mat.setIndices(new int[] { 0, 0, 0, 1, 1, 1 });
		// We used the CompactData policy, each plane will has its own control point information or control point-based vertex element information.
		planes = PolygonModifier.splitMesh(box, SplitMeshPolicy.COMPACT_DATA);


### splitMesh(Scene scene, SplitMeshPolicy policy) {#splitMesh-com.aspose.threed.Scene-com.aspose.threed.SplitMeshPolicy-}

public static void splitMesh(Scene scene, SplitMeshPolicy policy)



सबस्ट्रक्चर को [VertexElementMaterial](../../com.aspose.threed/vertexelementmaterial) द्वारा विभाजित करें। प्रत्येक सब‑मेश केवल एक सामग्री का उपयोग करेगा। दृश्य के सभी नोड्स पर मेष विभाजन करें **उदाहरण:** निम्नलिखित कोड दिखाता है कि सामग्री सूचकांकों का उपयोग करके बॉक्स को उप‑मेश में कैसे विभाजित किया जाए।

		// Now split it into 2 sub meshes, first mesh will contains 0/1/2 planes, and second mesh will contains the 3/4/5th planes.
		mat.setIndices(new int[] { 0, 0, 0, 1, 1, 1 });
		// We used the CompactData policy, each plane will has its own control point information or control point-based vertex element information.
		planes = PolygonModifier.splitMesh(box, SplitMeshPolicy.COMPACT_DATA);


**Parameters:**
| पैरामीटर | प्रकार | विवरण |
| --- | --- | --- |
| scene | [Scene](../../com.aspose.threed/scene) |  |
| policy | [SplitMeshPolicy](../../com.aspose.threed/splitmeshpolicy) |  |

### splitMesh(Scene scene, SplitMeshPolicy policy, boolean removeOldMesh) {#splitMesh-com.aspose.threed.Scene-com.aspose.threed.SplitMeshPolicy-boolean-}

public static void splitMesh(Scene scene, SplitMeshPolicy policy, boolean removeOldMesh)



सबस्ट्रक्चर को [VertexElementMaterial](../../com.aspose.threed/vertexelementmaterial) द्वारा विभाजित करें। प्रत्येक सब‑मेश केवल एक सामग्री का उपयोग करेगा। दृश्य के सभी नोड्स पर मेष विभाजन करें **उदाहरण:** निम्नलिखित कोड दिखाता है कि सामग्री सूचकांकों का उपयोग करके बॉक्स को उप‑मेश में कैसे विभाजित किया जाए।

		// Now split it into 2 sub meshes, first mesh will contains 0/1/2 planes, and second mesh will contains the 3/4/5th planes.
		mat.setIndices(new int[] { 0, 0, 0, 1, 1, 1 });
		// We used the CompactData policy, each plane will has its own control point information or control point-based vertex element information.
		planes = PolygonModifier.splitMesh(box, SplitMeshPolicy.COMPACT_DATA);


**Parameters:**
| पैरामीटर | प्रकार | विवरण |
| --- | --- | --- |
| scene | [Scene](../../com.aspose.threed/scene) |  |
| policy | [SplitMeshPolicy](../../com.aspose.threed/splitmeshpolicy) |  |
| removeOldMesh | boolean |  |

### toString() {#toString--}

public String toString()





**Returns:**
java.lang.String
### triangulate(Mesh mesh) {#triangulate-com.aspose.threed.Mesh-}

public static Mesh triangulate(Mesh mesh)



बहुभुज-आधारित मेष को पूर्ण त्रिकोणीय मेष में बदलें।

**Parameters:**
| पैरामीटर | प्रकार | विवरण |
| --- | --- | --- |
| mesh | [Mesh](../../com.aspose.threed/mesh) | मूल गैर‑त्रिभुज मेष |

**Returns:**
[Mesh](../../com.aspose.threed/mesh) - The generated new triangle mesh **Example:** The following code shows how to merge all objects from a scene into a single mesh.