public void loadTexture(shader_gl shader, shader_p surface, stage_gl stage)
{
int i;
if (shader.sky)
{
Console.WriteLine("[skybox] {0}", shader.name);
}
if (stage.map == null)
{
stage.texture = white;
return;
}
else if (stage.map.Contains("$lightmap"))
{
stage.texture = (surface.geomType != 3 ? q3bsp.lightmap : white);
return;
}
else if (stage.map.Contains("$whiteimage"))
{
stage.texture = white;
return;
}
stage.texture = defaultTexture;
if (stage.map == "anim")
{
stage.animTexture = new List <int>();
for (i = 0; i < stage.animMaps.Count; ++i)
{
if (i > stage.animTexture.Count - 1)
{
stage.animTexture.Add(defaultTexture);
}
string url = Config.q3bsp_base_folder + "/" + stage.animMaps[i];
loadTextureUrl(stage, url, (int texture) =>
{
stage.animTexture.Insert(i, texture);
});
}
stage.animFrame = 0;
}
else
{
if (shader.sky == false)
{
string url = Config.q3bsp_base_folder + "/" + stage.map;
loadTextureUrl(stage, url, (int texture) =>
{
stage.texture = texture;
});
}
}
}
/// <summary>
/// Texture loading
/// </summary>
public void loadShaderMaps(shader_p surface, shader_gl shader)
{
if (shader.sky == true)
{
q3bsp.skybox_env = skybox.loadFromShader(surface, shader);
}
for (int i = 0; i < shader.stages.Count; ++i)
{
stage_gl stage = shader.stages[i];
stage.shaderName = shader.name;
if (stage.map != null)
{
loadTexture(shader, surface, stage);
}
if (stage.shaderSrc != null && stage.program == null)
{
Console.WriteLine("Compiling " + shader.name);
//fetch_update("Compiling " + shader.name);
stage.program = compileShaderProgram(stage.shaderSrc.vertex.source_code,
stage.shaderSrc.fragment.source_code);
}
}
}
public shader_gl buildDefault(shader_p surface)
{
stage_gl diffuseStage = new stage_gl();
diffuseStage.map = (surface != null ? surface.shaderName + ".jpg" : null);
diffuseStage.isLightmap = false;
diffuseStage.blendSrc = (int)BlendingFactorSrc.One;
diffuseStage.blendDest = (int)BlendingFactorDest.Zero;
diffuseStage.depthFunc = DepthFunction.Lequal;
diffuseStage.depthWrite = true;
shader_gl glShader = new shader_gl();
glShader.cull = CullFaceMode.Front;
glShader.blend = false;
glShader.sort = 3;
glShader.stages = (new stage_gl[] { diffuseStage }).ToList();
glShader.sky = false;
if (surface != null)
{
loadTexture(glShader, surface, diffuseStage);
}
else
{
diffuseStage.texture = defaultTexture;
}
return(glShader);
}
/// <summary>
/// Shader building
/// </summary>
public shader_gl build(shader_t shader, shader_p surface)
{
if (shader == null)
{
return(null);
}
shader_gl glShader = new shader_gl();
glShader.cull = translateCull(shader.cull);
glShader.sort = shader.sort;
glShader.sky = shader.sky;
glShader.blend = shader.blend;
glShader.name = shader.name;
glShader.sky_env_map = shader.sky_env_map;
glShader.stages = new List <stage_gl>();
for (int j = 0; j < shader.stages.Count; ++j)
{
stage_t t = shader.stages[j];
stage_gl s = new stage_gl();
//s.animFrame = t.animFrame;
s.animFreq = t.animFreq;
s.animMaps = t.animMaps;
//s.animTexture = t.animTexture;
s.texture = -1;
s.blendSrc = translateBlendSrc(t.blendSrc);
s.blendDest = translateBlendDest(t.blendDest);
s.depthFunc = translateDepthFunc(t.depthFunc);
s.map = t.map;
s.tcMods = t.tcMods;
s.depthWrite = t.depthWrite;
s.isLightmap = t.isLightmap;
s.shaderSrc = t.shaderSrc;
s.clamp = t.clamp;
s.tcGen = t.tcGen;
s.rgbGen = t.rgbGen;
s.rgbWaveform = t.rgbWaveform;
s.alphaGen = t.alphaGen;
s.alphaFunc = t.alphaFunc;
s.alphaWaveform = t.alphaWaveform;
s.hasBlendFunc = t.hasBlendFunc;
s.depthWriteOverride = t.depthWriteOverride;
s.blend = t.blend;
s.opaque = t.opaque;
glShader.stages.Add(s);
}
return(glShader);
}
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)
// {
//
// }
}
public void loadTextureUrl(stage_gl stage, String url, OnTextueLoad onload)
{
texture.fetch_texture(url, (int texture) =>
{
onload(texture);
},
(int texture, 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, texture);
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 (stage.clamp == true)
{
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.ClampToEdge);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.ClampToEdge);
}
if (isPowerOf2)
{
GL.GenerateMipmap(GenerateMipmapTarget.Texture2D);
}
GL.BindTexture(TextureTarget.Texture2D, 0);
onload(texture);
});
}
public shader_prog_t setShaderStage_EffectDEBUG(shader_gl shader, stage_gl shaderStage, float time)
{
shader_prog_t program;
stage_gl stage = shaderStage;
if (stage == null)
{
stage = defaultShader.stages[0];
}
if (stage.animFreq.HasValue && stage.animFreq != 0)
{
// Texture animation seems like a natural place for setInterval, but that approach has proved error prone.
// It can easily get out of sync with other effects (like rgbGen pulses and whatnot) which can give a
// jittery or flat out wrong appearance. Doing it this way ensures all effects are synced.
float ff = time * (float)stage.animFreq.Value;
//var animFrame = ff.floor() % stage.animTexture.length;
stage.texture = stage.animTexture[stage.animFrame]; // stage.animTexture.animFrame;
}
GL.BlendFunc((BlendingFactorSrc)stage.blendSrc, (BlendingFactorDest)stage.blendDest);
if (stage.depthWrite == true && shader.sky == false)
{
GL.DepthMask(true);
}
else
{
GL.DepthMask(false);
}
GL.DepthFunc(stage.depthFunc);
program = stage.program;
int prog = program != null ? program.program : -1;
if (prog == -1)
{
if (shader.model == true)
{
program = modelProgram;
prog = program.program;
}
else
{
program = defaultProgram;
prog = program.program;
}
}
//program = defaultProgram;
//prog = program.program;
GL.UseProgram(prog);
if (shader.sky == true)
{
//q3bsp.skybox_env.bindSkyTexture(stage, program, time);
//var a = 3;
}
else
{
int texture = stage.texture;
if (texture == -1)
{
texture = defaultTexture;
}
//texture = defaultTexture;
GL.ActiveTexture(TextureUnit.Texture0);
if (program.uniform.ContainsKey("texture"))
{
GL.Uniform1(program.uniform["texture"], 0);
}
GL.BindTexture(TextureTarget.Texture2D, texture);
}
if (program.uniform.ContainsKey("lightmap"))
{
GL.ActiveTexture(TextureUnit.Texture1);
GL.Uniform1(program.uniform["lightmap"], 1);
GL.BindTexture(TextureTarget.Texture2D, q3bsp.lightmap);
}
if (program.uniform.ContainsKey("time"))
{
GL.Uniform1(program.uniform["time"], time);
}
return(program);
}
