# Pixazo 3D MCP > Pixazo 3D converts visuals and text into production-ready 3D assets. You can run models from photos or just describe the object you want. It uses specialized pipelines—like Hunyuan for high fidelity, Hyper3D for game meshes, and Trellis for clean topology—to generate everything from low-poly characters to fully textured, animated rigs (FBX/GLB). The output is always ready for engines like Unity or Unreal. ## Overview - **Category:** design-creative - **Price:** Free - **Tags:** 3d-modeling, generative-ai, pbr-textures, mesh-optimization, 3d-rendering, asset-generation ## Description You're connecting your AI client to **Pixazo 3D**, meaning you can generate and polish production-ready 3D assets right from your prompt. You don't need a team of modelers; your agent handles the complex geometry, texturing, and optimization process behind the scenes so you get files ready for engines like Unity or Unreal. **Generate Models From Text** When you just have an idea, you tell the server what you want. The `generate_text_to_3d` tool builds a complete 3D model directly from your text description—you don't need any pictures for this one. For fast work when speed's everything, try `generate_tripo_3d`, which quick-tracks generation from images and is great for getting rapid previews or batch results. **Converting Images to 3D Assets** If you got a photo or even just a rough sketch, the server can turn it into a usable model. The general `generate_image_to_3d` tool handles any reference image—whether it's concept art or a regular snapshot—and returns a downloadable 3D file. Want high fidelity for product shots? Use `generate_hunyuan_3d`; this creates detailed models with realistic PBR textures based on your images. Need game-ready assets focused on clean geometry? `generate_hyper_3d` delivers those meshes, perfect for e-commerce or gaming visuals. You can also use `generate_styled_3d` to make an asset match a specific artistic vibe—like anime or cartoon—from a picture you supply. **Building Complex Assets and Characters** For characters, the server handles rigging automatically. The `generate_rigged_3d` tool creates figures complete with skeletal rigging and weight painting; they're ready for animation right out of the gate. If you need clean topology for careful manual editing, use `generate_trellis_3d`; it builds structured models with logical edge flow. For general optimization that keeps things neat, `generate_lowpoly_3d` produces minimal-polygon assets that are ideal for mobile games or web viewers where performance is critical. **Refining and Optimizing Geometry** Sometimes the generated model is too heavy or needs a specific look. The `optimize_3d_mesh` tool takes an existing 3D file and reduces its polygon count without losing the overall shape or visual quality, which is key for web deployment. If you need maximum realism in rendering, `generate_pbr_textures_3d` creates models that include full PBR texture maps—normal, metallic, roughness—so your assets react properly to light in any modern engine. **Working with Specific Needs and Formats** * **Topology:** If you need clean structure for animation prep, `generate_trellis_3d` gives you that controlled edge flow. * **Game Meshes:** For sharp geometry suitable for games and e-commerce, run the `generate_hyper_3d` tool. * **Low Poly:** To make assets fast enough for mobile or web viewing, use `generate_lowpoly_3d` to keep the poly count low. * **Rigging:** For animated characters that are ready to go, `generate_rigged_3d` handles the automatic skeletal setup. When your project moves from creation to deployment, you'll need file flexibility. The `convert_3d_format` tool changes a 3D model—say, from GLB to FBX—while keeping all its geometry and textures intact so it works in whatever software you need it for. ## Tools ### convert_3d_format Changes a 3D model from one file format (like GLB) to another (like FBX), preserving its geometry and textures. ### generate_hunyuan_3d Creates high-detail 3D models with realistic PBR textures using reference images, perfect for product shots. ### generate_hyper_3d Generates clean 3D meshes suitable for games and e-commerce from images, focusing on precise geometry. ### generate_image_to_3d Converts any reference image—whether a photo or sketch—into a usable 3D model file. ### generate_lowpoly_3d Produces low-polygon models optimized for performance, ideal for mobile games and web viewers. ### optimize_3d_mesh Reduces the polygon count of an existing 3D model while maintaining its overall shape and visual quality for better performance. ### generate_pbr_textures_3d Creates 3D models that include full PBR texture maps (normal, metallic, roughness) for realistic rendering in engines. ### generate_rigged_3d Generates characters with automatic skeletal rigging and weight painting, ready to be animated immediately. ### generate_styled_3d Creates 3D assets that match a specific artistic style (anime, cartoon, photorealistic) from an input image. ### generate_text_to_3d Builds a complete 3D model directly from a text description without needing any reference images. ### generate_trellis_3d Generates structured models with clean topology and logical edge flow, useful for careful animation preparation. ### generate_tripo_3d Fast-tracks 3D generation from images when speed is the priority, offering quick previews or batch processing results. ## Prompt Examples **Prompt:** ``` Generate a 3D model of a running shoe from this product image: https://example.com/shoe.jpg ``` **Response:** ``` Generating 3D model using Hunyuan 3D... Processing product image. Generation complete! Model generated in GLB format (5.8 MB) with full PBR textures (4K albedo, normal, roughness, metallic, AO). Download URL: https://s3.pixazo.ai/models/shoe_3d_pbr.glb. The model includes accurate geometry with 120K polygons and photorealistic material reproduction. Compatible with Unity, Unreal Engine, Blender, and e-commerce 3D viewers. Would you like a low-poly version for web or a rigged version for animation? ``` **Prompt:** ``` Create a low-poly 3D tree for my mobile game from this reference image. ``` **Response:** ``` Generating low-poly 3D tree... Using optimized low-poly pipeline with max 5000 polygons. Generation complete! Model in GLB format (320 KB). Download: https://s3.pixazo.ai/models/lowpoly_tree.glb. The tree features clean topology with 4,200 triangles, optimized UV layout, and baked lighting — perfect for mobile games and web-based 3D viewers. Poly count is 96% lower than the high-poly version while maintaining recognizable shape. Would you like me to generate a forest pack with variations? ``` **Prompt:** ``` Generate an anime-style 3D character from this concept art. ``` **Response:** ``` Generating anime-style 3D character... Using styled generation with anime preset. Generation complete! Model in FBX format with skeletal rigging (18.4 MB). Download: https://s3.pixazo.ai/models/anime_character_rigged.fbx. The character features stylized anime proportions, cel-shaded textures, and full humanoid rig with 54 bones. Ready for import into Unity or Blender for animation. Texture resolution is 2K with albedo and normal maps. Would you like additional facial expression blend shapes? ``` ## Capabilities ### Generate 3D Models from Text The system creates a full 3D asset based purely on the language description you provide. ### Convert Images to 3D Assets You give it any reference photo or sketch, and it returns a corresponding, downloadable 3D model. ### Create Game-Ready Characters The server generates characters with automatic skeletal rigging and full PBR texture maps for animation pipelines. ### Optimize Models for Web Use It takes a large 3D file and reduces the polygon count to improve loading speed without losing recognizable shape. ### Change File Format The tool converts models between formats like GLB, FBX, OBJ, or USDZ so they work in whatever software you need them for. ## Use Cases ### The E-commerce Problem: Visualizing Products A client needs 3D views of a new chair for their site, but they only have studio photos. Instead of hiring an artist to manually model the product, they prompt their agent: 'Use this image and generate a high-fidelity 3D asset.' The agent uses `generate_hunyuan_3d` or `generate_image_to_3d`, returning a fully textured GLB file ready for web embedding. ### The Game Dev Problem: Scaling Assets A game team needs dozens of environmental props, but the high-poly models are too big for mobile. The lead artist runs a batch job using `generate_lowpoly_3d` on reference images, generating optimized meshes that drastically cut down polygon count while keeping the recognizable shape. ### The Character Design Problem: Animation Prep A concept artist has an amazing sketch of a character but needs them to be animatable. They use `generate_styled_3d` combined with `generate_rigged_3d`. The server gives back a full FBX file, complete with bones and weight painting, ready for the animation team. ### The Rapid Prototyping Problem: Idea Validation A product manager needs to see what a futuristic toaster looks like before committing budget. They use `generate_text_to_3d` with a prompt like 'Sleek, metallic toaster with glowing elements.' Within minutes, they get a model file allowing immediate client visualization. ## Benefits - **Speed:** Need quick previews? Use `generate_tripo_3d`. It sacrifices some fidelity for speed, letting you iterate on design concepts instantly—no waiting hours for the initial pass. - **Realism:** Stop using flat images. Generating PBR textures via `generate_pbr_textures_3d` gives your assets realistic material response to light, essential if they're going into a game engine. - **Animation Ready:** Creating characters is easy with `generate_rigged_3d`. The server handles the bone structure and weight painting so you don't have to manually rig every character from scratch. - **Performance Control:** Don't ship massive files. Use `optimize_3d_mesh` to cut polygon counts dramatically, making your web viewers or mobile game assets run faster without looking degraded. - **Flexibility:** The server handles the whole lifecycle: concept creation (`generate_text_to_3d`), refinement (`generate_hyper_3d`), and final deployment preparation (using `convert_3d_format`) across all major formats. ## How It Works The bottom line is, your agent handles all the complex calls to specialized 3D algorithms; you just talk to it like normal. 1. Connect your AI agent to the Pixazo 3D MCP Server and provide a prompt (e.g., 'Generate a low-poly tree from this image'). 2. Your AI client routes the request, sending the reference data and specific parameters to the correct specialized tool (e.g., `generate_lowpoly_3d`). 3. The server processes the asset through its backend pipelines and returns the final 3D model file(s) ready for download. ## Frequently Asked Questions **Do I need to know which tool to use for `generate_hunyuan_3d`?** No, you just tell your agent what you want. But remember that Hunyuan is best when the asset needs maximum geometric accuracy, like a detailed product photo. **How do I make sure my model can run in Unreal Engine?** You'll need to use `generate_pbr_textures_3d` for accurate materials and then always pass the final result through `convert_3d_format` to get an FBX or GLB file. These formats work best. **`optimize_3d_mesh` is only for reducing polygons, right?** It does that, but it's more than just size reduction. It ensures the mesh remains clean and performance-friendly—which matters a ton when running assets in real time. **What if I don’t have an image for `generate_text_to_3d`?** No problem. That's what the tool is built for. You simply write out exactly what you want—be specific about materials and style—and it generates the model from text alone. **Can I use Pixazo 3D MCP Server to convert a single image to low-poly?** Yes. You can combine `generate_image_to_3d` first, and then run that resulting model through `generate_lowpoly_3d`. That way, you get both the shape and the optimization in one flow. **When I use `convert_3d_format`, what data is preserved when changing file types?** It preserves geometry, textures, materials, and rigging data. This means you don't lose crucial information just because you switched from GLB to FBX or USDZ for a specific platform requirement. **What is the functional difference between `generate_hunyuan_3d` and `generate_hyper_3d`?** Hyper3D prioritizes clean mesh topology, making it ideal for game engines. Hunyuan excels at producing detailed geometry with highly accurate proportions from reference images. **What does 'automatic skeletal rigging' mean when I use `generate_rigged_3d`?** It generates a complete setup including bone hierarchies and weight painting. The resulting model is ready to go into standard animation workflows within engines like Unity or Blender. **Can my AI generate a 3D model from a product photo with PBR textures?** Yes! Use the `generate_pbr_textures_3d` tool with your product image URL. Pixazo will generate a 3D model with complete PBR texture maps including albedo, normal, roughness, metallic, and ambient occlusion. You can specify texture resolution (1024, 2048, or 4096) and output format (GLB, OBJ, FBX). The resulting model is ready for game engines, product visualization, and e-commerce platforms with physically accurate materials. **Which model should I use for the highest quality 3D generation?** For the highest quality, use `generate_hunyuan_3d` (Hunyuan by Tencent) or `generate_hyper_3d` (Hyper3D). Both produce production-quality geometry with detailed surface reproduction. Hunyuan excels at accurate proportions and realistic details, while Hyper3D focuses on clean topology and precise texture mapping. For text-to-3D with quality control, use `generate_text_to_3d` with quality set to ultra. All models support output formats GLB, OBJ, FBX, GLTF, and USDZ. **Can I generate 3D characters with automatic rigging for animation?** Yes! Use the `generate_rigged_3d` tool with a character reference image. You can specify the rig type (humanoid, quadruped, or biped) and the API will generate a 3D model with automatic skeletal rigging including bone hierarchies and weight painting. The output is suitable for direct import into Unity, Unreal Engine, Blender, or any animation software. Output formats include FBX (recommended for rigs), GLB, and GLTF.