internal ViewportEffect(
string name,
ShaderWindow window,
string fragmentShader,
IEnumerable <StateConfiguration> renderState,
IEnumerable <UniformConfiguration> shaderUniforms,
IEnumerable <BufferBindingConfiguration> bufferBindings,
FramebufferConfiguration framebuffer,
Mesh texturedQuad)
: base(name,
window,
VertexShader,
null,
fragmentShader,
renderState,
shaderUniforms,
bufferBindings,
framebuffer)
{
if (texturedQuad == null)
{
throw new ArgumentNullException("texturedQuad");
}
mesh = texturedQuad;
}
internal Effect(
string name,
ShaderWindow window,
string vertexShader,
string geometryShader,
string fragmentShader,
IEnumerable <StateConfiguration> renderState,
IEnumerable <UniformConfiguration> shaderUniforms,
IEnumerable <BufferBindingConfiguration> bufferBindings,
FramebufferConfiguration framebuffer)
: base(name, window)
{
if (vertexShader == null)
{
throw new ArgumentNullException("vertexShader", "No vertex shader was specified for material " + name + ".");
}
if (fragmentShader == null)
{
throw new ArgumentNullException("fragmentShader", "No fragment shader was specified for material " + name + ".");
}
vertexSource = vertexShader;
geometrySource = geometryShader;
fragmentSource = fragmentShader;
CreateShaderState(renderState, shaderUniforms, bufferBindings, framebuffer);
}
private void Process(ShaderWindow window)
{
foreach (var state in renderState)
{
state.Execute(window);
}
}
internal Shader(string name, ShaderWindow window)
{
if (window == null)
{
throw new ArgumentNullException("window");
}
Name = name;
shaderWindow = window;
}
static float GetAspectRatio(ShaderWindow window)
{
if (window == null)
{
throw new ArgumentNullException("window");
}
var viewport = window.Viewport;
return(GetAspectRatio(viewport.Width * window.Width, viewport.Height * window.Height));
}
protected virtual void Dispose(bool disposing)
{
if (program != 0)
{
if (disposing)
{
shaderState.Dispose();
GL.DeleteProgram(program);
shaderWindow = null;
update = null;
program = 0;
}
}
}
public FramebufferAttachment(ShaderWindow window, FramebufferAttachmentConfiguration attachmentConfiguration)
{
textureName = attachmentConfiguration.TextureName;
textureWidth = attachmentConfiguration.Width.GetValueOrDefault(window.Width);
textureHeight = attachmentConfiguration.Height.GetValueOrDefault(window.Height);
attachment = attachmentConfiguration.Attachment;
internalFormat = attachmentConfiguration.InternalFormat;
format = attachmentConfiguration.Format;
type = attachmentConfiguration.Type;
clearColor = attachmentConfiguration.ClearColor;
clearMask = attachmentConfiguration.ClearMask;
texture = window.ResourceManager.Load <Texture>(attachmentConfiguration.TextureName);
ClearTexture(texture.Id, textureWidth, textureHeight);
}
internal ComputeProgram(
string name,
ShaderWindow window,
string computeShader,
IEnumerable <StateConfiguration> renderState,
IEnumerable <UniformConfiguration> shaderUniforms,
IEnumerable <BufferBindingConfiguration> bufferBindings,
FramebufferConfiguration framebuffer)
: base(name, window)
{
if (computeShader == null)
{
throw new ArgumentNullException("computeShader", "No compute shader was specified for compute program " + name + ".");
}
computeSource = computeShader;
CreateShaderState(renderState, shaderUniforms, bufferBindings, framebuffer);
}
public FramebufferState(ShaderWindow window, FramebufferConfiguration framebufferConfiguration)
{
if (window == null)
{
throw new ArgumentNullException("window");
}
if (framebufferConfiguration == null)
{
throw new ArgumentNullException("framebufferConfiguration");
}
framebufferWidth = 0;
framebufferHeight = 0;
framebufferWindow = window;
framebufferAttachments = framebufferConfiguration.FramebufferAttachments
.Select(configuration => new FramebufferAttachment(window, configuration))
.ToList();
if (framebufferAttachments.Count > 0)
{
foreach (var attachment in framebufferAttachments)
{
var width = attachment.Width;
var height = attachment.Height;
if (framebufferWidth == 0 || width < framebufferWidth)
{
framebufferWidth = width;
}
if (framebufferHeight == 0 || height < framebufferHeight)
{
framebufferHeight = height;
}
}
GL.GenFramebuffers(1, out fbo);
GL.BindFramebuffer(FramebufferTarget.Framebuffer, fbo);
foreach (var attachment in framebufferAttachments)
{
attachment.Attach();
}
GL.BindFramebuffer(FramebufferTarget.Framebuffer, 0);
}
}
internal Material(
string name,
ShaderWindow window,
string vertexShader,
string geometryShader,
string fragmentShader,
IEnumerable <StateConfiguration> renderState,
IEnumerable <UniformConfiguration> shaderUniforms,
IEnumerable <BufferBindingConfiguration> bufferBindings,
FramebufferConfiguration framebuffer)
: base(name,
window,
vertexShader,
geometryShader,
fragmentShader,
renderState,
shaderUniforms,
bufferBindings,
framebuffer)
{
}
internal static IObservable <ShaderWindow> CreateWindow(ShaderWindowSettings configuration)
{
return(Observable.Create <ShaderWindow>(observer =>
{
// return Task.Factory.StartNew(() =>
// {
// GraphicsContext.ShareContexts = false;
using (var window = new ShaderWindow(configuration))
// using (var notification = cancellationToken.Register(window.Close))
using (var disposable = SubjectManager.ReserveSubject())
{
var subject = disposable.Subject;
window.Load += delegate
{
observer.OnNext(window);
subject.OnNext(window);
};
window.Unload += delegate
{
subject.OnCompleted();
observer.OnCompleted();
};
try { window.Run(); }
catch (Exception ex)
{
observer.OnError(ex);
subject.OnError(ex);
}
}
// },
// cancellationToken,
// TaskCreationOptions.LongRunning,
// TaskScheduler.Default);
return Disposable.Empty;
}));
}
internal WindowManager(ShaderWindow window)
{
Window = window;
}
internal WindowManagerConfiguration(ShaderWindow owner)
{
Name = string.Empty;
window = owner;
}
internal FrameEvent(ShaderWindow sender, double elapsedTime, FrameEventArgs e)
: base(sender, e)
{
TimeStep = new TimeStep(elapsedTime, e.Time);
}
