/**
* Set Sampler
**/
public void SetSampler(TextureUnit sindex, ITexture tex)
{
GL.ActiveTexture(sindex);
}
private void RenderImDrawData(ImDrawDataPtr draw_data)
{
uint vertexOffsetInVertices = 0;
uint indexOffsetInElements = 0;
if (draw_data.CmdListsCount == 0)
{
return;
}
uint totalVBSize = (uint)(draw_data.TotalVtxCount * Unsafe.SizeOf <ImDrawVert>());
if (totalVBSize > _vertexBufferSize)
{
int newSize = (int)Math.Max(_vertexBufferSize * 1.5f, totalVBSize);
GL.NamedBufferData(_vertexBuffer, newSize, IntPtr.Zero, BufferUsageHint.DynamicDraw);
_vertexBufferSize = newSize;
Console.WriteLine($"Resized vertex buffer to new size {_vertexBufferSize}");
}
uint totalIBSize = (uint)(draw_data.TotalIdxCount * sizeof(ushort));
if (totalIBSize > _indexBufferSize)
{
int newSize = (int)Math.Max(_indexBufferSize * 1.5f, totalIBSize);
GL.NamedBufferData(_indexBuffer, newSize, IntPtr.Zero, BufferUsageHint.DynamicDraw);
_indexBufferSize = newSize;
Console.WriteLine($"Resized index buffer to new size {_indexBufferSize}");
}
for (int i = 0; i < draw_data.CmdListsCount; i++)
{
ImDrawListPtr cmd_list = draw_data.CmdListsRange[i];
GL.NamedBufferSubData(_vertexBuffer, (IntPtr)(vertexOffsetInVertices * Unsafe.SizeOf <ImDrawVert>()), cmd_list.VtxBuffer.Size * Unsafe.SizeOf <ImDrawVert>(), cmd_list.VtxBuffer.Data);
Util.CheckGLError($"Data Vert {i}");
GL.NamedBufferSubData(_indexBuffer, (IntPtr)(indexOffsetInElements * sizeof(ushort)), cmd_list.IdxBuffer.Size * sizeof(ushort), cmd_list.IdxBuffer.Data);
Util.CheckGLError($"Data Idx {i}");
vertexOffsetInVertices += (uint)cmd_list.VtxBuffer.Size;
indexOffsetInElements += (uint)cmd_list.IdxBuffer.Size;
}
// Setup orthographic projection matrix into our constant buffer
ImGuiIOPtr io = ImGui.GetIO();
Matrix4 mvp = Matrix4.CreateOrthographicOffCenter(
-1.0f,
io.DisplaySize.X,
io.DisplaySize.Y,
0.0f,
-1.0f,
1.0f);
_shader.UseShader();
GL.ProgramUniformMatrix4(_shader.Program, _shader.GetUniformLocation("projection_matrix"), false, ref mvp);
GL.ProgramUniform1(_shader.Program, _shader.GetUniformLocation("in_fontTexture"), 0);
Util.CheckGLError("Projection");
GL.BindVertexArray(_vertexArray);
Util.CheckGLError("VAO");
draw_data.ScaleClipRects(io.DisplayFramebufferScale);
GL.Enable(EnableCap.Blend);
GL.Enable(EnableCap.ScissorTest);
GL.BlendEquation(BlendEquationMode.FuncAdd);
GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
GL.Disable(EnableCap.CullFace);
GL.Disable(EnableCap.DepthTest);
// Render command lists
int vtx_offset = 0;
int idx_offset = 0;
for (int n = 0; n < draw_data.CmdListsCount; n++)
{
ImDrawListPtr cmd_list = draw_data.CmdListsRange[n];
for (int cmd_i = 0; cmd_i < cmd_list.CmdBuffer.Size; cmd_i++)
{
ImDrawCmdPtr pcmd = cmd_list.CmdBuffer[cmd_i];
if (pcmd.UserCallback != IntPtr.Zero)
{
throw new NotImplementedException();
}
else
{
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2D, (int)pcmd.TextureId);
Util.CheckGLError("Texture");
// We do _windowHeight - (int)clip.W instead of (int)clip.Y because gl has flipped Y when it comes to these coordinates
var clip = pcmd.ClipRect;
GL.Scissor((int)clip.X, _windowHeight - (int)clip.W, (int)(clip.Z - clip.X), (int)(clip.W - clip.Y));
Util.CheckGLError("Scissor");
GL.DrawElementsBaseVertex(PrimitiveType.Triangles, (int)pcmd.ElemCount, DrawElementsType.UnsignedShort, (IntPtr)(idx_offset * sizeof(ushort)), vtx_offset);
Util.CheckGLError("Draw");
}
idx_offset += (int)pcmd.ElemCount;
}
vtx_offset += cmd_list.VtxBuffer.Size;
}
GL.Disable(EnableCap.Blend);
GL.Disable(EnableCap.ScissorTest);
}
/// <summary>
/// Generates the font image, the VAO and the <see cref="CharSheet"/> storing all <see cref="Character"/>
/// </summary>
/// <param name="rect">The rect.</param>
public void GenerateFontImage(GLRectangleF rect)
{
int bitmapWidth = _glyphsPerLine * _glyphWidth; //calculate bitmap dimensions
int bitmapHeight = _glyphLineCount * _glyphHeight;
//generating the bitmap and setting it up first
using (Bitmap bitmap = new Bitmap(bitmapWidth, bitmapHeight, System.Drawing.Imaging.PixelFormat.Format32bppArgb))
{
Font font;
font = new Font(new FontFamily(_fontName), _fontSize, FontStyle.Regular, GraphicsUnit.Pixel);
using (var g = Graphics.FromImage(bitmap))
{
if (_bitmapFont)
{
g.SmoothingMode = SmoothingMode.None;
g.TextRenderingHint = TextRenderingHint.SingleBitPerPixel;
}
else
{
g.SmoothingMode = SmoothingMode.HighQuality;
g.TextRenderingHint = TextRenderingHint.AntiAliasGridFit;
}
//draw each character onto the bitmap
for (int p = 0; p < _glyphLineCount; p++)
{
for (int n = 0; n < _glyphsPerLine; n++)
{
char c = (char)(n + p * _glyphsPerLine);
g.DrawString(c.ToString(), font, Brushes.Black,
n * _glyphWidth + _atlasOffsetX, p * _glyphHeight + _atlasOffsetY);
}
}
}
bitmap.Save(_fontBitmapFilename);//save the bitmap
_textureWidth = bitmap.Width; _textureHeight = bitmap.Height;
}
_shaders.TextShader.Use();
//bind the bitmap to an OpenGL Texture
_fontTextureID = GL.GenTexture();
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2D, _fontTextureID);
using (var image = new Bitmap(_fontBitmapFilename))
{//load the bitmap into OpenGL
var data = image.LockBits(
new Rectangle(0, 0, image.Width, image.Height),
ImageLockMode.ReadOnly,
System.Drawing.Imaging.PixelFormat.Format32bppArgb);
GL.TexImage2D(TextureTarget.Texture2D,
0,
PixelInternalFormat.Rgba,
image.Width,
image.Height,
0,
OpenTK.Graphics.OpenGL4.PixelFormat.Bgra,
PixelType.UnsignedByte,
data.Scan0);
}
//set up the filters for the bitmap
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat);
//generate the VAO and bind it
_VAO = GL.GenVertexArray();
GL.BindVertexArray(_VAO);
//enable the vertex attribute arrays, very important otherwise no vertix can be loaded into OpenGL
GL.EnableVertexAttribArray(_shaders.TextShader.TexCoordLocation);
GL.EnableVertexAttribArray(_shaders.TextShader.VertexLocation);
//generate the CharSheet from the information about the bitmap
_charSheet = new CharSheet(_glyphLineCount, _glyphsPerLine, _glyphHeight, _glyphWidth, _textureWidth, _textureHeight, rect);
//set the attribpointers to tell the Shader how the Vertices will be passed.
GL.VertexAttribPointer(_shaders.TextShader.VertexLocation, 2, VertexAttribPointerType.Float, false, 4 * sizeof(float), 0);
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2D, _fontTextureID);
GL.VertexAttribPointer(_shaders.TextShader.TexCoordLocation, 2, VertexAttribPointerType.Float, false, 4 * sizeof(float), 2 * sizeof(float));
GL.BindVertexArray(0);
_shaders.TextShader.StopUse();
GL.Enable(EnableCap.Blend);//enable blending for the bitmap
GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
}
public void Bind(TextureUnit texU)
{
GL.ActiveTexture(texU);
GL.BindTexture(textureTarget, _texture);
}
private void PrepareBoneInformation(SepdChunk sepd, PrmsChunk prms)
{
/* TODO!! B/C HURR DURR, DON'T KNOW https://www.the-gcn.com/topic/2859-oot-3d-3ds-model-format-discussion/page-3#entry46121 */
if (prms.SkinningMode == PrmsChunk.SkinningModes.PerVertex)
{
uint[] lookupInts = new uint[(int)(Root.VatrChunk.BoneIndexLookup.Length - sepd.BoneIndexLookupArrayOffset) / sepd.BoneIndexLookupSize];
for (int i = 0; i < lookupInts.Length; i++)
{
switch (sepd.BoneIndexLookupArrayDataType)
{
case Constants.PicaDataType.Byte:
case Constants.PicaDataType.UnsignedByte:
lookupInts[i] = (uint)Root.VatrChunk.BoneIndexLookup[sepd.BoneIndexLookupArrayOffset + (i * sizeof(byte))];
break;
case Constants.PicaDataType.Short:
case Constants.PicaDataType.UnsignedShort:
lookupInts[i] = (uint)BitConverter.ToUInt16(Root.VatrChunk.BoneIndexLookup, (int)(sepd.BoneIndexLookupArrayOffset + (i * sizeof(ushort))));
break;
case Constants.PicaDataType.Int:
case Constants.PicaDataType.UnsignedInt:
lookupInts[i] = (uint)BitConverter.ToUInt32(Root.VatrChunk.BoneIndexLookup, (int)(sepd.BoneIndexLookupArrayOffset + (i * sizeof(uint))));
break;
case Constants.PicaDataType.Float:
lookupInts[i] = (uint)BitConverter.ToSingle(Root.VatrChunk.BoneIndexLookup, (int)(sepd.BoneIndexLookupArrayOffset + (i * sizeof(float))));
break;
}
}
GL.ActiveTexture(TextureUnit.Texture0 + vertBoneTexUnit);
GL.BindTexture(TextureTarget.TextureBuffer, vertBoneTexId);
GL.BindBuffer(BufferTarget.TextureBuffer, vertBoneBufferId);
GL.BufferData <uint>(BufferTarget.TextureBuffer, new IntPtr(lookupInts.Length * sizeof(uint)), lookupInts, BufferUsageHint.StaticDraw);
GL.BindBuffer(BufferTarget.TextureBuffer, 0);
}
/* Maaaaaaybe? I dunno... not using this yet either */
Vector2[] weights = new Vector2[(int)(Root.VatrChunk.BoneWeights.Length - sepd.BoneWeightArrayOffset) / 2];
for (int i = 0, j = 0; i < weights.Length; i++, j += 2)
{
weights[i] = new Vector2(
Root.VatrChunk.BoneWeights[sepd.BoneWeightArrayOffset + j],
Root.VatrChunk.BoneWeights[sepd.BoneWeightArrayOffset + (j + 1)]);
}
for (int i = 0; i < prms.BoneIndexCount; i++)
{
Matrix4 matrix = Matrix4.Identity;
SklChunk.Bone bone = Root.SklChunk.Bones.FirstOrDefault(x => x.BoneID == prms.BoneIndices[i]);
if (bone != null)
{
matrix = bone.GetMatrix(prms.SkinningMode != PrmsChunk.SkinningModes.PerVertexNoTrans);
}
GL.UniformMatrix4(GL.GetUniformLocation(program, string.Format("boneMatrix[{0}]", i)), false, ref matrix);
}
}
public void BindBuffers(ref Texture tex)
{
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2D, tex.TBO); //was 0
}
float UniformOffsetY = 1.8f; // fractal vertical offset
#endregion private Fields
#region OnLoad
/// <summary>
/// Setup OpenGL and load resources here.
/// </summary>
/// <param name="e">Not used.</param>
protected override void OnLoad(EventArgs e)
{
// Check for necessary capabilities:
string version = GL.GetString(StringName.Version);
int major = (int)version[0];
int minor = (int)version[2];
if (major < 2)
{
MessageBox.Show("You need at least OpenGL 2.0 to run this example. Aborting.",
"GLSL not supported", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
this.Exit();
}
this.VSync = VSyncMode.On;
GL.Disable(EnableCap.Dither);
GL.ClearColor(0.2f, 0f, 0.4f, 0f);
// declare some variables for tracking which shader did compile, and which texture to use
string[] ShaderFilenames = new string[2];
ShaderFilenames[0] = "Data/Shaders/JuliaSet_SM3_FS.glsl";
ShaderFilenames[1] = "Data/Shaders/JuliaSet_SM2_FS.glsl";
byte CurrentOption = 0;
string LogInfo;
#region Shaders
// Load&Compile Vertex Shader
using (StreamReader sr = new StreamReader("Data/Shaders/JuliaSet_VS.glsl"))
{
VertexShaderObject = GL.CreateShader(ShaderType.VertexShader);
GL.ShaderSource(VertexShaderObject, sr.ReadToEnd());
GL.CompileShader(VertexShaderObject);
}
GL.GetShaderInfoLog(VertexShaderObject, out LogInfo);
if (LogInfo.Length > 0 && !LogInfo.Contains("hardware"))
{
Trace.WriteLine("Vertex Shader Log:\n" + LogInfo);
}
else
{
Trace.WriteLine("Vertex Shader compiled without complaint.");
}
// Load&Compile Fragment Shader
FragmentShaderObject = GL.CreateShader(ShaderType.FragmentShader);
do
{
using (StreamReader sr = new StreamReader(ShaderFilenames[CurrentOption]))
{
GL.ShaderSource(FragmentShaderObject, sr.ReadToEnd());
GL.CompileShader(FragmentShaderObject);
}
GL.GetShaderInfoLog(FragmentShaderObject, out LogInfo);
if (LogInfo.Length > 0 && !LogInfo.Contains("hardware"))
{
Trace.WriteLine("Compiling " + ShaderFilenames[CurrentOption] + " failed!\nLog:\n" + LogInfo);
}
else
{
Trace.WriteLine("Fragment Shader compiled without complaint.");
break;
}
if (++CurrentOption > 1)
{
MessageBox.Show("Neither SM2 nor SM3 Fragment Shader compiled successfully. Aborting.",
"Fatal Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
this.Exit();
}
} while (true);
// Link the Shaders to a usable Program
ProgramObject = GL.CreateProgram();
GL.AttachShader(ProgramObject, VertexShaderObject);
GL.AttachShader(ProgramObject, FragmentShaderObject);
GL.LinkProgram(ProgramObject);
// make current
GL.UseProgram(ProgramObject);
// Flag ShaderObjects for delete when app exits
GL.DeleteShader(VertexShaderObject);
GL.DeleteShader(FragmentShaderObject);
#endregion Shaders
#region Textures
// Load&Bind the 1D texture for color lookups
GL.ActiveTexture(TextureUnit.Texture0); // select TMU0
GL.GenTextures(1, out TextureObject);
GL.TexParameter(TextureTarget.Texture1D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
GL.TexParameter(TextureTarget.Texture1D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
GL.TexParameter(TextureTarget.Texture1D, TextureParameterName.TextureWrapS, (int)(TextureWrapMode)All.ClampToEdge);
using (Bitmap bitmap = new Bitmap("Data/Textures/JuliaColorTable.bmp"))
{
BitmapData data = bitmap.LockBits(new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly,
System.Drawing.Imaging.PixelFormat.Format24bppRgb);
GL.TexImage1D(TextureTarget.Texture1D, 0, PixelInternalFormat.Rgb8, data.Width, 0, OpenTK.Graphics.OpenGL.PixelFormat.Bgr,
PixelType.UnsignedByte, data.Scan0);
bitmap.UnlockBits(data);
}
#endregion Textures
Keyboard.KeyUp += KeyUp;
}
public override void Draw(GL_ControlModern control, Pass pass)
{
if (!Runtime.OpenTKInitialized || !Runtime.PBR.UseSkybox || pass == Pass.TRANSPARENT)
{
return;
}
GL.Disable(EnableCap.CullFace);
GL.Enable(EnableCap.DepthTest);
GL.DepthFunc(DepthFunction.Lequal);
// GL.Enable(EnableCap.LineSmooth);
// GL.Enable(EnableCap.StencilTest);
// GL.StencilOp(StencilOp.Keep, StencilOp.Keep, StencilOp.Replace);
control.CurrentShader = defaultShaderProgram;
// enable seamless cubemap sampling for lower mip levels in the pre-filter map.
GL.Enable(EnableCap.TextureCubeMapSeamless);
Matrix4 proj = control.ProjectionMatrix;
// Matrix4 rot = Matrix4.CreateFromQuaternion(control.ModelMatrix.ExtractRotation());
Matrix4 rot = new Matrix4(new Matrix3(control.CameraMatrix));
defaultShaderProgram.SetMatrix4x4("projection", ref proj);
defaultShaderProgram.SetMatrix4x4("rotView", ref rot);
if (CustomCubemap != null)
{
GL.ActiveTexture(TextureUnit.Texture0);
CustomCubemap.Bind();
}
else
{
if (Runtime.PBR.UseDiffuseSkyTexture)
{
//Load Cubemap
if (RenderTools.diffusePbr != null)
{
GL.ActiveTexture(TextureUnit.Texture0);
RenderTools.diffusePbr.Bind();
}
}
else
{
//Load Cubemap
if (RenderTools.specularPbr != null)
{
GL.ActiveTexture(TextureUnit.Texture0);
RenderTools.specularPbr.Bind();
}
}
}
int cubeVBO = 0;
if (cubeVBO == 0)
{
float[] vertices =
{
// back face
-1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, // bottom-left
1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, // top-right
1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, // bottom-right
1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, // top-right
-1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, // bottom-left
-1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, // top-left
// front face
-1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, // bottom-left
1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, // bottom-right
1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, // top-right
1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, // top-right
-1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, // top-left
-1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, // bottom-left
// left face
-1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, // top-right
-1.0f, 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f, // top-left
-1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, // bottom-left
-1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, // bottom-left
-1.0f, -1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, // bottom-right
-1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, // top-right
// right face
1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, // top-left
1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, // bottom-right
1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, // top-right
1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, // bottom-right
1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, // top-left
1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, // bottom-left
// bottom face
-1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, // top-right
1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 1.0f, // top-left
1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, // bottom-left
1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, // bottom-left
-1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, // bottom-right
-1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, // top-right
// top face
-1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, // top-left
1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, // bottom-right
1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, // top-right
1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, // bottom-right
-1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, // top-left
-1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f // bottom-left
};
GL.GenVertexArrays(1, out cubeVBO);
GL.GenBuffers(1, out cubeVBO);
GL.BindBuffer(BufferTarget.ArrayBuffer, cubeVBO);
GL.BufferData(BufferTarget.ArrayBuffer, 4 * vertices.Length, vertices, BufferUsageHint.StaticDraw);
GL.BindVertexArray(cubeVBO);
GL.EnableVertexAttribArray(0);
GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, 8 * sizeof(float), (IntPtr)0);
GL.EnableVertexAttribArray(1);
GL.VertexAttribPointer(1, 3, VertexAttribPointerType.Float, false, 8 * sizeof(float), (IntPtr)(3 * sizeof(float)));
GL.EnableVertexAttribArray(2);
GL.VertexAttribPointer(2, 2, VertexAttribPointerType.Float, false, 8 * sizeof(float), (IntPtr)(6 * sizeof(float)));
GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
GL.BindVertexArray(0);
}
GL.BindVertexArray(cubeVBO);
GL.DrawArrays(PrimitiveType.Triangles, 0, 36);
GL.BindVertexArray(0);
GL.Enable(EnableCap.CullFace);
}
public override void Bind(int texu)
{
GL.ActiveTexture(TextureUnit.Texture0 + texu);
GL.Enable(EnableCap.TextureCubeMap);
GL.BindTexture(TextureTarget.TextureCubeMap, ID);
}
private void SetTextureUniforms(ShaderProgram shader, HSFMaterialWrapper mat)
{
if (uboAtt == -1)
{
SetAttributeUBO();
}
var index = GL.GetUniformBlockIndex(shader.program, "AttributeBlock");
GL.UniformBlockBinding(shader.program, index, 0);
GL.BindBuffer(BufferTarget.UniformBuffer, uboAtt);
GL.BufferData(BufferTarget.UniformBuffer, TextureAttribute.Size, IntPtr.Zero, BufferUsageHint.StaticDraw);
GL.BindBufferBase(BufferRangeTarget.UniformBuffer, index, uboAtt);
GL.BindBuffer(BufferTarget.UniformBuffer, 0);
LoadDebugTextureMaps(shader);
GL.ActiveTexture(TextureUnit.Texture0 + 1);
GL.BindTexture(TextureTarget.Texture2D, RenderTools.defaultTex.RenderableTex.TexID);
shader.SetInt("textureCount", mat.TextureMaps.Count);
Console.WriteLine($"textureCount {mat.TextureMaps.Count}");
TextureAttribute[] attriutes = new TextureAttribute[6];
for (int i = 0; i < 6; i++)
{
if (i == 1)
{
attriutes[i].texPositionStart = new Vector2(0.5f, 1);
attriutes[i].texPositionEnd = new Vector2(1, 1);
attriutes[i].texScaleStart = new Vector2(1, 1);
attriutes[i].texScaleEnd = new Vector2(0, 0);
}
else
{
attriutes[i].texPositionStart = new Vector2(0, 0);
attriutes[i].texPositionEnd = new Vector2(1, 1);
attriutes[i].texScaleStart = new Vector2(1, 1);
attriutes[i].texScaleEnd = new Vector2(0, 0);
}
}
var attributeData = mat.ParentHSF.Header.AttributeData;
for (int i = 0; i < mat.TextureMaps.Count; i++)
{
var hsfTexture = (HSFMatTexture)mat.TextureMaps[i];
var texStart = hsfTexture.Attribute.TexAnimStart;
var texEnd = hsfTexture.Attribute.TexAnimEnd;
attriutes[i].texPositionStart = new Vector2(texStart.Position.X, texStart.Position.Y);
attriutes[i].texPositionEnd = new Vector2(texEnd.Position.X, texEnd.Position.Y);
attriutes[i].texScaleStart = new Vector2(texStart.Scale.X, texStart.Scale.Y);
attriutes[i].texScaleEnd = new Vector2(texEnd.Scale.X, texEnd.Scale.Y);
// attriutes[i].texParam = hsfTexture.Attribute.NbtEnable;
// attriutes[i].blendingFlag = hsfTexture.Attribute.BlendingFlag;
// attriutes[i].alphaFlag = hsfTexture.Attribute.AlphaFlag;
int attIndex = attributeData.Attributes.IndexOf(hsfTexture.Attribute);
if (HSFParent.Header.AttributeAnimControllers.ContainsKey(attIndex))
{
var controller = HSFParent.Header.AttributeAnimControllers[attIndex];
attriutes[i].texPositionStart.X = controller.TranslateX;
attriutes[i].texPositionStart.Y = controller.TranslateY;
}
var binded = BindTexture(shader, Scene.Models[0].Textures, (HSFMatTexture)mat.TextureMaps[i], i + 1);
shader.SetInt($"texture{i}", i + 1);
}
GL.BindBuffer(BufferTarget.UniformBuffer, uboAtt);
GL.BufferSubData(BufferTarget.UniformBuffer, IntPtr.Zero, TextureAttribute.Size, attriutes);
GL.BindBuffer(BufferTarget.UniformBuffer, 0);
}
Font(byte[] fontData)
{
atlasWidth = 0;
atlasHeight = 0;
int roww = 0;
int rowh = 0;
fntFace = new Face(fntLibrary, fontData, 0);
fntFace.SetPixelSizes(0, FONT_SIZE);
for (uint i = 0; i < 512; i++)
{
fntFace.LoadChar(i, LoadFlags.Render, LoadTarget.Normal);
if (roww + fntFace.Glyph.Bitmap.Width + 1 >= MAX_SIZE)
{
atlasWidth = Math.Max(atlasWidth, roww);
atlasHeight += rowh;
roww = 0;
rowh = 0;
}
roww += fntFace.Glyph.Bitmap.Width + 1;
rowh = Math.Max(rowh, fntFace.Glyph.Bitmap.Rows);
}
atlasWidth = Math.Max(atlasWidth, roww);
atlasHeight += rowh;
GL.PixelStore(PixelStoreParameter.UnpackAlignment, 1);
AtlasTexture = new Texture(atlasWidth, atlasHeight);
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2D, AtlasTexture.Handle);
int ox = 0, oy = 0;
rowh = 0;
characters = new Dictionary <char, Character>();
for (uint i = 32; i < 512; i++)
{
fntFace.LoadChar(i, LoadFlags.Render, LoadTarget.Normal);
if (ox + fntFace.Glyph.Bitmap.Width + 1 >= MAX_SIZE)
{
oy += rowh;
rowh = 0;
ox = 0;
}
GL.TexSubImage2D(TextureTarget.Texture2D, 0, ox, oy, fntFace.Glyph.Bitmap.Width, fntFace.Glyph.Bitmap.Rows, PixelFormat.Alpha, PixelType.UnsignedByte, fntFace.Glyph.Bitmap.Buffer);
var chara = new Character
{
AdvanceX = fntFace.Glyph.Advance.X.Value >> 6,
AdvanceY = fntFace.Glyph.Advance.Y.Value >> 6,
BitmapWidth = fntFace.Glyph.Bitmap.Width,
BitmapHeight = fntFace.Glyph.Bitmap.Rows,
BitmapLeft = fntFace.Glyph.BitmapLeft,
BitmapTop = fntFace.Glyph.BitmapTop,
TexCoordX = (float)ox / (float)atlasWidth,
TexCoordY = (float)oy / (float)atlasHeight
};
rowh = Math.Max(rowh, fntFace.Glyph.Bitmap.Rows);
ox += fntFace.Glyph.Bitmap.Width + 1;
characters.Add((char)i, chara);
if (fntFace.Glyph.Bitmap.Rows > LineHeight)
{
LineHeight = fntFace.Glyph.Bitmap.Rows;
}
}
GL.PixelStore(PixelStoreParameter.UnpackAlignment, 4);
}
public void EnableTextureOne()
{
GL.ActiveTexture(TextureUnit.Texture0);
GL.Enable(EnableCap.Texture2D);
}
private void CreateImmutableStorage()
{
TextureTarget target = Info.Target.Convert();
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(target, Handle);
FormatInfo format = FormatTable.GetFormatInfo(Info.Format);
SizedInternalFormat internalFormat;
if (format.IsCompressed)
{
internalFormat = (SizedInternalFormat)format.PixelFormat;
}
else
{
internalFormat = (SizedInternalFormat)format.PixelInternalFormat;
}
int levels = Info.GetLevelsClamped();
switch (Info.Target)
{
case Target.Texture1D:
GL.TexStorage1D(
TextureTarget1d.Texture1D,
levels,
internalFormat,
Info.Width);
break;
case Target.Texture1DArray:
GL.TexStorage2D(
TextureTarget2d.Texture1DArray,
levels,
internalFormat,
Info.Width,
Info.Height);
break;
case Target.Texture2D:
GL.TexStorage2D(
TextureTarget2d.Texture2D,
levels,
internalFormat,
Info.Width,
Info.Height);
break;
case Target.Texture2DArray:
GL.TexStorage3D(
TextureTarget3d.Texture2DArray,
levels,
internalFormat,
Info.Width,
Info.Height,
Info.Depth);
break;
case Target.Texture2DMultisample:
GL.TexStorage2DMultisample(
TextureTargetMultisample2d.Texture2DMultisample,
Info.Samples,
internalFormat,
Info.Width,
Info.Height,
true);
break;
case Target.Texture2DMultisampleArray:
GL.TexStorage3DMultisample(
TextureTargetMultisample3d.Texture2DMultisampleArray,
Info.Samples,
internalFormat,
Info.Width,
Info.Height,
Info.Depth,
true);
break;
case Target.Texture3D:
GL.TexStorage3D(
TextureTarget3d.Texture3D,
levels,
internalFormat,
Info.Width,
Info.Height,
Info.Depth);
break;
case Target.Cubemap:
GL.TexStorage2D(
TextureTarget2d.TextureCubeMap,
levels,
internalFormat,
Info.Width,
Info.Height);
break;
case Target.CubemapArray:
GL.TexStorage3D(
(TextureTarget3d)All.TextureCubeMapArray,
levels,
internalFormat,
Info.Width,
Info.Height,
Info.Depth);
break;
default:
Logger.Debug?.Print(LogClass.Gpu, $"Invalid or unsupported texture target: {target}.");
break;
}
}
protected override void OnLoad(EventArgs e)
{
Vertex[] vertices =
{
new Vertex(new Vector2(-0.5f, 0.5f), Color.Red, new Vector2(0.0f, 0.0f)),
new Vertex(new Vector2(0.5f, 0.5f), Color.Green, new Vector2(1.0f, 0.0f)),
new Vertex(new Vector2(0.5f, -0.5f), Color.Yellow, new Vector2(1.0f, 1.0f)),
new Vertex(new Vector2(-0.5f, -0.5f), Color.Blue, new Vector2(0.0f, 1.0f))
};
uint[] elements =
{
0, 1, 2,
2, 3, 0
};
//vbo
GL.GenBuffers(1, out uint vboHandle); //speicher reservieren auf GK
GL.BindBuffer(BufferTarget.ArrayBuffer, vboHandle); //buffer "aktivieren"
GL.BufferData(BufferTarget.ArrayBuffer, vertices.Length * Vertex.SIZE, vertices, BufferUsageHint.StaticDraw); //vertices array auf GK schreiben
//vao
GL.GenVertexArrays(1, out vaoHandle);
GL.BindVertexArray(vaoHandle);
//eao
GL.GenBuffers(1, out uint eaoHandle);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, eaoHandle);
GL.BufferData(BufferTarget.ElementArrayBuffer, elements.Length * sizeof(uint), elements, BufferUsageHint.StaticDraw);
//shaders
#region shadercode
string vertShaderSource = @"#version 450
in vec2 position;
in vec4 color;
in vec2 texCoord;
out vec4 Color;
out vec2 TexCoord;
void main(){
Color = color;
TexCoord = texCoord;
gl_Position = vec4(position , 0.0, 1.0);
}";
string fragShaderSource = @"#version 450
uniform sampler2D texKatze;
uniform sampler2D texPuppy;
in vec4 Color;
in vec2 TexCoord;
out vec4 outColor;
void main(){
//outColor = color;
vec4 colKatze = texture(texKatze, TexCoord);
vec4 colPuppy = texture(texPuppy, TexCoord);
outColor = mix(colPuppy,colKatze, 0.5) * (0.5* Color);
}";
#endregion
int vertShaderHandle = GL.CreateShader(ShaderType.VertexShader); //reserve some mem for shader
GL.ShaderSource(vertShaderHandle, vertShaderSource); //load glsl code to shader
GL.CompileShader(vertShaderHandle); //compile shader
Console.WriteLine("VertShader: " + GL.GetShaderInfoLog(vertShaderHandle)); //write log to output
int fragShaderHandle = GL.CreateShader(ShaderType.FragmentShader);
GL.ShaderSource(fragShaderHandle, fragShaderSource);
GL.CompileShader(fragShaderHandle);
Console.WriteLine("FragShader: " + GL.GetShaderInfoLog(fragShaderHandle));
shaderProgHandle = GL.CreateProgram();
GL.AttachShader(shaderProgHandle, vertShaderHandle);
GL.AttachShader(shaderProgHandle, fragShaderHandle);
GL.BindFragDataLocation(shaderProgHandle, 0, "outColor");
GL.LinkProgram(shaderProgHandle);
GL.UseProgram(shaderProgHandle);
GL.DetachShader(shaderProgHandle, vertShaderHandle);
GL.DetachShader(shaderProgHandle, fragShaderHandle);
//attributes
int posAttrLoc = GL.GetAttribLocation(shaderProgHandle, "position"); //handle des attributs finden
GL.EnableVertexAttribArray(posAttrLoc); //attribut aktivieren (abwehrkräfte)
GL.VertexAttribPointer(posAttrLoc, 2, VertexAttribPointerType.Float, false, Vertex.SIZE, 0); //attribut "lesbar machen2
int colAttrLoc = GL.GetAttribLocation(shaderProgHandle, "color");
GL.EnableVertexAttribArray(colAttrLoc);
GL.VertexAttribPointer(colAttrLoc, 4, VertexAttribPointerType.Float, false, Vertex.SIZE, 2 * sizeof(float));
int texAttrLoc = GL.GetAttribLocation(shaderProgHandle, "texCoord");
GL.EnableVertexAttribArray(texAttrLoc);
GL.VertexAttribPointer(texAttrLoc, 2, VertexAttribPointerType.Float, false, Vertex.SIZE, 6 * sizeof(float));
//texture
uint[] textureHandles = new uint[2];
GL.GenTextures(2, textureHandles);
//katze
GL.ActiveTexture(TextureUnit.Texture0);
Bitmap bmpKatze = (Bitmap)Bitmap.FromFile("sample.png"); //load texture
System.Drawing.Imaging.BitmapData dataKatze = bmpKatze.LockBits(new Rectangle(0, 0, bmpKatze.Width, bmpKatze.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
GL.BindTexture(TextureTarget.Texture2D, textureHandles[0]); //bind texture to operate on it
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, bmpKatze.Width, bmpKatze.Height, 0, PixelFormat.Rgba, PixelType.UnsignedByte, dataKatze.Scan0);
bmpKatze.UnlockBits(dataKatze);
GL.Uniform1(GL.GetUniformLocation(shaderProgHandle, "texKatze"), 0); //set texKatze to texture 0
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)All.Linear); //set texture parameter
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)All.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)All.ClampToEdge);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)All.ClampToEdge);
//hund
GL.ActiveTexture(TextureUnit.Texture1);
Bitmap bmpHund = (Bitmap)Bitmap.FromFile("sample2.png"); //lade textur
System.Drawing.Imaging.BitmapData dataHund = bmpHund.LockBits(new Rectangle(0, 0, bmpHund.Width, bmpHund.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
GL.BindTexture(TextureTarget.Texture2D, textureHandles[1]);
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, bmpHund.Width, bmpHund.Height, 0, PixelFormat.Rgba, PixelType.UnsignedByte, dataHund.Scan0);
bmpHund.UnlockBits(dataHund);
GL.Uniform1(GL.GetUniformLocation(shaderProgHandle, "texPuppy"), 1);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)All.Linear); //set texture parameter
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)All.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)All.ClampToEdge);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)All.ClampToEdge);
Console.WriteLine(GL.GetError());
GL.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
}
public void DrawBatch(SpriteSortMode sortMode, SamplerState samplerState)
{
// nothing to do
if (_batchItemList.Count == 0)
{
return;
}
// sort the batch items
switch (sortMode)
{
case SpriteSortMode.Texture:
_batchItemList.Sort(CompareTexture);
break;
case SpriteSortMode.FrontToBack:
_batchItemList.Sort(CompareDepth);
break;
case SpriteSortMode.BackToFront:
_batchItemList.Sort(CompareReverseDepth);
break;
}
int size = sizeof(float) * 4 + sizeof(uint);
GL.VertexPointer(2, VertexPointerType.Float, size, _vertexHandle.AddrOfPinnedObject());
GL.ColorPointer(4, ColorPointerType.UnsignedByte, size, (IntPtr)((UInt64)_vertexHandle.AddrOfPinnedObject() + sizeof(float) * 2));
GL.TexCoordPointer(2, TexCoordPointerType.Float, size, (IntPtr)((UInt64)_vertexHandle.AddrOfPinnedObject() + sizeof(float) * 2 + sizeof(uint)));
// setup the vertexArray array
int startIndex = 0;
int index = 0;
int texID = -1;
// make sure the vertexArray has enough space
if (_batchItemList.Count * 4 > _vertexArray.Length)
{
ExpandVertexArray(_batchItemList.Count);
}
foreach (SpriteBatchItem item in _batchItemList)
{
// if the texture changed, we need to flush and bind the new texture
if (item.TextureID != texID)
{
FlushVertexArray(startIndex, index);
startIndex = index;
texID = item.TextureID;
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2D, texID);
samplerState.Activate();
}
// store the SpriteBatchItem data in our vertexArray
_vertexArray[index++] = item.vertexTL;
_vertexArray[index++] = item.vertexTR;
_vertexArray[index++] = item.vertexBL;
_vertexArray[index++] = item.vertexBR;
_freeBatchItemQueue.Enqueue(item);
}
// flush the remaining vertexArray data
FlushVertexArray(startIndex, index);
_batchItemList.Clear();
}
public void Bind(TextureUnit textureSlot = TextureUnit.Texture0)
{
//When we bind a texture we can choose which textureslot we can bind it to.
_gl.ActiveTexture(textureSlot);
_gl.BindTexture(TextureTarget.Texture2D, _handle);
}
// This gets called when the drawing surface is ready
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
try {
// Clear the current Context
GraphicsContext.MakeCurrent(null);
// Create a secondary context using the same information the primary
// context was created with
backgroundContext = new AndroidGraphicsContext(GraphicsMode, WindowInfo, GraphicsContext, ContextRenderingApi, GraphicsContextFlags.Embedded);
}catch {
// secondary context not supported
backgroundContext = null;
}
MakeCurrent();
var vertexShader = LoadShader(ShaderType.VertexShader, vertexShaderCode);
var fragmentShader = LoadShader(ShaderType.FragmentShader, fragmentShaderCode);
program = GL.CreateProgram(); // create empty OpenGL Program
GL.AttachShader(program, vertexShader); // add the vertex shader to program
GL.AttachShader(program, fragmentShader); // add the fragment shader to program
GL.BindAttribLocation(program, ATTRIB_VERTEX, "position");
GL.BindAttribLocation(program, ATTRIB_TEXCOORD, "texcoord");
GL.LinkProgram(program); // create OpenGL program executables
uniformTextureLocation = GL.GetUniformLocation(program, "texture");
if (vertexShader != 0)
{
GL.DetachShader(program, vertexShader);
GL.DeleteShader(vertexShader);
}
if (fragmentShader != 0)
{
GL.DetachShader(program, fragmentShader);
GL.DeleteShader(fragmentShader);
}
GL.Viewport(0, 0, Width, Height);
// Run the render loop
Run();
Task.Factory.StartNew(() => {
//Thread.Sleep(500);
// load the bitmap
bitmap = BitmapFactory.DecodeResource(Context.Resources, Resource.Drawable.f_spot);
// the device may or may not support a background Context. But rather than
// duplicating this code we just create an Action which we can invoke on this
// background thread later or queue to be executed on the rendering thread.
Action acton = new Action(() => {
GL.Enable(EnableCap.Texture2D);
GL.GenTextures(1, out textureid);
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2D, textureid);
// setup texture parameters
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.ClampToEdge);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.ClampToEdge);
Android.Opengl.GLUtils.TexImage2D((int)TextureTarget.Texture2D, 0, bitmap, 0);
// make sure the texture is pushed to the GPU.
GL.Flush();
// make sure we free resources
bitmap.Recycle();
bitmap.Dispose();
bitmap = null;
});
// take a lock so the main rendering thread does not try to draw anything
// there are other ways to do this, but its is probably the simplest
lock (lockobject) {
if (backgroundContext != null)
{
// Clear the current context bound to the Display
backgroundContext.MakeCurrent(null);
// make this context active
backgroundContext.MakeCurrent(WindowInfo);
// do our processing
acton.Invoke();
// clear the current context again so we don't error on the main thread
backgroundContext.MakeCurrent(null);
}
else
{
// Secondary Context's are not supported on this device
// queue the action for execution later.
actions.Enqueue(acton);
}
}
});
}
// render the mesh using the supplied shader and matrix
public void Render(Shader shader, Matrix4 transform, int texture, bool specular)
{
// on first run, prepare buffers
Prepare(shader);
// safety dance
GL.PushClientAttrib(ClientAttribMask.ClientVertexArrayBit);
// enable texture
int texLoc = GL.GetUniformLocation(shader.programID, "pixels");
GL.Uniform1(texLoc, 0);
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2D, texture);
int spec = GL.GetUniformLocation(shader.programID, "specular");
GL.UseProgram(shader.programID);
GL.Uniform1(spec, specular ? 1 : 0);
// enable shader
GL.UseProgram(shader.programID);
// pass transform to vertex shader
//transform.Row1 = new Vector4(0,transform.Row1.Y,0,1);
//Console.WriteLine(transform.Row1);
Matrix4 toWorld = transform;
transform *= Matrix4.CreateTranslation(-Game.CamPos);
transform *= Matrix4.CreateFromAxisAngle(new Vector3(0, 0, 1), Game.z);
transform *= Matrix4.CreateFromAxisAngle(new Vector3(0, 1, 0), Game.y);
transform *= Matrix4.CreateFromAxisAngle(new Vector3(1, 0, 0), Game.x);
transform *= Matrix4.CreatePerspectiveFieldOfView(1.2f, 1.3f, .1f, 1000);
GL.UniformMatrix4(shader.uniform_mview, false, ref transform);
GL.UniformMatrix4(shader.uniform_2wrld, false, ref toWorld);
// enable position, normal and uv attributes
GL.EnableVertexAttribArray(shader.attribute_vpos);
GL.EnableVertexAttribArray(shader.attribute_vnrm);
GL.EnableVertexAttribArray(shader.attribute_vuvs);
// bind interleaved vertex data
GL.EnableClientState(ArrayCap.VertexArray);
GL.BindBuffer(BufferTarget.ArrayBuffer, vertexBufferId);
GL.InterleavedArrays(InterleavedArrayFormat.T2fN3fV3f, Marshal.SizeOf(typeof(ObjVertex)), IntPtr.Zero);
// link vertex attributes to shader parameters
GL.VertexAttribPointer(shader.attribute_vuvs, 2, VertexAttribPointerType.Float, false, 32, 0);
GL.VertexAttribPointer(shader.attribute_vnrm, 3, VertexAttribPointerType.Float, true, 32, 2 * 4);
GL.VertexAttribPointer(shader.attribute_vpos, 3, VertexAttribPointerType.Float, false, 32, 5 * 4);
// bind triangle index data and render
GL.BindBuffer(BufferTarget.ElementArrayBuffer, triangleBufferId);
GL.DrawArrays(PrimitiveType.Triangles, 0, triangles.Length * 3);
// bind quad index data and render
if (quads.Length > 0)
{
GL.BindBuffer(BufferTarget.ElementArrayBuffer, quadBufferId);
GL.DrawArrays(PrimitiveType.Quads, 0, quads.Length * 4);
}
// restore previous OpenGL state
GL.UseProgram(0);
GL.PopClientAttrib();
}
public void DisplayPixelBuffer(CVPixelBuffer pixelBuffer)
{
DrawTextInCorner(pixelBuffer);
CVReturn error;
if (pixelBuffer != null)
{
int frameWidth = (int)pixelBuffer.Width;
int frameHeight = (int)pixelBuffer.Height;
if (videoTextureCache == null)
{
Console.WriteLine("No video texture cache");
return;
}
CleanUpTextures();
CVAttachmentMode attachmentMode;
var colorAttachments = pixelBuffer.GetAttachment <NSString> (CVImageBuffer.YCbCrMatrixKey, out attachmentMode);
if (colorAttachments == CVImageBuffer.YCbCrMatrix_ITU_R_601_4)
{
preferredConversion = colorConversion601;
}
else
{
preferredConversion = colorConversion709;
}
GL.ActiveTexture(TextureUnit.Texture0);
lumaTexture = videoTextureCache.TextureFromImage(pixelBuffer, true, All.RedExt, frameWidth, frameHeight,
All.RedExt, DataType.UnsignedByte, 0, out error);
if (lumaTexture == null)
{
Console.WriteLine("Error at CVOpenGLESTextureCach.TextureFromImage");
}
GL.BindTexture(lumaTexture.Target, lumaTexture.Name);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)All.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)All.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)All.ClampToEdge);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)All.ClampToEdge);
GL.ActiveTexture(TextureUnit.Texture1);
chromaTexture = videoTextureCache.TextureFromImage(pixelBuffer, true, All.RgExt, frameWidth / 2, frameHeight / 2,
All.RgExt, DataType.UnsignedByte, 1, out error);
if (chromaTexture == null)
{
Console.WriteLine("Error at CVOpenGLESTextureCach.TextureFromImage");
}
GL.BindTexture(chromaTexture.Target, chromaTexture.Name);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)All.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)All.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)All.ClampToEdge);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)All.ClampToEdge);
GL.BindFramebuffer(FramebufferTarget.Framebuffer, frameBufferHandle);
GL.Viewport(0, 0, backingWidth, backingHeight);
}
GL.ClearColor(0f, 0f, 0f, 1f);
GL.Clear(ClearBufferMask.ColorBufferBit);
GL.UseProgram(Program);
GL.Uniform1(uniforms [(int)UniformIndex.RotationAngle], 0f);
GL.UniformMatrix3(uniforms [(int)UniformIndex.ColorConversionMatrix], 1, false, preferredConversion);
CGRect vertexSamplingRect = AVUtilities.WithAspectRatio(Bounds, PresentationRect);
var normalizedSamplingSize = new CGSize(0f, 0f);
var cropScaleAmount = new CGSize(vertexSamplingRect.Width / Bounds.Width, vertexSamplingRect.Height / Bounds.Height);
if (cropScaleAmount.Width > cropScaleAmount.Height)
{
normalizedSamplingSize.Width = 1f;
normalizedSamplingSize.Height = cropScaleAmount.Height / cropScaleAmount.Width;
}
else
{
normalizedSamplingSize.Width = 1f;
normalizedSamplingSize.Height = cropScaleAmount.Width / cropScaleAmount.Height;
}
float[] quadVertexData =
{
-1f * (float)normalizedSamplingSize.Width, -1f * (float)normalizedSamplingSize.Height,
(float)normalizedSamplingSize.Width, -1f * (float)normalizedSamplingSize.Height,
-1f * (float)normalizedSamplingSize.Width, (float)normalizedSamplingSize.Height,
(float)normalizedSamplingSize.Width, (float)normalizedSamplingSize.Height,
};
GL.VertexAttribPointer((int)AttributeIndex.Vertex, 2, VertexAttribPointerType.Float, false, 0, quadVertexData);
GL.EnableVertexAttribArray((int)AttributeIndex.Vertex);
var textureSamplingRect = new CGRect(0, 0, 1, 1);
float[] quadTextureData =
{
(float)textureSamplingRect.GetMinX(), (float)textureSamplingRect.GetMaxY(),
(float)textureSamplingRect.GetMaxX(), (float)textureSamplingRect.GetMaxY(),
(float)textureSamplingRect.GetMinX(), (float)textureSamplingRect.GetMinY(),
(float)textureSamplingRect.GetMaxX(), (float)textureSamplingRect.GetMinY()
};
GL.VertexAttribPointer((int)AttributeIndex.TextureCoordinates, 2, VertexAttribPointerType.Float, false, 0, quadTextureData);
GL.EnableVertexAttribArray((int)AttributeIndex.TextureCoordinates);
GL.DrawArrays(BeginMode.TriangleStrip, 0, 4);
GL.BindRenderbuffer(RenderbufferTarget.Renderbuffer, colorBufferHandle);
context.PresentRenderBuffer((int)RenderbufferTarget.Renderbuffer);
}
public static int LoadTexture(string filename, CacheStorage cache)
{
GL.ActiveTexture(TextureUnit.Texture0);
filename = filename.ToLower();
if (cache.materials.ContainsKey(filename))
{
return(cache.materials[filename]);
}
int textureId = GL.GenTexture();
using (var blp = new BlpFile(CASC.cascHandler.OpenFile(filename)))
{
switch (blp.encoding)
{
case 1:
case 2: // Temporary
case 3:
var bmp = blp.GetBitmap(0);
if (bmp == null)
{
throw new Exception("BMP is null!");
}
GL.BindTexture(TextureTarget.Texture2D, textureId);
cache.materials.Add(filename, textureId);
System.Drawing.Imaging.BitmapData bmp_data = bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, bmp_data.Width, bmp_data.Height, 0, PixelFormat.Bgra, PixelType.UnsignedByte, bmp_data.Scan0);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat);
bmp.UnlockBits(bmp_data);
break;
/*case 2:
* DXTDecompression.DXTFlags flags = (blp.alphaDepth > 1) ? ((blp.alphaEncoding == 7) ? DXTDecompression.DXTFlags.DXT5 : DXTDecompression.DXTFlags.DXT3) : DXTDecompression.DXTFlags.DXT1;
*
* var width = blp.width / (int)Math.Pow(2.0, blp.MipMapCount);
* var height = blp.height / (int)Math.Pow(2.0, blp.MipMapCount);
*
* int blockSize;
* PixelInternalFormat format;
*
* if ((flags & DXTDecompression.DXTFlags.DXT1) != 0)
* {
* blockSize = 8;
* format = PixelInternalFormat.CompressedRgbaS3tcDxt1Ext;
* }
* else if((flags & DXTDecompression.DXTFlags.DXT3) != 0)
* {
* blockSize = 16;
* format = PixelInternalFormat.CompressedRgbaS3tcDxt3Ext;
* }
* else if((flags & DXTDecompression.DXTFlags.DXT5) != 0)
* {
* blockSize = 16;
* format = PixelInternalFormat.CompressedRgbaS3tcDxt5Ext;
* }
* else
* {
* throw new Exception("Unsupported DXT format!");
* }
*
* GL.BindTexture(TextureTarget.Texture2D, textureId);
* cache.materials.Add(filename, textureId);
*
* for (var i = blp.MipMapCount - 1; i >= 0; i--)
* {
* if ((width *= 2) == 0)
* {
* width = 1;
* }
*
* if ((height *= 2) == 0)
* {
* height = 1;
* }
*
* var size = ((width + 3) / 4) * ((height + 3) / 4) * blockSize;
*
* var data = blp.GetPictureData(i);
*
* GL.CompressedTexImage2D(TextureTarget.Texture2D, i, format, width, height, 0, size, );
* }
*
* GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.LinearMipmapLinear);
* GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
* GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat);
* GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat);
*
* break;
*/
default:
throw new Exception("BLP error!");
}
}
return(textureId);
}
private void _drawGrids()
{
var mapId = _eyeManager.CurrentMap;
if (!_mapManager.TryGetMap(mapId, out var map))
{
// fall back to the default eye's map
_eyeManager.CurrentEye = null;
map = _mapManager.GetMap(_eyeManager.CurrentMap);
}
var atlasTexture = _tileDefinitionManager.TileTextureAtlas;
var loadedTex = _loadedTextures[((ClydeTexture)atlasTexture).TextureId];
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2D, loadedTex.OpenGLObject.Handle);
GL.ActiveTexture(TextureUnit.Texture1);
if (_lightingReady)
{
var lightTexture = _loadedTextures[LightRenderTarget.Texture.TextureId].OpenGLObject;
GL.BindTexture(TextureTarget.Texture2D, lightTexture.Handle);
}
else
{
var white = _loadedTextures[((ClydeTexture)Texture.White).TextureId].OpenGLObject;
GL.BindTexture(TextureTarget.Texture2D, white.Handle);
}
var gridProgram = _loadedShaders[_defaultShader.Handle].Program;
gridProgram.Use();
gridProgram.SetUniformTextureMaybe(UniIMainTexture, TextureUnit.Texture0);
gridProgram.SetUniformTextureMaybe(UniILightTexture, TextureUnit.Texture1);
gridProgram.SetUniform(UniIModUV, new Vector4(0, 0, 1, 1));
gridProgram.SetUniform(UniIModulate, Color.White);
foreach (var mapGrid in map.GetAllGrids())
{
var grid = (IMapGridInternal)mapGrid;
if (!_mapChunkData.ContainsKey(grid.Index))
{
continue;
}
var model = Matrix3.Identity;
model.R0C2 = grid.WorldPosition.X;
model.R1C2 = grid.WorldPosition.Y;
gridProgram.SetUniform(UniIModelMatrix, model);
foreach (var(index, chunk) in grid.GetMapChunks())
{
if (_isChunkDirty(grid, chunk))
{
_updateChunkMesh(grid, chunk);
}
var datum = _mapChunkData[grid.Index][chunk.Indices];
if (datum.TileCount == 0)
{
continue;
}
GL.BindVertexArray(datum.VAO);
datum.EBO.Use();
datum.VBO.Use();
GL.DrawElements(BeginMode.TriangleStrip, datum.TileCount * 5, DrawElementsType.UnsignedShort, 0);
}
}
}
public void PrepareForRead()
{
GL.ActiveTexture(TextureUnit);
GL.Enable(EnableCap.Texture2D);
GL.BindTexture(TextureTarget.Texture2D, TextureID);
}
public void PrepareGL()
{
if (!Root.TexChunk.AreTexturesLoaded)
{
Root.TexChunk.LoadTextures();
}
if (!GL.IsTexture(emptyTexture))
{
emptyTexture = GL.GenTexture();
GL.BindTexture(TextureTarget.Texture2D, emptyTexture);
byte[] empty = new byte[]
{
255, 255, 255, 255,
255, 255, 255, 255,
255, 255, 255, 255,
255, 255, 255, 255
};
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, 2, 2, 0, OpenTK.Graphics.OpenGL.PixelFormat.Bgra, PixelType.UnsignedByte, empty);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat);
}
if (!GL.IsProgram(program))
{
string fsOverlay =
"#version 110\n" +
"\n" +
"void main()\n" +
"{\n" +
" gl_FragColor = vec4(1.0, 1.0, 1.0, 0.5);\n" +
"}\n";
Aglex.GLSL.CreateFragmentShader(ref fragmentObject, File.Open("general-fs.glsl", FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite));
Aglex.GLSL.CreateFragmentShader(ref fragmentObjectOverlay, fsOverlay);
Aglex.GLSL.CreateVertexShader(ref vertexObject, File.Open("general-vs.glsl", FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite));
Aglex.GLSL.CreateProgram(ref program, fragmentObject, vertexObject);
skinningModeLocation = GL.GetUniformLocation(program, "skinningMode");
boneIdLocation = GL.GetUniformLocation(program, "boneId");
vertBoneSamplerLocation = GL.GetUniformLocation(program, "vertBoneSampler");
tex0Location = GL.GetUniformLocation(program, "tex0");
tex1Location = GL.GetUniformLocation(program, "tex1");
tex2Location = GL.GetUniformLocation(program, "tex2");
materialColorLocation = GL.GetUniformLocation(program, "materialColor");
vertexScaleLocation = GL.GetUniformLocation(program, "vertexScale");
texCoordScaleLocation = GL.GetUniformLocation(program, "texCoordScale");
normalScaleLocation = GL.GetUniformLocation(program, "normalScale");
disableAlphaLocation = GL.GetUniformLocation(program, "disableAlpha");
enableLightingLocation = GL.GetUniformLocation(program, "enableLighting");
enableSkeletalStuffLocation = GL.GetUniformLocation(program, "enableSkeletalStuff");
Aglex.GLSL.CreateProgram(ref programOverlay, fragmentObjectOverlay, vertexObject);
vertexScaleLocationOverlay = GL.GetUniformLocation(programOverlay, "vertexScale");
skinningModeLocationOverlay = GL.GetUniformLocation(programOverlay, "skinningMode");
boneIdLocationOverlay = GL.GetUniformLocation(programOverlay, "boneId");
vertBoneSamplerLocationOverlay = GL.GetUniformLocation(programOverlay, "vertBoneSampler");
enableSkeletalStuffLocationOverlay = GL.GetUniformLocation(programOverlay, "enableSkeletalStuff");
}
if (vertBoneBufferId == -1)
{
vertBoneBufferId = GL.GenBuffer();
GL.BindBuffer(BufferTarget.TextureBuffer, vertBoneBufferId);
GL.BufferData(BufferTarget.TextureBuffer, new IntPtr(0x10000), IntPtr.Zero, BufferUsageHint.StaticDraw);
GL.BindBuffer(BufferTarget.TextureBuffer, 0);
}
if (vertBoneTexId == -1)
{
vertBoneTexId = GL.GenTexture();
GL.ActiveTexture(TextureUnit.Texture0 + vertBoneTexUnit);
GL.BindTexture(TextureTarget.TextureBuffer, vertBoneTexId);
GL.TexBuffer(TextureBufferTarget.TextureBuffer, SizedInternalFormat.R32ui, vertBoneBufferId);
GL.BindTexture(TextureTarget.TextureBuffer, 0);
}
if (vertexBufferObjects == null)
{
PrepareBuffers();
}
ready = true;
}
public void FinishRead()
{
GL.ActiveTexture(TextureUnit);
GL.Disable(EnableCap.Texture2D);
}
protected override void OnRenderFrame(FrameEventArgs e)
{
base.OnRenderFrame(e);
GL.Enable(EnableCap.DepthTest);
GL.Enable(EnableCap.LineSmooth);
GL.ClearColor(0.1f, 0.1f, 0.1f, 0.1f);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
modelShader.UseProgram();
// directional light
modelShader.SetVec3("dirLight.direction", -0.2f, -1.0f, -0.3f);
modelShader.SetVec3("dirLight.ambient", 0.05f, 0.05f, 0.05f);
modelShader.SetVec3("dirLight.diffuse", 0.4f, 0.4f, 0.4f);
modelShader.SetVec3("dirLight.specular", 0.5f, 0.5f, 0.5f);
// point light 1
modelShader.SetVec3("pointLights[0].position", pointLightPositions[0]);
modelShader.SetVec3("pointLights[0].ambient", 0.05f, 0.05f, 0.05f);
modelShader.SetVec3("pointLights[0].diffuse", 0.8f, 0.8f, 0.8f);
modelShader.SetVec3("pointLights[0].specular", 1.0f, 1.0f, 1.0f);
modelShader.SetFloat("pointLights[0].constant", 1.0f);
modelShader.SetFloat("pointLights[0].linear", 0.09f);
modelShader.SetFloat("pointLights[0].quadratic", 0.032f);
// point light 2
modelShader.SetVec3("pointLights[1].position", pointLightPositions[1]);
modelShader.SetVec3("pointLights[1].ambient", 0.05f, 0.05f, 0.05f);
modelShader.SetVec3("pointLights[1].diffuse", 0.8f, 0.8f, 0.8f);
modelShader.SetVec3("pointLights[1].specular", 1.0f, 1.0f, 1.0f);
modelShader.SetFloat("pointLights[1].constant", 1.0f);
modelShader.SetFloat("pointLights[1].linear", 0.09f);
modelShader.SetFloat("pointLights[1].quadratic", 0.032f);
// point light 3
modelShader.SetVec3("pointLights[2].position", pointLightPositions[2]);
modelShader.SetVec3("pointLights[2].ambient", 0.05f, 0.05f, 0.05f);
modelShader.SetVec3("pointLights[2].diffuse", 0.8f, 0.8f, 0.8f);
modelShader.SetVec3("pointLights[2].specular", 1.0f, 1.0f, 1.0f);
modelShader.SetFloat("pointLights[2].constant", 1.0f);
modelShader.SetFloat("pointLights[2].linear", 0.09f);
modelShader.SetFloat("pointLights[2].quadratic", 0.032f);
// point light 4
modelShader.SetVec3("pointLights[3].position", pointLightPositions[3]);
modelShader.SetVec3("pointLights[3].ambient", 0.05f, 0.05f, 0.05f);
modelShader.SetVec3("pointLights[3].diffuse", 0.8f, 0.8f, 0.8f);
modelShader.SetVec3("pointLights[3].specular", 1.0f, 1.0f, 1.0f);
modelShader.SetFloat("pointLights[3].constant", 1.0f);
modelShader.SetFloat("pointLights[3].linear", 0.09f);
modelShader.SetFloat("pointLights[3].quadratic", 0.032f);
// spotLight
modelShader.SetVec3("spotLight.position", camera.Position);
modelShader.SetVec3("spotLight.direction", camera.Front);
modelShader.SetVec3("spotLight.ambient", 0.0f, 0.0f, 0.0f);
modelShader.SetVec3("spotLight.diffuse", 1.0f, 1.0f, 1.0f);
modelShader.SetVec3("spotLight.specular", 1.0f, 1.0f, 1.0f);
modelShader.SetFloat("spotLight.constant", 1.0f);
modelShader.SetFloat("spotLight.linear", 0.09f);
modelShader.SetFloat("spotLight.quadratic", 0.032f);
modelShader.SetFloat("spotLight.cutOff", (float)Math.Cos(MathUtil.ToRadian(12.5f)));
modelShader.SetFloat("spotLight.outerCutOff", (float)Math.Cos(MathUtil.ToRadian(15.0f)));
modelShader.SetFloat("material.shininess", 32.0f);
modelShader.SetVec3("viewPos", camera.Position);
modelShader.SetMat4("view", camera.ViewMatrix);
var projection = Matrix4.CreatePerspectiveFieldOfView((float)(45.0f * Math.PI / 180),
Width / Height, 0.1f, 100.0f);
modelShader.SetMat4("projection", projection);
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2D, diffuseMap);
GL.ActiveTexture(TextureUnit.Texture1);
GL.BindTexture(TextureTarget.Texture2D, specularMap);
GL.BindVertexArray(cubeVAO);
// draw container box
for (int i = 0; i < cubePositions.Length; i++)
{
float angle = 20.0f * i;
var translation = Matrix4.CreateTranslation(cubePositions[i]);
var rotation = Matrix4.CreateFromAxisAngle(new Vector3(1.0f, 0.3f, 0.5f), MathUtil.ToRadian(angle));
var model = rotation * translation;
modelShader.SetMat4("model", model);
GL.DrawArrays(PrimitiveType.Triangles, 0, 36);
}
// draw point light
lampShader.UseProgram();
lampShader.SetMat4("projection", projection);
lampShader.SetMat4("view", camera.ViewMatrix);
for (int i = 0; i < pointLightPositions.Length; i++)
{
var lampModel = Matrix4.CreateScale(0.2f) * Matrix4.CreateTranslation(pointLightPositions[i]);
lampShader.SetMat4("model", lampModel);
GL.BindVertexArray(lightVAO);
GL.DrawArrays(PrimitiveType.Triangles, 0, 36);
}
SwapBuffers();
}
private void BindShadowMapToTexture()
{
GL.ActiveTexture(m_textureUnit);
GL.BindTexture(TextureTarget.Texture2D, m_textureID);
}
public void BindAndActivate(int unit)
{
GL.BindTexture(TextureTarget.Texture2D, GlHandle);
GL.ActiveTexture(TextureUnit.Texture0 + unit);
}
public SSShadowMapBase(TextureUnit texUnit, int textureWidth, int textureHeight)
{
if (!OpenTKHelper.areFramebuffersSupported())
{
m_isValid = false;
return;
}
#if false
if (s_numberOfShadowMaps >= c_maxNumberOfShadowMaps)
{
throw new Exception("Unsupported number of shadow maps: "
+ (c_maxNumberOfShadowMaps + 1));
}
#endif
++s_numberOfShadowMaps;
m_frameBufferID = GL.Ext.GenFramebuffer();
if (m_frameBufferID < 0)
{
throw new Exception("gen fb failed");
}
m_textureID = GL.GenTexture();
m_textureWidth = textureWidth;
m_textureHeight = textureHeight;
// bind the texture and set it up...
m_textureUnit = texUnit;
BindShadowMapToTexture();
GL.TexParameter(TextureTarget.Texture2D,
TextureParameterName.TextureMagFilter,
(int)TextureMagFilter.Nearest);
GL.TexParameter(TextureTarget.Texture2D,
TextureParameterName.TextureMinFilter,
(int)TextureMinFilter.Nearest);
GL.TexParameter(TextureTarget.Texture2D,
TextureParameterName.TextureWrapS,
(int)TextureWrapMode.ClampToEdge);
GL.TexParameter(TextureTarget.Texture2D,
TextureParameterName.TextureWrapT,
(int)TextureWrapMode.ClampToEdge);
GL.TexImage2D(TextureTarget.Texture2D, 0,
PixelInternalFormat.DepthComponent32f,
m_textureWidth, m_textureHeight, 0,
PixelFormat.DepthComponent, PixelType.Float, IntPtr.Zero);
// done creating texture, unbind
GL.BindTexture(TextureTarget.Texture2D, 0);
// ----------------------------
// now bind the texture to framebuffer..
GL.Ext.BindFramebuffer(FramebufferTarget.DrawFramebuffer, m_frameBufferID);
GL.Ext.BindFramebuffer(FramebufferTarget.ReadFramebuffer, m_frameBufferID);
GL.Ext.FramebufferTexture2D(FramebufferTarget.DrawFramebuffer, FramebufferAttachment.DepthAttachment,
TextureTarget.Texture2D, m_textureID, 0);
//GL.Ext.FramebufferTexture (FramebufferTarget.FramebufferExt, FramebufferAttachment.Color,
//(int)All.None, 0);
GL.Viewport(0, 0, m_textureWidth, m_textureHeight);
GL.DrawBuffer(DrawBufferMode.None);
GL.ReadBuffer(ReadBufferMode.None);
if (!assertFramebufferOK(FramebufferTarget.DrawFramebuffer))
{
throw new Exception("failed to create-and-bind shadowmap FBO");
}
// leave in a sane state...
unbindFramebuffer();
GL.ActiveTexture(TextureUnit.Texture0);
if (!assertFramebufferOK(FramebufferTarget.DrawFramebuffer))
{
throw new Exception("failed to ubind shadowmap FBO");
}
}
public void Use(TextureUnit unit = TextureUnit.Texture0)
{
GL.ActiveTexture(unit);
GL.BindTexture(TextureTarget.Texture2D, texture);
}
public void BindTexture(int textureId)
{
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2D, textureId);
GL.Uniform1(_id, 0); // bind the shader to "Texture0"
}
