Skip to main content
100%

A simple tidy workflow for handling external 3rd party code in Unity 2018

✓ Published0🌍 Public
Aandybak
Last edited Jun 23, 2018
Created on Jun 10, 2018

A simple, text-based workflow for integrating external third-party code into Unity 2018 projects, shown as a set of markdown instructions and shell/JSON snippets. The example demonstrates a manual process using `git submodule add` to clone a repository, then wiring it into the Unity package system by authoring a `package.json` with a unique identifier (e.g., `com.uap.unitytimelineevents`) and referencing it in `manifest.json` via a file path. It also documents licensing guidance for open-source assets, recommending MIT for code and Creative Commons for artwork.

AI-generated description

Similar vizzes

Loading thumbnail…

Neater Unity 2018 projects with git submodules and sparse checkout

This example shows how to manage Unity 2018 projects more cleanly by combining git submodules with sparse checkout to include only necessary asset folders from external repositories. It demonstrates a shell script (`addpackage.sh`) that clones a repository, registers it as a submodule, enables sparse checkout, and specifies which `Assets/` directories to pull, while a `package.json` file defines the package metadata for Unity’s package manager. The code uses git commands like `git clone`, `git submodule`, and `git config core.sparseCheckout` to achieve selective inclusion, without any visualization libraries or rendering APIs.

Aandybak
76% match
Loading thumbnail…

Gist 163847197f2c33368934a7c89ba711bc

This example visualizes a particle system and its interactions, built with the Unity game engine. It uses Unity's built-in modules for rendering, physics, and user interface elements, including the TextMeshPro and UI systems. The visualization is driven by Unity's component-based architecture, with a manifest that declares the package dependencies. The work does not use typical JavaScript data-visualization libraries like D3 or Three.js; instead, it leverages Unity's own animation, audio, and particle system modules to create the interactive scene.

Aandybak
59% match
Loading thumbnail…

Gist 1973ba4fdee5e215ecb28f0db7f0aadb

This example shows a Unity Editor tool that automatically grants internal access to Shader Graph’s assembly during compilation. It hooks into `CompilationPipeline.assemblyCompilationStarted` to detect when the `Unity.ShaderGraph.Editor` assembly is being compiled, then locates its `AssemblyInfo.cs` file and appends an `InternalsVisibleTo` attribute referencing `BovineLabs.Vision.Editor`. The code uses `File.ReadAllLines`, `File.AppendAllText`, and `File.SetAttributes` to modify the file, while skipping the modification if the attribute already exists.

Aandybak
58% match
Loading thumbnail…

Gist 8f883887f8b89a94058b

This example shows the onboarding workflow for starting a new Maptime chapter, using a checklist-style document that walks through signing up for platforms like Twitter, Slack, GitHub, and Meetup, as well as setting up a chapter website and finding community contacts. The code is plain Markdown text, with no JavaScript or visualization libraries involved. It relies on standard Markdown formatting for headings, lists, and hyperlinks to external resources such as Google Docs and GitHub repositories, making the guide easy to read and follow as a static reference.

AAlan McConchie
56% match
Loading thumbnail…

GitHub-Native Merge Automation — a complete replacement for merge-automation bots (Mergify/Kodiak/Bulldozer/Trunk/Aviator/Graphite/MergeFreeze/backport bots), with native config + CI recipes for each feature

This example shows how to replace third-party merge-automation bots (Mergify, Kodiak, Bulldozer, Trunk, Aviator, Graphite, MergeFreeze, backport bots) using only GitHub-native features: auto-merge, merge queue, rulesets, and custom CI workflows. The code uses GitHub's GraphQL API (`enqueuePullRequest`) for eligibility-gated enqueueing, YAML workflow files for the `ci` job and `merge_group` event handling, and shell/gh CLI commands for configuration. It covers architecture, plan requirements, queue batching and bisection, freeze windows, and backport recipes.

Aandrewxhill
56% match
Loading thumbnail…

Gist 8e4a7859bf351698daff

This example displays a collection of Git command-line snippets organized by workflow categories, with each command as a labeled node. The visualization uses D3.js to render these commands as interactive text elements, applying a force-directed layout to spatially group related commands like repository creation, branching, and syncing. The code references `d3.forceSimulation` for positioning nodes and includes the raw command strings from a public Gist, with no external data fetching. Each node displays its command syntax and a brief comment, while the layout dynamically adjusts to avoid overlap based on the text content.

LLayne Smith
56% match
Loading thumbnail…

Gist fc88f1df47cdf606c9380f88c710c097

This visualization presents a step-by-step guide to a GitHub workflow, rendered as a vertical sequence of command blocks. It shows the process from checking out the master branch through creating a feature branch, committing changes, pushing, and merging via pull request. The code uses D3.js to bind the workflow steps to SVG elements, with `d3.forceSimulation` likely managing the layout of connected command nodes and arrows. Text is styled with D3 selections, and the data source is a hardcoded array of workflow instructions.

VVeronicaM
56% match
Loading thumbnail…

How to make git repo to be another's repo subfolder preserving history

This example shows a multi-step Git workflow for relocating an existing repository (`Proto`) into a subfolder of another repository (`Main`) while preserving full commit history. It demonstrates the use of `git checkout --orphan`, `git rebase`, and the history-rewriting command `git filter-branch --tree-filter` to move all files into `SRC/proto` across every prior commit. The process also addresses hidden files (like `.editorconfig`) and explains how to merge the two repositories via `git remote add` and a final `git rebase`. The source is a plain-text markdown guide with shell commands.

RRestuta
55% match