GLSLEffect.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

/* TODO:
 * * apply
 *   * HOW????
 *   * OnApply: protecteed internal :(
 *   * INTERNAL_applyEffect: internal...
 *     + calls mojoshader! --> hijack?!!
 *       -> glEffect{Begin,End}: state mgmt | unbind shader!
 *       -> glEffect{Begin,End}Pass: bind shader! | state mgmt
 *   * GD draw calls: ok
 *     * EXCEPT mojoshader: glProgramReady, glProgramViewportInfo
 *       -> set up uniforms and vertex arrays!
 *       --> circumvent? --> HOW??
 *       --> just go with it?? --> glProgramReady ok, glProgramViewportInfo might segfault!
 *
 * * samplers, textures
 *   -> https://www.khronos.org/opengl/wiki/Program_Introspection
 *   -> https://stackoverflow.com/questions/440144/in-opengl-is-there-a-way-to-get-a-list-of-all-uniforms-attribs-used-by-a-shade#442819
 *   -> https://www.khronos.org/opengl/wiki/Basic_Type_(GLSL)
 *
 *   -> https://www.khronos.org/opengl/wiki/Sampler_(GLSL)
 *   -> https://www.khronos.org/opengl/wiki/Texture
 * * vertex format verification!
 */

namespace PoroCYon.FNAGLSL {
	struct UnifData {
		public int location;
		public string name;
		public GLSLType type;
		public int size;
		public int rows, cols;
		public EffectParameterClass epclass;
		public EffectParameterType eptype;
		public uint bytesize;

		public UnifData(int loc, string n, GLSLType t, int sz, int r, int c,
				EffectParameterClass epc, EffectParameterType ept, uint bsz) {
			location = loc; name = n; type = t; size = sz; rows = r;
			cols = c; epclass = epc; eptype = ept; bytesize = bsz;
		}
	}
	struct TexT {
		public uint slot, getn, setn, texid;

		public TexT(uint sl, uint g, uint s, uint t) {
			slot = sl; getn = g; setn = s; texid = t;
		}
	};

	public partial class GLSLEffect : Effect {
		public struct ActiveEffect : IDisposable {
			internal GraphicsDevice gd;
			internal uint oldprgm;
			internal List<TexT> texs;
			bool disposed;

			internal ActiveEffect(GraphicsDevice d, uint old, List<TexT> ts) {
				gd = d; oldprgm = old; disposed = false; texs = ts;
			}

			public unsafe void Dispose() {
				if (disposed) return;

				GL.GetError();

				GL.UseProgram(oldprgm);
				GL.Throw();
				oldprgm = 0;

				uint actSlot = unchecked((uint)GL.GetIntegerv(GL.ACTIVE_TEXTURE));
				GL.Throw();
				try {
					for (int i = 0; i < texs.Count; ++i) {
						GL.ActiveTexture(GL.TEXTURE0 + texs[i].slot);
						GL.Throw();
						GL.BindTexture(texs[i].setn, 0);
						GL.Throw();

						/*Console.WriteLine("clear slot " + texs[i].slot + " texid " + texs[i].texid
							+ " getn 0x" + texs[i].getn.ToString("X") + " setn 0x" + texs[i].setn.ToString("X"));*/

					}
				} finally {
					GL.ActiveTexture(actSlot);
					//GL.Throw();
					texs.Clear();
				}

				GL.DebugMessageControl(GL.DONT_CARE, GL.DEBUG_TYPE_ERROR,
						GL.DONT_CARE, 0, null, 1);
				GL.GetError();

				disposed = true;
			}
		}

		static int maxTextureSlots = -1;

		GraphicsDevice gd;

		uint[] glshdrs;
		uint glprgm;

		EffectTechnique fakeTech;

		IntPtr unifDataBacking;
		UnifData[] unifs;

		//readonly static List<EffectTechnique> emptyEffTechList = new List<EffectTechnique>();
		public unsafe GLSLEffect(GraphicsDevice gd,
					IDictionary<GLSLPurpose, string> shaders)
				: base(/*UGLY hack*/new BasicEffect(gd)) {
			this.gd = gd;
			fakeTech = Techniques[0];
			unifDataBacking = IntPtr.Zero;

			// cause NullRefExns when dumb code would try to access the techns
			this.SetTechniques(null/*ReflUtil.CreateTechColl(emptyEffTechList)*/);

			GL.Init(gd);
			GL.GetError(); // ignore errors from FNA/mojoshader

			if (maxTextureSlots < 0) {
				maxTextureSlots = GL.GetIntegerv(GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS);
				GL.Throw();
			}

			// this basically makes FNA think this effect is a noop, so binding
			// this effect will do the same as binding the 0 program in OpenGL,
			// so the BasicEffect used won't do much anymore
			/*gd.DeleteEffect(this);
			this.SetGLEffectData(IntPtr.Zero);
			this.SetEffectData  (IntPtr.Zero);*/
			// turns out we can't do this, or libmojoshader will segfault
			// because it lacks some null checking in
			// glEffectEnd, glEffectBeginPass, glProgramViewportInfo :/ ...
			// so we basically have to make sure the usual route of Apply()ing
			// the shader happens (unless we can circumvent this *somehow*),
			// and then apply the shader manually.

			var shdrs = new uint[shaders.Count];
			bool ok = false;
			uint prgm = 0;

			try {
				prgm = GL.CreateProgram();
				if (prgm == 0) GL.Throw();

				int i = 0;
				foreach (var kvp in shaders) {
					uint sh = GL.CreateShader(kvp.Key);
					if (sh == 0) GL.Throw();

					GL.ShaderSource(sh, kvp.Value);
					GL.Throw();

					GL.CompileShader(sh);

					if (GL.GetError() != 0 || GL.GetShaderiv(sh, GL.COMPILE_STATUS) == 0) {
						int len = GL.GetShaderiv(sh, GL.INFO_LOG_LENGTH);
						var msg = GL.GetShaderInfoLog(sh, len);
						throw new GLSLCompileException("Failed to compile "
								+ kvp.Key + ": " + msg);
					}

					GL.AttachShader(prgm, sh);
					GL.Throw();

					shdrs[i++] = sh;
				}

				GL.LinkProgram(prgm);
				if (GL.GetError() != 0 || GL.GetProgramiv(prgm, GL.LINK_STATUS) == 0) {
					int len = GL.GetProgramiv(prgm, GL.INFO_LOG_LENGTH);
					var msg = GL.GetProgramInfoLog(prgm, len);
					throw new GLSLLinkException("Failed to link shader: " + msg);
				}

				glshdrs = shdrs;
				glprgm  = prgm ;

				ParseAttribUnif();

				ok = true;
			}
			finally {
				if (!ok) {
					DelShdrPrgm();
				} else {
					glshdrs = shdrs;
					glprgm  = prgm ;
				}
			}
		}

		/*readonly static EffectParameterCollection  emptyParamColl
			= ReflUtil.CreateParamColl(new List<EffectParameter >());
		readonly static EffectAnnotationCollection emptyAnnotColl
			= ReflUtil.CreateAnnotColl(new List<EffectAnnotation>());*/
		void ParseAttribUnif() {
			/*int attrs = GL.GetProgramiv(glprgm, GL.ACTIVE_ATTRIBUTES);
			GL.Throw();
			Console.WriteLine("#attrs = " + attrs);
			for (int i = 0; i < attrs; ++i) {
				int size; GLSLType type; string name;
				GL.GetActiveAttrib(glprgm, unchecked((uint)i), out size,
						out type, out name);
				GL.Throw();
				int loc = GL.GetAttribLocation(glprgm, name);
				GL.Throw();

				Console.WriteLine("attrs["+i+"] = {size=" + size + ", type="
						+ type + ", name=" + name + ", loc="+loc+"}");
			}*/

			int nunifs = GL.GetProgramiv(glprgm, GL.ACTIVE_UNIFORMS);
			GL.Throw();
			unifs = new UnifData[nunifs];
			var parms = new List<EffectParameter>();
			uint totalsize = 0;
			//Console.WriteLine("#unifs = " + nunifs);
			for (int i = 0; i < nunifs; ++i) {
				int size; GLSLType type; string name;
				GL.GetActiveUniform(glprgm, unchecked((uint)i), out size,
						out type, out name);
				GL.Throw();
				int loc = GL.GetUniformLocation(glprgm, name);
				GL.Throw();

				uint bytesize = unchecked((uint)(typ2size[type]*size));
				unifs[i] = new UnifData(loc, name, type, size, GetRows(type),
					GetCols(type), typ2class[type], typ2type[type], bytesize);
				totalsize += bytesize;
			}

			IntPtr bleh = Marshal.AllocHGlobal((IntPtr)totalsize);
			ILUtil.Initblk(bleh, 0, (IntPtr)totalsize);
			bool ok = false;

			try {
				uint sizepos = 0;
				for (int i = 0; i < nunifs; ++i) {
					var u = unifs[i];

					IntPtr bps = (IntPtr)((long)bleh + sizepos);
					parms.Add(ReflUtil.CreateParameter(u.name, null/*semantic: ???*/,
							u.rows, u.cols, (u.size == 1) ? 0 : u.size,
							u.epclass, u.eptype, null, null, //emptyParamColl, emptyAnnotColl,
							bps, u.bytesize));
					sizepos += u.bytesize;
				}

				ok = true;
			} finally {
				if (ok) {
					unifDataBacking = bleh;
					this.SetParameters(ReflUtil.CreateParamColl(parms));
				} else {
					Marshal.FreeHGlobal(bleh);
					unifDataBacking = IntPtr.Zero;
				}
			}
		}

		List<TexT> usedTextures = new List<TexT>();
		void ApplyUnifs() {
			usedTextures.Clear();
			// TODO: get active texture to restore later -> glGetIntegerv(GL_ACTIVE_TEXTURE)
			// TODO: make list to hold used texture slots

			uint actSlot = unchecked((uint)GL.GetIntegerv(GL.ACTIVE_TEXTURE));
			GL.Throw();
			try {
				IntPtr data = unifDataBacking;
				uint firstEmptySlot = 0;
				for (int i = 0; i < unifs.Length; ++i) {
					var u = unifs[i];
					var p = Parameters[i];

					if (Array.IndexOf(GL.samplerTypes, (uint)u.type) >= 0) // it's a texture
						SetTexture(ref firstEmptySlot, ref u, p);
					else SetUniform(ref u, data);

					data = (IntPtr)((long)data + u.bytesize);
				}
			} finally {
				GL.ActiveTexture(actSlot);
			}
		}

		// TODO: find out a better (i.e. more API-conform) way to do this!
		///<summary>
		///USAGE: using (var eff &eq; glslEffect.Bind()) { ... gd.DrawPrimitives(...); ... }
		///</summary>
		public unsafe ActiveEffect Bind() { // TODO: how to warn on discarding the retval?
			GL.GetError(); // ignore errors from FNA/mojoshader

			// workaround FNA crap
			CurrentTechnique = fakeTech;
			fakeTech.Passes[0].Apply();

			uint oldprgm = unchecked((uint)GL.GetIntegerv(GL.CURRENT_PROGRAM));
			GL.Throw();

			GL.UseProgram(glprgm);
			GL.Throw();

			ApplyUnifs();

			/*
			 * FNA will fail binding vertex attributes because it sets the
			 * vertex array buffer to 0 while passing non-null ptrs to
			 * glVertexAttribArray, which is an INVALID_OPERATION. When FNA is
			 * compiled with debugging enabled, this will throw an exception.
			 * (libmojoshader will also call a glUniform which will also most
			 *  likely fail)
			 *
			 * so what we do is we disable DEBUG_TYPE_ERRORs and set up vertex
			 * attributes ourselves (and undo that afterwards)
			 */
			//// TODO: we kinda need the vertex format in the first place...
			// eh, seems to work without...

			GL.DebugMessageControl(GL.DONT_CARE, GL.DEBUG_TYPE_ERROR,
					GL.DONT_CARE, 0, null, 0);
			GL.GetError();

			return new ActiveEffect(gd, oldprgm, usedTextures);
		}
		[Obsolete("Please use Bind() instead")]
		public ActiveEffect Apply() { return Bind(); }

		void DelShdrPrgm() {
			for (int i = 0; glshdrs != null && i < glshdrs.Length; ++i)
				if (glshdrs[i] != 0)
					GL.DeleteShader(glshdrs[i]);
			glshdrs = null;

			if (glprgm != 0)
				GL.DeleteProgram(glprgm);
		}

		protected override void Dispose(bool disposing) {
			if (!IsDisposed) {
				DelShdrPrgm();

				if (fakeTech != null) {
					this.SetTechniques(ReflUtil.CreateTechColl(new[]{fakeTech}.ToList()));
					fakeTech = null;
				}

				if (unifDataBacking != IntPtr.Zero) {
					Marshal.FreeHGlobal(unifDataBacking);
					unifDataBacking = IntPtr.Zero;
				}
			}

			base.Dispose(disposing);
		}

		unsafe void SetTexture(ref uint firstEmpty, ref UnifData u, EffectParameter p) {
			uint getn = typ2getn[u.type]/*,
			     setn = typ2setn[u.type]*/;

			// find a free texture slot
			bool foundSlot = false;
			for (uint j = firstEmpty; j < maxTextureSlots; ++j) {
				GL.ActiveTexture(GL.TEXTURE0 + j);
				GL.Throw();
				uint curbound = unchecked((uint)GL.GetIntegerv(getn));
				GL.Throw();

				if (curbound == 0) { // free!
					var tar = p.GetValueTexture();
					if (tar == null)
						throw new InvalidOperationException("texture of param '"
								+ u.name + "'is null?!");

					uint setn = unchecked((uint)tar.GetGLTexTarget());
					uint texn = tar.GetGLTexID();

					/*Console.WriteLine("set slot " + j + " texid " + texn
							+ " getn 0x" + getn.ToString("X") + " setn 0x" + setn.ToString("X")
							+ " -> to unif. " + u.name);*/

					// bind the uniform to the texture slot
					GL.Uniform1i(u.location, unchecked((int)j));
					GL.Throw();

					// bind the texture to the texture slot!
					GL.BindTexture(setn, texn);
					GL.Throw();
					usedTextures.Add(new TexT(j, getn, setn, texn));
					firstEmpty = j+1;
					foundSlot = true;
					break;
				}
			}

			if (!foundSlot)
				throw new InvalidOperationException("param '" + u.name
						+ "': can't find a free texture slot...");
		}
	}
}