Is vertex coordinate limited to -1 to +1f range

Question

I thought that everything outside of [-1.0f, +1.0f] should not be renderable in Open GL. However, this code renders just fine with Silk.NET. I draw 3 axes and one of them is longer than the others.

private static readonly float[] AxisPoints =
{
  // X
  -2.0f, 0.0f, 0.0f,
  2.0f, 0.0f, 0.0f,

  // Y
  0.0f, -1.0f, 0.0f,
  0.0f, 1.0f, 0.0f,

  // Z
  0.0f, 0.0f, -1.0f,
  0.0f, 0.0f, 1.0f
};

private static readonly uint[] Indices =
{
  0, 1,
  2, 3,
  4, 5
};

var numberOfLines = AxisPoints.Length / 3 / 2;

gl.VertexAttributePointer(0, numberOfLines, VertexAttribPointerType.Float, 3, 0);
gl.DrawElements(GLEnum.Lines, Indices.Length, DrawElementsType.UnsignedInt, 0);

Fragment shader

#version 330 core
out vec4 FragColor;

void main()
{
    FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);
}

Vertex shader

#version 330 core
layout (location = 0) in vec3 Position;

uniform mat4 Model;
uniform mat4 View;
uniform mat4 Projection;

void main()
{
    gl_Position = Projection * View * Model * vec4(Position, 1.0);
}

Question

What is the minimum and maximum value that I can specify for a vertex?

Answer 1

I thought that everything outside of [-1.0f, +1.0f] should not be renderable in Open GL.

The [-1.0f, +1.0f] range is what you have to arrive at as the output of your vertex shader. Because anything outside of that range is outside of the player's screen rectangle. But during any of the steps that come before that, OpenGL lets you use the whole range of single-precision floating point values.

How your intermediate coordinates scale in relation to the screen coordinates is managed by the matrices. For example, if you have two 3d models, one using coordinates in the [-1.0f, +1.0f] range and the other in the [-1000.0f, +1000.0f] range, then you can use different model matrices with different scaling factors for them. That way you can make them have the same dimensions in world space. Which range is "normal" size? That's for you to decide. Because your projection matrix is then used to control the overall scaling factor between world space and screen space. So 100 world-space units can be huge or tiny, depending on what you want them to be in your game.

See also How to transform 2D world to screen coordinates OpenGL on Stackoverflow.