Here's a new Basics tutorial that covers performance, going through the game windows statistics panel, the frame debugger, and the profiler to get a better idea of what's going on. We also compare dynamic batching, GPU instancing, and the SRP Batcher. We follow that with the creation of our own frame rate counter. And for a little extra fun we make our graph morph from one function to the next!
We hope you enjoy using it. yiff.party operates on a non-profit basis, and as such, all the server expenses are paid by our users. We don't want to run ads or infect you with crypto miners. We depend on users like you to keep the site running, and to preserve years and terabytes of amazing content—some of which is no longer available from its original creators!
Because of the nature of the site, many users are reluctant to donate. That's OK! yiff.party was created so everyone can enjoy the content we host without any restrictions or paywalls. But if you value the service we provide, and are able to, we—and our users—would be tremendously grateful if you considered making a donation.
So far, approximately $400.00 has been raised out of our target of $400.00. We're about 100% of the way there! Please note: this tracker is updated manually—don't worry if your donation doesn't show up immediately!
yiff.party's server costs are due on the last day of each month. So, we need to meet this goal before 31 October!
At this time, yiff.party can only accept donations in numerous cryptocurrencies. Please select a currency below to display the relevant donation address.
Due to the nature of sites like yiff.party, it is very difficult to find payment processors who will accept clients like us. If we were to accept donations via PayPal, it wouldn't take more than a day for someone to submit an abuse report and get our account frozen. Until a viable way of accepting monetary donations becomes available, cryptocurrency will remain the only option.
There are many resources available on how to purchase crypto. For Bitcoin, check out bitcoin.org's page on buying Bitcoin for a list of methods. For beginner Bitcoin users, yiff.party recommends using an escrow service such as LocalBitcoins.
1 / 5
This time we add various color grading tools to our RP, mimicking some of the URP/HDRP ones. Then we bake both color grading and tone mapping in a LUT.
I upgraded Game Objects and Scripts, Building a Graph, and Mathematical Surfaces, releasing them as if they were a single new tutorial. Three for the price of one! This is a complete rewrite of the Basics series, moving forward to Unity 2019 LTS, adding subjects like the package manager, URP, and shader graph. Most of the same old ground is still covered, but with a fresh approach.
Now that this upgrade is out the way I can publish some cool new Basics tutorials.
In the final installment of the Movement series we turn our sphere into a real rolling ball.
This month the custom SRP tutorial comes first, and it's about HDR rendering! We fight fireflies, create scatter-based bloom, and apply tone mapping.
This time we lay the groundwork for our own post-FX stack. The first effect that we create is artistic bloom, because it's so obvious.
This time we make the environment more interesting by making it react to our movement.
Point and spot lights should get realtime shadows too! Now they do.
Unfortunately I haven't yet figured out how to stop Unity from switching the cull mode for point light shadows. It becomes a non-issue when universally rendering two-sided shadows, but it's not ideal.
It's summer. High time we teach our sphere how to swim!
We finally move beyond only supporting directional lights, including point and spot lights as well! This tutorial covers realtime, baked, and shadow mask for those other light types. Realtime shadows will come later.
Our sphere keeps evolving. It has now gained the ability to climb!
It's time to add support for some more complex materials to our RP's shader!
Our sphere is not the only thing that can move. What it's standing on can move as well, and the sphere should react accordingly. In this tutorial we make sure that happens.
This time we extend our custom RP with support for LOD groups and reflections. We keep the reflections simple, specifically one probe per object, no box projections.
Walking on a sphere isn't cool enough. So we add support for planes and boxes as well. Still not enough? What about multiple gravity sources at the same time? Have fun jumping from sphere to sphere to box!
This time we deal with the truly mixed lighting modes: those that mix realtime lighting and shadows with baked shadows!
In this tutorial we leave the limitations of uniform gravity behind and make it possible to walk on the outside of a sphere. Or on the inside of it.
This time we cover baking light in the Custom SRP series. Light maps, light probes, and light probe proxy volumes. We also consolidate the shader input in a single file so we don't have to redefine it for each pass, as we now also need a meta pass.
This time we pull back from the sphere a bit and instead concern ourselves with the camera. We'll create a third-person orbit camera that focuses on the sphere. We also adjust the sphere so we control its movement relative to the camera's point of view.
We wrap up 2019 with part 4 of the SRP series, and it is massive! All of our directional lights get cascaded shadow maps in one large atlas, with filtering up to PCF 7x7, cascade blending, semitransparent shadow casters, and more. Enjoy!
Part 3 of the movement series is here! Dive in to make your sphere stick to the ground, navigate stairs, escape from crevasses, and wall jump!
The third Custom SRP tutorial dives into lighting. We limit ourselves to directional lights only, but that's already a lot of ground to cover. It works through topics that got covered by multiple tutorials of the old SRP series, besides using a new approach.
The second Movement tutorial is here! We're diving into the world of physics, handing control of our sphere to PhysX while still pushing it toward a desired velocity.
It's also #ThankYouPatrons day. Hey! Thank you all for making it possible to create these tutorials!
We continue building our custom SRP, this time creating an unlit shader and figuring out how to draw things efficiently. It's covering old ground from the previous SRP series, including a crash-course of writing shaders because some people today have only used the shader graph. But it goes fast and has enough new stuff to keep you on your toes, including the SRP batcher and drawing a thousand meshes at once!
A new series has begun! It's a beginner-level series about character movement. We start simple, by sliding a sphere around on a plane. This involves changing position, velocity, and acceleration. We also make the sphere bounce off edges. This experience prepares us for more complex movement in the future.
Here is the first part of Custom SRP, my new series covering the scriptable render pipeline in Unity 2019 and later.
This first installment is mostly an upgrade from the old experimental API to the current one. But it also introduces a dedicated camera-renderer, segregates code more, uses partial classes, and covers rendering with multiple cameras.
The final part of the Tower Defense series is about animating enemies. We record our own animations and play them by creating a playable graph. Then we also import an existing model and animations from the asset store and make those work as well.
The final installment of the SRP series deals with render scale, MSAA, and HDR to make our images as pretty as possible.
The last installment? Yes. I end the current SRP series here. I will follow it up with a new modern SRP series that will both upgrade everything to Unity 2019 and also introduce new techniques that will make it worthwhile to go through it again. This isn't a simple API upgrade, it's much more! I have a lot in the pipeline but still have to work out how exactly to approach this, because it turns out to be quite modular.
It's getting rather cozy on the board, because we're spawning waves of enemies! Small, medium, big, cubes and spheres, all spawned according to a scenario. Survive all waves and win the game! Unless it's a survival scenario and it goes on until your unavoidable demise.
Unity has multiple post-processing solutions. There's the old OnRenderImage approach, there's the PPV2 stack, and there's the upcoming new stacks specific to the LW/Universal and HD render pipelines. And now we're going to make our own.
Post-processing solutions can be quite complex, but for this series we keep it as simple as possible, to give you an idea of how to set one up yourself. We make a separate stack asset, allow configuration per camera, and create example blur and depth stripes effects.
We expand our game with support for mortar towers. This involves calculating ballistic trajectories so we know how to launch our explosive shells. So there's a bunch of math, safely hidden away in asides for those who are curious.
In this part of the SRP series we're taking a look at LOD groups. We add support for cross-fading LOD levels by clipping with a screen-space blue noise bias. Once that's done we implement shader variant stripping to limit how many shader variants get included in builds, because each feature we add that depends on a multi-compile keyword creates lots more variants.
In other news, Unity is working on that one bug, but they're no longer displaying assigned priories and release schedules in the public issue tracker. So let's see how long it takes.
Our tower defense game gets its titular element! Put towers on the board, have them acquire a target, track it, and apply the heat with a laser beam.
During the process of upgrading the SRP series to Unity 2019 I have encountered a Unity bug that I consider a showstopper. In short, all light indices beyond the fourth per object are broken.
The issue has been reproduced and is in the issue tracker. It currently has a low priority. I'd like to get it fixed before publishing the upgrade. Please vote on the issue to get Unity Technologies to focus on it. Let's see how many votes it can get!
We move on from global illumination to mixed lighting, which means combining realtime lighting with baked shadows. Or the other way around, in case of subtractive lighting.
This tutorial is still for Unity 2018. The upgrade of the SRP series to 2019 is progressing, but not finished yet. It's a lot of work not only due to API changes but also because I'm adding and improving some stuff along the way.
The second tower defense installment is here, and it introduces enemies! Their movement starts simple but we gradually make it more interesting.
This installment of the Scriptable Render Pipeline series covers the big subject of indirect lighting in one go, both static and dynamic, with light maps, probe groups, LPPVs, and emission.
Shadow masks aren't part of this, because they are for direct lighting. I'll cover them later.
We have a new series, and it's about creating a game! Specifically, a tile-based tower defense game. The first installment covers the board, including pathfinding and the placement of destinations and walls.
The tower defense game comes after Object Management. It uses things that we learned from that series, like factories, although we won't spend much time on repeating the same work.
I have added a new goal. Once it's reached, I'll begin adding pages to my website that cover fundamental principles and theories. You can think of them as super asides that deserve their own page. They're not specific to Unity but are about the underlying concepts that we use all the time. Topics will range from what a number actually is to the specifics of BRDFs.
Reaching this goal will make it possible for me to write about stuff that I've wanted to cover for a long time but doesn't fit in any specific tutorial.
We're going to enhance our scriptable render pipeline with reflections! Specular highlights, fresnel, and environment maps. All those were already covered by the Rendering series, but now we're doing it ourselves in our own pipeline.
The final part of the Object Management tutorial has arrived! It adds automatic spawn zones, kill and life zones, centralized level updating, and a little convenient editor functionality.
This time we'll add support for transparency to our pipeline, first alpha clipping and then fading. This tutorial is all about editing shaders, including adding a shader GUI for some convenient functionality.
The next part of my object management series deals with growth and death. It can only really be appreciated in action, not with a still image. Instead of just popping in and out of existence, we'll make shapes smoothly grow and shrink. This requires a few changes to the way we keep track of shapes.
After spotlight shadows, we add support for directional shadows. Mixing directional and spotlight shadows requires a little work. Once that's finished, we move on to cascaded shadow maps. We'll define a main light that uses a separate cascaded shadow map to better use our shadow texels.
This installment of my Object Management series adds a satellite behavior to the game, which makes shapes orbit other shapes. It's more complex than the other behavior, because we have to keep track of a relationship between shapes, which has to be saved and become invalid when a shape gets recycled. Also, when a satellite's focus is gone it becomes free and its behavior can be removed.
I have upgraded the Scriptable Render Pipeline series so it works with Unity 2018.3. There are a few changes.
MyShaderIncludePaths is gone, as that approach is no longer supported. Instead, core library files are included via Packages/com.unity.render-pipelines.core and our own files via a relative include path.
The MyRP folder has been removed. Everything in it has been moved up into My Pipeline.
Updated to core library to version 4.6.0-preview.
The shadow keywords are now declared in const strings.
ConfigureLights and RenderShadows are only invoked if there are any visible lights. When there are no lights, the keywords are disabled, unity_LightIndicesOffsetAndCount is cleared, and PerObjectLightIndices8 is not used. This is needed because otherwise Unity crashes when there are no visible lights.
I also switched the project to use linear light intensity. That's done by setting GraphicsSettings.lightsUseLinearIntensity to true. It's now included in section 2.3 of Lights. To keep the intensity of all lights the same, raise their intensity value to the power of 2.2. You can do that directly in the input field, for example by replacing 7 with 7^2.2.
We're adding support for shadows to our pipeline now! We start with spotlight shadows, which are simplest. That's still plenty for one tutorial, because we have to figure out how to deal with up to sixteen shadowed spotlights, while sticking to single-pass forward rendering for the regular camera. We have to store all the shadow maps somewhere...
The next Object Management tutorial makes our shapes more expressive! We'll create a modular behavior framework that allows shapes to do different things, while still supporting recycling. We limit ourselves to just linear movement, rotation, and oscillation, at least for now. The next tutorial will introduce more complex behavior.
It's time that we enhance our render pipeline by supporting lights! We collect lighting data and send it to the GPU, where we perform simple diffuse lighting for directional, point, and spotlights. We do that using single-pass forward rendering, so at most one draw call per object, no matter how many lights affect them.
This installment of the Object Management series is about working with more than a single factory. It also introduces some complex shapes, so we can identify two types of shapes, each getting their own factory.
Sometimes, I end up creating a tutorial, but then decide that it's actually better to cover a different topic first. This is one of those cases. Dealing with complex shapes and multiple factories first will make the next installment much smoother.
Also, this tutorial is the first to be made available as a Bitbucket repository!
1 / 5