static void bindSkyMatrix(shader_prog_t shader, Matrix4 modelViewMat, Matrix4 projectionMat)
{
Matrix4 model;
SceneCamera cam;
Matrix4 cameraTransl;
Matrix4 cameraRot;
Matrix4 MV;
model = Matrix4.Identity;
cam = AlethaApplication.camera;
cameraTransl = Matrix4.CreateTranslation(-cam.Position - new Vector3(0, 0, Config.playerHeight));
cameraRot = Matrix4.CreateFromQuaternion(cam.Orientation);
MV = (model * cameraTransl) * cameraRot;
skyboxMat = modelViewMat; //mat4.set(modelViewMat, this.skyboxMat);
//skyboxMat = Matrix4.Identity;
//skyboxMat = new Matrix4(modelViewMat.Row0, modelViewMat.Row1, modelViewMat.Row2, modelViewMat.Row3);
//skyboxMat = Matrix4.Identity * AlethaApplication.camera.GetWorldOrientation();
// Clear out the translation components
//skyboxMat.M12 = 0.0f;
//skyboxMat.M13 = 0.0f;
//skyboxMat.M14 = 0.0f;
// Set uniforms
GL.UniformMatrix4(shader.uniform["modelViewMat"], false, ref skyboxMat);
GL.UniformMatrix4(shader.uniform["projectionMat"], false, ref projectionMat);
}
public ShaderCompiler()
{
white = -1;
defaultShader = null;
defaultTexture = -1;
texMat = Matrix4.Identity; // mat4.create()
defaultProgram = null;
//defaultShader = buildDefault(null);
//defaultProgram = compileShaderProgram(Config.q3bsp_default_vertex, Config.q3bsp_default_fragment);
}
public void bindSkyTexture(stage_gl stage, shader_prog_t program, float time)
{
//map.render();
// if(type == skybox_type.one_tex)
// {
//if(skymap == null) { skymap = q3bsp.glshading.defaultTexture; }
GL.ActiveTexture(TextureUnit.Texture0);
GL.Uniform1(program.uniform["texture"], 0);
GL.BindTexture(TextureTarget.TextureCubeMap, skymap);
// }
// else if(type == skybox_type.six_tex)
// {
//
// }
}
static void bindSkyAttribs(shader_prog_t shader)
{
// Setup vertex attributes
GL.EnableVertexAttribArray(shader.attrib["position"]);
GL.VertexAttribPointer(shader.attrib["position"],
3,
VertexAttribPointerType.Float,
false,
Config.q3bsp_sky_vertex_stride,
0);
if (shader.attrib.ContainsKey("texCoord"))
{
GL.EnableVertexAttribArray(shader.attrib["texCoord"]);
GL.VertexAttribPointer(shader.attrib["texCoord"],
2,
VertexAttribPointerType.Float,
false,
Config.q3bsp_sky_vertex_stride,
3 * 4);
}
}
/// <summary>
/// Shader program compilation
/// </summary>
public shader_prog_t compileShaderProgram(string vertexSrc, string fragmentSrc)
{
int fragmentShader = GL.CreateShader(ShaderType.FragmentShader);
GL.ShaderSource(fragmentShader, fragmentSrc);
GL.CompileShader(fragmentShader);
String si;
int i;
int attribCount;
int uniformCount;
//var xf = GL.getShaderParameter(fragmentShader, RenderingContext.COMPILE_STATUS);
si = GL.GetShaderInfoLog(fragmentShader);
//if (!(xf != null && xf == true))
if (!string.IsNullOrEmpty(si.Trim()))
{
si = si == null ? "" : si;
Console.WriteLine("[shader-exception] fragment compilation error " + si);
if (shader_source_tracing)
{
Console.WriteLine("[shader].[begin]");
Console.WriteLine(vertexSrc);
Console.WriteLine("[shader].[end]");
Console.WriteLine("[shader].[begin]");
Console.WriteLine(fragmentSrc);
Console.WriteLine("[shader].[end]");
}
GL.DeleteShader(fragmentShader);
return(null);
}
int vertexShader = GL.CreateShader(ShaderType.VertexShader);
GL.ShaderSource(vertexShader, vertexSrc);
GL.CompileShader(vertexShader);
//var xv = GL.getShaderParameter(vertexShader, RenderingContext.COMPILE_STATUS);
si = GL.GetShaderInfoLog(vertexShader);
//if (!(xv != null && xv == true))
if (!string.IsNullOrEmpty(si.Trim()))
{
si = si == null ? "" : si;
Console.WriteLine("[shader-exception] vertex compilation error: " + si);
if (shader_source_tracing)
{
Console.WriteLine("[shader].[begin]");
Console.WriteLine(vertexSrc);
Console.WriteLine("[shader].[end]");
Console.WriteLine("[shader].[begin]");
Console.WriteLine(fragmentSrc);
Console.WriteLine("[shader].[end]");
}
GL.DeleteShader(vertexShader);
return(null);
}
int shaderProgram = GL.CreateProgram();
GL.AttachShader(shaderProgram, vertexShader);
GL.AttachShader(shaderProgram, fragmentShader);
GL.LinkProgram(shaderProgram);
//var xp = GL.getProgramParameter(shaderProgram, RenderingContext.LINK_STATUS);
si = GL.GetProgramInfoLog(shaderProgram);
//if (!(xp != null && xp == true))
if (!string.IsNullOrEmpty(si.Trim()))
{
GL.DeleteProgram(shaderProgram);
GL.DeleteShader(vertexShader);
GL.DeleteShader(fragmentShader);
Console.WriteLine("[shader-exception] Could not link shaders. Check if there are any additional errors.");
/*
* console.debug(vertexSrc);
* console.debug(fragmentSrc);*/
return(null);
}
shader_prog_t shader_prog = new shader_prog_t();
shader_prog.program = shaderProgram;
shader_prog.attrib = new Dictionary <string, int>();
shader_prog.uniform = new Dictionary <string, int>();
// SHADER PROGRAM INTROSPECTION
GL.GetProgramInterface(shaderProgram, ProgramInterface.ProgramInput, ProgramInterfaceParameter.ActiveResources, out attribCount);
GL.GetProgramInterface(shaderProgram, ProgramInterface.Uniform, ProgramInterfaceParameter.ActiveResources, out uniformCount);
string name;
ProgramProperty[] properties;
int[] values;
int length;
StringBuilder nameBuilder;
properties = new ProgramProperty[]
{
ProgramProperty.NameLength,
ProgramProperty.Type,
ProgramProperty.ArraySize
};
values = new int[properties.Length];
nameBuilder = new StringBuilder();
for (i = 0; i < attribCount; i++)
{
GL.GetProgramResource(shaderProgram, ProgramInterface.ProgramInput, i, properties.Length, properties, values.Length, out length, values);
#pragma warning disable
GL.GetProgramResourceName(shaderProgram, ProgramInterface.ProgramInput, i, 256, out length, nameBuilder);
#pragma warning restore
name = nameBuilder.ToString();
shader_prog.attrib[name] = GL.GetAttribLocation(shaderProgram, name);
}
for (i = 0; i < uniformCount; i++)
{
GL.GetProgramResource(shaderProgram, ProgramInterface.Uniform, i, properties.Length, properties, values.Length, out length, values);
#pragma warning disable
GL.GetProgramResourceName(shaderProgram, ProgramInterface.Uniform, i, 256, out length, nameBuilder);
#pragma warning restore
name = nameBuilder.ToString();
shader_prog.uniform[name] = GL.GetUniformLocation(shaderProgram, name);
}
return(shader_prog);
}
public void init()
{
white = createSolidTexture(new Vector4(255, 255, 255, 0));
//white = createSolidTexture(gl, [0,0,0,255]);
defaultProgram = compileShaderProgram(Config.q3bsp_default_vertex, Config.q3bsp_default_fragment);
modelProgram = compileShaderProgram(Config.q3bsp_default_vertex, Config.q3bsp_model_fragment);
// Load default texture
texture.fetch_texture(Config.q3bsp_no_shader_default_texture_url, (int defau) =>
{
defaultTexture = defau;
},
(int defau, Bitmap image) =>
{
bool isPowerOf2 = false;
BitmapData pixelData;
Rectangle boundingbox;
boundingbox = new Rectangle(0, 0, image.Width, image.Height);
pixelData = image.LockBits(boundingbox,
System.Drawing.Imaging.ImageLockMode.ReadOnly,
System.Drawing.Imaging.PixelFormat.Format32bppArgb);
GL.BindTexture(TextureTarget.Texture2D, defau);
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, image.Width, image.Height, 0, OpenTK.Graphics.OpenGL4.PixelFormat.Bgra, PixelType.UnsignedByte, pixelData.Scan0);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (isPowerOf2 ? (int)TextureMinFilter.LinearMipmapNearest : (int)TextureMinFilter.Linear));
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
if (isPowerOf2)
{
GL.GenerateMipmap(GenerateMipmapTarget.Texture2D);
}
image.UnlockBits(pixelData);
});
texture.fetch_texture(Config.q3bsp_no_shader_default_texture_url2, (int defau) =>
{
defaultTextureRed = defau;
},
(int defau, Bitmap image) =>
{
bool isPowerOf2 = false;
BitmapData pixelData;
Rectangle boundingbox;
boundingbox = new Rectangle(0, 0, image.Width, image.Height);
pixelData = image.LockBits(boundingbox,
System.Drawing.Imaging.ImageLockMode.ReadOnly,
System.Drawing.Imaging.PixelFormat.Format32bppArgb);
GL.BindTexture(TextureTarget.Texture2D, defau);
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, image.Width, image.Height, 0, OpenTK.Graphics.OpenGL4.PixelFormat.Bgra, PixelType.UnsignedByte, pixelData.Scan0);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (isPowerOf2 ? (int)TextureMinFilter.LinearMipmapNearest : (int)TextureMinFilter.Linear));
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
if (isPowerOf2)
{
GL.GenerateMipmap(GenerateMipmapTarget.Texture2D);
}
});
// Load default stage
defaultShader = buildDefault(null);
}
