User Tools

Site Tools


en:content_creation:advanced:advanced_building

Advanced Building

resident content_creator

Advanced techniques for building complex structures in Caprica.

Introduction

Now that you've mastered the basics of building, let's explore advanced techniques for creating more complex, efficient, and impressive structures. This guide covers advanced prim manipulation, mesh usage, and optimization strategies.

What You'll Learn: * Mesh import and usage * Complex linking strategies - Advanced texturing techniques - LOD (Level of Detail) optimization - Performance optimization

Mesh Import

What is Mesh?

Mesh (3D models) allows you to import custom 3D objects created in external software.

Benefits: * Create any shape imaginable - Lower prim count for complex objects - More realistic and detailed - Better optimization potential

Requirements: * External 3D modeling software - Understanding of mesh creation - Knowledge of export formats

Supported Formats

Common Formats: * COLLADA (.dae) — Most common - OBJ (.obj) — Limited support - FBX (.fbx) — Limited support

Recommended: * COLLADA (.dae) for OpenSimulator - Blender for modeling (free) - Maya/3ds Max (commercial)

Creating Mesh in Blender

Basic Setup: 1. Download and install Blender 2. Set unit scale to meters 3. Set dimensions appropriately 4. Create your model

Exporting: 1. File → Export → Collada (.dae) 2. Check export settings 3. Ensure scale is correct 4. Export the file

Uploading Mesh

Upload Process: 1. In viewer, go to Build → Upload Mesh 2. Select your .dae file 3. Set physics shape type 4. Set mesh parameters 5. Upload

Physics Shape Types: * Convex Hull — Simple, good performance * Prim — Each face has physics * None — No physics

Mesh Cost: * Calculated based on complexity - Limits apply (usually 250 prims equivalent) - Optimize to reduce cost

Mesh Optimization

Polygon Count: * Keep polygon count reasonable - Remove unnecessary faces - Use subdivision wisely - Optimize for target use

LOD (Level of Detail): * Create multiple detail levels - High detail for close viewing - Low detail for distance - Improves performance

Texturing: * Use texture atlases - Minimize texture count - Optimize texture sizes - Use efficient UV mapping

Complex Linking

Large Linksets

Linkset Limits: * Maximum 256 prims per linkset - Performance decreases with size - Consider splitting large builds

Best Practices: * Split into logical groups - Use scripts to coordinate - Keep under 32 prims for performance - Link related components

Root Prim Selection

Importance: Root Prim: * Determines object center - Affects rotation pivot - Used for physics calculations - Position reference point

Choosing Root: * Center of your build - Largest component - Most stable part - Middle of the structure

Advanced Linking Techniques

Multi-Part Linking: * Link in stages - Build sections separately - Link sections together - Use scripts for coordination

Link Coordination: * Use link messages - Coordinate between linksets - Sync animations - Share state

Advanced Texturing

Texture Atlases

What is Texture Atlas: * Multiple textures combined into one - Reduces texture count - Improves performance - Saves upload costs

Creating Atlases: * Plan UV mapping - Combine textures in image editor - Adjust UV coordinates - Upload single texture

Multi-Texture Objects

Face Selection: * Select specific faces - Apply different textures - Use texture masks - Layer textures

Texture Animation: * Animate texture offsets - Create scrolling effects - Simulate movement - Add visual interest

Bump and Specular Maps

Bump Maps: * Simulate surface detail - Add depth without geometry - Create texture variation - Improve realism

Specular Maps: * Control shininess - Define reflective areas - Create material variation - Enhance realism

Performance Optimization

Prim Count Optimization

Strategies: * Use mesh for complex shapes - Combine simple shapes - Use sculpted prims wisely - Remove unnecessary prims

Measurement: * Monitor prim count * Calculate prim cost * Plan for limits * Optimize iteratively

Script Optimization

Script Performance: * Minimize script time - Use efficient algorithms - Avoid busy loops - Use event-driven programming

Best Practices: * Use state changes instead of busy loops - Minimize sensor usage - Optimize listener usage - Remove unused scripts

Viewer Optimization

Settings: * Adjust draw distance - Reduce detail at distance - Disable unnecessary features - Use appropriate graphics settings

LOD Configuration: * Set appropriate LOD distances - Balance quality and performance - Test on different hardware - Monitor frame rate

Advanced Building Techniques

Modular Building

Concept: * Build reusable modules - Combine modules for variety - Standardize dimensions - Create building kits

Benefits: * Faster building - Consistent quality - Easy modification - Collaborative building

Parametric Building

Using Scripts: * Generate structures programmatically - Use variables for dimensions - Create variation easily - Automate repetitive tasks

Examples: * Procedural buildings - Generative terrain - Automated layouts - Dynamic structures

Animation in Building

Animate Objects: * Use LSL for animation - Create moving parts - Add interactive elements - Enhance user experience

Techniques: * Keyframe animation - Physics-based movement - Scripted transitions - Interactive animations

Collaboration

Group Building

Collaborative Work: * Set group permissions - Coordinate team efforts - Use version control - Document your work

Best Practices: * Clear communication - Defined roles - Regular syncs - Conflict resolution

Asset Management

Organization: * Name objects consistently - Use folders/boxes - Document components - Maintain inventory

Version Control: * Save versions - Document changes - Keep backups - Test before deployment

Troubleshooting

Mesh Issues

Mesh Won't Upload: * Check file format - Verify file size - Check mesh complexity - Review export settings

Mesh Looks Wrong: * Check scale - Verify rotation - Check UV mapping - Review normals

Physics Issues: * Adjust physics shape - Check collision settings - Verify mesh cost - Test collision

Linking Issues

Can't Link: * Check prim count - Verify selection - Check permissions - Try linking in stages

Linkset Distorts: * Check root prim - Verify link order - Check for conflicts - Relink if needed

Performance Issues

Low Frame Rate: * Check prim count - Monitor script time - Reduce complexity - Optimize textures

Lag: * Identify bottleneck - Optimize scripts - Reduce prim count - Check server performance

Best Practices

Planning

* Plan before building - Sketch your design - Calculate prim budget - Plan textures - Consider optimization

Building

* Build efficiently - Use appropriate tools - Save frequently - Test regularly - Document your work

Optimization

* Optimize as you build - Test performance - Iterate on design - Balance quality and performance - Learn from others

Resources

Further Reading

* Building Basics — Fundamentals - Working with Prims — Prim techniques - LSL Basics — Scripting

External Resources

* Blender tutorials - OpenSimulator mesh documentation - Building communities - Texture resources

Next Steps

Now that you understand advanced building:

* Practice mesh creation - Experiment with complex linking - Optimize your builds - Collaborate with others - Share your knowledge

Advanced building takes practice. Keep experimenting and learning!

en/content_creation/advanced/advanced_building.txt · Last modified: 2026/10/04 19:11 (external edit)

Page Tools