Ferhat Tanman

Sr. Technical Artist

Portfolio About Me Contact Resume

Featured

Pseudo 3D Road Shader

A shader-based imitation of an old game-dev trick we mostly used back in the 8-bit era.

#GLSL #Shader #Breakdown

Cartoon Sky Shader with Atmospheric Scattering

It's a cartoon sky shader with an atmospheric scattering feature that I made in Unity with Shader Graph.

#Shader #Unity #HLSL Source

Web Avatar Project

This is a breakdown of my website project for those curious about the process.

#Three.js #GLSL #Breakdown

Toon Rocket

A shader-based cartoon smoke-and-fire VFX that I made in Blender.

#Shader #VFX #Breakdown

Procedural Eye Generator

It's a shader-based procedural eye generator with a Python configurator panel.

#Shader #Python #Breakdown

Mourning Sea Dog

A cinematic character that I created in my spare time to improve myself in painting realistic skin. No skin textures or scandata used.

#Realism #Cinematic #Hand-Painted

Overview

Pseudo 3D is a great trick that was mostly used in racing games back in the day. I made some pre-study to implement an interactive one to be used in Unity. After making some progress in code, I decided to implement it in Blender. As you can see in the video below, everything on the Arcade's screen is procedural. Also the steering wheel controls the ball on the screen. All the shapes on the screen like the road, the curbs and the mountains can be manipulated in real time.

The node setup of the Blender version and the code for the GLSL version are shared below.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

What does the trick...

In short, we can say that we are CURLING the UV space along the y axis and fractionally scaling the y component to zero, to create a UV space that looks like its y component goes to infinity towards the depth.

Now we have a fake depth driven by the y component of the UV and it does the trick :)

glsl

...
              
//Normalizing the coordinates.
vec2 uv = (fragCoord-0.5*iResolution.xy)/iResolution.y;

//Uv space transformation.
uv = vec2(uv.x/uv.y, 1.0/uv.y);

...

You can control the curve of the road by click & drag on the shader window. In the textured version, I left the stripes intentionally, even though we don't need them in this version because in the end, I wanted a master material to suit every need by changing a few values in Blender.

The node setup for Blender is at the bottom of the page.

glsl

// An imitation of Pseudo 3D Road trick by F3R0 @2020
// Solid color version.

#define TIMESCALE 5.0
#define GRASSCOLOR1 vec3(0.4,0.8,0.2)
#define GRASSCOLOR2 vec3(0.2,0.6,0.0)
#define ROADCOLOR1 vec3(0.5,0.5,0.5)
#define ROADCOLOR2 vec3(0.35,0.35,0.35)
#define CURBSCOLOR1 vec3(1.0,1.0,1.0)
#define CURBSCOLOR2 vec3(0.75,0.0,0.0)
#define LINESCOLOR vec3(0.85,0.85,0.85)
#define PIXELRES 128.0
#define LINEWIDTH 0.03
#define LINEFREQ 0.66

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
    //UV Coordinates
    vec2 uv = (fragCoord-0.5*iResolution.xy)/iResolution.y;
    
    //Uncomment to pixelate.
    uv = floor(uv*PIXELRES)/PIXELRES;
    
    //Prepare the curve
    float curveAmount = (0.5-iMouse.x/iResolution.x)*4.0;
    float roadCurve = pow((uv.y+1.0),8.0);
    float roadOffset = (0.5-iMouse.x/iResolution.x)*4.0;

    //curve the UV
    uv = vec2(uv.x+roadCurve*curveAmount,uv.y);
    
    //Pseudo 3D Coordinates
    vec2 uvp = vec2(uv.x/uv.y, 1.0/uv.y-iTime*TIMESCALE);

    //Horizontal Stripes
    float stripes = clamp(round(fract(uvp.y)),0.0,1.0);
    float lines = clamp(round(fract(uvp.y*LINEFREQ))*round(1.0-abs(uvp.x)-0.5+LINEWIDTH),0.0,1.0);
    
    //Stripes Colors
    vec3 grassStripes = mix(GRASSCOLOR1, GRASSCOLOR2, stripes);
    vec3 roadStripes = mix(ROADCOLOR1, ROADCOLOR2, stripes);
    vec3 curbStripes = mix(CURBSCOLOR1, CURBSCOLOR2, stripes);
    
    //Road & Curbs width   
    float roadWidth = 1.3;
    float curbsWidth = roadWidth + 0.3;
    float linesWidth = 0.1;
    
    //Road Shapes
    float roadShape = clamp(ceil(abs(uvp.x) - roadWidth),0.0,1.0);
    float grassShape = clamp(ceil(abs(uvp.x) - curbsWidth),0.0,1.0);
    
    //Render ground elements
    vec3 roadColor = mix(roadStripes, curbStripes, roadShape);
    vec3 roadLines = mix(roadColor, LINESCOLOR, lines);
    vec3 groundColor = mix(roadLines, grassStripes, grassShape);
   
    //Split sky & ground elements
    if(uv.y < -0.09) 
    {
        fragColor = vec4(groundColor,1);
    }
    else
    {
        uv = round(uv*16.0)/16.0;
        vec3 skyCol = mix(vec3(0.5,0.7, 0.7), vec3(0.0,0.4,0.8), uv.y*3.0);
        fragColor = vec4(skyCol,1.0);
    }
}

Node Setup

#GLSL #Shader #Breakdown

Overview

It's a cartoon style skybox shader that I made by using Unity's Shader Graph in Universal Render Pipeline. You can see a quick demonstration of the shader in this video.

The main purpose was to make the sky colors blend in a specific way that creates the scattering effect. Atmospheric scattering is a difficult task and the equations that describe it are very complex. I was in need of a well-optimized solution to make it usable on mobile devices. So I decided to imitate the effect. The result may not be physically accurate but it looks good for a stylized sky.

The code that I wrote in GLSL as a pre-study to imitate the atmospheric scattering effect is shared below.

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

GLSL code:

glsl

//Atmospheric Scattering effect by F3R0 @2021
    
    const vec3 skyColor = vec3(0.2,0.3,0.5);
    const vec3 sunColor = vec3(0.75,0.3,0.05);
    
    void mainImage( out vec4 fragColor, in vec2 fragCoord )
    {
    
      vec2 uv = (fragCoord.xy-0.5*iResolution.xy) / iResolution.y;
        
        uv = vec2(uv.x, uv.y+0.5);
        
        vec2 sunPos = vec2(0.0,(0.8+sin(iTime))/2.5);
    
        float sun = 1.0-clamp(pow(1.0/length(uv - sunPos) * 0.12, 3.0),0.0,1.0);
        
        float sky = clamp(max(1.0 - (sunPos.y/2.0 + sunPos.y) * sun,0.0),0.0,1.0);
        
        sky += pow(1.0-uv.y,12.0)/5.0;
        
        //Uncomment to remove the blue horizon line.
        //sky = clamp(sky,0.0,1.0);
        
        fragColor = vec4(mix(skyColor*2., sunColor , sky),1.0);
        
        fragColor *= ((1.-uv.y) + pow(sky,8.) * sunPos.y * 20.);
        
    }

Here you can see how it works on Shader Toy website.

#Shader #Unity #HLSL Source

Story

My avatar project is something I simply cannot go without mentioning. I learned so much while implementing it on web. And it was a whole different experience for me.

Frankly, I hate web development. Frontend, backend and whatever other end it has, I hate them all. After all those years staying away from everything about web development, all those hatred smoothly started fading away at the time I saw the examples of Three.js.

One day, I was talking to a friend who is a software engineer about my portfolio. He came with an offer to help building a portfolio website by using three.js. It would be a madness to reject that kind of professional help and here we are :)

Below, I shared a breakdown of the process and some of the shaders that I created for the website.

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

Design & Optimization

I started by sculpting a stylized version of myself in Zbrush. I played with clay for hours till I remembered why I wanted to be in the technical side of the computer graphics :) The retopology phase is the one I have to use my special skills as an old timer. After a quick research, I decided to keep the polycount under 5000.

Web Integration

I thought the painful part would be the integration process. However, I didn't had any problem with rendering the character on web. Thanks to react-3-fiber and GLTF format, everything worked like a charm. At least for start.

With my limited javascript knowledge, trying to make animations by coding was like hell. In addition, I never made a website before. I just knew about things like responsiveness, mobile first as a concept of the web but, I never imagined that I had to implement these stuff by myself.Fortunately, and with some help, I could finish the painful tasks and start coding GLSL :)

Shaders!

I wanted to create 4 different shaders representing or at least somewhat relevant with the sections of my portfolio. Of course, I had to consider mobile device performances, so the shaders should be lightweight as possible.

For these shaders, I only used a pregenerated perlin noise texture. Both the texture and the shaders are available in my GLSL-Shaders repository .
The noise for the radar and the fog is created by using a fractal brownian motion implementation. I'll make a little breakdown about it later.

An in-game looking radar screen for SHADERS & VFX section.

A wireframe with a syntwave vibe for 3D MODELING & ART section.

A fractal fog for the MISC.TECH-ART section.

The End

In the end, the avatar looks cool. And it was a significant educational experience for me. Lastly, I want to show you the three generations of my avatars. My 3D avatar, my pixel art avatar and my IRL avatar. :)

#Three.js #GLSL #Breakdown

Overview

My main focus was achieving an anime style toon feeling. Therefore, I used a cartoonish palette, ramped colors and maybe the most common effect amongst all cartoons:

Speedlines.

Stretching a noise in one direction is enough to create an anisotropic pattern. Afterwards, subtracting some value from it creates the separated lines. A mixture of these two layers nearly makes the job done.

In Blender, I used the procedural noises without hesitation, because this was only a proof of concept at the time. If I had to make this effect in a game engine, I definitely would use pregenerated noise textures for the same algorithm. Because in most cases, sampling a texture is much cheaper than calculating a noise.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

Scene setup

I used some icospheres for the fire/smoke trail which are in a parent/child hierarchy with different amounts of influence to have a stretching effect when I rotate or move the rocket around.

The fire and smoke trails are produced by the same shader with different color values. And lastly, I used a voronoi noise to produce star-shaped particles.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

Node Setup

The shader nodes below show the trails and particles node setups. This approach can also be used in a game engine just by doing some minimal optimizations like replacing procedural noises with pregenerated noise textures.

#Shader #VFX #Breakdown

Overview

It's a shader-based procedural eye generator with a Python configurator panel. The shader is based on pregenerated perlin & voronoi textures. I didn't use any procedural nodes or anything that is Blender-exclusive. So the shader is easy to recreate in any game engine or in any shader language. It's also well optimized. No color ramps or other nodes with high instruction counts are used.

You can see the features in the video below. Also, I shared the node setup of the shader part of this generator.

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

Node Setup

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

#Shader #Python #Breakdown

I made this piece in my spare time to improve my modeling and rendering. Mostly inspired by characters of the Black Sails series. My starting point was something between Edward Teach (Blackbeard) and Captain Flint.

My main focus was achieving realism by hand-painting the skin. After I sculpted the base mesh in Zbrush, I detailed it by sculpting the low and medium frequency skin bumps. Skin details with higher frequencies were painted as normals in Substance Painter. No textures or scandata used in the progress. Particle hair, lighting, procedural eye material and rendering done in Blender. (cycles)

Creating a Cinematic look...

When it comes to creating a cinematic look, almost everytime the first thing I need is a backstory. So, in this case I decided to create one about a captain who lost his crew, his SOUL and everything else but the cursed treasure he worked so hard to gain. The curse turned him into a creature of the night. A Vampire.That's why this Sea Dog is Mourning... Endlessly...

Behind the scenes

In the cinematic scene, the ship parts, sails and all the backdrops are used to create a feeling like the captain is on the deck of his ship and there is a lantern weakly illuminates his face.

Let's talk about the truth...

There is neither a lantern, nor the ship. There is also no moon. Not even the bottom half of the Captain's body.

All we have is a story and a bunch of lies around it. But... This is the only thing we need to create a believable cinematic scene. And that's ok :)

Progress

These are some turntables rendered in Blender (Cycles) to see the progression of the model.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

Creating own tools...

Creating some reusable tools & assets is crucial in CG. And this one is a great example about it. Here you can see my procedural eye material in action. You can find some details about it in Tools & Solutions category. And the other one is a screenshot from Blender's viewport.

#Realism #Cinematic #Hand-Painted

Toon Rocket

A shader-based cartoon smoke-and-fire VFX that I made in Blender.

#Shader #VFX #Breakdown

Pseudo 3D Road Shader

A shader-based imitation of an old game-dev trick we mostly used back in the 8-bit era.

#GLSL #Shader #Breakdown

Anisotropy Shader for Eevee

I created this shader to compensate the lack of anisotropy feature in Blender's realtime renderer Eevee.

#Shader #Eevee #Breakdown

Procedural Eye Generator

It's a shader-based procedural eye generator with a Python configurator panel.

#Shader #Python #Breakdown

CRT Shader with Shadowmask

This is a shader I made for a VR arcade emulator project in Unreal Engine 4.

#Shader #Unreal Engine #Breakdown

Cartoon Sky Shader with Atmospheric Scattering

It's a cartoon sky shader with an atmospheric scattering feature that I made in Unity with Shader Graph.

#Shader #Unity #HLSL Source

Alternate Fog/Smoke Method

This is a breakdown of an alternate method I use to create volumetric effects like fog and smoke in Blender.

#Shader VFX #Breakdown

Sniper Scope Shader

It's a procedural sniper scope shader that I made in Unity. Written in CG by using Unity Shaderlab.

#Unity #CG #ShaderLab

Interactive Dissolve Shader

This is a dissolve shader that works with multiple effector objects which create an effect that blends in an adjustable distance.

#Shader #VFX #Blender

Stylized Fire Shader

It's a stylized fire shader that I made to use as a rocket engine fire for a game project.

#Shader #VFX #Toon

Interactive Water Shader

This is a dynamic water shader that interacts with some predefined meshes.

#Shader #VFX #Breakdown

Misc. GLSL Shaders

Other GLSL shaders I wrote for various projects or experiments.

#GLSL #Shader #Source

Overview

My main focus was achieving an anime style toon feeling. Therefore, I used a cartoonish palette, ramped colors and maybe the most common effect amongst all cartoons:

Speedlines.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

Scene setup

I used some icospheres for the fire/smoke trail which are in a parent/child hierarchy with different amounts of influence to have a stretching effect when I rotate or move the rocket around.

The fire and smoke trails are produced by the same shader with different color values. And lastly, I used a voronoi noise to produce star-shaped particles.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

Node Setup

#Shader #VFX #Breakdown

Overview

The node setup of the Blender version and the code for the GLSL version are shared below.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

What does the trick...

glsl

...
              
//Normalizing the coordinates.
vec2 uv = (fragCoord-0.5*iResolution.xy)/iResolution.y;

//Uv space transformation.
uv = vec2(uv.x/uv.y, 1.0/uv.y);

...

The node setup for Blender is at the bottom of the page.

glsl

// An imitation of Pseudo 3D Road trick by F3R0 @2020
// Solid color version.

#define TIMESCALE 5.0
#define GRASSCOLOR1 vec3(0.4,0.8,0.2)
#define GRASSCOLOR2 vec3(0.2,0.6,0.0)
#define ROADCOLOR1 vec3(0.5,0.5,0.5)
#define ROADCOLOR2 vec3(0.35,0.35,0.35)
#define CURBSCOLOR1 vec3(1.0,1.0,1.0)
#define CURBSCOLOR2 vec3(0.75,0.0,0.0)
#define LINESCOLOR vec3(0.85,0.85,0.85)
#define PIXELRES 128.0
#define LINEWIDTH 0.03
#define LINEFREQ 0.66

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
    //UV Coordinates
    vec2 uv = (fragCoord-0.5*iResolution.xy)/iResolution.y;
    
    //Uncomment to pixelate.
    uv = floor(uv*PIXELRES)/PIXELRES;
    
    //Prepare the curve
    float curveAmount = (0.5-iMouse.x/iResolution.x)*4.0;
    float roadCurve = pow((uv.y+1.0),8.0);
    float roadOffset = (0.5-iMouse.x/iResolution.x)*4.0;

    //curve the UV
    uv = vec2(uv.x+roadCurve*curveAmount,uv.y);
    
    //Pseudo 3D Coordinates
    vec2 uvp = vec2(uv.x/uv.y, 1.0/uv.y-iTime*TIMESCALE);

    //Horizontal Stripes
    float stripes = clamp(round(fract(uvp.y)),0.0,1.0);
    float lines = clamp(round(fract(uvp.y*LINEFREQ))*round(1.0-abs(uvp.x)-0.5+LINEWIDTH),0.0,1.0);
    
    //Stripes Colors
    vec3 grassStripes = mix(GRASSCOLOR1, GRASSCOLOR2, stripes);
    vec3 roadStripes = mix(ROADCOLOR1, ROADCOLOR2, stripes);
    vec3 curbStripes = mix(CURBSCOLOR1, CURBSCOLOR2, stripes);
    
    //Road & Curbs width   
    float roadWidth = 1.3;
    float curbsWidth = roadWidth + 0.3;
    float linesWidth = 0.1;
    
    //Road Shapes
    float roadShape = clamp(ceil(abs(uvp.x) - roadWidth),0.0,1.0);
    float grassShape = clamp(ceil(abs(uvp.x) - curbsWidth),0.0,1.0);
    
    //Render ground elements
    vec3 roadColor = mix(roadStripes, curbStripes, roadShape);
    vec3 roadLines = mix(roadColor, LINESCOLOR, lines);
    vec3 groundColor = mix(roadLines, grassStripes, grassShape);
   
    //Split sky & ground elements
    if(uv.y < -0.09) 
    {
        fragColor = vec4(groundColor,1);
    }
    else
    {
        uv = round(uv*16.0)/16.0;
        vec3 skyCol = mix(vec3(0.5,0.7, 0.7), vec3(0.0,0.4,0.8), uv.y*3.0);
        fragColor = vec4(skyCol,1.0);
    }
}

Node Setup

#GLSL #Shader #Breakdown

Overview

In the real world, anisotropic reflections are the result of the refraction differences on a surface material. These differences depend on the light direction and polarization. We often see this kind of reflection on the surfaces with microscopic imperfections. For example, there are small pits and bumps on the surface of the optical discs, that serve to create a binary sequence depending on whether it reflects the laser beam or not.

Here, I explained my approach to create similar reflections and color variations on a surface.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

Breakdown

I created a radial gradient to manipulate the vector coordinates of the noise to generate a radial pattern. Also, it is useful for controlling the burned area of the CD. The image below on the right shows the pattern which is created after I connected the radial gradient to the vector input of the noise node.

I used the Fresnel node to create a fake reflection which depends on the camera position. Manipulating its IOR(index of refraction) value with the noise pattern gives a result closer to an anisotropic reflection. Lastly, to create the color variations, I used the color output of another noise.

This is the final node setup. It's a simple approach to have a realistic anisotropic feeling. It's improvable and adaptable for use in other renderers.

#Shader #Eevee #Breakdown

Overview

You can see the features in the video below. Also, I shared the node setup of the shader part of this generator.

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

Node Setup

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

#Shader #Python #Breakdown

Overview

The main purpose was to recreate the famous shadowmask RGB patterns of old CRT monitors. Normally, it can't be seen with a naked eye but, in a VR game it would be great to see the RGB shadowmask when you bump your head into the screen. In this case I used some pregenerated scanline & rgb pattern textures to optimize the performance and to keep the shader instructions count low.

The node setup and some of the GLSL code that I made to create a shadowmask is shared below.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

GLSL Shadowmask & Scanlines

Here is an experimental shader that I made on Shadertoy. It only works right on 16:9 aspect ratio at the moment. You can go to the shadertoy website to see the source.

Of course, it can't feel like a real arcade monitor without some glitches and vertical alignment issues. :)

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

Node Setup

#Shader #Unreal Engine #Breakdown

Overview

It's a cartoon style skybox shader that I made by using Unity's Shader Graph in Universal Render Pipeline. You can see a quick demonstration of the shader in this video.

The code that I wrote in GLSL as a pre-study to imitate the atmospheric scattering effect is shared below.

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

GLSL code:

glsl

//Atmospheric Scattering effect by F3R0 @2021
    
    const vec3 skyColor = vec3(0.2,0.3,0.5);
    const vec3 sunColor = vec3(0.75,0.3,0.05);
    
    void mainImage( out vec4 fragColor, in vec2 fragCoord )
    {
    
      vec2 uv = (fragCoord.xy-0.5*iResolution.xy) / iResolution.y;
        
        uv = vec2(uv.x, uv.y+0.5);
        
        vec2 sunPos = vec2(0.0,(0.8+sin(iTime))/2.5);
    
        float sun = 1.0-clamp(pow(1.0/length(uv - sunPos) * 0.12, 3.0),0.0,1.0);
        
        float sky = clamp(max(1.0 - (sunPos.y/2.0 + sunPos.y) * sun,0.0),0.0,1.0);
        
        sky += pow(1.0-uv.y,12.0)/5.0;
        
        //Uncomment to remove the blue horizon line.
        //sky = clamp(sky,0.0,1.0);
        
        fragColor = vec4(mix(skyColor*2., sunColor , sky),1.0);
        
        fragColor *= ((1.-uv.y) + pow(sky,8.) * sunPos.y * 20.);
        
    }

Here you can see how it works on Shader Toy website.

#Shader #Unity #HLSL Source

Overview

In Blender, meshes can be used to create volumetric shapes by removing its surface shader and using a volume shader like the Principled Volume Shader. As you can see in the video below, the cube shape is only there to define the bounds of the volume and the value provided in the shader defines the density. With a little bit math, we can create any shape we want and render it as a volume. It's explained in the details below.

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

How it works?

If we provide a sphere mask as a Vector3 in the shader, the volume output gives us the shape of a 3D sphere. It also works with any other complex shapes we can calculate in the shader. This means it can be manipulated easily.

In this example I used a signed distance field(SDF) function that I learnt from Inigo Quilez's article.

glsl

float sdTorus( vec3 p, vec2 t )
{
  vec2 q = vec2(length(p.xz)-t.x,p.y);
  return length(q)-t.y;
}

Note that there is a little difference between the code and the node setup. Since we were using the values as density, not as distances. We had to invert the result by subtracting the value from 1.0

Because the shape is a result of a calculated value in the shader, it's easy to transform or manipulate it by using other calculated values like noises.

In the example below, you can see how I used a noise to deform the torus shape and smoothly blended 2 toruses by using a smooth maximum node.

Conclusion

Pros: This method is much faster, easy to adjust and also cheaper than particles in many cases. Cons: The preview in real time doesn't look perfect. Since it's not a surface, it's hard to make it effected by the lights.

As a guy who likes game art tricks, I prefer this method over anything else. I mean look at this. It took 5 minutes for me to make this. :)

#Shader VFX #Breakdown

Overview

This is a procedural sniper scope shader to use in FPS games. Written in CG in Unity's ShaderLab. I made this as a part of an FPS game project. You can see most of it's features in this demonstration video.

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

Features

It's a very common issue with FPS weapons clipping into the walls. To avoid this, in some cases the weapons can be rendered in front of everything else like a canvas. In another case, the weapons can be placed in the same Z position with the camera an then scaled down till it stays inside the character collider.

My focus was to create a shader that will suit both of this cases.

The scope body may be a mesh or can be replaced with a scope sprite to use in ortographic mode. In both cases the lens reflections / specular values can be adjustable to match the rest of the scene

- Customizable lens shape, opacity and color.

- Customizable crosshair shape, position, opacity and color.

- The reflection amount on the lens is adjustable.

- Adjustable glass dispersion.

- Both usable with a scope mesh or a scope sprite.

Sprite version.

#Unity #CG #ShaderLab

Overview

This is a dissolve shader that works with multiple effector objects which create an effect that blends in an adjustable distance. The dissolved area is determined by two empty objects. Location and scale transforms of these two objects affect the radius of the dissolving area.

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

I used drivers to expose the effector object's transform to the shader as parameters. The distance value of the smooth minimum function determines the amount of blending between two effector objects.

While the effects can be blended, it's also possible to create some specific shapes / patterns as dissolving area on the surface of the mesh.

#Shader #VFX #Blender

Overview

It's a pre-study version of a stylized fire shader that I made to use in a game project as a rocket engine fire. I made this version as a pre-study to create the desired visual style.

After I was satisfied with the result, I was going to write this in HLSL to use in Unity. Therefore, I had to make some effort to keep it optimized. I only used one pregenerated perlin texture to generate this effect. The rest of the algorithm is only math.

Features

- Lightweight, usable in mobile devices.

- Adjustable color, shape and density.

- Adjustable top-bottom fade.

- Can be curved by an effector object.

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

Some fire presets

#Shader #VFX #Toon

Overview

This is a dynamic water shader that interacts with some predefined meshes. I made this to be used in a demonstration video. The concrete blocks interact with the water surface, generating a pool around themselves and blocking the waves. Also the dirt spread around depending on the concrete block's vertical position in the water. A short breakdown of the shader is shared below.

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

Node Setup

Most of the work is done by using shader nodes but I also used some python expressions to prevent the pool effect to remain visible when the block is out of the water.

The image on the left shows how the dirt looks as a mask. And the right one shows the stretching effect of the pool on the waves.

#Shader #VFX #Breakdown

Pseudo 3D First Person Camera

Here are some of the shaders I shared on various platforms like ShaderToy, CodeSandbox or GitHub.

Split-screen pixelate shader with mouse control. X axis controls the horizontal split and Y axis controls the pixel size. Source
Experimental pseudo 3D first person camera movement effect. Source
Liquid Tunnel Source

The shaders I wrote in GLSL for my website project. Can be previewed with the ShaderToy extension for VsCode.
Sources are available in my GLSL-Shaders repository

#GLSL #Shader #Source

Lookup Baker Tool in Unity

Unity tool for baking patterns, noises or lookup textures from math functions or shader files.

#Tool #Unity #C-Sharp

Light Linking solution for Blender

This is a shader based solution to compensate the lack of light linking feature in Blender.

#Shader #Python #Blender

Comic Style Rendering

This was an experimental rendering solution I worked on for quickly generating comic style scenes in Blender to use in a game project.

Shader Toon Solution

Ray Marching implementation.

This is a ray marching algorithm implemented in Blender to make a pseudo liquid simulation effect.

Shader GLSL Blender

CopyPose to RestPose

This is a simple script I wrote to change an armature's rest pose by copying another armature's pose over it.

#Python #Rigging Artist Tools

Web Avatar Project

This is a breakdown of my website project for those curious about the process.

#Three.js #GLSL #Breakdown

Fruit Peeling Game Mechanic

This is a proof of concept aimed to demonstrate how a shader-based fruit peeling game mechanic can be implemented.

#Unity #ShaderGraph #Toon

Pixel Dungeon 3D

This is a proof of concept aimed to demonstrate how a 2D/3D hybrid game scene could be created by using 2D pixel art assets

#PixelArt #Voxel #Solution

Asset Validation addon

Some other python scripts I wrote to automate various works in Blender.

#Python #Rigging Artist Tools

Lookup Baker Tool

In most cases, sampling a texture is much faster than procedurally calculating some patterns, lookup textures or noises. Thus, I decided to create a tool to quickly create and bake these kinds of visuals into a texture file. The tool allows you to enter some math functions as an input or select a custom shader file to visualize its result on the inspector GUI and bake it into a PNG texture file.

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

I want to elaborate on the baking part. Here is the code:

csharp

public void Bake(string name, int width, int height, Material mat)
{
    if (string.IsNullOrEmpty(name))
    {
        Debug.LogError("Enter a filename!");
        return;
    }
    rt = new RenderTexture(width, height, 0);
    Graphics.Blit(mat.mainTexture, rt, mat); //add -1 as a parameter to bake multiple passe

    texture = new Texture2D(rt.width, rt.height, TextureFormat.RGB24, false);
    texture.ReadPixels(new Rect(0, 0, rt.width, rt.height), 0, 0)

    byte[] bytes = texture.EncodeToPNG()

    string texturePath = $"Assets/Baked/{name}.png";
    File.WriteAllBytes(texturePath, bytes);
    AssetDatabase.ImportAsset(texturePath)
    
    // Dispose all allocated objects
    RenderTexture.active = null;
    DestroyImmediate(texture);
    DestroyImmediate(rt);
}}

First I created a new RenderTexture and used Graphics.Blit() to copy my shader result (material's maintexture) into the destination RenderTexture. Since Graphics.Blit() already sets its destination argument as the active render target, there is no need to set RenderTexture.active or calling Graphics.SetRenderTarget in this case.

After creating a new Texture2D, I used ReadPixels() to read the current active render target and write them to the texture. This method copies a rectangular pixel area from the active render target and writes it to the texture starting by the given position which is 0,0 (lower left) in this case.

EncodeToPNG() method returns a byte array and this is our PNG file here. File.WriteAllBytes() writes these bytes into a given file path. Lastly, after importing the created texture file as an asset, I manually removed the created object from the memory. Since delayed destruction will never be invoked in edit mode, I used DestroyImmediate() instead of Destroy().

The rest of the tool is about writing lots of editor script. :)

Here is some example screenshots:

#Tool #Unity #C-Sharp

Just another point light

Since there is no linking option for the lights in Blender, I created this shader based solution to compensate the lack of this feature. The empty object works like a point light. It has attenuation feature and produces specular highlights. Also works with PBR textures. The only difference is, there is no reflection of the light itself. Nevertheless, a reflection can be granted by using this fake light as a child of an emissive object or as an adjustment to a real light.

I made it by using the equations described in the Point Lights section of learnopengl.com. Here is the link.

glsl

//lightingShader.setFloat("light.constant",  1.0f);
//lightingShader.setFloat("light.linear",    0.09f);
//lightingShader.setFloat("light.quadratic", 0.032f);	
float distance    = length(light.position - FragPos);
float attenuation = 1.0 / (light.constant + light.linear * distance + 
                    light.quadratic * (distance * distance));

It almost matches with Blender's own point light. At least, it's good enough for the common use cases of light linking. Since there is no such filter in real life, we generally use this technique to make some fine tuning on a light setup or in some cases, to create an unnatural but attractive lighting.

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

#Shader #Python #Blender

This was an experimental rendering solution I worked on for a gaming project. I made some experiments with a custom light shader and a few different toon shading methods.The outlines are just a few quick lines with grease pencil. I used a displacement and edge split modifiers together to create cut and deformed lines. This video was one of the results rendered in Blender as a proof of concept.

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

Custom Light

There are two custom lights in this version which lighten only one side of the meshes. One of the lights was linked with the objects in front of the desk and the other one with the shelves at the background.

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

Alternate styles

I created a brush texture and used it as a diffuse map on each mesh in the scene to capture a hand-painted feel.

Here are some of the alternate styles I created.

Shader Toon Solution

Ray Marching

This is a ray marching algorithm made in Blender's shader editor. I made this to demonstrate a controllable flow in real time. It's an experimental thing.

SDF Functions are based on Inigo Quilez's articles. and Ray Marching code is based on the tutorials of The_ArtOfCode.

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

Node Setup

Other ray marching based works...

We made a little game with a friend by using a ray marching algorithm to participate in Love2d Jam. You can see the game on its itch.io page.

Shader GLSL Blender

Overview

This is a helper script that automates the process of changing the rest pose of an armature by copying the pose of a target armature over it. I wrote this to solve some retargeting and mesh transfer issues.

It can be used by installing as an addon and calling the operator function via the search bar or the console. The only requirement is the bone names to match in both armatures. Bone counts, hierarchy or scalings can be different.

In case I update/improve the script, here is the GitHub Link.

#Python #Rigging Artist Tools

Story

My avatar project is something I simply cannot go without mentioning. I learned so much while implementing it on web. And it was a whole different experience for me.

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

Design & Optimization

Web Integration

Shaders!

The End

#Three.js #GLSL #Breakdown

Overview

A client consulted me about implementing a shader-based fruit peeling game mechanic. As a solution I created a very simple but effective dissolve shader that can be used as the fruit peel as long as they want. I used the dynamic paint in Blender to paint a mask for the peel on the fruit mesh. And I created this interactive peeling effect in the video below to demonstrate how they should implement the shader.

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

Multiline dissolve...

As you can see in this video, the shader uses a full texture area to dissolve one line at a time and jumps to the next line seamlessly right after finishing the last line. Just by changing the snap value, it is possible to use the texture area in different fractions.

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

#Unity #ShaderGraph #Toon

Overview

This is a proof of concept aimed to demonstrate how a 2D/3D hybrid game scene could be created by using 2D pixel art assets. There are 4 different wall textures, a door sprite, a torch sprite, a vine sprite and 4 frames of fire. The rocks are simply generated in Blender by using voxel and displace modifiers. To create color variations, a simple shader generates the colors based on the height of the rocks. For further information, see the details on the images below.

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

Breakdown

#PixelArt #Voxel #Solution

Overview

This is some simple addon to automate some painful tasks in game-ready workflow. It's also good for dictating a proper naming convention to the teammates :)

The addon itself still needs a lot of features and polish to call it a tool and share with the community, but I wanted to talk about a method I use to keep things modular as possible while developing an addon for Blender.

First, let's take a look at the current and work in progress features to make it clear why I need modularity.

Features:

- Object Categorizer: Searches the objects for a user-defined suffix, if it finds, places them to the corresponding collections.
- Naming Convention Validator: Checks the objects if they match a user-defined regular expression pattern.
- Mesh Data Fixer: Renames all mesh data names to its parent object names.

Work in progress:

- Check Mesh: Validates Mesh polycount, Unapplied transforms, etc.
- Mixamo Name Changer: Replace the bone names of Mixamo armatures with the names of the Rigify bones. - Bunch of other validations to maintain PBR, engine and expot format limitations.

A little touch for modularity

As you can see, the addon is like a group of operators which have different and mostly unrelated tasks. And this is why I need modularity, for the sake of code readibility, improving ease of development and of course keeping sanity while debugging.

This method is something I learned a few years ago by inspecting the codes of different professional addon developers. They mostly use the same approach. In short, they are organizing everything in separate files(Python modules) and when the plugin is activated the initialization file registers them all in one shot.

It's always good to care about separation of concerns, so I decided to use the same approach and I started by creating separate modules for all my operator classes. Then I imported them at the top of the the initalization module named __init__.py, which runs automatically when the addon is activated.

python

from .panel import FTOOLS_PT_Panel
from .categorize import FTOOLS_OT_Categorize
from .properties import CustomProperties
...

In Python, creating a module(.py script file) creates an additional namespace for that module, so just by importing a module, we can access the classes in it without further hassle. This makes our job even easier. After importing them I made a list named toRegister which contains all of the imported classes, my custom properties and etc.

python

toRegister = (
                FTOOLS_PT_Panel,
                FTOOLS_OT_Categorize,
                CustomProperties,
                ...
                
                )

In the register and unregister functions I'm running a for loop to register all the classes in the list. So I don't have to call register/unregister functions separately at the end of every script file.

python

def register():
   for cls in toRegister:
     bpy.utils.register_class(cls)
   bpy.types.Scene.ftools = bpy.props.PointerProperty(type=CustomProperties)

 def unregister():
   del bpy.types.Scene.ftools
   for cls in toRegister:
     bpy.utils.unregister_class(cls)

Let's say I want to add another operator to this plugin, all I need to import it at the top of the __init__.py file and place its name in toRegister. And that's all. :)

#Python #Rigging Artist Tools

Principal Blood Sorceress

A character that I created it's concept and also made the visualization. Inspired by Vampire The Masquerade universe.

#Character #Hand-Painted #Animated

Mourning Sea Dog

A cinematic character that I created in my spare time to improve myself in painting realistic skin. No skin textures or scandata used.

#Realism #Cinematic #Hand-Painted

Project Sniper - Protagonist

A stylized game character that I made for a game project. It's the protagonist of a story driven FPS action game.

#Game-Ready #Stylized #Hand-Painted

Hamza The Wrestler

This is an exaggerated stylized game-character which I made for Worm Animation Studio. Original concept created by Cemre Özkurt.

#Game-Ready #Stylized #Hand-painted

Kratos Bust, God of War Fan art

This is a fan art project which I made to improve myself in game-ready hair Workflow.

#Game Hair #Realism

Arcade Room: A scene from the past.

This scene is a recreation of one of my childhood memories. There are both realtime and rendered versions of it.

#Game-Ready #Environment #Props

Kael'Thas Sunstrider Fan Art

This is a fan art recreation of Kael'Thas from World of Warcraft. I used this model to demonstrate some procedural procedural animations for a ragdoll system.

#Animated #Handpainted

Undead Girl - No70: Eye of Basir

This is the villain character I designed and modeled for the horror game No70: Eye of Basir.

#Game-Ready #Unreal Engine 4 #Rigging

Fel Infused Varian Wrynn

This is a fan art re-imagined version of the hero Varian Wrynn from World of Warcraft. I made it for a 3D bust challenge.

#Hand-Painted #Stylized

Boxer Girl Scene

This is a quick scene and a character I created just for fun. Inspired by an urban myth about an alcoholic boxer.

#Lighting #Environment #Props

Worn Out Arcade Cabinet

This is an imitation of NeoGeo's legendary MVS Arcade Cabinet. I made this for a personal project.

#Game-Ready #Props

Other assets & models

These are some of my other 3D models. Most of them may be out of context, unrendered, or shown in only a single shot.

#Uncategorized

Pixel Art

Description

#PixelArt #Aseprite #Commodore64

Demoscene Stuff

These are my creations on retro computers like Commodore64 and Amstrad CPC464

#Demoscene #Retro #Assembly

The animations are procedural. There is only one rotation and one position key for all the moving bones. Rest of the animations are created by manipulating the curves with some noise and sinus waves. The reason I chose this way was to make an initial exploration for creating organic looking procedural animations.

I sculpted the base mesh and painted in ZBRUSH. The rig of the hands, animations and particle fur for her shirt made in BLENDER. Also, rendered with CYCLES(Blender)

The story behind...

She is a high sorceress of the Vampire society who is responsible for teaching dark arts to the recently embraced neonates. Society unofficially calls her 'the mother of hands', because of her numerous magical companions. Most of her enemies thought that her companions were just some silly illusions. As a result, they have turned into ashes.

This work is based on a character concept that I created long ago for one of our Vampire The Masquerade inspired FRP sessions. I drew this lady in my math notebook in high school and wrote a six full pages of story about her. Someday, I might share it on my blog.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

#Character #Hand-Painted #Animated

Creating a Cinematic look...

Behind the scenes

In the cinematic scene, the ship parts, sails and all the backdrops are used to create a feeling like the captain is on the deck of his ship and there is a lantern weakly illuminates his face.

Let's talk about the truth...

There is neither a lantern, nor the ship. There is also no moon. Not even the bottom half of the Captain's body.

All we have is a story and a bunch of lies around it. But... This is the only thing we need to create a believable cinematic scene. And that's ok :)

Progress

These are some turntables rendered in Blender (Cycles) to see the progression of the model.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

Creating own tools...

#Realism #Cinematic #Hand-Painted

He is the protagonist of a story driven FPS action game which is not yet anounced. These shots are taken for look development purpose. I have created the concept and made the final visualization. Sculpted in Zbrush, painted in Substance Painter. Rest of the scene and animations are created by using Blender.

Here is the animated version of the scene. The character idle animation is not final. It's just made for testing.

There is no particles in this scene. I used a simple and optimized way to produce a non-uniform fog like this. I created a sphere distance field and manipulated it with some 4d noise. With some scripted expressions, I managed to drive the W component of the noise by the camera movement.

You can find the details about procedural fog in the Tools & Solutions section.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

Character Rendering process & Turntables

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

For stylized characters, I usually paint a base texture in Zbrush and prepare some initial shots by using them, to have an idea about what the final image could look like. Here is an example of the body base texture I have painted in Zbrush with it's low poly wireframe rendered on it.

Some blendshape/facerig tests on head topology.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

#Game-Ready #Stylized #Hand-Painted

Overview

Although this is an old work of mine, it's still one of my favorites. Hamza is a Turkish Wrestler. He is a character from Karate Kamil cartoon series which was very popular back in the day. The original character created by Cemre Özkurt. Because of it's exaggerated form of anatomy, it was a great modeling challenge for me. Sculpted and painted in Zbrush. Retopology made with Topogun2. Rendered with Marmoset Toolbag 3 In the end, he reminded me one of my old toys, so I decided to exaggerate subsurface scattering and give him a smooth plastic feeling.

These muscles made me some real trouble while sculpting.

#Game-Ready #Stylized #Hand-painted

Kratos reimagined

As a REAL God of War fan, I hated the new design and decided to create a bearded Kratos with the old brutal GoW2 style. (Not a sorry-ass father figure like the new one) My main focus was creating an optimized game-ready beard. I sculpted the bust and prepared the beard geometry in Zbrush, painted the bust in Substance Painter, baked hair textures in Blender and rendered with Marmoset Toolbag 3
This work was selected for Artstation staff picks gallery in 2017.

Here is a bust render and turntable animation.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

Game-Ready Beard Breakdown

First, I extracted a geometry from the face and placed it under the beard to cover the skin. Then I made the haircards by using fibermeshes in Zbrush. Finally, I prepared the hair textures and added some longer and curled beard pieces to make them look more natural.

#Game Hair #Realism

One of my clients wanted me to render some arcade cabinets in different places for an advertisement. After I finished the job, I decided to make another arcade scene but this time for myself. I wanted to recreate one of my childhood memories. There was an arcade cabinet in the basement of a store, surrounded by the posters of popular games from 80s and 90s.

I modeled everything in Blender and painted in Substance Painter. Rendered in Blender. This one is a real time scene which is rendered in Blender with an early version of Eevee.

These are the shots of the same scene with a different camera angles and with lighting setups. Rendered with Cycles.

#Game-Ready #Environment #Props

I created this model for 3D printing as a figure for myself. It's a fan art recreation of Kael'Thas Sunstrider from World of Warcraft.

A few years ago a client asked me how they could improve their ragdoll animations. I did some research and decided to demonstrate some simple procedural animation loops on this model.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

#Animated #Handpainted

No70: Eye of Basir is a story-driven first person horror game which released back in 2017. I was responsible for creating the villain as a fully featured game-ready character. The idea was creating a really disturbing villain. Therefore, we decided to exaggerate the amount of gore. The main feature I need to mention about is that, this character had a much complex rig system than a normal humanoid because there was a creature with a full humanoid rig inside her stomach in the first version.

I sculpted the character in Zbrush painted it in Substance Painter. Retopology made in Blender Final shots are taken directly from Unreal Engine 4 viewport.

Test Animations

These are just some simple animations I made for testing purposes.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

#Game-Ready #Unreal Engine 4 #Rigging

Varian Wrynn is my favorite Warcraft character. He died a hero in the 'Legion' expansion so I decided to make a tribute to him. But with a little twist. I redesigned him in a demonic form.

Sculpted and hand-painted in Zbrush, rendered in Blender

Some clay render shots taken with Cycles. Turntable rendered with Eevee

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

#Hand-Painted #Stylized

There is an urban myth in my boxing gym. It's about an alcoholic female boxer who wins most of her matches. I was working on some boxing equipment like punching bag and gloves. Suddenly I remembered this story and wanted to create a scene about it. I sculpted the character in Zbrush, painted in Substance Painter and rendered with Marmoset Toolbag 3 Everything else is modeled in Blender.

#Lighting #Environment #Props

As a 3D artist who has an obsession with arcades and other devices with CRT monitors, I modeled this one to use as reference for my Arcade Cab building project. I made a clean version first and then applied some substance dirt on it to achieve this sad image. Modeled in Blender, painted and rendered in Substance Painter

These are the same scene with a different camera angles and with lighting setups. Rendered with Cycles.

Here is the cleanest version of it and the other one is my baby :)

#Game-Ready #Props

I used smoothing groups to create stylized edges on the meshes.

I tried to achieve some realism in ZBrush

Another sad arcade scene. This one is an imitation of PacMan.

Vimeo video

This will load content from Vimeo, which may set third-party cookies or similar tracking technologies.

This is the first model that made me money. Also the last model I made by using Maya

Character Skin Shading test in Unity 5.0

#Uncategorized

Ellie from Last of Us, C64 Pixel Art

Ellie from 'The Last of Us' painted within the limitations of Commodore 64 Hardware. The Commodore 64 has 16 colors. Screen resolution is 160*200 Doublewide(2x1) pixels. The screen is divided into 40*25 cells. Each cell contains 4 * 8 pixels. In this mode, you can use a maximum of 4 colors in a cell.

Vigil

Some pixelart scenes and characters I designed for a game project named Vigil. Sadly we had to cancel the project. It was a game that combines Point & Click Adventure and Rpg elements. You can find more information about the game from its dev blog .

Some other pixel art works.

#PixelArt #Aseprite #Commodore64

Raat #6 Invitro

This is an invitation intro ('Invitro') I made for RAAT #6 Demo party. I learned basic level MOS6510 Assembly programming in a few weeks, just to prepare this invitation. This is something I am very proud of. This party was the last one we made before the pandemic. I still hope for the next one. If you are interested, here you can download the executable (.prg) file of the invitro to run on an emulator or on a real Commodore 64. The video of the intro is shared below.

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

My other C64 demoscene stuff.

Skyrim Theme on C64

YouTube video

This will load content from YouTube, which may set third-party cookies or similar tracking technologies.

Batman pixelart on Amstrad CPC464

This is how it works on a real hardware.

#Demoscene #Retro #Assembly

About Me

My story with computer graphics goes back to the mid-90s. I started painting and coding sprites on 8-bit computers like Amstrad CPC464 and Commodore 64. In my opinion, dealing with this ancient hardware made me a guy who understands the concept really well.

During my years of experience working as a freelance 3D generalist, I naturally evolved into a technical artist, because I was the one who cared about the math that artists won't and about the art that programmers can't. XD

Contact