OpenGL - How could I color objects in pixelated fashion through shaders?

Question

I'm trying to figure out a way to light up my object in a pixelated fashion through the use of shaders.

To ilustrate, my goal is to turn this:

Into this:

I've tried looking up ways to do this through the fragment shader, however, there is no way I can access the local position of a fragment to determine the "fake pixel" it would belong to. I also had the idea to use a geometry shader to create a vertex for each of those boxes, but I'm under suspicion there could be a better way to do this. Would it be possible?

EDIT: These are the shaders currently being used for the object illustrated by the first image:

vertex shader:

#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aColor;
layout (location = 2) in vec2 aTex;

uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

out vec3 oColor; //Output of a color
out vec2 oTex; //Output of a Texture
out vec3 oPos; //Output of Position in space for light calculation
out vec3 oNormal; //Output of Normal vector for light calculation. 

void main(){
    gl_Position = projection * view * model * vec4(aPos, 1.0);
    oColor = aColor;
    oTex = aTex;
    oPos = vec3(model * vec4(aPos, 1.0));
    oNormal = vec3(0, 0, -1); //Not being calculated at the moment.
}

fragment shader:

#version 330 core

in vec3 oColor;
in vec2 oTex;
in vec3 oPos;  
in vec3 oNormal;  

out vec4 FragColor;

uniform sampler2D tex;
uniform vec3 lightColor; //Color of the light on the scene, there's only one
uniform vec3 lightPos; //Position of the light on the scene

void main(){
   //Ambient Light Calculation
   float ambientStrength = 0.1;
   //vec3 ambient = ambientStrength * lightColor * vec3(texture(tex, oTex));
   vec3 ambient = ambientStrength * lightColor;

   //Diffuse Light Calculation
   float diffuseStrength = 1.0;
   vec3 norm = normalize(oNormal);
   vec3 lightDir = normalize(lightPos - oPos);

   float diff = max(dot(norm, lightDir), 0.0);
   //vec3 diffuse = diff * lightColor* vec3(texture(tex, oTex)) * diffuseStrength;
   vec3 diffuse = diff * lightColor;

   //Specular Light Calculation
   float specularStrength = 0.25;
   float shinnyness = 8;
   vec3 viewPos = vec3(0, 0, -10);

   vec3 viewDir = normalize(viewPos - oPos);
   vec3 reflectDir = reflect(-lightDir, norm);    

   float spec = pow(max(dot(viewDir, reflectDir), 0.0), shinnyness);
   vec3 specular = specularStrength * spec * lightColor;  

   //Result Light
   vec3 result = (ambient+diffuse+specular) * oColor;
   FragColor = vec4(result, 1.0f);
}

Answer 1

The lighting depends on oPos. You need to "cascade" the position. e.g:

vec3 pos = vec3(round(oPos.xy * 10.0) / 10.0, oPos.z);

In the following use pos instead of oPos.

Note that this only works if oPos is a position in the view space, respectively if the XY plane of the oPos` coordinate system is parallel to the XY plane of the view.

---

Alternatively you can compute the a position depending on gl_FragCoord.

Add a uniform variable with the resolution of the screen:

uniform vec2 resolution;

Compute pos depending on resolution and gl_FragCoord:

vec3 pos = vec3(round(20.0 * gl_FragCoord.xy/resolution.y) / 20.0, oPos.z);

---

If you want to align the inner squares with the object you need to introduce texture coordinates. Where the bottom left coordinate of the object is (0, 0) and the top right is (1, 1).