For some reason `NulPoint`

is not found even though I’ve verified that `glGetAttribLocation()`

is called with the right information so I can only think that it’s classed as unused because of the way I attempted to use my shaders. Any ideas from the below?

Vertex Shader:

```
#version 440
vec4 NulPoint;
out vec4 DyeColor;
void main()
{
gl_Position = vec4( NulPoint.xyz, 1.0 );
DyeColor = vec4(1.0,1.0,1.0,1.0);
}
```

Geometry Shader

```
#version 440
#include "same.glsl"
layout(points) in;
layout(triangle_strip, max_vertices=256) out;
const int INT_MAX = int( ~0u >> 1 );
const int INT_MIN = int(~(~0u >> 1));
const uint uqtr = ~0u / 4;
const uint uoct = ~0u / 8;
const double dcap = double(~0u);
const double dqtr = double(~0u / 4);
out vec4 DyeColor;
out vec4 DyeTexel;
vec2 square_vertices[] =
{
{ 0.0, 0.0 },
{ 0.0, 1.0 },
{ 1.0, 1.0 },
{ 1.0, 0.0 }
};
vec4 edge_vertex( uint x, uint y )
{
vec4 point;
point.x = float(double(x) / dqtr);
point.y = float(double(y) / dqtr);
point.xy *= fnum_uniforms.WinScale.xy * fnum_uniforms.RegScale.xy;
point.xy += fnum_uniforms.RegPoint.xy;
point.z = fnum_uniforms.RegPoint.z;
point.w = 1.0;
return point;
}
void emit_vertex( vec4 point )
{
gl_Position = point;
DyeColor = vec4( 1.0, 1.0, 1.0, 1.0 );
DyeTexel = vec4( 1.0, 1.0, 1.0, 1.0 );
EmitVertex();
}
void emit_point( uint v, uint vertices )
{
double aim = double(v);
double max = double(vertices);
uint rotate = uint((aim / max) * dcap);
uint linear = rotate % uqtr;
if ( dint_uniforms.FlatLine != 0 )
emit_vertex( edge_vertex( linear, uqtr - linear ) );
else
{
uint curved = linear + (linear / 3);
if ( linear < uoct )
emit_vertex( edge_vertex( curved, uqtr - linear ) );
else
emit_vertex( edge_vertex( linear, uqtr - curved ) );
}
}
void emit_square_half( bool left )
{
uint i = uint(left);
emit_vertex( vec4( square_vertices[i++], 0.0, 1.0 ) );
emit_vertex( vec4( square_vertices[i++], 0.0, 1.0 ) );
emit_vertex( vec4( square_vertices[i++], 0.0, 1.0 ) );
}
void main()
{
uint v, vertices = dint_uniforms.VtxCount, stop;
vec4 center = vec4( 0.0, 0.0, 0.0, 1.0 );
if ( vertices < 2 )
vertices = 2;
stop = vertices - 1;
for ( v = 0; v < stop; ++v )
{
if ( vertices == 4 )
{
emit_square_half(false);
EndPrimitive();
emit_square_half(true);
EndPrimitive();
}
else
{
emit_vertex( center );
emit_point( v, vertices );
emit_point( v + 1, vertices );
EndPrimitive();
}
}
}
```

same.glsl

```
#ifndef SHARED_H
#define SHARED_H
#if defined(GL_SPIRV) || defined(GL_core_profile) || \
defined(GL_compatibility_profile) || defined(GL_es_profile)
#define IS_OPENGL
#endif
#if defined(IS_OPENGL) || defined(VULKAN)
/* Mappings to CGLM union names */
#define uvec2s uvec2
#define uvec3s uvec3
#define uvec4s uvec4
#define ivec2s ivec2
#define ivec3s ivec3
#define ivec4s ivec4
#define vec2s vec2
#define vec3s vec3
#define vec4s vec4
#define dvec2s dvec2
#define dvec3s dvec3
#define dvec4s dvec4
#else
#include <cglm/struct.h>
#include <cglm/cglm.h>
#include <cglm/call.h>
#define uniform typedef struct
#endif
uniform UINTS { uint uunused; } uint_uniforms;
#define SHARED_UINT_NAMES "uunused"
#define SHARED_UINT_TYPES VFXTYPE_UINT
#define SHARED_UINT_COUNT (1)
uniform DINTS
{
int FlatLine;
int VtxCount;
ivec2s WinPoint;
ivec3s WinSpace;
} dint_uniforms;
#define SHARED_DINT_NAMES \
"VtxCount", "FlatLine", "WinPoint", "WinSpace"
#define SHARED_DINT_TYPES \
VFXTYPE_DINT, VFXTYPE_DINT, VFXTYPE_IVEC2, VFXTYPE_IVEC3
#define SHARED_DINT_COUNT (1+1+2+3)
uniform FNUMS
{
float funused;
vec3s WinScale;
vec3s RegScale;
vec3s RegPoint;
/* Light emitted */
vec3s RegEmits;
/* Light taken before ray bounces */
vec3s RegTakes;
} fnum_uniforms;
#define SHARED_FNUM_NAMES \
"funused", "WinScale", "RegScale", "RegPoint", "RegEmits", "RegTakes"
#define SHARED_FNUM_TYPES \
VFXTYPE_FNUM, \
VFXTYPE_FVEC3, VFXTYPE_FVEC3, VFXTYPE_FVEC3, VFXTYPE_FVEC3, VFXTYPE_FVEC3
#define SHARED_FNUM_COUNT (1+3+3+3+3+3)
uniform DNUMS { double dunused; } dnum_uniforms;
#define SHARED_DNUM_NAMES "dunused"
#define SHARED_DNUM_TYPES VFXTYPE_DNUM
#define SHARED_DNUM_COUNT (1)
#ifndef IS_OPENGL
#undef uniform
#endif
#endif
```

Colour Shader:

```
#version 440
in vec4 DyeColor;
/* We use a vec4 so we can store our information in 1 cache, we can just use
* the extra values for something else, like say the index of the texel */
in vec4 DyeTexel;
uniform sampler2D Texture;
out vec4 UseColor;
void main()
{
vec4 ImgColor = texture( Texture, DyeTexel.xy );
UseColor = vec4(0.5,0.5,0.5,1.0) + DyeColor * ImgColor;
}
```