/// <summary>
/// Create OpenGL object. Standard object constructor for ProtoFX.
/// </summary>
/// <param name="block"></param>
/// <param name="scene"></param>
/// <param name="debugging"></param>
public GLFragoutput(Compiler.Block block, Dict scene, bool debugging)
: base(block.Name, block.Anno)
{
var err = new CompileException($"fragoutput '{name}'");
// PARSE ARGUMENTS
Cmds2Fields(block, err);
// CREATE OPENGL OBJECT
glname = GL.GenFramebuffer();
GL.BindFramebuffer(FramebufferTarget.Framebuffer, glname);
// PARSE COMMANDS
foreach (var cmd in block)
Attach(cmd, scene, err | $"command '{cmd.Name}'");
// if any errors occurred throw exception
if (err.HasErrors())
throw err;
// CHECK FOR OPENGL ERRORS
Bind();
var status = GL.CheckFramebufferStatus(FramebufferTarget.Framebuffer);
Unbind();
// final error checks
if (HasErrorOrGlError(err, block))
throw err;
if (status != FramebufferErrorCode.FramebufferComplete)
throw err.Add("Could not be created due to an unknown error.", block);
}
/// <summary>
/// Create OpenGL object. Standard object constructor for ProtoFX.
/// </summary>
/// <param name="block"></param>
/// <param name="scene"></param>
/// <param name="debugging"></param>
public GLVertoutput(Compiler.Block block, Dict scene, bool debugging)
: base(block.Name, block.Anno)
{
var err = new CompileException($"vertoutput '{name}'");
// PARSE ARGUMENTS
Cmds2Fields(block, err);
// CREATE OPENGL OBJECT
glname = GL.GenTransformFeedback();
GL.BindTransformFeedback(TransformFeedbackTarget.TransformFeedback, glname);
// parse commands
int numbindings = 0;
foreach (var cmd in block["buff"])
Attach(numbindings++, cmd, scene, err | $"command '{cmd.Text}'");
// if errors occurred throw exception
if (err.HasErrors())
throw err;
// unbind object and check for errors
GL.BindTransformFeedback(TransformFeedbackTarget.TransformFeedback, 0);
if (HasErrorOrGlError(err, block))
throw err;
}
/// <summary>
/// Create OpenGL object specifying the referenced scene objects directly.
/// </summary>
/// <param name="block"></param>
/// <param name="scene"></param>
/// <param name="glbuff"></param>
/// <param name="glimg"></param>
public GLTexture(Compiler.Block block, Dict scene, GLBuffer glbuff, GLImage glimg)
: base(block.Name, block.Anno)
{
var err = new CompileException($"texture '{name}'");
// PARSE ARGUMENTS
Cmds2Fields(block, err);
// set name
glBuff = glbuff;
glImg = glimg;
// GET REFERENCES
if (Buff != null)
scene.TryGetValue(Buff, out glBuff, block, err);
if (Img != null)
scene.TryGetValue(Img, out glImg, block, err);
if (glBuff != null && glImg != null)
err.Add("Only an image or a buffer can be bound to a texture object.", block);
if (glBuff == null && glImg == null)
err.Add("Ether an image or a buffer has to be bound to a texture object.", block);
// IF THERE ARE ERRORS THROW AND EXCEPTION
if (err.HasErrors())
throw err;
// INCASE THIS IS A TEXTURE OBJECT
Link(block.Filename, block.LineInFile, err);
if (HasErrorOrGlError(err, block))
throw err;
}
/// <summary>
/// Create OpenGL object. Standard object constructor for ProtoFX.
/// </summary>
/// <param name="block"></param>
/// <param name="scene"></param>
/// <param name="debugging"></param>
public GLTech(Compiler.Block block, Dict scene, bool debugging)
: base(block.Name, block.Anno)
{
var err = new CompileException($"tech '{name}'");
// PARSE COMMANDS
ParsePasses(ref init, block, scene, err);
ParsePasses(ref passes, block, scene, err);
ParsePasses(ref uninit, block, scene, err);
// IF THERE ARE ERRORS THROW AND EXCEPTION
if (err.HasErrors())
throw err;
}
/// <summary>
/// Create OpenGL object. Standard object constructor for ProtoFX.
/// </summary>
/// <param name="block"></param>
/// <param name="scene"></param>
/// <param name="debugging"></param>
public GLVertinput(Compiler.Block block, Dict scene, bool debugging)
: base(block.Name, block.Anno)
{
var err = new CompileException($"vertinput '{name}'");
// CREATE OPENGL OBJECT
glname = GL.GenVertexArray();
GL.BindVertexArray(glname);
int numAttr = 0;
foreach (var cmd in block["attr"])
Attach(numAttr++, cmd, scene, err | $"command '{cmd.Text}'");
// if errors occurred throw exception
if (err.HasErrors())
throw err;
// unbind object and check for errors
GL.BindVertexArray(0);
if (HasErrorOrGlError(err, block))
throw err;
}
/// <summary>
/// Create class instance of a C# class compiled through GLCSharp.
/// </summary>
/// <param name="params">Input parameters for GLObject creation.</param>
public GLInstance(Compiler.Block block, Dict scene, bool debugging)
: base(block.Name, block.Anno)
{
var err = new CompileException($"instance '{name}'");
// INSTANTIATE CSHARP CLASS FROM CODE BLOCK
Instance = GLCsharp.CreateInstance(block, scene, err);
if (err.HasErrors())
throw err;
// get Bind method from main class instance
update = Instance.GetType().GetMethod("Update", new[] {
typeof(int), typeof(int), typeof(int), typeof(int), typeof(int)
});
// get Unbind method from main class instance
endpass = Instance.GetType().GetMethod("EndPass", new[] { typeof(int) });
// get Delete method from main class instance
delete = Instance.GetType().GetMethod("Delete");
// get all public methods and check whether
// they can be used as event handlers for glControl
var reference = scene.GetValueOrDefault<GLReference>(GraphicControl.nullname);
var glControl = (GraphicControl)reference.reference;
var methods = Instance.GetType().GetMethods(BindingFlags.Public | BindingFlags.Instance);
foreach (var method in methods)
{
var info = glControl.GetType().GetEvent(method.Name);
if (info != null)
{
var csmethod = Delegate.CreateDelegate(info.EventHandlerType, Instance, method.Name);
info.AddEventHandler(glControl, csmethod);
}
}
}
/// <summary>
/// Create OpenGL image object.
/// </summary>
/// <param name="params">Input parameters for GLObject creation.</param>
public GLImage(Compiler.Block block, Dict scene, bool debugging)
: base(block.Name, block.Anno)
{
var err = new CompileException($"image '{name}'");
// PARSE ARGUMENTS
Cmds2Fields(block, err);
if (Target == 0 && Size == null)
err.Add("Texture needs to specify a file or texture size " +
"(e.g., size <width> <height> <depth> <length>).", block);
// on errors throw an exception
if (err.HasErrors())
throw err;
// complete size array
if (Size == null)
Size = Enumerable.Repeat(1, 4).ToArray();
else if (Size.Length < 4)
Size = Enumerable.Range(0, 4).Select(i => i < Size.Length ? Size[i] : 1).ToArray();
// LOAD IMAGE DATA
var dir = Path.GetDirectoryName(block.Filename) + Path.DirectorySeparatorChar;
var data = LoadImageFiles(dir, File, Size, Format);
// if type was not specified
if (Target == 0)
{
if (Width > 1 && Height == 1 && Depth == 1 && Length == 1)
Target = TexTarget.Texture1D;
else if (Width > 1 && Height == 1 && Depth == 1 && Length > 1)
Target = TexTarget.Texture1DArray;
else if (Width > 1 && Height > 1 && Depth == 1 && Length == 1)
Target = TexTarget.Texture2D;
else if (Width > 1 && Height > 1 && Depth == 1 && Length > 1)
Target = TexTarget.Texture2DArray;
else if (Width > 1 && Height > 1 && Depth > 1 && Length == 1)
Target = TexTarget.Texture3D;
else
err.Add("Texture type could not be derived from 'width', 'height', "
+ "'depth' and 'length'. Please check these parameters or specify "
+ "the type directly (e.g. 'type = texture2D').", block);
}
// CREATE OPENGL OBJECT
glname = GL.GenTexture();
GL.BindTexture(Target, glname);
GL.TexParameter(Target, TexParamName.TextureMinFilter,
(int)(Mipmaps > 0 ? TexMinFilter.NearestMipmapNearest : TexMinFilter.Nearest));
GL.TexParameter(Target, TexParamName.TextureMagFilter,
(int)(Mipmaps > 0 ? TexMinFilter.NearestMipmapNearest : TexMinFilter.Nearest));
GL.TexParameter(Target, TexParamName.TextureWrapR, (int)TextureWrapMode.ClampToEdge);
GL.TexParameter(Target, TexParamName.TextureWrapS, (int)TextureWrapMode.ClampToEdge);
GL.TexParameter(Target, TexParamName.TextureWrapT, (int)TextureWrapMode.ClampToEdge);
// ALLOCATE IMAGE MEMORY
if (data != null)
{
var dataPtr = Marshal.AllocHGlobal(data.Length);
Marshal.Copy(data, 0, dataPtr, data.Length);
TexImage(Target, Width, Height, Depth, Length, PixelFormat.Bgra, PixelType.UnsignedByte, dataPtr);
Marshal.FreeHGlobal(dataPtr);
}
else
TexImage(Target, Width, Height, Depth, Length, Mipmaps);
// GENERATE MIPMAPS
if (Mipmaps > 0)
GL.GenerateMipmap((GenerateMipmapTarget)Target);
GL.BindTexture(Target, 0);
if (HasErrorOrGlError(err, block))
throw err;
}
/// <summary>
/// Get xml text from scene structure by processing the specified command.
/// </summary>
/// <param name="cmd"></param>
/// <param name="scene"></param>
/// <param name="err"></param>
/// <returns></returns>
private static byte[] LoadXml(Compiler.Command cmd, Dict scene, CompileException err)
{
// Get text from file or text object
string str = GetText(scene, cmd);
if (str == null)
{
err.Add("Could not process command. Second argument must "
+ "be a name to a text object or a filename.", cmd);
return null;
}
try
{
// Parse XML string
var document = new XmlDocument();
document.LoadXml(str);
// Load data from XML
var filedata = new byte[cmd.ArgCount - 1][];
for (int i = 1; i < cmd.ArgCount; i++)
{
try
{
filedata[i - 1] = DataXml.Load(document, cmd[i].Text);
}
catch (XmlException ex)
{
err.Add(ex.Message, cmd);
}
}
// Merge data
if (!err.HasErrors())
return filedata.Cat().ToArray();
}
catch (Exception ex)
{
err.Add(ex.GetBaseException().Message, cmd);
}
return null;
}
