Antigravity × Unity: Design Asset Creation Workflow

/*
Generate a physically-based rendering (PBR) shader optimized for mobile platforms.
 
Requirements:
- Support albedo, normal, roughness, and metallic textures
- Implement Cook-Torrance specular highlights
- Include environment reflection using ambient light
- Minimize texture samples for mobile performance
- Support up to 4 directional lights (URP forward rendering)
- Include alpha blending option
 
Target: Assets/Shaders/PBRMobile.shader
Language: ShaderLab with HLSL
Optimization: Mobile (iOS/Android at 60fps on mid-range devices)
*/

Shader "Custom/PBRMobile"
{
    Properties
    {
        _MainTex ("Albedo (RGB) Alpha (A)", 2D) = "white" {}
        _NormalMap ("Normal Map", 2D) = "bump" {}
        _RoughnessMap ("Roughness", 2D) = "white" {}
        _MetallicMap ("Metallic", 2D) = "black" {}
        _Roughness ("Roughness", Range(0, 1)) = 0.5
        _Metallic ("Metallic", Range(0, 1)) = 0.0
        _AmbientIntensity ("Ambient Intensity", Range(0, 1)) = 0.3
    }
 
    SubShader
    {
        Tags { "RenderType" = "Opaque" "RenderPipeline" = "UniversalPipeline" }
        LOD 200
 
        Pass
        {
            Name "ForwardLit"
            Tags { "LightMode" = "UniversalForward" }
 
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS
            #pragma multi_compile _ _ADDITIONAL_LIGHTS
 
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
 
            TEXTURE2D(_MainTex);
            SAMPLER(sampler_MainTex);
            TEXTURE2D(_NormalMap);
            SAMPLER(sampler_NormalMap);
            TEXTURE2D(_RoughnessMap);
            SAMPLER(sampler_RoughnessMap);
            TEXTURE2D(_MetallicMap);
            SAMPLER(sampler_MetallicMap);
 
            CBUFFER_START(UnityPerMaterial)
                float4 _MainTex_ST;
                float4 _NormalMap_ST;
                float _Roughness;
                float _Metallic;
                float _AmbientIntensity;
            CBUFFER_END
 
            struct Attributes
            {
                float4 positionOS : POSITION;
                float3 normalOS : NORMAL;
                float4 tangentOS : TANGENT;
                float2 uv : TEXCOORD0;
            };
 
            struct Varyings
            {
                float4 positionCS : SV_POSITION;
                float3 positionWS : TEXCOORD0;
                float3 normalWS : TEXCOORD1;
                float3 tangentWS : TEXCOORD2;
                float3 bitangentWS : TEXCOORD3;
                float2 uv : TEXCOORD4;
            };
 
            Varyings vert(Attributes input)
            {
                Varyings output = (Varyings)0;
                output.positionWS = TransformObjectToWorld(input.positionOS.xyz);
                output.positionCS = TransformWorldToHClip(output.positionWS);
                output.normalWS = TransformObjectToWorldNormal(input.normalOS);
                output.tangentWS = TransformObjectToWorldDir(input.tangentOS.xyz);
                output.bitangentWS = cross(output.normalWS, output.tangentWS) * input.tangentOS.w;
                output.uv = TRANSFORM_TEX(input.uv, _MainTex);
                return output;
            }
 
            float4 frag(Varyings input) : SV_Target
            {
                // Sample base color and normal map
                float4 albedoAlpha = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, input.uv);
                float3 normalTS = UnpackNormal(
                    SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, input.uv)
                );
 
                // Convert tangent-space normal to world space
                float3x3 tbn = float3x3(
                    input.tangentWS,
                    input.bitangentWS,
                    input.normalWS
                );
                float3 normalWS = normalize(mul(normalTS, tbn));
 
                // Sample PBR parameters
                float roughness = SAMPLE_TEXTURE2D(_RoughnessMap, sampler_RoughnessMap, input.uv).r * _Roughness;
                float metallic = SAMPLE_TEXTURE2D(_MetallicMap, sampler_MetallicMap, input.uv).r * _Metallic;
 
                // Simple PBR calculation
                float3 viewDir = normalize(_WorldSpaceCameraPos - input.positionWS);
                float3 lightDir = normalize(_MainLightPosition.xyz);
                float ndotl = max(0.0, dot(normalWS, lightDir));
 
                // Simplified Fresnel (for mobile optimization)
                float fresnel = pow(1.0 - max(0.0, dot(normalWS, viewDir)), 5.0);
                float specular = pow(max(0.0, dot(reflect(-viewDir, normalWS), lightDir)), 1.0 - roughness);
 
                // Combine: diffuse + specular + ambient
                float3 color = albedoAlpha.rgb * _MainLightColor.rgb * ndotl;
                color += mix(float3(0.04), albedoAlpha.rgb, metallic) * specular * _MainLightColor.rgb;
                color += albedoAlpha.rgb * _AmbientIntensity;
 
                return float4(color, albedoAlpha.a);
            }
            ENDHLSL
        }
 
        Pass
        {
            Name "ShadowCaster"
            Tags { "LightMode" = "ShadowCaster" }
 
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
 
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/SurfaceInput.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Shadows.hlsl"
 
            float3 _LightDirection;
 
            Varyings vert(Attributes input)
            {
                Varyings output = (Varyings)0;
                output.positionCS = GetShadowPositionHClip(input);
                return output;
            }
 
            half4 frag(Varyings input) : SV_TARGET
            {
                return 0;
            }
            ENDHLSL
        }
    }
 
    FallBack "Universal Render Pipeline/Lit"
}

// Generated: MaterialController.cs
using UnityEngine;
 
[RequireComponent(typeof(Renderer))]
public class MaterialController : MonoBehaviour
{
    [SerializeField] private Material material;
    [Range(0f, 1f)] public float roughness = 0.5f;
    [Range(0f, 1f)] public float metallic = 0f;
    [Range(0f, 1f)] public float ambientIntensity = 0.3f;
 
    private static readonly int RoughnessID = Shader.PropertyToID("_Roughness");
    private static readonly int MetallicID = Shader.PropertyToID("_Metallic");
    private static readonly int AmbientIntensityID = Shader.PropertyToID("_AmbientIntensity");
 
    private void OnValidate()
    {
        if (material == null)
            material = GetComponent<Renderer>().material;
        UpdateMaterialProperties();
    }
 
    public void UpdateMaterialProperties()
    {
        if (material == null) return;
        material.SetFloat(RoughnessID, roughness);
        material.SetFloat(MetallicID, metallic);
        material.SetFloat(AmbientIntensityID, ambientIntensity);
    }
 
    // Runtime API for dynamic material changes
    public void SetRoughness(float value)
    {
        roughness = Mathf.Clamp01(value);
        material.SetFloat(RoughnessID, roughness);
    }
 
    public void SetMetallic(float value)
    {
        metallic = Mathf.Clamp01(value);
        material.SetFloat(MetallicID, metallic);
    }
}

// Generated: ModelImportOptimizer.cs
using UnityEditor.AssetImporters;
using UnityEngine;
 
public class ModelImportOptimizer : AssetPostprocessor
{
    void OnPreprocessModel()
    {
        ModelImporter importer = assetImporter as ModelImporter;
 
        // Compression: reduces file size and load times
        importer.meshCompression = ModelImporterMeshCompression.High;
 
        // For runtime read-only models, disable CPU access
        importer.isReadable = false;
 
        // Automatic mesh optimization
        importer.optimizeMeshPolygons = true;
        importer.optimizeMeshVertices = true;
 
        // Bone weight constraints for mobile
        importer.maxBoneWeights = 4;
        importer.skinWeights = ModelImporterSkinWeights.Max4Bones;
 
        // Import normals and tangents for proper lighting
        importer.importNormals = ModelImporterNormals.Import;
        importer.importTangents = ModelImporterTangents.ImportNormals;
 
        // Animation support
        importer.importAnimation = true;
        importer.animationType = ModelImporterAnimationType.Generic;
    }
 
    void OnPostprocessModel(GameObject g)
    {
        // Post-import mesh optimization
        foreach (var meshFilter in g.GetComponentsInChildren<MeshFilter>())
        {
            Mesh mesh = meshFilter.sharedMesh;
            if (mesh != null)
            {
                mesh.RecalculateBounds();
                mesh.RecalculateNormals();
            }
        }
    }
}

// Generated: LODSystemBuilder.cs
using UnityEngine;
 
public class LODSystemBuilder : MonoBehaviour
{
    [SerializeField] private Mesh highPolyMesh;
    [SerializeField] private float[] lodScreenHeights = { 0.5f, 0.25f, 0.1f };
 
    public void BuildLODGroup()
    {
        LODGroup lodGroup = gameObject.AddComponent<LODGroup>();
        LOD[] lods = new LOD[lodScreenHeights.Length + 1];
 
        // LOD 0: High-quality (original mesh)
        lods[0] = CreateLOD(highPolyMesh, 1.0f);
 
        // LOD 1+: Progressively simplified
        for (int i = 0; i < lodScreenHeights.Length; i++)
        {
            float reductionRatio = Mathf.Pow(0.5f, i + 1);
            Mesh simplifiedMesh = SimplifyMesh(highPolyMesh, reductionRatio);
            lods[i + 1] = new LOD(lodScreenHeights[i], CreateRenderer(simplifiedMesh));
        }
 
        lodGroup.SetLODs(lods);
    }
 
    private LOD CreateLOD(Mesh mesh, float screenHeight)
    {
        var renderer = gameObject.AddComponent<MeshRenderer>();
        var filter = gameObject.AddComponent<MeshFilter>();
        filter.mesh = mesh;
        return new LOD(screenHeight, new Renderer[] { renderer });
    }
 
    private Mesh SimplifyMesh(Mesh original, float reductionRatio)
    {
        // Integration with mesh simplification libraries
        // (e.g., SimplygonUnity, Weld3D, or QuadricMeshSimplifier)
        Mesh simplified = new Mesh();
        // Implementation details...
        return simplified;
    }
 
    private Renderer CreateRenderer(Mesh mesh)
    {
        var renderer = gameObject.AddComponent<MeshRenderer>();
        var filter = gameObject.AddComponent<MeshFilter>();
        filter.mesh = mesh;
        return renderer;
    }
}

// Generated: TextureAtlasBuilder.cs
using UnityEngine;
using System.Collections.Generic;
 
public class TextureAtlasBuilder : MonoBehaviour
{
    [System.Serializable]
    public class AtlasConfig
    {
        public int width = 2048;
        public int height = 2048;
        public TextureFormat format = TextureFormat.RGBA32;
    }
 
    public Dictionary<string, Rect> PackTexturesIntoAtlas(
        List<Texture2D> sourceTextures,
        AtlasConfig config)
    {
        // Sort by descending area (greedy bin packing)
        sourceTextures.Sort((a, b) =>
            (b.width * b.height).CompareTo(a.width * a.height)
        );
 
        Texture2D atlas = new Texture2D(config.width, config.height, config.format, false);
        Dictionary<string, Rect> uvMap = new Dictionary<string, Rect>();
 
        int currentX = 0, currentY = 0, rowHeight = 0;
 
        foreach (var texture in sourceTextures)
        {
            // New row if texture doesn't fit
            if (currentX + texture.width > config.width)
            {
                currentX = 0;
                currentY += rowHeight;
                rowHeight = 0;
            }
 
            if (currentY + texture.height > config.height)
            {
                Debug.LogError("Atlas overflow. Increase size or reduce textures.");
                return null;
            }
 
            // Copy texture data to atlas
            Graphics.CopyTexture(
                texture, 0, 0, 0, 0,
                texture.width, texture.height,
                atlas, 0, 0, currentX, currentY
            );
 
            // Record UV mapping
            Rect uvRect = new Rect(
                (float)currentX / config.width,
                (float)currentY / config.height,
                (float)texture.width / config.width,
                (float)texture.height / config.height
            );
            uvMap[texture.name] = uvRect;
 
            currentX += texture.width;
            rowHeight = Mathf.Max(rowHeight, texture.height);
        }
 
        return uvMap;
    }
}

// Generated: ResolutionOptimizer.cs
using UnityEngine;
 
public class ResolutionOptimizer : MonoBehaviour
{
    private static class PlatformTiers
    {
        public static (int width, int height, TextureFormat format) GetTier(
            RuntimePlatform platform)
        {
            return platform switch
            {
                // High-end: PC/Console (4K capable)
                RuntimePlatform.WindowsPlayer or
                RuntimePlatform.OSXPlayer or
                RuntimePlatform.WindowsEditor or
                RuntimePlatform.OSXEditor
                    => (4096, 4096, TextureFormat.RGBA32),
 
                // Mid-range: Modern Android/iOS devices
                RuntimePlatform.Android or RuntimePlatform.IPhonePlayer
                    => (2048, 2048, TextureFormat.RGBA32),
 
                // Budget: Older mobile (2-4 year old devices)
                RuntimePlatform.WebGLPlayer
                    => (1024, 1024, TextureFormat.RGB24),
 
                _ => (2048, 2048, TextureFormat.RGBA32)
            };
        }
    }
 
    public void OptimizeTexturesForPlatform(Texture2D[] textures)
    {
        var (targetWidth, targetHeight, format) = PlatformTiers.GetTier(Application.platform);
 
        foreach (var texture in textures)
        {
            // Resize using GPU for efficiency
            RenderTexture rt = RenderTexture.GetTemporary(targetWidth, targetHeight, 0);
            Graphics.Blit(texture, rt);
 
            // Readback and encode
            RenderTexture.active = rt;
            Texture2D resized = new Texture2D(targetWidth, targetHeight, format, false);
            resized.ReadPixels(new Rect(0, 0, targetWidth, targetHeight), 0, 0);
            resized.Apply();
 
            RenderTexture.ReleaseTemporary(rt);
 
            // Save optimized texture
            byte[] encoded = resized.EncodeToPNG();
            System.IO.File.WriteAllBytes($"{texture.name}_optimized.png", encoded);
        }
    }
}

// Generated: AssetBundlePipeline.cs
using UnityEditor;
using UnityEngine;
using System.Collections.Generic;
using System.Linq;
 
public class AssetBundlePipeline
{
    [System.Serializable]
    public class BundleDefinition
    {
        public string name;
        public string[] assetPaths;
        public string[] dependencies;
    }
 
    public static void BuildAllBundles(
        BundleDefinition[] definitions,
        string outputDir,
        BuildTarget target)
    {
        // Configure bundle names
        foreach (var def in definitions)
        {
            foreach (var assetPath in def.assetPaths)
            {
                var importer = AssetImporter.GetAtPath(assetPath);
                importer.assetBundleName = def.name;
            }
        }
 
        // Build with compression
        var manifest = BuildPipeline.BuildAssetBundles(
            outputDir,
            BuildAssetBundleOptions.ChunkBasedCompression |
            BuildAssetBundleOptions.StrictMode,
            target
        );
 
        // Log and validate
        LogBundleInfo(manifest, definitions);
    }
 
    private static void LogBundleInfo(
        AssetBundleManifest manifest,
        BundleDefinition[] definitions)
    {
        var bundleNames = manifest.GetAllAssetBundles();
        Debug.Log($"Built {bundleNames.Length} asset bundles:");
 
        foreach (var bundle in bundleNames)
        {
            var hash = manifest.GetAssetBundleHash(bundle);
            var deps = manifest.GetAllDependencies(bundle);
            Debug.Log($"  {bundle}: hash={hash}, deps=[{string.Join(", ", deps)}]");
        }
    }
}

# .github/workflows/build-bundles.yml
name: Build Asset Bundles
 
on:
  push:
    branches: [main, develop]
 
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
 
      - name: Setup Unity
        uses: game-ci/unity-builder@v3
        with:
          unityVersion: 2022.3.0f1
 
      - name: Build Bundles
        run: |
          /opt/Unity/Editor/Unity -projectPath . \
            -executeMethod AssetBundlePipeline.BuildAllBundles \
            -outputPath ./build/bundles \
            -buildTarget StandaloneLinux64 \
            -batchmode -nographics -quit
 
      - name: Create Release
        run: |
          cd build/bundles
          tar -czf bundles-${{ github.sha }}.tar.gz *.bundle *.manifest
          gsutil cp bundles-*.tar.gz gs://cdn-bucket/releases/
 
      - name: Update Version
        run: |
          echo "${{ github.sha }}" > version.txt
          echo "Built: $(date)" >> version.txt
          gsutil cp version.txt gs://cdn-bucket/latest/version.txt