Skip to main content
100%

Gist 540bb6cf2f6ceada6387cc673f971498

✓ Published0🌍 Public
Aandybak
Last edited Nov 6, 2019
Created on Nov 6, 2019

This example demonstrates how to change an object’s appearance and size at runtime using Unity’s core APIs. It shows a script that accesses a GameObject’s MeshRenderer component to set its material color to red, then modifies the object’s Transform to scale it uniformly to five times its original size. The code relies on Unity’s `GetComponent<MeshRenderer>()` and the `transform.localScale` property, with `Color.red` and `Vector3` supplying the new values. The behavior is triggered directly in the `ChangeStuff()` method, illustrating a simple, immediate state change without animation or external data sources.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist a33a5c0eb38ae642af46a478b3951163

A Unity shader demonstrates a mesh-spherization effect by morphing a flat textured surface into a sphere. The vertex shader normalizes each vertex position, scales it by a configurable radius, and blends between the original and spherical coordinates using an amount parameter. The fragment shader samples the main texture and halves its color output. The shader uses Unity's `UnityObjectToClipPos` for projection and applies fog through standard CG macros. The material exposes radius and amount properties for interactive control.

Aandybak
62% match
Loading thumbnail…

Gist e8a05cce9a76090a14ba06fd8f53a274

This example demonstrates a minimal Unity camera control utility through a static C# class. It exposes the main camera’s position as a property and provides a method to move it by an offset vector, while also offering a property to read or set the global time scale. The code uses Unity’s `Camera.main`, `Transform.position`, and `Time.timeScale` APIs. It shows how to encapsulate common scene-level operations in a reusable static helper, with no rendering or data visualization logic beyond the camera manipulation itself.

Aandybak
59% match
Loading thumbnail…

Gist 38e049a8e58056d8542d9ee67c7957e0

This example shows a simple 3D pyramid whose apex moves upward or downward when the user presses the arrow keys. It demonstrates how to create and update a mesh at runtime using Unity’s Mesh API, with vertex data stored in a `NativeArray<float3>` for efficient modification. The code sets up a triangle-based submesh, defines vertex and index buffers via `SetVertexBufferParams` and `SetIndexBufferParams`, and redraws the mesh each frame with `Graphics.DrawMesh`. The pyramid is rendered using a provided material, and only the top vertex’s position is altered in response to input.

Aandybak
59% match
Loading thumbnail…

Gist d458751b92cc86c44bc44f8540a8b29b

This example displays a tetrahedron built from four triangular faces, with each face defined by three vertices and connected to form a closed 3D shape. The code uses Unity’s MeshFilter and MeshRenderer components, creating a new Mesh object and assigning vertex positions and triangle indices manually. It computes the geometry using vector math, including square roots for equilateral triangle proportions, then calls RecalculateNormals and RecalculateBounds to prepare the mesh for rendering. The script runs in edit mode via ExecuteInEditMode, so the tetrahedron appears immediately in the Unity editor without requiring playback.

Aandybak
58% match
Loading thumbnail…

Gist 92b2b6610d2371b2da7c34152657f751

This visualization demonstrates Möbius transformations applied to a 3D object in real time. A shader written in Unity’s ShaderLab and CG/HLSL takes each vertex, performs a reverse stereographic projection onto a 3-sphere, rotates the hypersphere in 4D space, then projects back to flat 3D. The user controls the rotation amount via the `_Amount` slider. The surface shader uses the Standard lighting model and applies vertex colors, with adjustable saturation, smoothness, and metallic properties through exposed parameters.

Aandybak
58% match
Loading thumbnail…

Gist 8b0da6e9acc76b7251547a0ad1dad5f1

This shader example demonstrates a technique for snapping pixel-art sprites to a fixed pixel grid in a 3D game engine. It shows how vertex positions are aligned to integer multiples of a tunable “pixels per unit” value prior to rendering, preventing visual distortion or shimmering when sprites are placed in world space. The code is written for Unity’s proprietary shader language and uses a Cginc/UnityCG-style vertex and fragment program, aligning object-space vertices before passing them through the standard MVP matrix. The shader samples a main texture and optionally an external alpha texture, tinting the result with a `_Color` property.

FFrozenfire92
58% match
Loading thumbnail…

Gist 660f765a1eaf8b00dd819920da0c2613

This example converts a selected PNG texture into a 3D mesh using Unity’s Sprite API. It shows how the image’s alpha channel defines a tight sprite outline, which becomes the mesh’s vertex geometry, while the original texture is applied as a material. The code uses `Sprite.Create`, `SpriteMeshType.Tight`, and `Mesh` to build the object, then assigns the Standard shader and recalculates normals, bounds, and tangents. It runs only when a .png asset is selected via the editor menu.

Aandybak
57% match
Loading thumbnail…

Gist e4337d3399b3937aa809a0179293bd13

This visualization reads a CSV file containing x, y, z position, width, height, depth, and RGB color columns, then plots each row as a colored 3D box in Unity. The data points are normalized to a 0–1 range, scaled by a plotScale factor, and instantiated as prefabs with their original size and color from the file. The code uses Unity’s `GameObject.Instantiate`, `Transform`, and `Renderer.material.color` to place and style each box, with positions and scales derived from the CSV values.

Aandybak
57% match