Optimizing Workflows To Increase Development Velocity

Streamlining Asset Pipelines

Asset pipelines process art assets like 3D models, textures, animations, and audio clips to optimize them for use in games. Manual asset processing can hamper developer velocity. Automating asset processing, enabling incremental builds, and parallelizing tasks can significantly streamline workflows.

Automating asset processing and builds

Manually processing assets is time-consuming and error-prone. Automating asset imports, processing steps like texture compression and mesh optimization, as well as final build steps can save significant developer time.

Solutions like the Unity Asset Pipeline automate importing asset files, processing materials and textures, building asset bundles, and deploying them for testing. Developer time is freed up to focus on game logic and content rather than manual processes.

Implementing incremental builds

Full rebuild times can slow down iteration speed, reducing developer velocity. Incremental builds only process assets that have changed since the last build, avoiding unnecessary work and providing faster feedback.

Solutions like the Unity Cache Server and IncrediBuild’s incremental build system analyze asset dependencies, enable distributed processing, and build only changed assets. This takes builds from hours to minutes in many cases.

Parallelizing tasks

Serial asset processing creates bottlenecks. Enabling processing tasks like animation baking, lighting calculation, and final build steps to happen in parallel can significantly reduce wait times.

Tools like Autodesk Shotgun integrate with DCCs like Maya to background process tasks. Cloud-based services like Unity’s Operate Solution and IncrediBuild leverage distributed computing to divide tasks across compute resources, speeding up development.

Optimizing Scene Workflow

Careful scene management and organization is vital for efficient development. Employing best practices like composition, prefabs, and asset bundles can optimize iteration times and team workflows.

Employing composition over inheritance

Composition focuses on components that can be mixed and matched to extend functionality. Inheritance creates deep chains of class dependencies that increase coupling and reduce flexibility. Composition encourages reusable, swappable capabilities.

For example, an audio component could be added to any object without needing to embed audio handling in a base class. Components stay de-coupled so changes cause minimal rework across other systems.

Making prefabs and templates

Prefab assets allow object prototypes to be defined once and instantiated multiple times. Any changes to the prefab propagate to all instances saving duplication of work. Templates take this further with parameterized reusable sub-systems.

For example, a door prefab with properties like width and height can be tweaked into multiple configurations and places throughout levels. Taking this to templates, a procedural room system could construct any style room from a simple interface.

Using asset bundles

Asset bundles allow assets to be dynamically loaded at runtime rather than all packed into initial installs. This optimizes install size, build times, and content releases. New content can be downloaded on demand.

For example, gameplay asset bundles keep initial installs small. Additional maps, characters, and other content can be updated over time without full application installs. Saves user bandwidth and storage while enabling flexible content.

Improving Team Collaboration

Well-defined processes enable smooth collaboration between team members. Version control, communication protocols, code reviews, and other workflows vastly improve development velocity for teams.

Adopting version control

Source control systems like Git and Perforce provide centralized repositories where developers can review histories, create branches, and merge in changes. This coordinates collaboration and ensures nothing is lost or overwritten.

Implementing peer code reviews ensures changes meet quality guidelines and fit architecture plans. Automated testing gives confidence that new functionality does not break existing systems. Tools like GitHub and GitLab facilitate this collaboration through their platforms.

Promoting communication

Daily standups via chat or video ensure all developers know current status and blockers. Kanban boards through tools like Trello provide visibility into tasks and workloads. Always on chat tools like Slack enable questions and feedback to be handled instantly.

Promoting communication eliminates silos where developers feel isolated and directionless. Enabling constant collaboration vastly improves productivity over just emailing documents back and forth.

Defining team workflows

Clarifying individual roles and responsibilities ensures tasks do not slip between the cracks. Establishing processes for task tracking, code reviews, testing signoffs, and releases provides structure.

Daily builds ensure integration issues surface quickly. Coding standards reduce variability across modules touched by different developers. Clear processes let developers focus on tasks rather than lose time determining next steps.

Monitoring Performance

Performance profiling exposes optimization opportunities that can improve runtime efficiency and application stability. Identifying hotspots, enabling telemetry, and utilizing profiling tools helps accelerate fixes.

Identifying performance bottlenecks

Areas like rendering, physics, AI, and scene management are common hotspots. Slow routines hurt frame rates and responsiveness. Targeted optimizations to hot functions can improve performance exponentially.

For example, a particle system updating thousands of nodes every frame may benefit from more efficient vector math routines, multi-threading, or batched updates. Optimizations often speed up surrounding systems as well.

Using profiling tools

Built-in profilers within game engines provide detailed performance data down to individual draw calls and function traces. Platform profiling tools offer system-wide analysis spanning multiple processes and resources.

For example, Visual Studio’s diagnostic tools integrate into Unity providing CPU and GPU profiling views. NVidia’s Nsight highlights graphics bottleneck while Tracy displays CPU timings through visualization. Data enables high impact optimizations.

Optimizing draw calls and garbage collection

Draw calls occur when the GPU renders an object’s mesh, materials, and textures. High draw call overhead creates bottlenecks. Object pooling, batching, culling, and LODs optimize renders.

Excessive memory allocations and deallocations increase garbage collection pauses. Reusing objects via pools minimizes allocations. Efficient data layouts also improve cache utilization and access speeds.

Automating Testing

Automated testing enables rapid validation of new changes to prevent functionality and stability regressions. Unit tests exercise specific functions. Integration tests validate interactions between systems. UI tests confirm usability flows. Test automation spots issues early, reducing costs and time.

Implementing unit testing

Unit tests validate individual functions and classes by injecting inputs and checking outputs match expectations. Tests pinpoint where new changes break existing contracts early on.

For example, a damage calculation routine would test different attack values yield excepted health changes. Tests run automatically on code changes via frameworks like NUnit, bypassing manual verification.

Enabling continuous integration

CI systems automatically build, test, analyze, and validate project health every time code gets checked in. Fast feedback speeds up fixing issues before functionality diverges significantly.

Services like Jenkins and Circle CI integrate with version control systems to drive automation. Code does not get merged until all tests pass, ensuring mainline stability. Engineers spend less time on ventures that end up getting scrapped.

Adding automated playtesting

Smoke tests drive game clients through key scenarios to validate responsiveness, stability, and correctness. Recording macro tools streamline authoring tests without manual scripting. AI agents can also drive procedural playthroughs.

For example, Perforce’s Perfecto offers test recording, replay, and analysis capabilities for mobile game test automation. Tests exercise journeys like tutorials, purchases, battles, and progression enabling regression detection.