uniform mat3 LightNormalMatrix;
uniform mat4 LightModelViewMatrix;
uniform mat4 LightProjectionMatrix; // must contain LightModelView

varying vec3 position;
varying vec3 normal;


void main() {
  vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
  pos.x /= pos.z; 
  pos.z = sqrt(pos.z);
  pos.xz *= pos.y; // y und z werden später in den Matrizen vertauscht; Projektion soll rückgängig gemacht werden;
   
  gl_Position = LightProjectionMatrix * pos; //geht nicht
  position = vec3(LightModelViewMatrix * gl_Vertex); //geht wahrscheinlich
  normal = normalize(LightNormalMatrix * gl_Normal); //geht nicht
  gl_FrontColor = gl_Color;
}

  vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
  pos.x /= pos.z; 
  pos.z = sqrt(pos.z);

pos.xz *= pos.y;

position = vec3(LightModelViewMatrix * gl_Vertex); //geht wahrscheinlich
normal = normalize(LightNormalMatrix * gl_Normal); //geht nicht
gl_FrontColor = gl_Color;

var
  NormalM: TAffineMatrix;
  MVMat: TMatrix;
  CameraMat: TMatrix;
  CameraAffMat: TAffineMatrix;
  X, Y, Z: TVector;
  i1, i2: Integer;
begin
  if RenderMode = rm_Shadow_Map then begin
    Z:= Terra.Lights[0][L_Pos]; //Z soll in Lichtrichtung zeigen
    Z[3]:= 0;
    NormalizeVector( Z );
    NormalM:= IdentityMatrix; // NormalM:= Rotationsmatrix der Kamera
    NormalM:= MatrixMultiply( CreateAffineRotationMatrix(AffineVectorMake(1, 0, 0), Camera.Rotation[0]), NormalM );
    NormalM:= MatrixMultiply( CreateAffineRotationMatrix(AffineVectorMake(0, 1, 0), Camera.Rotation[1]), NormalM );
    NormalM:= MatrixMultiply( CreateAffineRotationMatrix(AffineVectorMake(0, 0, 1), Camera.Rotation[2]), NormalM ); // normale RotationsMatrix machen;
    X:= VectorMake(NormalM[0, 0], NormalM[1, 0], NormalM[2, 0], 0);
    SubtractVector(X, VectorScale( Z, VectorDotProduct(X, Z) ) ); // X soll normal auf Z sein; X -= Z*(Z dot X); length(Z) = 1, daher ist die division überflüssig
    NormalizeVector( X );
    Y:= VectorCrossProduct( Z, X );
    NormalizeVector(Y);  //überflüssig?

    for i1:= 0 to 3 do
      for i2:= 0 to 3 do
        if (i1 < 3) and (i2 < 3) then
          CameraMat[i1, i2]:= NormalM[i1, i2]
        else if (i1 < 3) xor (i2 < 3) then
          CameraMat[i1, i2]:= 0
        else CameraMat[i1, i2]:= 1; // NormalM in CameraMat kopieren

    InvertMatrix(CameraMat);

    for i1:= 0 to 2 do
      for i2 := 0 to 2 do
        CameraAffMat[i1, i2]:= CameraMat[i1, i2];



    NormalM[0, 0]:= X[0];  NormalM[1, 0]:= X[1];  NormalM[2, 0]:= X[2];
    NormalM[0, 1]:= Z[0];  NormalM[1, 1]:= Z[1];  NormalM[2, 1]:= Z[2]; // Y and Z axes must be swapped for shader
    NormalM[0, 2]:= Y[0];  NormalM[1, 2]:= Y[1];  NormalM[2, 2]:= Y[2];

    NormalM:= MatrixMultiply(NormalM, CameraAffMat);  // Camerarotation soll nicht wiederholt werden

    MVMat[0, 0]:= X[0];  MVMat[1, 0]:= X[1];  MVMat[2, 0]:= X[2];  MVMat[3, 0]:= 0;
    MVMat[0, 1]:= Z[0];  MVMat[1, 1]:= Z[1];  MVMat[2, 1]:= Z[2];  MVMat[3, 1]:= 0;
    MVMat[0, 2]:= Y[0];  MVMat[1, 2]:= Y[1];  MVMat[2, 2]:= Y[2];  MVMat[3, 2]:= 0;
    MVMat[0, 3]:= 0;     MVMat[1, 3]:= 0;     MVMat[2, 3]:= 0;     MVMat[3, 3]:= 1; // Translation wird bereits von den anderen Matrizen gemacht;

    MVMat:= MatrixMultiply(MVMat, CameraMat);

    Scene.ShadowMapRenderer.Bind;
    Scene.ShadowMapRenderer.NormalMatrix:= NormalM;  // Uniformvariablen setzen
    Scene.ShadowMapRenderer.ModelViewMatrix:= MVMat;
    Scene.ShadowMapRenderer.ProjectionMatrix:= MVMat;
  end;
end;