DEVELOPER DOCUMENTATION

# Install DittoLLM CLI
npm install -g ditto-cli

# Initialize new project
ditto init my-3d-project
cd my-3d-project

# Set your API key
ditto config set-key YOUR_API_KEY

# Generate your first asset
ditto generate "red sports car" --platform roblox --quality high

use ditto_core::{GenerationEngine, AssetRequest, PlatformTarget};
use tokio::sync::mpsc;
use std::sync::Arc;
use rayon::prelude::*;

pub struct DittoEngine {
    neural_weights: Arc<NeuralWeights>,
    mesh_processor: Arc<MeshProcessor>,
    texture_gen: Arc<TextureGenerator>,
    platform_optimizers: HashMap<PlatformTarget, Box<dyn PlatformOptimizer>>,
}

impl DittoEngine {
    pub fn new() -> Result<Self, DittoError> {
        let neural_weights = Arc::new(NeuralWeights::load_from_checkpoint("models/ditto-v3.safetensors")?);
        let mesh_processor = Arc::new(MeshProcessor::new()?);
        let texture_gen = Arc::new(TextureGenerator::new()?);
        
        let mut platform_optimizers: HashMap<PlatformTarget, Box<dyn PlatformOptimizer>> = HashMap::new();
        platform_optimizers.insert(PlatformTarget::Roblox, Box::new(RobloxOptimizer::new()));
        platform_optimizers.insert(PlatformTarget::Unity, Box::new(UnityOptimizer::new()));
        platform_optimizers.insert(PlatformTarget::Fortnite, Box::new(FortniteOptimizer::new()));
        
        Ok(DittoEngine {
            neural_weights,
            mesh_processor,
            texture_gen,
            platform_optimizers,
        })
    }
    
    pub async fn generate_asset(&self, request: AssetRequest) -> Result<GeneratedAsset, DittoError> {
        let start_time = std::time::Instant::now();
        
        // Tokenize and encode the prompt using our custom tokenizer
        let prompt_embedding = self.neural_weights.encode_prompt(&request.prompt).await?;
        
        // Parallel generation pipeline
        let (mesh_tx, mut mesh_rx) = mpsc::channel(1);
        let (texture_tx, mut texture_rx) = mpsc::channel(1);
        
        // Generate mesh and textures concurrently
        let mesh_task = self.generate_mesh(prompt_embedding.clone(), mesh_tx);
        let texture_task = self.generate_textures(prompt_embedding, request.texture_resolution, texture_tx);
        
        // Wait for both tasks to complete
        tokio::try_join!(mesh_task, texture_task)?;
        
        let base_mesh = mesh_rx.recv().await.ok_or(DittoError::MeshGenerationFailed)?;
        let textures = texture_rx.recv().await.ok_or(DittoError::TextureGenerationFailed)?;
        
        // Platform-specific optimization
        let optimizer = self.platform_optimizers.get(&request.target_platform)
            .ok_or(DittoError::UnsupportedPlatform)?;
        
        let optimized_asset = optimizer.optimize(&base_mesh, &textures, &request).await?;
        
        Ok(GeneratedAsset {
            mesh: optimized_asset.mesh,
            textures: optimized_asset.textures,
            metadata: AssetMetadata {
                prompt: request.prompt,
                generation_time: start_time.elapsed(),
                triangle_count: optimized_asset.triangle_count,
                vertex_count: optimized_asset.vertex_count,
                platform: request.target_platform,
            }
        })
    }
    
    async fn generate_mesh(&self, embedding: PromptEmbedding, tx: mpsc::Sender<Mesh>) -> Result<(), DittoError> {
        // Neural network forward pass to generate vertex positions and topology
        let raw_vertices = self.neural_weights.generate_vertices(&embedding).await?;
        let topology_indices = self.neural_weights.generate_topology(&embedding).await?;
        
        // Parallel processing of vertex data using Rayon
        let processed_vertices: Vec<Vertex> = raw_vertices
            .par_iter()
            .map(|&raw_vertex| {
                let position = Vector3::new(raw_vertex.x, raw_vertex.y, raw_vertex.z);
                let normal = self.mesh_processor.compute_normal(&raw_vertex);
                let uv = self.mesh_processor.compute_uv(&raw_vertex);
                
                Vertex { position, normal, uv }
            })
            .collect();
        
        // Create final mesh with optimized topology
        let mesh = Mesh::new(processed_vertices, topology_indices)?;
        tx.send(mesh).await.map_err(|_| DittoError::ChannelError)?;
        
        Ok(())
    }
}

// Roblox-specific optimizer implementation
pub struct RobloxOptimizer;

impl RobloxOptimizer {
    fn new() -> Self {
        RobloxOptimizer
    }
}

#[async_trait]
impl PlatformOptimizer for RobloxOptimizer {
    async fn optimize(&self, mesh: &Mesh, textures: &[Texture], request: &AssetRequest) -> Result<OptimizedAsset, DittoError> {
        // Roblox has specific poly count limits and material restrictions
        let target_polys = match request.quality_level {
            QualityLevel::Mobile => 2000,
            QualityLevel::Standard => 5000,
            QualityLevel::High => 10000,
        };
        
        // Decimate mesh if needed
        let optimized_mesh = if mesh.triangle_count() > target_polys {
            self.decimate_mesh(mesh, target_polys).await?
        } else {
            mesh.clone()
        };
        
        // Convert textures to Roblox-compatible format (1024x1024 max)
        let roblox_textures = self.optimize_textures_for_roblox(textures).await?;
        
        // Generate Roblox Lua scripts for the asset
        let lua_scripts = self.generate_roblox_scripts(&optimized_mesh, &roblox_textures)?;
        
        Ok(OptimizedAsset {
            mesh: optimized_mesh,
            textures: roblox_textures,
            triangle_count: optimized_mesh.triangle_count(),
            vertex_count: optimized_mesh.vertex_count(),
            platform_data: Some(PlatformData::Roblox { scripts: lua_scripts }),
        })
    }
}