SharkJets

Making a Unity Game with Claude AI in Two Hours

Thu, 01 Oct 2026 00:00:00 GMT

Making a Unity Game with Claude AI in Two Hours

or how AI is making gamedev hella easy.

This year I took a break from working on gamedev, I haven’t touched Unity since January when I last worked on ShipVipers. Work and family and life just got a little too busy for me to keep grinding like I was.

Recently, Valve released their Steam Frame VR headset and I was lucky enough to get on the list. This got me all fired up again. A Quest-like headset with slightly better specs and way better focus on games? Sign me up!

..and sign me up I did! To the Steam Developer platform. ShipVipers is definitely going to be a Steam Frame game! (say that three times fast)

Now, as a professional web developer, I’ve been using Claude and Codex (and almost any other LLM you can think of) to help me with my day to day work. I used it in Unity a few times a year ago, but it wasn’t the best experience.

Every AI update is monumental, so I thought I’d give it another whirl. I installed the latest Unity, which now has an awesome new CLI specifically to help agents out! Then I fired up a new project and committed it as a starting point.

the idea

You can’t go into building something blindly, so the first step was to think about what I wanted to build.

I’ve been writing a futuristic short story and when I thought about it, for some reason, the NES Classic game Bionic Commando popped into my head.

So I went into Claude and had it create a plan for how to create such a game. I used a claude skill I created called Code Mentor which creates nice guides to walk me through whatever I want to build. (This keeps me from forgetting how to code and also teaches me new things!)

It also has the nice side effect of creating a step-by-step process for the agents to follow. Next, I pointed Claude to the newly created game folder (where the guides are now too) and said “Implement Guide #1.”

Off it went, writing code, testing what it made, and making adjustments. It was really cool watching it run Unity and fixing things as it went.

the results

After about an hour, and a few pieces of input from me, this is what it made.

Not bad at all.

The next day, I thought I’d spend another hour on it and see where we could get. The more I played it, the more I wondered why I went with Bionic Commando? The character in my story has a jet pack, not a grappling hook! So I asked Claude to replace the grapple with a jetpack.

Then I:

imported one of my favorite asset packs, SurrounDead (a zombie game setting)
imported a handful of animations from Mixamo
told Claude to create a level and implement the assets.

This is where we landed after the second hour of development:

Pretty neat, right?

I gotta say, we’re going place with AI. I feel like Tony Stark working with Jarvis.

My plan is to keep hitting this project for an hour a day until Claude finally starts to choke. What if that never happens? Well, I guess I’ll be shipping this game to Steam!

Stay tuned.

Achieve Stunning Visual Effects with Unity URP Green Screen

Sat, 16 Dec 2023 08:46:33 GMT

Achieve Stunning Visual Effects with Unity URP Green Screen

Date: 2023-12-16T08:46:33+00:00 - (Skid Vis)

Welcome to this comprehensive tutorial on creating professional green screen effects in Unity! In this guide, I’ll walk you through the process of putting yourself (or anyone else) into your game using Unity’s Universal Render Pipeline (URP) and a green screen video. This technique is perfect for game developers, content creators, and virtual production enthusiasts looking to blend real-world footage with digital environments.

What You’ll Learn

In this tutorial, you’ll discover how to:

Set up a green screen material in Unity using Shader Graph
Configure a video player to display green screen footage
Fine-tune the chroma key effect for clean results
Position and scale your video subject within the game world

Prerequisites

To follow along with this tutorial, you’ll need:

Unity 2022 LTS (or a similar recent version)
A video with a green screen background
Basic familiarity with Unity’s interface

Step-by-Step Tutorial

1. Setting Up Your Project

I’m using Unity 2022 LTS for this tutorial. To get started:

Create a new Unity project or use an existing one
Add a plane to your scene to serve as a surface for placing objects
Import your green screen video footage
Import a screenshot of your video (optional, but helpful for color picking)

2. Creating the Green Screen Material

The heart of this effect is a custom shader that will mask out the green color:

Import the Shader Graph (you can download mine from the link below)
Right-click on the Shader Graph and select “Create Material”
In the material settings, ensure:
- Surface Type is set to “Transparent”
- Blending Mode is set to “Alpha”

The Shader Graph includes several important parameters:

Texture: The video feed to apply the green screen effect to
Color: The specific green color to mask out
Hue Range: For fine-tuning which colors get masked
Fuzziness: Controls the softness of the mask edges

3. Setting Up the Video Player

Now let’s create the object that will display our green screen video:

Create a new empty GameObject in your scene (I named mine “Player”)
Add a Video Player component to this object
Inside the Player object, add a Plane (this will be our video display surface)
Resize the plane to match your video’s aspect ratio (I used 16:9, so I set X to 16 and Z to 9)
Scale down the parent object to a reasonable size (I used 0.5)
Lift the object slightly to prevent Z-clipping

4. Configuring the Material and Video

Now we need to connect everything together:

Apply the green screen material to the plane
In the material settings:
- Drag your screenshot into the Texture field (for testing)
- Use the eyedropper tool to select the exact green color to mask out
- Fine-tune the Hue Range and Fuzziness as needed
Configure the Video Player component:
- Drag your green screen video clip into the Video Clip field
- Set Update Mode to “DSP” for smoother playback (especially on slower computers)
- Enable Loop if you want the video to repeat
- Change Render Mode to “Material Override”
- Drag the Plane into the Renderer field
- Uncheck “Auto Select Property” and set it to “texture”

5. Positioning and Orientation

To position your video subject correctly in the scene:

Rotate the Player object 90 degrees on the X-axis (so it’s standing upright)
Adjust the height so the feet touch the ground
Optional: Add a script to make the player always face the camera for a billboard effect

6. Testing the Result

Hit Play to see your green screen video integrated into your Unity scene! The background should be transparent, showing only your subject against the game environment.

Tips for Best Results

Lighting: Ensure your green screen is evenly lit when recording
Color Selection: Use the eyedropper to pick the exact shade of green from your footage
Fine-tuning: Adjust the Hue Range and Fuzziness parameters for cleaner edges
Performance: If you experience lag, try reducing video resolution or using a more optimized codec

Resources and Support

For those who want to dive deeper, I’ve made my URP Green Screen Shadergraph available at: https://ko-fi.com/s/14f8a769c1

I would love to connect with you through my Discord server where we can discuss more about Unity and virtual production: https://discord.com/invite/CVNuqSZ

If you’d like to support my work, consider becoming a Patreon member: http://www.patreon.com/sharkjets

The background music in the video tutorial is by Flawed Human Being, check them out at: https://open.spotify.com/artist/0ywnFmJWQwP4adEG9otvYA

Conclusion

This green screen technique opens up countless possibilities for integrating real-world footage into your Unity projects. Whether you’re creating a game with live-action elements, a mixed reality experience, or just want to put yourself in your game world, this approach provides a professional-looking result with minimal setup.

If you found this tutorial helpful, please consider subscribing to my channel for more Unity and game development content. If you have any questions or run into issues, feel free to leave a comment on the video!

Watch the full tutorial on YouTube

Level Up Your Game with AI: Unleashing the Future of Game Asset Design

Fri, 06 Oct 2023 01:20:53 GMT

Level Up Your Game with AI: Unleashing the Future of Game Asset Design

Date: 2023-10-06T01:20:53+00:00 - (Skid Vis)

In this comprehensive guide, I’ll show you how to leverage artificial intelligence to revolutionize your game asset creation process. AI tools have transformed the way developers can approach asset design, allowing for rapid prototyping, unique visual elements, and professional-quality results with minimal effort.

Introduction: The AI Game Asset Revolution

Game development is resource-intensive, with asset creation often consuming a significant portion of development time and budget. AI-powered tools are changing this landscape dramatically, enabling developers of all skill levels to create high-quality assets quickly and efficiently.

In this article, I’ll walk you through a real-world example of how I used various AI tools to create a complete commercial for a fictional company called “Ship Vipers” - a post-battle cleanup service in a sci-fi universe. The entire commercial was created using AI tools, with my only contribution being the assembly and editing of the generated elements.

The AI Toolkit for Game Developers

Let’s explore the powerful AI tools that are transforming game asset creation:

1. Leonardo.ai - Background and Environment Generation

Leonardo.ai is a versatile image generation platform that excels at creating backgrounds, environments, and concept art for games.

How to use Leonardo.ai:

Create an account (free to start with limited credits)
Configure your generation settings:
- Number of images to generate
- Image style/type
- Privacy settings
- Resolution
Enter your prompt (keywords describing what you want)
Select your preferred visual style
Click generate

Leonardo.ai provides several useful features:

Multiple image variations to choose from
Ability to zoom in/out on generated images
Background removal
Download options for different resolutions

Real Example: For my Ship Vipers commercial, I used Leonardo.ai to generate space scenes with escape pods floating in space, creating the perfect backdrop for my sci-fi cleanup service.

2. Midjourney - Artistic Elements and Logo Design

Midjourney operates through Discord and excels at creating stylized, artistic images that can give your game a unique visual identity.

How to use Midjourney:

Join the Midjourney Discord server
Use the /imagine command followed by your prompt
Wait for four variations to be generated
Choose your preferred option:
- U1-U4: Upscale (higher resolution version)
- V1-V4: Create variations of that specific image

Midjourney offers additional refinement options:

Zoom out to expand the scene
Convert to square format
Pan the camera in different directions

Real Example: I used Midjourney to create the Ship Vipers logo by generating individual elements (a gun, a mop, and a skull) and then combining them in Photoshop to create a unique crossed-guns-and-mop design reminiscent of a skull and crossbones.

3. Play.ht - Voice Acting and Narration

Play.ht is an AI voice generation platform that can create professional-sounding narration and character voices for your games.

How to use Play.ht:

Visit the website
Type or paste your script
Select from a wide variety of voice options (male/female, accents, etc.)
Generate the audio
If you’re not satisfied, regenerate for different inflections
Download the final audio file

Real Example: For my Ship Vipers commercial, I initially recorded my own voice but wanted something different. Using Play.ht, I was able to generate a professional-sounding narrator who delivered the commercial script with perfect inflection and timing.

4. D-ID - Character Animation and Video Creation

D-ID allows you to animate still images, creating talking head videos that can be used for NPCs, cutscenes, or promotional materials.

How to use D-ID:

Upload an image to serve as your “actor”
Either:
- Type text and select one of D-ID’s voices, or
- Upload your own audio file
Generate the video
Download the result

Real Example: For the Ship Vipers commercial, I uploaded an image and my Play.ht generated audio. D-ID created a video with perfectly synchronized lip movements, bringing my character to life with minimal effort.

5. Adobe Photoshop’s Generative Fill - Quick Asset Creation

The latest versions of Photoshop include AI-powered generative fill capabilities that can be incredibly useful for game asset creation.

How to use Generative Fill:

Open Photoshop
Select an area (or create a blank canvas)
Access the Generative Fill tool
Enter a text prompt describing what you want
Choose from the generated options
Continue adding elements by selecting new areas and generating more content

Real Example: I demonstrated how you can quickly create a desert sunset scene and then add elements like a truck and an astronaut, showing how this tool can be used to create background elements, props, and environmental details for games.

Practical Applications for Game Development

These AI tools have numerous applications in game development:

Background Elements and Props

Generate unique props, background elements, and environmental details that would otherwise require significant time to model or illustrate.

Marketing Materials

Create professional-looking promotional materials, trailers, and social media content to market your game.

Placeholder Assets

Use AI-generated assets as placeholders during development, allowing you to test gameplay and mechanics before final art is complete.

Supplementary Content

Create secondary assets like in-game magazines, posters, photographs, and background details that add depth to your world without consuming significant development resources.

Best Practices and Considerations

While AI tools are powerful, here are some tips for getting the best results:

Prompt Engineering: Learning to write effective prompts is crucial. Be specific about what you want, including style, lighting, perspective, and mood.
Iteration: Don’t settle for the first result. Generate multiple options and refine your prompts based on what works.
Combining Tools: The most powerful approach is combining multiple AI tools. Generate images with one tool, voices with another, and animations with a third.
Post-Processing: Most AI-generated assets benefit from some manual refinement in traditional tools like Photoshop or Blender.
Focus on Secondary Assets: While AI can create impressive assets, consider using it primarily for secondary elements while investing in custom-designed primary assets for your game’s unique identity.

Conclusion

AI tools have democratized game asset creation, allowing developers of all skill levels to create professional-quality assets quickly and efficiently. By incorporating these tools into your workflow, you can focus more on gameplay and mechanics while still achieving impressive visual and audio results.

The Ship Vipers commercial I created demonstrates how these tools can work together to produce a polished final product with minimal manual asset creation. Whether you’re an indie developer with limited resources or a professional looking to streamline your workflow, AI asset generation tools offer exciting possibilities for the future of game development.

If you found this guide helpful, please like and subscribe to my channel for more game development content. Let me know in the comments if there are other AI tools or techniques you’d like me to cover in future videos!

Watch the full video here to see these AI tools in action and learn how you can transform your game development process!

Unity XR - How to make a touchscreen

Sat, 29 Apr 2023 07:06:53 GMT

Unity XR - How to make a touchscreen

Date: 2023-04-29T07:06:53+00:00 - (Skid Vis)

In this tutorial, I’ll walk you through creating a touchscreen interface in Unity XR. I’ve designed this guide to help you build a simple quest game with touchscreen controls for your Virtual Reality projects.

By the end of this tutorial, you’ll have all the knowledge needed to implement intuitive touchscreen interactions in your Unity games. This is perfect for those looking to enhance their VR experiences with interactive UI elements.

I’ve made all the code for this project available at my code bundle site: https://code.sharkjets.com/l/code-bundle

For this project, I recommend using the VR Interaction Framework (VRIF), which you can get here: https://tinyurl.com/vrframework

If you’re developing for Oculus devices, I also suggest downloading the Oculus Developer Hub: https://developer.oculus.com/documentation/unity/ts-odh/

I’d love to connect with you to discuss this project or answer any questions! Join my Discord server at https://discord.com/invite/CVNuqSZ

If you found this tutorial helpful, consider supporting my work by becoming a patron: http://www.patreon.com/sharkjets

You can watch the full tutorial video here: Unity XR - How to make a touchscreen

Special thanks to Flawed Human Being for the music used in this tutorial. Check out their work on Spotify: https://open.spotify.com/artist/0ywnFmJWQwP4adEG9otvYA

Unity XR - How to catch bugs

Fri, 20 Jan 2023 06:33:18 GMT

Unity XR - How to catch bugs

Date: 2023-01-20T06:33:18+00:00 - (Skid Vis)

Debugging VR applications presents unique challenges that traditional debugging methods don’t adequately address. In this comprehensive guide, I’ll show you how to effectively track and manage bugs in your Unity XR applications, especially when they’re running on a headset where you can’t see the console logs.

The Problem with Traditional Debugging in VR

When developing standard Unity applications, Debug.Log is often our go-to tool for troubleshooting issues. We can see messages appear in the console, track variables, and identify where problems occur. However, this approach falls short in VR development for several reasons:

You can’t see the console while wearing a VR headset - This makes real-time debugging difficult
Console logs aren’t available in production builds - Once your app is deployed, you lose access to these logs
User-reported bugs are hard to reproduce - Without detailed error information, it’s challenging to understand what went wrong for your users

To demonstrate this limitation, I’ve set up a simple scene in Unity 2021 LTS with:

A VRIF player rig
A small red cube that can be grabbed
A blue trigger box that detects when objects enter it

In a traditional approach, we might use code like this to detect interactions:

private void OnTriggerEnter(Collider other)
{
    Debug.Log("You have entered the trigger");
}

While this works fine during development when you can see the Unity console, it’s useless once your application is deployed to users or when you’re testing with a headset on.

Introducing Bugsnag: Remote Error Tracking for VR

To solve this problem, we can use Bugsnag, a powerful error monitoring platform that supports Unity applications. Bugsnag allows you to:

Track errors and custom events remotely
Receive detailed information about the device, OS, and application state
Monitor issues in production builds
Get notified when new errors occur

Best of all, Bugsnag offers a free tier that’s sufficient for most indie developers and small projects.

Setting Up Bugsnag in Your Unity XR Project

Let’s walk through the process of integrating Bugsnag into your Unity VR application:

Step 1: Create a Bugsnag Account

Visit bugsnag.com and sign up for a free account
Once logged in, create a new project
Select “Unity” as your platform
Give your project a name and click “Continue”

Step 2: Install the Bugsnag Package in Unity

Bugsnag provides a Unity package that you can install directly via the Package Manager:

In Unity, open the Package Manager (Window > Package Manager)
Click the “+” button in the top-left corner
Select “Add package from git URL…”
Paste the Bugsnag Unity package URL provided in your Bugsnag dashboard
Click “Add”

Unity will download and install the Bugsnag package from GitHub.

Step 3: Configure Bugsnag in Unity

After installation, you need to configure Bugsnag with your API key:

In Unity, go to Window > Bugsnag Settings
Copy your API key from the Bugsnag dashboard
Paste it into the API Key field in the Bugsnag Settings window
Save your settings

Step 4: Replace Debug.Log with Bugsnag.Notify

Now you can update your code to use Bugsnag instead of Debug.Log:

private void OnTriggerEnter(Collider other)
{
    // Instead of Debug.Log
    Bugsnag.Notify("triggered", "You have entered a trigger", "nothing here");
}

The Bugsnag.Notify method takes three parameters:

Error name or type
Error message
Stack trace (optional, you can leave this empty or add custom context)

Step 5: Handling Exceptions with Try-Catch

Bugsnag really shines when handling exceptions. You can wrap potentially problematic code in try-catch blocks and report any exceptions to Bugsnag:

try
{
    // Your code that might throw an exception
    // For example, processing an in-app purchase or loading external data
}
catch (Exception e)
{
    // Report the exception to Bugsnag
    Bugsnag.Notify(e, "error", "On trigger for the Box");
    
    // You can also specify severity
    // Bugsnag.Notify(e, Bugsnag.Severity.Error, "On trigger for the Box");
}

Real-World Use Cases

Testing with Friends and Beta Users

When you distribute your VR application to friends or beta testers, Bugsnag allows you to:

See exactly what errors they encounter
Get detailed information about their device and OS
Understand the frequency and impact of issues

Monitoring Production Applications

For released applications, Bugsnag helps you:

Identify issues affecting multiple users
Prioritize fixes based on frequency and severity
Track the effectiveness of your updates

Tracking Custom Events

Beyond error reporting, you can use Bugsnag to track important events in your application:

Completed levels or achievements
Feature usage statistics
Performance metrics

Viewing and Managing Errors

Once your application is sending data to Bugsnag, you can view all reported issues in your Bugsnag dashboard:

Each error appears in your project’s inbox
You can see when the error occurred
Detailed information about the device, OS, and application state is provided
You can assign, comment on, and track the status of each issue

Conclusion

While Debug.Log is a valuable tool during development, it falls short when debugging VR applications in production environments. By implementing Bugsnag in your Unity XR projects, you gain powerful remote error tracking capabilities that help you identify, understand, and fix issues more efficiently.

This approach is especially valuable for VR development where traditional debugging methods are limited by the nature of the platform. With Bugsnag, you can continue to monitor and improve your application even after it’s in users’ hands.

For VR development, I use the VR Interaction Framework (VRIF), which provides a solid foundation for building interactive VR experiences.

If you’d like to discuss VR development further, feel free to join my Discord server where we can chat about various aspects of XR development.

For those who want to support my work, consider becoming a Patreon member.

The music in my video is by Flawed Human Being, whose work you can find on Spotify.

Unity XR - Oculus Point and Spawn Objects

Tue, 29 Nov 2022 15:09:59 GMT

Unity XR - Oculus Point and Spawn Objects

Date: 2022-11-29T15:09:59+00:00 - (Skid Vis)

In this tutorial, I demonstrate how to set up a raycast spawning system with VRIF (Virtual Reality Interaction Framework) in Unity. If you’ve ever wanted to point and make objects appear in your VR application, this is the perfect guide for you!

I’ve made all the code available at my code bundle site: https://code.sharkjets.com/l/code-bundle

If you want to follow along with the video tutorial, you can watch it here: Unity XR - Oculus Point and Spawn Objects

To get started, you’ll need the VRIF framework, which you can pick up here: https://tinyurl.com/vrframework

I cover everything from setting up the raycast to creating spawnable objects in your VR environment. This technique is especially useful for interactive VR experiences where users need to create or place objects in the virtual world.

If you have any questions or want to discuss this further, I’d love to have you join my Discord server: https://discord.com/invite/CVNuqSZ

For those who appreciate my tutorials and want to support my work, you can become a Patreon member: http://www.patreon.com/sharkjets

Special thanks to Flawed Human Being for the music used in the tutorial! Check out their work on Spotify: https://open.spotify.com/artist/0ywnFmJWQwP4adEG9otvYA

Q & A: How NFTs can be used in Game Development

Fri, 21 Jan 2022 20:59:25 GMT

Q & A: How NFTs can be used in Game Development

Date: 2022-01-21T20:59:25+00:00 - (Skid Vis)

I was recently invited by Dan Violet Sagmiller to discuss the potential for using NFTs in game development. In this Q&A session, I share my insights on how blockchain technology and NFTs can be integrated into games, addressing common misconceptions and exploring exciting future possibilities for the gaming industry.

Understanding NFTs and Blockchain Technology

What Exactly Are NFTs?

NFTs (Non-Fungible Tokens) are often misunderstood, so I started by explaining the fundamentals. At their core, NFTs are entries in a blockchain - essentially a permanent, immutable digital ledger that everyone can see but no one can alter.

Think of a blockchain as a giant journal floating in space that records ownership. Once something is written in this journal, it can’t be changed - only added to through new transactions. This immutability is what gives NFTs their value.

For example, if the blockchain records that you own a particular digital asset (like an in-game item), everyone can verify your ownership by checking the blockchain. No one can fraudulently claim it’s theirs or alter the record.

Common Misconceptions

One major misconception I addressed is that owning an NFT means owning the copyright to the content. This isn’t the case - similar to how buying an MP3 doesn’t give you rights to the song itself. When you purchase an NFT, you’re buying proof of ownership of a specific digital item, not the intellectual property rights.

I referenced a recent example where a group spent millions on a copy of the book “Dune,” mistakenly believing they had purchased the copyright to the entire franchise. This highlights the importance of understanding what NFTs actually represent.

NFTs in Gaming: Beyond the Hype

A Living Achievement System

One of the most exciting applications I discussed is what I call a “living achievement system.” Imagine if your gaming achievements weren’t locked to a single platform or company but existed on a public, decentralized ledger.

For example, if you beat The Legend of Zelda 35 years ago on Nintendo, that achievement could be recorded on the blockchain. Then, decades later, when you start playing a completely different game from a different company (like Assassin’s Creed), it could check this public ledger and reward you with a special item - perhaps a Master Sword-inspired weapon - acknowledging your past achievement.

This creates a persistent gaming identity and history that transcends individual games and platforms - something like the interconnected world seen in “Ready Player One.”

True Digital Ownership

Another compelling use case is true ownership of in-game assets. I shared my personal experience with World of Warcraft, where I spent countless hours grinding for gold and items, even occasionally purchasing gold from third parties. When I eventually stopped playing, I had nothing to show for my investment of time and money.

With blockchain technology, in-game currencies and items could have real value outside the game. If you decide to stop playing or if the game shuts down, you could potentially trade or sell your assets, preserving the value of your time and financial investment.

Cross-Game Asset Utilization

I also discussed how NFTs could enable items to be used across different games. Imagine earning a special vehicle in one racing game that you could then use in any other compatible racing game. This creates an ecosystem where your digital possessions have utility beyond a single game’s ecosystem.

Addressing Concerns and Criticisms

Energy Consumption

One of the most common criticisms of blockchain technology is its energy consumption. I clarified that while Bitcoin does consume significant energy due to its “proof of work” consensus mechanism, many newer blockchains that support NFTs use “proof of stake” instead, which requires far less energy.

I explained the difference between these approaches:

Proof of Work: Requires millions of computers solving complex mathematical problems to validate transactions, consuming enormous amounts of energy
Proof of Stake: Validates transactions by having participants lock up (stake) their own tokens as collateral, requiring minimal computational resources

Most modern NFT platforms like Ethereum (which is transitioning to proof of stake), Polygon, and Solana are moving toward or already using these more energy-efficient methods.

Corporate Adoption Challenges

We discussed whether game companies would actually embrace this technology, given that they currently benefit from keeping players locked into their ecosystems. I suggested that companies could still profit by creating their own tokens and holding reserves, potentially benefiting from the increased value if their game and token ecosystem becomes popular.

This creates an interesting alignment of incentives - if the game succeeds and its token economy thrives, both players and developers benefit.

The Future of NFTs in Gaming

Play-to-Earn Models

Looking ahead, I believe we’ll see more “play-to-earn” models where players can make real money simply by playing games. This is already happening in some economies where the income from playing certain blockchain games exceeds what people can earn in traditional jobs.

Standardization and Mainstream Adoption

I compared the current state of blockchain gaming to the early days of MP3s, when there was controversy, resistance from established industries, and a lack of standardized platforms. Eventually, services like Spotify emerged to create user-friendly experiences that gained mainstream adoption.

We’re still in the “Wild West” phase of NFTs in gaming, with many competing blockchains and approaches. Over time, standards will likely emerge that balance benefits for both companies and players.

Conclusion

While NFTs in gaming are still in their early stages, the technology offers exciting possibilities for creating persistent player identities, enabling true digital ownership, and developing new economic models in games.

The key is finding implementations that provide genuine value to players rather than simply capitalizing on the NFT trend. As the technology matures and standards develop, we’ll likely see more meaningful integrations that enhance gaming experiences rather than just serving as marketing gimmicks.

Watch the video on YouTube

If you’re interested in the full discussion, you can watch the complete version on Twitch at Dan Violet Sagmiller’s channel.

For those interested in exploring NFT projects I’ve mentioned:

Check out Everdragons2
Try the DragonMound matic game at dragonmound.com

I’d love to continue this conversation with you! Join my Discord server and let’s chat: Discord Invite

If you appreciate my content and want to support my work, consider becoming a Patreon member: Patreon

Unity XR - Oculus Hand Tracking

Tue, 11 Jan 2022 03:15:22 GMT

Unity XR - Oculus Hand Tracking

Date: 2022-01-11T03:15:22+00:00 - (Skid Vis)

In this tutorial, I demonstrate how to quickly set up hand tracking with VRIF (Virtual Reality Interaction Framework) and Oculus Integration. Oculus Meta makes it easy to track your hands in VR applications, and I walk through the process step by step.

If you’re looking to implement hand tracking in your Unity XR project, this tutorial will help you get started right away!

Resources

For those following along, you can get VRIF here: https://tinyurl.com/vrframework

I’d love to connect with you! Join my Discord server and let’s chat: https://discord.com/invite/CVNuqSZ

If you enjoy my content and want to support my work, consider becoming a Patreon member: http://www.patreon.com/sharkjets

Video Tutorial

For the complete walkthrough, check out my tutorial on Unity XR - Oculus Hand Tracking.

Music Credits

Music by: Flawed Human Being https://open.spotify.com/artist/0ywnFmJWQwP4adEG9otvYA

Unity - Load NFT from OpenSea

Thu, 23 Dec 2021 00:12:08 GMT

Unity - Load NFT from OpenSea

Date: 2021-12-23T00:12:08+00:00 - (Skid Vis)

In this tutorial, I’ll show you how to integrate NFTs from OpenSea into your Unity game. Whether you want to display a player’s NFT collection or incorporate NFT artwork into your virtual world, this step-by-step guide will walk you through the process of fetching NFT data from the OpenSea API and displaying it in your Unity project.

Introduction

NFTs (Non-Fungible Tokens) have become increasingly popular in the digital space, and many game developers are looking for ways to incorporate them into their projects. By connecting to the OpenSea API, you can access a vast marketplace of digital assets and display them within your Unity game.

In this tutorial, we’ll:

Explore the OpenSea API
Convert JSON responses to C# classes
Create Unity scripts to fetch and display NFT images
Set up a simple scene to showcase the NFT

Prerequisites

To follow along with this tutorial, you’ll need:

Unity 2019 or newer
Basic understanding of C# and Unity
Internet connection to access the OpenSea API

Step 1: Understanding the OpenSea API

First, let’s explore the OpenSea API to understand what data we can access. Visit the OpenSea API documentation to see the available endpoints.

For this tutorial, we’ll focus on the “Retrieving Assets” endpoint, which allows us to fetch NFT data including images. The endpoint URL looks like this:

https://api.opensea.io/api/v1/assets

You can test this endpoint directly in the documentation by clicking the “Try it” button. This will show you the JSON response structure, which includes an array of assets with properties like ID, image URL, and metadata.

Step 2: Converting JSON to C# Classes

To work with the JSON response in Unity, we need to convert it to C# classes. Here’s how:

Copy a sample JSON response from the OpenSea API documentation
Visit JSON to C# converter
Paste the JSON and convert it to C# classes

When copying the JSON, make sure to include the complete structure with proper closing brackets. The converter will generate C# classes that match the JSON structure, which we’ll use in our Unity project.

Step 3: Creating the C# Classes in Unity

Now, let’s create our first script in Unity:

Create a new C# script named OpenSea.cs
Replace the default code with the converted C# classes
Make the following modifications to make it compatible with Unity:

// Add these using statements
using System;
using System.Collections.Generic;

// Add [Serializable] attribute to all classes
[Serializable]
public class Asset
{
    public string id;
    public string image_url;
    // Other properties...
}

[Serializable]
public class OpenSea
{
    public List<Asset> assets;
}

Important modifications to make:

Replace property getters/setters with simple fields (e.g., change public string id { get; set; } to public string id;)
Add the [Serializable] attribute to all classes to make them compatible with Unity’s serialization system
Rename the root class from Root to OpenSea to match our file name

Step 4: Creating the API Handler Script

Next, we’ll create a script to handle the API requests:

Create a new C# script named OpenSeaAPI.cs
Add the following code:

using System.Collections;
using System.IO;
using System.Net;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.UI;

public class OpenSeaAPI : MonoBehaviour
{
    [SerializeField] private RawImage img;
    
    void Start()
    {
        FetchNFT();
    }
    
    void FetchNFT()
    {
        string url = "https://api.opensea.io/api/v1/assets";
        
        HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
        HttpWebResponse response = (HttpWebResponse)request.GetResponse();
        
        StreamReader reader = new StreamReader(response.GetResponseStream());
        string json = reader.ReadToEnd();
        
        OpenSea openSea = JsonUtility.FromJson<OpenSea>(json);
        
        StartCoroutine(DownloadImage(openSea.assets[1].image_url));
    }
    
    IEnumerator DownloadImage(string url)
    {
        UnityWebRequest request = UnityWebRequestTexture.GetTexture(url);
        yield return request.SendWebRequest();
        
        Texture2D texture = DownloadHandlerTexture.GetContent(request);
        img.texture = texture;
    }
}

This script does the following:

Makes a web request to the OpenSea API
Reads the JSON response
Converts the JSON to our C# classes
Starts a coroutine to download the image from the NFT’s image URL
Assigns the downloaded image to a RawImage component

Note: We’re using assets[1] to get the second asset in the array, as the first one might not always have an image. In a production environment, you’d want to add error checking and handle cases where images might be missing.

Step 5: Setting Up the Unity Scene

Now, let’s set up our Unity scene to display the NFT:

Create an empty GameObject and attach the OpenSeaAPI script to it
Create a Canvas (set to World Space for 3D projects)
Add a RawImage component to the Canvas
Adjust the Canvas scale to make it visible in your scene (e.g., 0.01 for a 3D scene)
Drag the RawImage component into the img field of the OpenSeaAPI script in the Inspector

Step 6: Testing the Implementation

When you run the game, the script will:

Fetch NFT data from OpenSea
Extract the image URL from the second asset in the response
Download the image
Display it on the RawImage component

If everything is set up correctly, you should see an NFT image displayed in your game!

Customizing the Implementation

This basic implementation can be extended in several ways:

Fetch specific NFTs: Modify the API URL to fetch NFTs from a specific wallet or collection
Display multiple NFTs: Create a grid or gallery of images to showcase multiple NFTs
Add interactivity: Allow players to interact with the NFTs in your game
Use NFT metadata: Incorporate other NFT properties like name, description, or attributes

Conclusion

By following this tutorial, you’ve learned how to integrate OpenSea NFTs into your Unity game. This opens up possibilities for creating NFT galleries, allowing players to showcase their collections, or incorporating NFT artwork into your virtual worlds.

While this example focuses on displaying images, the same approach can be used to access any API data, making it a valuable technique for connecting your Unity games to external services.

If you’d like to discuss this topic further or have questions, I invite you to join my Discord server where we can chat about Unity, NFTs, and game development.

For those interested in supporting my work, consider becoming a Patreon member.

The background music in the video tutorial is by Flawed Human Being, who you can find on Spotify.

Check out the full tutorial here on YouTube.

Unity XR - Oculus Meta In-App Purchases

Thu, 18 Nov 2021 12:57:10 GMT

Unity XR - Oculus Meta In-App Purchases

Date: 2021-11-18T12:57:10+00:00 - (Skid Vis)

In this tutorial, I demonstrate how to implement in-app purchases (IAP) in your Oculus Meta AppLab games using Unity. Oculus Meta now allows Unity game developers to monetize their AppLab games through IAP, giving you another revenue stream beyond the initial purchase price.

I’ve put together a comprehensive guide on getting started with in-app purchases quickly so you can start earning money from your VR applications. The process is straightforward once you understand the basics.

For those looking to implement this in their own projects, I’ve made the code available at: https://code.sharkjets.com/l/code-bundle

If you’re working with VR in Unity, I highly recommend checking out VRIF (Virtual Reality Interaction Framework): https://tinyurl.com/vrframework

To test and manage your Oculus applications, you’ll want to download the Oculus Developer Hub: https://developer.oculus.com/documentation/unity/ts-odh/

I’d love to connect with fellow VR developers! Join my Discord server and let’s chat: https://discord.com/invite/CVNuqSZ

If you enjoy my content and would like to support my work, consider becoming a patron: http://www.patreon.com/sharkjets

Special thanks to Flawed Human Being for the music In this tutorial: https://open.spotify.com/artist/0ywnFmJWQwP4adEG9otvYA

Watch the full tutorial on YouTube

Unity XR - Unity crashes on Play exit with Oculus Integration

Sat, 25 Sep 2021 16:22:09 GMT

Unity XR - Unity crashes on Play exit with Oculus Integration

Date: 2021-09-25T16:22:09+00:00 - (Skid Vis)

If you’re developing VR applications with Unity and Oculus Integration, you might have encountered a frustrating issue: Unity crashes every time you exit Play mode. This problem has been affecting many developers, particularly with Oculus Integration version 32. In this guide, I’ll walk you through the exact steps to fix this issue and get your development workflow back on track.

The Problem

When using Oculus Integration in Unity (particularly version 32 at the time of this writing), you may experience the following scenario:

You enter Play mode to test your VR application
Everything works fine while in Play mode
When you click the Play button again to exit Play mode, Unity crashes with an error related to UnityEngine.SubsystemBindings.DestroySubsystem

This crash is not caused by your code or project setup - it’s related to how the Oculus Integration package interacts with Unity’s XR systems, particularly around the new OpenXR backend.

The Solution: Step-by-Step Guide

The fix involves reinstalling the Oculus Integration package and making specific choices during the setup process. Here’s how to resolve the issue:

Step 1: Remove the Current Oculus Integration

First, we need to completely remove the current Oculus Integration package:

Navigate to your project’s Assets folder
Find and delete the Oculus folder (this contains the Oculus Integration assets)
Reopen your Unity project

At this point, you’ll notice that any Oculus-related components in your scene (like the OVR Player Controller) will be missing their references.

Step 2: Reinstall Oculus Integration

Now we’ll reinstall the Oculus Integration package, but with specific settings:

Open the Package Manager (Window > Package Manager)
Switch to “My Assets” (you may need to be logged into your Unity account)
Find and select “Oculus Integration”
Click “Download” or “Import” (depending on whether you’ve downloaded it before)
In the import window, select all assets (or customize as needed for your project)
Click “Import”

Step 3: Critical Setup Choices

This is the most important part. After importing, you’ll receive a series of popup dialogs. Here’s how to respond to each one:

First popup - “New plugin detected…” - Click Yes
- This acknowledges the Oculus plugin
Second popup - “OpenXR Backend…” - Click Cancel
- This is crucial! Do NOT select “Use OpenXR” as this is what causes the crashes
- By clicking Cancel, you’re sticking with the legacy OVR plugin which is more stable
Third popup - “The standard legacy OVR plugin will be activated by default…” - Click Restart
- This confirms you want to use the legacy plugin and restarts the editor
Fourth popup - “Audio Spatializer Plugin…” - Click Yes
- This updates the audio spatializer plugin
Final popup - “Plugin was updated…” - Click Restart
- This completes the installation and restarts the editor again

Step 4: Verify the Fix

After Unity restarts:

Set up your scene again if needed (re-add any missing Oculus components)
Enter Play mode to test your VR application
Exit Play mode

Unity should now exit Play mode without crashing!

Why This Works

The key to fixing this issue is avoiding the OpenXR backend that’s included in Oculus Integration. While OpenXR is the future standard for XR development, the implementation in Oculus Integration version 32 has compatibility issues with Unity’s subsystem management.

By choosing the legacy OVR plugin instead, you bypass these compatibility issues while still having full access to Oculus functionality.

Additional Tips

This solution works for Unity 2020 and similar versions
If you’re using VRIF (VR Interaction Framework) alongside Oculus Integration, this fix should resolve compatibility issues between them
Future versions of Oculus Integration may resolve this issue, but until then, this workaround is your best option
If you update Oculus Integration in the future, you may need to repeat these steps

Conclusion

This seemingly simple issue can cause major headaches for VR developers, leading to lost time and frustration. By following the steps outlined above, you can avoid the Unity crashes when exiting Play mode and maintain a smooth development workflow.

Remember that VR development tools are constantly evolving, and sometimes these kinds of issues arise during transitional periods between different standards and implementations. Staying informed about workarounds like this can save you countless hours of troubleshooting.

If you’re experiencing this frustrating crash, check out my solution in the video walkthrough here.

For those working on VR projects, I recommend checking out VRIF (VR Interaction Framework) which you can find at: https://tinyurl.com/vrframework

I’d love to chat with you about any VR development challenges you’re facing! Join my Discord server at: https://discord.com/invite/CVNuqSZ

If you appreciate my content, please consider becoming a Patreon member: http://www.patreon.com/sharkjets

The music In this tutorial is by Flawed Human Being, who you can find on Spotify: https://open.spotify.com/artist/0ywnFmJWQwP4adEG9otvYA

Unity XR - How to change the way the bow looks in your Quest games using VRIF

Tue, 07 Sep 2021 01:50:53 GMT

Unity XR - How to change the way the bow looks in your Quest games using VRIF

Date: 2021-09-07T01:50:53+00:00 - (Skid Vis)

In this tutorial, I’ll show you how to customize the appearance of the bow in your Oculus Quest 2 games developed with Unity and VRIF (Virtual Reality Interaction Framework).

If you’re looking to give your game a more unique look by changing the default VRIF bow, you’ve come to the right place. This customization will help your VR game stand out with a more personalized weapon design.

Resources You’ll Need

To follow along with this tutorial, you’ll need:

VRIF (Virtual Reality Interaction Framework)
Free Pack of Medieval Weapons for the bow assets

Watch the Tutorial

For a detailed step-by-step guide, check out my full video tutorial:

Unity XR - How to change the way the bow looks in your Quest games using VRIF

Connect With Me

I’d love to hear about your game development projects and answer any questions you might have:

Join my Discord server to chat and connect with other developers
Support my tutorials by becoming a Patreon member

Music Credits

The music in the video is by Flawed Human Being. Check them out on Spotify.