{"version":"https:\/\/jsonfeed.org\/version\/1","title":"Joe Fazzino","home_page_url":"https:\/\/fazz.dev","feed_url":"https:\/\/fazz.dev\/rss\/feed.json","description":"Your blog description","icon":"https:\/\/fazz.dev\/favicon.ico","author":{"name":"Joe Fazzino"},"items":[{"id":"https:\/\/fazz.dev\/articles\/technical-writing-sucks","content_html":"
\"\"
The Fighting Temeraire<\/figcaption><\/figure>\n

I'm not gonna pretend I made this website to "help out other developers". I made it because it looks good to employers to have some sort of site out there and I generally like teaching.<\/p>\n

So this is my attempt to put them off (if my salary expectations weren't doing a good enough job of that already).<\/p>\n

What I have discovered is that technical writing is not teaching, it's not really even writing either. For me technical writing is a process of feeling incredibly anxious that anything I've written is wrong because all of this [gestures around]<\/strong> is pretty hard.<\/p>\n

On a broader level though, does technical writing actually do<\/strong> anything to help make better games?<\/p>\n

I've now worked on two long term games projects (6 months+), three if you include the one I've been working on outside of work. Luckily they've all been pretty well recieved despite the fact that the code and architecture are... lacking.<\/p>\n

This has given me the thought.<\/p>\n

\n

What is the point of programming beyond just being the tool that enables you to make things?<\/p>\n<\/blockquote>\n

Is a good programmer one who gets shit done or is it one who writes good code? Ideally both but this is games, it's never both.<\/p>\n

I don't want people to think I'm ignorant, I am aware that good code\/architecture have benefits. If you're making a GaaS then you can even put a dollar value on how maintainable and extensible your code is. I'm not talking about this though, I'm talking about making good<\/em> games<\/strong>.<\/p>\n

Even if you understand ECS to the level of Richard Fabian or Mike Acton, will it make the game you're working on a better<\/em> game? Understanding technology and it's constraints only helps you appreciate the limitations that you have to work within and the types of experience you can make. It doesn't mean that the actual product is going to be good, I would even go as far as to say there is no correlation<\/strong> between the quality of the code and the quality of the final product.<\/p>\n

\n

How many 4\/10 games and failed start up companies rest on the foundations of a SOLID codebase?<\/p>\n<\/blockquote>\n

I was recently describing my thoughts on programming to a friend (also a programmer) and I offhandedly said what I have felt for maybe a couple of years now.<\/p>\n

\n

I don't really like programming<\/p>\n<\/blockquote>\n

As an activity, programming, does very little for me. I hate getting stuck on bugs and I don't really find it satisfying when I fix them except for the 10ish seconds after it happens. Breaking down tasks into smaller subtasks isn't a special magic thing exclusive to programming, most jobs have this parrallel in one way or another.<\/p>\n

I often describe myself as a "product focused programmer". I want to make things and programming is just the only way I know how to. If I could do it another way (that I enjoyed more) then I would.<\/p>\n

This is now going to be pretentious.<\/p>\n

My thoughts on programming are similar to the way (I have to imagine) a painter thinks about paint. Studying the nuance and the relationships of the subject, figuring out how to use what's in front of you to solve a complex\/abstract problem is absolutely an interesting and compelling part of the job. But I'm not here to paint I'm here to make art.<\/p>","url":"https:\/\/fazz.dev\/articles\/technical-writing-sucks","title":"I don't like technical writing","summary":"and I barely like programming too","date_modified":"2023-09-26T00:00:00.000Z","author":{"name":"Joe Fazzino"}},{"id":"https:\/\/fazz.dev\/articles\/outline-shader-urp-part-two","content_html":"

Hi! Hopefully you've done part one before you get to this point otherwise it's going to be chaos. As this tutorial is based entirely off of the Roystan Outline Shader tutorial and this part will be more about recreating the aspects of what's written there. I'm not going to be going over the technical detail of how<\/em> the outline shader works but I will be using the code and give a brief summary of what it achieves and only go into depth when we need to do something that really diverges from the original tutorial. Capeesh? Okay lets start.<\/p>\n

Adding Shader Properties<\/h2>\n

I'll cover this one at the top as the tutorial asks that this be done quite frequently. It is pretty simple to add properties to our Outline shader that we can configure in the ScriptableRenderFeature. I'll explain the process briefly here because I expect if you can follow these tutorials and understand what you're writing you could quite easily figure it out youself. Feel free to skip if that's you!<\/p>\n

[<\/span>Serializable<\/span><\/span>]<\/span>\npublic<\/span> class<\/span> OutlineSettings<\/span>\n{<\/span>\n    public<\/span> Shader<\/span> OutlineShader;<\/span>\n    public<\/span> Color<\/span> OutlineColor;<\/span>\n    public<\/span> int<\/span><\/span> Scale =<\/span> 1<\/span>;<\/span>\n    ..<\/span>.<\/span>\n\npublic<\/span> class<\/span> OutlineRenderFeature<\/span> :<\/span> ScriptableRendererFeature<\/span><\/span>\n{<\/span>\n    OutlinePass<\/span> m_OutlinePass;<\/span>\n\n    public<\/span> OutlineSettings<\/span> Settings;<\/span>\n\n    Material<\/span> m_Material;<\/span>\n\n    public<\/span> override<\/span> void<\/span><\/span> Create<\/span>(<\/span>)<\/span>\n    {<\/span>\n        if<\/span> (<\/span>Settings.<\/span>OutlineShader !=<\/span> null<\/span>)<\/span>\n            m_Material =<\/span> new<\/span> Material<\/span>(<\/span>Settings.<\/span>OutlineShader)<\/span>;<\/span>\n\n        m_OutlinePass =<\/span> new<\/span> OutlinePass<\/span>(<\/span>m_Material,<\/span>\n            Settings.<\/span>OutlineColor,<\/span>\n            Settings.<\/span>Scale,<\/span>\n            ..<\/span>.<\/span>\n<\/code><\/pre>\n
OutlineRenderFeature.cs<\/p>\n
class<\/span> OutlinePass<\/span> :<\/span> ScriptableRenderPass<\/span><\/span>\n{<\/span>\n    readonly<\/span> float<\/span><\/span> m_Scale,<\/span> m_DepthThreshold,<\/span> m_NormalThreshold,<\/span> m_DepthNormalThreshold,<\/span> m_DepthNormalThresholdScale;<\/span>\n    readonly<\/span> Color<\/span> m_Color;<\/span>\n    RenderTargetIdentifier<\/span> m_CameraColorTarget;<\/span>\n    Material<\/span> m_Material;<\/span>\n    static<\/span> int<\/span><\/span> colorID =<\/span> Shader.<\/span>PropertyToID<\/span>(<\/span>"_OutlineColor"<\/span>)<\/span>;<\/span>\n    static<\/span> int<\/span><\/span> scaleID =<\/span> Shader.<\/span>PropertyToID<\/span>(<\/span>"_Scale"<\/span>)<\/span>;<\/span>\n    ..<\/span>.<\/span>\n\n    public<\/span> OutlinePass<\/span>(<\/span>Material<\/span> material,<\/span> Color<\/span> color,<\/span> float<\/span><\/span> scale,<\/span> ..<\/span>.<\/span>)<\/span>\n    {<\/span>\n        m_Material =<\/span> material;<\/span>\n        m_Color =<\/span> color;<\/span>\n        m_Scale =<\/span> scale;<\/span>\n        ..<\/span>.<\/span>\n\n    public<\/span> override<\/span> void<\/span><\/span> Execute<\/span>(<\/span>ScriptableRenderContext<\/span> context,<\/span> ref<\/span> RenderingData<\/span> renderingData)<\/span>\n    {<\/span>\n        var<\/span><\/span> camera =<\/span> renderingData.<\/span>cameraData.<\/span>camera;<\/span>\n        if<\/span> (<\/span>camera.<\/span>cameraType !=<\/span> CameraType.<\/span>Game)<\/span>\n            return<\/span>;<\/span>\n\n        if<\/span> (<\/span>m_Material ==<\/span> null<\/span>)<\/span>\n            return<\/span>;<\/span>\n\n        CommandBuffer<\/span> cb =<\/span> CommandBufferPool.<\/span>Get<\/span>(<\/span>name<\/span>:<\/span> "OutlinePass"<\/span>)<\/span>;<\/span>\n        cb.<\/span>BeginSample<\/span>(<\/span>"Outline Pass"<\/span>)<\/span>;<\/span>\n\n        m_Material.<\/span>SetColor<\/span>(<\/span>colorID,<\/span> m_Color)<\/span>;<\/span>\n        m_Material.<\/span>SetFloat<\/span>(<\/span>scaleID,<\/span> m_Scale)<\/span>;<\/span>\n        ..<\/span>.<\/span>  \n<\/code><\/pre>\n
Sampling Camera Opaque\/Depth<\/h2>\n
We can get the Opaque and Depth textures from the camera by accessing the properties that are built in to the shader. These can be accessed because the shader is called late in the rendering pipeline when these textures already exist.<\/p>\n
TEXTURE2D<\/span>(<\/span>_CameraOpaqueTexture)<\/span>;<\/span>\nTEXTURE2D<\/span>(<\/span>_CameraDepthTexture)<\/span>;<\/span>\n\nSAMPLER<\/span>(<\/span>sampler_CameraOpaqueTexture)<\/span>;<\/span>\nSAMPLER<\/span>(<\/span>sampler_CameraDepthTexture)<\/span>;<\/span>\n\nfloat4<\/span> _CameraOpaqueTexture_TexelSize;<\/span>\n<\/code><\/pre>\n
The texel size is important for following the guide on generating the UVs for the edge detection to work.<\/p>\n
View Normals<\/h2>\n
This was probably the trickiest part of making this tutorial work with URP. I didn't want to do what the original author did in the tutorial which is just give a magic file that solves it for you.<\/p>\n
In the SRP there is a nice easy way to grab the DepthNormals texture for a camera.<\/p>\n
Alpha Blend<\/h2>\n
Alpha blend isn't a thing in our shader but we can achieve the same effect that the author has in their tutorial by calling the HLSL clip<\/code> command to tell shader to not render the fragments that don't have any outline. This means that we will 'see though' our shader to the cameras opaque texture achiving the same sort of effect that is in the original tutorial.<\/p>\n
Clip either does or doesn't draw a pixel, if you wanted to do an actual alpha blend it wouldn't be too hard just instead of clip you make sure that you render the fragments that have an outline with an alpha value of 1 and then every other fragment with a lower value. Not sure if this would actually look any good but have a go if you like!<\/p>\n
Plan<\/h2>\n