public BasicProgram()
{
vertexShader = shaderBuilder.VertexShader("Common", "Uniforms", "Vertex");
fragmentShader = shaderBuilder.FragmentShader("Common", "Uniforms", "Fragment");
Shaders.AddRange(vertexShader, fragmentShader);
MustLink();
}
public static CubeNode Create()
{
// vertex buffer and index buffer.
var model = new CubeModel();
// vertex shader and fragment shader.
var vs = new VertexShader(vertexCode);
var fs = new FragmentShader(fragmentCode);
var array = new ShaderArray(vs, fs);
// which vertex buffer maps to which attribute in shader.
var map = new AttributeMap();
map.Add("inPosition", CubeModel.strPosition);
// build a render method.
var builder = new RenderMethodBuilder(array, map);
// create node.
var node = new CubeNode(model, builder);
// initialize node.
node.Initialize();
return(node);
}
public static void CreateBasicShader(OpenGLWindow _window)
{
//ThrowIfNull(_window);
OpenGL context = _window.Context;
// Create a vertex shader.
VertexShader vertexShader = new VertexShader();
vertexShader.CreateInContext(context);
vertexShader.SetSource(
"void main()" + Environment.NewLine +
"{" + Environment.NewLine +
"gl_Position = ftransform();" + Environment.NewLine +
"}" + Environment.NewLine);
// Create a fragment shader.
FragmentShader fragmentShader = new FragmentShader();
fragmentShader.CreateInContext(context);
fragmentShader.SetSource(
"void main()" + Environment.NewLine +
"{" + Environment.NewLine +
"gl_FragColor = vec4(0.4,0.4,0.8,1.0);" + Environment.NewLine +
"}" + Environment.NewLine);
// Compile them both.
vertexShader.Compile();
fragmentShader.Compile();
// Build a program.
_window.m_shaderProgram.CreateInContext(context);
// Attach the shaders.
_window.m_shaderProgram.AttachShader(vertexShader);
_window.m_shaderProgram.AttachShader(fragmentShader);
_window.m_shaderProgram.Link();
}
public override void Prepare(GL_ControlLegacy control)
{
string pathFrag = System.IO.Path.Combine(Runtime.ExecutableDir, "Shader", "Legacy") + "\\KCL.frag";
string pathVert = System.IO.Path.Combine(Runtime.ExecutableDir, "Shader", "Legacy") + "\\KCL.vert";
var defaultFrag = new FragmentShader(File.ReadAllText(pathFrag));
var defaultVert = new VertexShader(File.ReadAllText(pathVert));
var solidColorFrag = new FragmentShader(
@"#version 330
uniform vec4 color;
out vec4 FragColor;
void main(){
FragColor = color;
}" );
var solidColorVert = new VertexShader(
@"#version 330
in vec3 vPosition;
in vec3 vNormal;
in vec3 vColor;
out vec3 normal;
out vec3 color;
out vec3 position;
void main(){
normal = vNormal;
color = vColor;
position = vPosition;
gl_Position = mvpMatrix * vec4(vPosition.xyz, 1.0);
}" );
defaultShaderProgram = new ShaderProgram(defaultFrag, defaultVert);
solidColorShaderProgram = new ShaderProgram(solidColorFrag, solidColorVert);
}
/// <summary>
/// 创建CSharpGL认可的模型
/// </summary>
/// <param name="flag">0=sp,1=dp,2=model</param>
/// <param name="path">点云路径</param>
/// <returns>模型</returns>
public static Model3DNode Create(int flag, string path)
{
IBufferSource model; vec3 size;
Model3D m = new Model3D();
size = m.GetModelSize();
if (flag == 0)
{
m.LoadSparsePC(path);
}
else if (flag == 1)
{
m.LoadDensePC(path);
}
else if (flag == 2)
{
m.LoadModel(path);
}
model = m;
string position = Model3D.strPosition;
string color = Model3D.strColor;
var vs = new VertexShader(vertexCode);
var fs = new FragmentShader(fragmentCode);
var provider = new ShaderArray(vs, fs);
var map = new AttributeMap();
map.Add(inPosition, position);
map.Add(inColor, color);
var builder = new RenderMethodBuilder(provider, map);
var node = new Model3DNode(model, position, builder);
node.Initialize();
node.ModelSize = size;
return(node);
}
public override void Prepare(GL_ControlModern control)
{
var solidColorFrag = new FragmentShader(
@"#version 330
uniform vec3 color;
out vec4 FragColor;
void main(){
FragColor = vec4(color, 1);
}" );
var solidColorVert = new VertexShader(
@"#version 330
in vec3 vPosition;
uniform mat4 mvpMatrix;
void main(){
gl_Position = mvpMatrix * vec4(vPosition.xyz, 1.0);
}" );
solidColorShaderProgram = new ShaderProgram(solidColorFrag, solidColorVert);
}
public void Dispose()
{
if (ProgramID != 0)
{
// Make sure this program isn't being used
if (GLShortcut.CurrentProgram == ProgramID)
{
Gl.UseProgram(0);
}
Gl.DetachShader(ProgramID, VertexShader.ShaderID);
Gl.DetachShader(ProgramID, FragmentShader.ShaderID);
Gl.DeleteProgram(ProgramID);
if (DisposeChildren)
{
VertexShader.Dispose();
FragmentShader.Dispose();
}
this.ProgramID = 0;
}
}
public static StaticSlicesNode Create(int sliceCount, Texture texture1D, Texture texture3D)
{
var vs = new VertexShader(vertexCode);
var fs = new FragmentShader(fragmentCode);
var array = new ShaderArray(vs, fs);
var map = new AttributeMap();
map.Add("inPosition", StaticSlicesModel.strPosition);
map.Add("inTexCoord", StaticSlicesModel.strTexCoord);
//var depthTestSwitch = new DepthTestSwitch(false);
//var polygonModeSwitch = new PolygonModeSwitch(PolygonMode.Line);
var blendSwitch = new BlendSwitch(BlendEquationMode.Add, BlendSrcFactor.SrcAlpha, BlendDestFactor.OneMinusSrcAlpha);
var builder = new RenderMethodBuilder(array, map, blendSwitch);
var model = new StaticSlicesModel(sliceCount);
var node = new StaticSlicesNode(model, builder);
node.texture1D = texture1D;
node.texture3D = texture3D;
node.Initialize();
return(node);
}
public override void Prepare(GL_ControlModern control)
{
var solidColorFrag = new FragmentShader(
@"#version 330
uniform vec3 gridColor;
out vec4 FragColor;
void main(){
FragColor = vec4(gridColor, 1);
}" );
var solidColorVert = new VertexShader(
@"#version 330
in vec3 vPosition;
uniform mat4 mtxMdl;
uniform mat4 mtxCam;
void main(){
gl_Position = mtxMdl * mtxCam * vec4(vPosition.xyz, 1);
}" );
gridShaderProgram = new ShaderProgram(solidColorFrag, solidColorVert);
}
/// <summary>
///
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static TexturedNode Create(ObjVNFMesh mesh)
{
var model = new ObjVNF(mesh);
RenderMethodBuilder builder;
{
var vs = new VertexShader(vertexCode);
var fs = new FragmentShader(fragmentCode);
var provider = new ShaderArray(vs, fs);
var map = new AttributeMap();
map.Add("inPosition", ObjVNF.strPosition);
map.Add("inNormal", ObjVNF.strNormal);
map.Add("inTexCoord", ObjVNF.strTexCoord);
builder = new RenderMethodBuilder(provider, map);
}
var node = new TexturedNode(model, ObjVNF.strPosition, builder);
node.ModelSize = model.GetSize();
node.WorldPosition = model.GetPosition();
node.Initialize();
return(node);
}
public static QuaterNode Create()
{
var model = new QuaterModel();
var vs = new VertexShader(vertexCode);
var fs = new FragmentShader(fragmentCode);
var array = new ShaderArray(vs, fs);
var map = new AttributeMap();
var stencilFunc = new StencilFuncState(EStencilFunc.Always, 1, 0xFF, EStencilFunc.Equal, 1, 0xFF);
var stencilOp = new StencilOpState(EStencilOp.Keep, EStencilOp.Keep, EStencilOp.Replace, EStencilOp.Keep, EStencilOp.Keep, EStencilOp.Keep);
var stencilMask = new StencilMaskState(0xFF, 0x00);
var colorMask = new ColorMaskState(false, false, false, false);
var depthMask = new DepthMaskState(false);
var clearBuffer = new UserDefineState();
clearBuffer.TurnOn += clearBuffer_On;
var builder = new RenderMethodBuilder(array, map, stencilFunc, stencilOp, stencilMask, colorMask, depthMask, clearBuffer);
var node = new QuaterNode(model, builder);
node.Initialize();
return(node);
}
public static ShadowVolumeNode Create(IBufferSource model, string position, string normal, vec3 size)
{
RenderMethodBuilder ambientBuilder, extrudeBuilder, underLightBuilder;
{
var vs = new VertexShader(ambientVert);
var fs = new FragmentShader(ambientFrag);
var array = new ShaderArray(vs, fs);
var map = new AttributeMap();
map.Add("inPosition", position);
ambientBuilder = new RenderMethodBuilder(array, map);
}
{
var vs = new VertexShader(extrudeVert);
var gs = new GeometryShader(extrudeGeom);
var fs = new FragmentShader(extrudeFrag);
var array = new ShaderArray(vs, gs, fs);
var map = new AttributeMap();
map.Add("inPosition", position);
extrudeBuilder = new RenderMethodBuilder(array, map);
}
{
var vs = new VertexShader(blinnPhongVert);
var fs = new FragmentShader(blinnPhongFrag);
var array = new ShaderArray(vs, fs);
var map = new AttributeMap();
map.Add("inPosition", position);
map.Add("inNormal", normal);
underLightBuilder = new RenderMethodBuilder(array, map);
}
var node = new ShadowVolumeNode(model, ambientBuilder, extrudeBuilder, underLightBuilder);
node.Initialize();
node.ModelSize = size;
return(node);
}
/// <summary>
/// Initializes Dualitys embedded default content.
/// </summary>
public static void InitDefaultContent()
{
if (defaultContentInitialized)
{
return;
}
Log.Core.Write("Initializing default content..");
Log.Core.PushIndent();
var oldResLib = resLibrary.Values.ToArray();
VertexShader.InitDefaultContent();
FragmentShader.InitDefaultContent();
ShaderProgram.InitDefaultContent();
DrawTechnique.InitDefaultContent();
Pixmap.InitDefaultContent();
Texture.InitDefaultContent();
Material.InitDefaultContent();
Font.InitDefaultContent();
#if !__ANDROID__
AudioData.InitDefaultContent();
Sound.InitDefaultContent();
#endif
// Make a list of all default content available
foreach (var pair in resLibrary)
{
if (oldResLib.Contains(pair.Value))
{
continue;
}
defaultContent.Add(pair.Value);
}
defaultContentInitialized = true;
Log.Core.PopIndent();
Log.Core.Write("..done");
}
public void swapShader(OpenGL gl, string Vertex_shader_textbox, string Fragment_shader_textbox)
{
// Create a vertex shader.
vertexShader = new VertexShader();
vertexShader.CreateInContext(gl);
vertexShader.SetSource(Vertex_shader_textbox);
// Create a fragment shader.
fragmentShader = new FragmentShader();
fragmentShader.CreateInContext(gl);
fragmentShader.SetSource(Fragment_shader_textbox);
// Compile them both.
vertexShader.Compile();
fragmentShader.Compile();
// Build a program.
m_shaderProgram.CreateInContext(gl);
// Attach the shaders.
m_shaderProgram.AttachShader(vertexShader);
m_shaderProgram.AttachShader(fragmentShader);
m_shaderProgram.Link();
}
//Create the shader program used in Transformable objects
static TransformableObject()
{
string vShaderCode;
string fShaderCode;
//Get the assembly
var assembly = Assembly.GetExecutingAssembly();
//Get the shader codes
using (var stream = assembly.GetManifestResourceStream("Shaders.Transformable.Vert"))
using (var reader = new StreamReader(stream))
vShaderCode = reader.ReadToEnd();
using (var stream = assembly.GetManifestResourceStream("Shaders.Transformable.Frag"))
using (var reader = new StreamReader(stream))
fShaderCode = reader.ReadToEnd();
//Create the shaders
var fShader = new FragmentShader(fShaderCode);
var vShader = new VertexShader(vShaderCode);
//Create the program
ShaderProgram = new ShaderProgram(fShader, vShader);
}
public static NormalMappingNode Create(IBufferSource model, vec3 size, string position, string texCoord, string normal, string tangent)
{
//var model = new NormalMappingModel();
var vs = new VertexShader(vertexCode);
var fs = new FragmentShader(fragmentCode);
var array = new ShaderArray(vs, fs);
var map = new AttributeMap();
//map.Add("inPosition", NormalMappingModel.strPosition);
//map.Add("inTexCoord", NormalMappingModel.strTexCoord);
//map.Add("inNormal", NormalMappingModel.strNormal);
//map.Add("inTangent", NormalMappingModel.strTangent);
map.Add("inPosition", position);
map.Add("inTexCoord", texCoord);
map.Add("inNormal", normal);
map.Add("inTangent", tangent);
var builder = new RenderMethodBuilder(array, map);
var node = new NormalMappingNode(model, builder);
node.ModelSize = size;
node.Initialize();
return(node);
}
public void ImportFile(string srcFile, string targetName, string targetDir)
{
string ext = Path.GetExtension(srcFile);
string[] output = this.GetOutputFiles(srcFile, targetName, targetDir);
string sourceCode = File.ReadAllText(srcFile);
if (string.Equals(ext, SourceFileExtVertex, StringComparison.InvariantCultureIgnoreCase))
{
VertexShader res = new VertexShader();
res.Source = sourceCode;
res.SourcePath = srcFile;
res.Compile();
res.Save(output[0]);
}
else
{
FragmentShader res = new FragmentShader();
res.Source = sourceCode;
res.SourcePath = srcFile;
res.Compile();
res.Save(output[0]);
}
}
/// <summary>
///
/// </summary>
/// <param name="model"></param>
/// <param name="position"></param>
/// <param name="normal"></param>
/// <param name="size"></param>
/// <returns></returns>
public static NormalNode Create(IBufferSource model, string position, string texCoord, string normal, vec3 size)
{
var builders = new RenderMethodBuilder[2];
{
// render model
var vs = new VertexShader(vertexShader);
var fs = new FragmentShader(fragmentShader);
var provider = new ShaderArray(vs, fs);
var map = new AttributeMap();
map.Add(vPosition, position);
map.Add(vTexCoord, texCoord);
map.Add(vNormal, normal);
builders[0] = new RenderMethodBuilder(provider, map);
}
{
// render normal
var vs = new VertexShader(normalVertex);
var gs = new GeometryShader(normalGeometry);
var fs = new FragmentShader(normalFragment);
var provider = new ShaderArray(vs, gs, fs);
var map = new AttributeMap();
map.Add(vPosition, position);
map.Add(vNormal, normal);
builders[1] = new RenderMethodBuilder(provider, map);
}
var node = new NormalNode(model, position, texCoord, builders);
string folder = System.Windows.Forms.Application.StartupPath;
node.TextureSource = new TextureSource(System.IO.Path.Combine(folder, @"superficie.png"));
node.ModelSize = size;
node.Initialize();
return(node);
}
public void Dispose()
{
// TODO: Move this to GL_Cleanup
if (ProgramID != 0)
{
// Make sure this program isn't being used
if (GL.CurrentProgram == ProgramID)
{
GL.UseProgram(0);
}
GL.DetachShader(ProgramID, VertexShader.ShaderID);
GL.DetachShader(ProgramID, FragmentShader.ShaderID);
GL.DeleteProgram(ProgramID);
if (DisposeChildren)
{
VertexShader.Dispose();
FragmentShader.Dispose();
}
this.ProgramID = 0;
}
}
public override void Prepare(GL_ControlModern control)
{
var defaultFrag = new FragmentShader(
@"#version 330
vec4 LineColor;
out vec4 FragColor;
void main(){
FragColor = LineColor;
}" );
var defaultVert = new VertexShader(
@"#version 330
in vec4 position;
uniform mat4 mtxCam;
uniform mat4 mtxMdl;
void main(){
gl_Position = mtxCam * mtxMdl * vec4(position.xyz, 1);
}" );
defaultShaderProgram = new ShaderProgram(defaultFrag, defaultVert, control);
}
public static DemoNode Create()
{
RenderMethodBuilder updateBuilder, updateBuilder2;
{
var vs = new VertexShader(updateVert);
var feedbackVaryings = new string[] { outPosition, };
IShaderProgramProvider updateProvider = new ShaderArray(feedbackVaryings, ShaderProgram.BufferMode.Separate, vs);
var map = new AttributeMap();
map.Add(inPosition, DemoModel.inPosition);
var map2 = new AttributeMap();
map2.Add(inPosition, DemoModel.inPosition2);
updateBuilder = new RenderMethodBuilder(updateProvider, map);
updateBuilder2 = new RenderMethodBuilder(updateProvider, map2);
}
RenderMethodBuilder renderBuilder, renderBuilder2;
{
IShaderProgramProvider renderProvider;
var vs = new VertexShader(renderVert);
var fs = new FragmentShader(renderFrag);
renderProvider = new ShaderArray(vs, fs);
var map = new AttributeMap();
map.Add(inPosition, DemoModel.inPosition);
var map2 = new AttributeMap();
map2.Add(inPosition, DemoModel.inPosition2);
renderBuilder = new RenderMethodBuilder(renderProvider, map);
renderBuilder2 = new RenderMethodBuilder(renderProvider, map2);
}
var model = new DemoModel();
var node = new DemoNode(model, updateBuilder, updateBuilder2, renderBuilder, renderBuilder2);
node.Initialize();
return(node);
}
public Shader Load(VertexShader vertex, FragmentShader fragment, bool continuousCompilation = false)
{
return(Load(vertex.ToString(), fragment.ToString(), continuousCompilation));
}
public static void Initialize(GL_ControlModern control)
{
if (DefaultShaderProgram != null && DefaultShaderProgram.programs.ContainsKey(control))
{
return;
}
if (DefaultShaderProgram == null)
{
var solidColorFrag = new FragmentShader(
@"#version 330
uniform vec4 color;
out vec4 fragColor;
void main(){
fragColor = color;
}");
var solidColorVert = new VertexShader(
@"#version 330
layout(location = 0) in vec4 position;
uniform mat4 mtxMdl;
uniform mat4 mtxCam;
void main(){
gl_Position = mtxCam*mtxMdl*position;
}");
var defaultFrag = new FragmentShader(
@"#version 330
uniform vec4 color;
in vec3 viewPosition;
in vec3 normal;
void main(){
gl_FragColor = color;
}");
var defaultVert = new VertexShader(
@"#version 330
layout(location = 0) in vec3 position;
layout(location = 1) in vec3 vNormal;
uniform mat4 mtxMdl;
uniform mat4 mtxCam;
out vec3 normal;
out vec3 viewPosition;
void main(){
normal = vNormal;
viewPosition = position;
gl_Position = mtxCam*mtxMdl*vec4(position, 1);
}");
DefaultShaderProgram = new ShaderProgram(defaultFrag, defaultVert, control);
SolidColorShaderProgram = new ShaderProgram(solidColorFrag, solidColorVert, control);
int buffer = GL.GenBuffer();
sphereVao = new VertexArrayObject(buffer);
sphereVao.AddAttribute(0, 3, VertexAttribPointerType.Float, false, 24, 0);
sphereVao.AddAttribute(1, 3, VertexAttribPointerType.Float, false, 24, 12);
sphereVao.Initialize(control);
List <float> list = new List <float>();
Vertices = GetVertices(1, 32);
for (int i = 0; i < Vertices.Length; i++)
{
list.Add(Vertices[i].Position.X);
list.Add(Vertices[i].Position.Y);
list.Add(Vertices[i].Position.Z);
list.Add(Vertices[i].Normal.X);
list.Add(Vertices[i].Normal.Y);
list.Add(Vertices[i].Normal.Z);
}
float[] data = list.ToArray();
GL.BufferData(BufferTarget.ArrayBuffer, sizeof(float) * data.Length, data, BufferUsageHint.StaticDraw);
}
else
{
sphereVao.Initialize(control);
DefaultShaderProgram.Link(control);
SolidColorShaderProgram.Link(control);
}
}
public MTOB(String Name)
{
Type = 0x8000000;
Signature = "MTOB";
Revision = 0x6000003;
this.Name = Name;
MaterialColor = new MaterialColorCtr();
Rasterization = new RasterizationCtr();
FragmentOperation = new FragmentOperationCtr();
NrActiveTextureCoordiators = 0;
TextureCoordiators = new TextureCoordinatorCtr[3];
TextureCoordiators[0] = new TextureCoordinatorCtr();
TextureCoordiators[1] = new TextureCoordinatorCtr();
TextureCoordiators[2] = new TextureCoordinatorCtr();
Shader = new SHDR();
FragShader = new FragmentShader();
}
public Program(CSGL gl,string VSFileName,string FSFileName)
: base(gl)
{
StreamReader SR;
SR = new StreamReader(VSFileName);
VShader = new CSGL.VertexShader(gl,SR.ReadToEnd());
SR.Close();
SR = new StreamReader(FSFileName);
FShader = new CSGL.FragmentShader(gl,SR.ReadToEnd());
SR.Close();
Initial();
}
public Program(CSGL gl,VertexShader VS,FragmentShader FS)
: base(gl)
{
VShader = VS;
FShader = FS;
Initial();
}
private void ReloadChangedShaders()
{
lock (changedShaders) {
foreach (string path in changedShaders) {
ContentRef<DrawTechnique> shader;
if (cachedShaders.TryGetValue(path, out shader)) {
string pathAbsolute = PathOp.Combine(DualityApp.DataDirectory, "Shaders", path + ".res");
ShaderJson json;
using (Stream s = FileOp.Open(pathAbsolute, FileAccessMode.Read)) {
lock (jsonParser) {
json = jsonParser.Parse<ShaderJson>(s);
}
}
if (json.Fragment == null && json.Vertex == null) {
// ToDo: ...
/*switch (json.BlendMode) {
default:
case BlendMode.Solid: shader = DrawTechnique.Solid; break;
case BlendMode.Mask: shader = DrawTechnique.Mask; break;
case BlendMode.Add: shader = DrawTechnique.Add; break;
case BlendMode.Alpha: shader = DrawTechnique.Alpha; break;
case BlendMode.Multiply: shader = DrawTechnique.Multiply; break;
case BlendMode.Light: shader = DrawTechnique.Light; break;
case BlendMode.Invert: shader = DrawTechnique.Invert; break;
}*/
return;
} else {
#if FAIL_ON_SHADER_COMPILE_ERROR && PLATFORM_ANDROID
requestShaderNesting++;
#endif
ContentRef<VertexShader> vertex;
ContentRef<FragmentShader> fragment;
try {
if (json.Vertex == null) {
vertex = VertexShader.Minimal;
} else if (json.Vertex.StartsWith("#inherit ")) {
string parentPath = json.Vertex.Substring(9).Trim();
ContentRef<DrawTechnique> parent = RequestShader(parentPath);
vertex = parent.Res.Vertex;
} else if (json.Vertex.StartsWith("#include ")) {
string includePath = Path.Combine(DualityApp.DataDirectory, "Shaders", json.Vertex.Substring(9).Trim());
using (Stream s = FileOp.Open(includePath, FileAccessMode.Read))
using (StreamReader r = new StreamReader(s)) {
vertex = new VertexShader(r.ReadToEnd());
}
} else {
vertex = new VertexShader(json.Vertex.TrimStart());
}
if (json.Fragment == null) {
fragment = FragmentShader.Minimal;
} else if (json.Fragment.StartsWith("#inherit ")) {
string parentPath = json.Fragment.Substring(9).Trim();
ContentRef<DrawTechnique> parent = RequestShader(parentPath);
fragment = parent.Res.Fragment;
} else if (json.Fragment.StartsWith("#include ")) {
string includePath = Path.Combine(DualityApp.DataDirectory, "Shaders", json.Fragment.Substring(9).Trim());
using (Stream s = FileOp.Open(includePath, FileAccessMode.Read))
using (StreamReader r = new StreamReader(s)) {
fragment = new FragmentShader(r.ReadToEnd());
}
} else {
fragment = new FragmentShader(json.Fragment.TrimStart());
}
} finally {
#if FAIL_ON_SHADER_COMPILE_ERROR && PLATFORM_ANDROID
requestShaderNesting--;
#endif
}
VertexDeclaration vertexFormat;
switch (json.VertexFormat) {
case "C1P3": vertexFormat = VertexC1P3.Declaration; break;
case "C1P3T2": vertexFormat = VertexC1P3T2.Declaration; break;
case "C1P3T4A1": vertexFormat = VertexC1P3T4A1.Declaration; break;
default: vertexFormat = null; break;
}
// Update shader
shader.Res.Blending = json.BlendMode;
shader.Res.PreferredVertexFormat = vertexFormat;
shader.Res.Vertex = vertex;
shader.Res.Fragment = fragment;
}
}
}
changedShaders.Clear();
}
}
public ContentRef<DrawTechnique> RequestShader(string path)
{
#if MULTIPLAYER && SERVER
return DrawTechnique.Solid;
#else
switch (path) {
case "Solid": return DrawTechnique.Solid;
case "Add": return DrawTechnique.Add;
//case "Alpha": return DrawTechnique.Alpha;
//case "Invert": return DrawTechnique.Invert;
//case "Light": return DrawTechnique.Light;
//case "Mask": return DrawTechnique.Mask;
//case "Multiply": return DrawTechnique.Multiply;
case "SharpAlpha": return DrawTechnique.SharpAlpha;
case "Picking": return DrawTechnique.Picking;
}
ContentRef<DrawTechnique> shader;
if (!cachedShaders.TryGetValue(path, out shader)) {
#if UNCOMPRESSED_CONTENT
string pathAbsolute = PathOp.Combine(DualityApp.DataDirectory, "Shaders", path + ".res");
#elif PLATFORM_ANDROID || PLATFORM_WASM
string pathAbsolute = PathOp.Combine(DualityApp.DataDirectory, "Main.dz", "Shaders.ES30", path + ".res");
#else
string pathAbsolute = PathOp.Combine(DualityApp.DataDirectory, "Main.dz", "Shaders", path + ".res");
#endif
ShaderJson json;
using (Stream s = FileOp.Open(pathAbsolute, FileAccessMode.Read)) {
lock (jsonParser) {
json = jsonParser.Parse<ShaderJson>(s);
}
}
if (json.Fragment == null && json.Vertex == null) {
switch (json.BlendMode) {
default:
case BlendMode.Solid: shader = DrawTechnique.Solid; break;
case BlendMode.Mask: shader = DrawTechnique.Mask; break;
case BlendMode.Add: shader = DrawTechnique.Add; break;
case BlendMode.Alpha: shader = DrawTechnique.Alpha; break;
case BlendMode.Multiply: shader = DrawTechnique.Multiply; break;
case BlendMode.Light: shader = DrawTechnique.Light; break;
case BlendMode.Invert: shader = DrawTechnique.Invert; break;
}
} else {
#if FAIL_ON_SHADER_COMPILE_ERROR && PLATFORM_ANDROID
requestShaderNesting++;
#endif
ContentRef<VertexShader> vertex;
ContentRef<FragmentShader> fragment;
try {
if (json.Vertex == null) {
vertex = VertexShader.Minimal;
} else if (json.Vertex.StartsWith("#inherit ")) {
string parentPath = json.Vertex.Substring(9).Trim();
ContentRef<DrawTechnique> parent = RequestShader(parentPath);
vertex = parent.Res.Vertex;
} else if (json.Vertex.StartsWith("#include ")) {
string includePath = Path.Combine(DualityApp.DataDirectory, "Shaders", json.Vertex.Substring(9).Trim());
using (Stream s = FileOp.Open(includePath, FileAccessMode.Read))
using (StreamReader r = new StreamReader(s)) {
vertex = new VertexShader(r.ReadToEnd());
}
} else {
vertex = new VertexShader(json.Vertex.TrimStart());
}
if (json.Fragment == null) {
fragment = FragmentShader.Minimal;
} else if (json.Fragment.StartsWith("#inherit ")) {
string parentPath = json.Fragment.Substring(9).Trim();
ContentRef<DrawTechnique> parent = RequestShader(parentPath);
fragment = parent.Res.Fragment;
} else if (json.Fragment.StartsWith("#include ")) {
string includePath = Path.Combine(DualityApp.DataDirectory, "Shaders", json.Fragment.Substring(9).Trim());
using (Stream s = FileOp.Open(includePath, FileAccessMode.Read))
using (StreamReader r = new StreamReader(s)) {
fragment = new FragmentShader(r.ReadToEnd());
}
} else {
fragment = new FragmentShader(json.Fragment.TrimStart());
}
} finally {
#if FAIL_ON_SHADER_COMPILE_ERROR && PLATFORM_ANDROID
requestShaderNesting--;
#endif
}
VertexDeclaration vertexFormat;
switch (json.VertexFormat) {
case "C1P3": vertexFormat = VertexC1P3.Declaration; break;
case "C1P3T2": vertexFormat = VertexC1P3T2.Declaration; break;
case "C1P3T4A1": vertexFormat = VertexC1P3T4A1.Declaration; break;
default: vertexFormat = null; break;
}
DrawTechnique result = new DrawTechnique(json.BlendMode, vertex, fragment);
result.PreferredVertexFormat = vertexFormat;
#if FAIL_ON_SHADER_COMPILE_ERROR && PLATFORM_ANDROID
if (requestShaderNesting == 0 && result.DeclaredFields.Count == 0) {
Android.CrashHandlerActivity.ShowErrorDialog(new InvalidDataException("Shader \"" + path + "\" cannot be compiled on your device."));
}
#endif
shader = result;
}
cachedShaders[path] = shader;
}
return shader;
#endif
}
public Graphics(Audio audio)
{
// Save a pointer to the audio class, for convenience
this.Audio = audio;
// Load Shader Programs.
ShaderProgram uvShader = new ShaderProgram(VertexShader.FromFile("data/shaders/uvcolor_vs.glsl"), FragmentShader.FromFile("data/shaders/uvcolor_fs.glsl"));
ShaderProgram objShader = new ShaderProgram(VertexShader.FromFile("data/shaders/obj_vs.glsl"), FragmentShader.FromFile("data/shaders/obj_fs.glsl"));
ShaderProgram objShaderHax = new ShaderProgram(VertexShader.FromFile("data/shaders/obj_vs_hax.glsl"), FragmentShader.FromFile("data/shaders/obj_fs.glsl"));
this.wallShader = objShader;
// Create matrix uniforms used for rendering.
this.view2D = new Matrix4Uniform("viewMatrix");
this.projection2D = new Matrix4Uniform("projectionMatrix");
this.view3D = new Matrix4Uniform("viewMatrix");
this.projection3D = new Matrix4Uniform("projectionMatrix");
this.createColorMatrices();
this.WallColorUniform = new Matrix4Uniform("mixColor", this.Blue);
this.lightDirection = new Vector3(-1f, -0.5f, -0.4f);
this.lightDirection.Normalize();
// Create the surfaces
#region Font Surface
Texture t = new Texture("data/fonts/freshman.png");
this.FontSurface = new IndexedSurface <UVColorVertexData>();
this.FontSurface.AddSettings(
this.view2D,
this.projection2D,
new TextureUniform("diffuseTexture", t),
SurfaceBlendSetting.Alpha,
SurfaceDepthMaskSetting.DontMask
);
this.FontSurface.SetShaderProgram(uvShader);
// the following line loads the json file
this.FontGeometry = new FontGeometry(this.FontSurface, amulware.Graphics.Font.FromJsonFile("data/fonts/freshman_monospaced_numbers.json"));
// this.FontGeometry.SizeCoefficient = new Vector2(1, -1); // FLIP IT
this.MenuFontGeometry = this.FontGeometry;
#endregion
#region 3D font Surface
t = new Texture("data/fonts/freshman.png");
this.FontSurface3D = new IndexedSurface <UVColorVertexData>();
this.FontSurface3D.AddSettings(
this.view3D,
this.projection3D,
new TextureUniform("diffuseTexture", t),
SurfaceBlendSetting.Alpha,
SurfaceDepthMaskSetting.DontMask
);
this.FontSurface3D.SetShaderProgram(uvShader);
// the following line loads the json file
this.FontGeometry3D = new FontGeometry(this.FontSurface3D, amulware.Graphics.Font.FromJsonFile("data/fonts/freshman_monospaced_numbers.json"));
this.FontGeometry3D.SizeCoefficient = new Vector2(1, -1); // FLIP IT
#endregion
#region PacmanSurface
MeshData m = new MeshData("data/models/Pacman.obj");
t = new Texture("data/sprites/PacmanTexture.png");
this.pacManModel = new Matrix4Uniform("modelMatrix", Matrix4.Identity);
this.PacmanSurface = m.ToIndexedSurface <NormalUVColorVertexData>(NormalUVColorVertexData.FromMesh);
this.PacmanSurface.AddSettings(
this.pacManModel,
this.view3D,
this.projection3D,
new TextureUniform("diffuseTexture", t),
new Vector3Uniform("lightDirection", this.lightDirection),
new FloatUniform("ambientIntensity", 0.3f),
new FloatUniform("diffuseIntensity", 0.8f),
new Matrix4Uniform("mixColor", Matrix4.Identity)
);
this.PacmanSurface.SetShaderProgram(objShader);
#endregion
#region PacmanMouthSurface (must be placed directly after the 'PacmanSurface')
m = new MeshData("data/models/Pacman_mouth.obj");
this.PacManMouthTopTexture = new Texture("data/sprites/OrbTexture.png"); // 't' is the same texture as pacman, 't-top' is a plain white pixel (as used for the orbs).
this.PacManMouthBottomTexture = t;
this.PacManMouthTextureUniform = new TextureUniform("diffuseTexture", t);
this.PacManMouthColorUniform = new Matrix4Uniform("mixColor", Matrix4.Identity);
this.PacmanMouthSurface = m.ToIndexedSurface <NormalUVColorVertexData>(NormalUVColorVertexData.FromMesh);
this.PacmanMouthSurface.AddSettings(
this.pacManModel,
this.view3D,
this.projection3D,
this.PacManMouthTextureUniform,
new Vector3Uniform("lightDirection", this.lightDirection),
new FloatUniform("ambientIntensity", 0.3f),
new FloatUniform("diffuseIntensity", 0.8f),
this.PacManMouthColorUniform
);
this.PacmanMouthSurface.SetShaderProgram(objShaderHax);
#endregion
#region GhostSurface
m = new MeshData("data/models/Ghost.obj");
t = new Texture("data/sprites/GhostTexture.png");
this.GhostColorUniform = new Matrix4Uniform("mixColor", this.Red);
this.ghostModel = new Matrix4Uniform("modelMatrix", Matrix4.Identity);
this.GhostSurface = m.ToIndexedSurface <NormalUVColorVertexData>(NormalUVColorVertexData.FromMesh);
this.GhostSurface.AddSettings(
this.ghostModel,
this.view3D,
this.projection3D,
new TextureUniform("diffuseTexture", t),
new Vector3Uniform("lightDirection", this.lightDirection),
new FloatUniform("ambientIntensity", 0.3f),
new FloatUniform("diffuseIntensity", 0.8f),
this.GhostColorUniform
);
this.GhostSurface.SetShaderProgram(objShader);
#endregion
#region OrbSurface
m = new MeshData("data/models/Orb.obj");
t = new Texture("data/sprites/OrbTexture.png");
this.orbModel = new Matrix4Uniform("modelMatrix", Matrix4.Identity);
this.OrbSurface = m.ToIndexedSurface <NormalUVColorVertexData>(NormalUVColorVertexData.FromMesh);
this.OrbSurface.AddSettings(
this.orbModel,
this.view3D,
this.projection3D,
new TextureUniform("diffuseTexture", t),
new Vector3Uniform("lightDirection", this.lightDirection),
new FloatUniform("ambientIntensity", 0.3f),
new FloatUniform("diffuseIntensity", 0.8f),
new Matrix4Uniform("mixColor", Matrix4.Identity)
);
this.OrbSurface.SetShaderProgram(objShader);
#endregion
}
public MTOB(EndianBinaryReader er)
{
Type = er.ReadUInt32();
Signature = er.ReadString(Encoding.ASCII, 4);
if (Signature != "MTOB") throw new SignatureNotCorrectException(Signature, "MTOB", er.BaseStream.Position);
Revision = er.ReadUInt32();
NameOffset = (UInt32)er.BaseStream.Position + er.ReadUInt32();
Unknown2 = er.ReadUInt32();
Unknown3 = er.ReadUInt32();
Flags = (MaterialFlags)er.ReadUInt32();
TexCoordConfig = er.ReadUInt32();
TranslucencyKind = er.ReadUInt32();
MaterialColor = new MaterialColorCtr(er);
Rasterization = new RasterizationCtr(er);
FragmentOperation = new FragmentOperationCtr(er);
NrActiveTextureCoordiators = er.ReadUInt32();
TextureCoordiators = new TextureCoordinatorCtr[3];
TextureCoordiators[0] = new TextureCoordinatorCtr(er);
TextureCoordiators[1] = new TextureCoordinatorCtr(er);
TextureCoordiators[2] = new TextureCoordinatorCtr(er);
TexMapper0Offset = er.ReadUInt32();
if (TexMapper0Offset != 0) TexMapper0Offset += (UInt32)er.BaseStream.Position - 4;
TexMapper1Offset = er.ReadUInt32();
if (TexMapper1Offset != 0) TexMapper1Offset += (UInt32)er.BaseStream.Position - 4;
TexMapper2Offset = er.ReadUInt32();
if (TexMapper2Offset != 0) TexMapper2Offset += (UInt32)er.BaseStream.Position - 4;
ProcTexMapperOffset = er.ReadUInt32();
if (ProcTexMapperOffset != 0) ProcTexMapperOffset += (UInt32)er.BaseStream.Position - 4;
ShaderOffset = (UInt32)er.BaseStream.Position + er.ReadUInt32();
FragmentShaderOffset = (UInt32)er.BaseStream.Position + er.ReadUInt32();
ShaderProgramDescriptionIndex = er.ReadUInt32();
NrShaderParameters = er.ReadUInt32();
ShaderParametersOffsetArrayOffset = er.ReadUInt32();
LightSetIndex = er.ReadUInt32();
FogIndex = er.ReadUInt32();
ShadingParameterHash = er.ReadUInt32();
ShaderParametersHash = er.ReadUInt32();
TextureCoordinatorsHash = er.ReadUInt32();
TextureSamplersHash = er.ReadUInt32();
TextureMappersHash = er.ReadUInt32();
MaterialColorHash = er.ReadUInt32();
RasterizationHash = er.ReadUInt32();
FragmentLightingHash = er.ReadUInt32();
FragmentLightingTableHash = er.ReadUInt32();
FragmentLightingTableParametersHash = er.ReadUInt32();
TextureCombinersHash = er.ReadUInt32();
AlphaTestHash = er.ReadUInt32();
FragmentOperationHash = er.ReadUInt32();
MaterialId = er.ReadUInt32();
long curpos = er.BaseStream.Position;
er.BaseStream.Position = NameOffset;
Name = er.ReadStringNT(Encoding.ASCII);
if (TexMapper0Offset != 0)
{
er.BaseStream.Position = TexMapper0Offset;
Tex0 = new TexInfo(er);
}
if (TexMapper1Offset != 0)
{
er.BaseStream.Position = TexMapper1Offset;
Tex1 = new TexInfo(er);
}
if (TexMapper2Offset != 0)
{
er.BaseStream.Position = TexMapper2Offset;
Tex2 = new TexInfo(er);
}
/*if (TexMapper3Offset != 0)
{
er.BaseStream.Position = Tex3Offset;
Tex3 = new TexInfo(er);
}*/
//TODO: Procedural Texture Mapper
er.BaseStream.Position = ShaderOffset;
Shader = new SHDR(er);
er.BaseStream.Position = FragmentShaderOffset;
FragShader = new FragmentShader(er);
er.BaseStream.Position = curpos;
}
public override void Prepare(GL_ControlModern control)
{
defaultFrag = new FragmentShader(
@"#version 330
in vec4 fragColor;
void main(){
gl_FragColor = fragColor;
}" );
defaultVert = new VertexShader(
@"#version 330
layout(location = 0) in vec4 position;
layout(location = 1) in vec4 color;
uniform mat4 mtxMdl;
uniform mat4 mtxCam;
uniform vec4 highlightColor;
out vec4 fragColor;
void main(){
gl_Position = mtxCam*mtxMdl*position;
fragColor = color+highlightColor.xyz*highlightColor.w;
}" );
pickingVert = new VertexShader(
@"#version 330
layout(location = 0) in vec4 position;
uniform vec4 color;
uniform mat4 mtxMdl;
uniform mat4 mtxCam;
out vec4 fragColor;
void main(){
gl_Position = mtxCam*mtxMdl*position;
fragColor = color;
}" );
defaultShaderProgram = new ShaderProgram(
defaultFrag, defaultVert
);
testShaderProgram = new ShaderProgram(
new FragmentShader(
@"#version 330
in vec4 vertPosition;
in vec4 fragColor;
void main(){
float v = round(abs(mod(vertPosition.x,2.0)-1.0)+
abs(mod(vertPosition.z,2.0)-1.0));
gl_FragColor = fragColor*v;
}" ),
new VertexShader(
@"#version 330
layout(location = 0) in vec4 position;
layout(location = 1) in vec4 color;
uniform mat4 mtxMdl;
uniform mat4 mtxCam;
out vec4 vertPosition;
out vec4 fragColor;
void main(){
gl_Position = mtxMdl*mtxCam*position;
vertPosition = position;
fragColor = color;
}" ));
control.CurrentShader = defaultShaderProgram;
int buffer;
GL.BindVertexArray(testVao = GL.GenVertexArray());
GL.BindBuffer(BufferTarget.ArrayBuffer, buffer = GL.GenBuffer());
float[] data = new float[] {
-10f, -0.25f, 5f, 1f, 0f, 0f, 1f,
10f, -0.25f, 5f, 0f, 1f, 0f, 1f,
10f, -0.25f, -5f, 1f, 1f, 0f, 1f,
-10f, -0.25f, -5f, 0f, 0f, 1f, 1f,
};
GL.BufferData(BufferTarget.ArrayBuffer, sizeof(float) * data.Length, data, BufferUsageHint.StaticDraw);
GL.EnableVertexAttribArray(0);
GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, sizeof(float) * 7, 0);
GL.EnableVertexAttribArray(1);
GL.VertexAttribPointer(1, 4, VertexAttribPointerType.Float, false, sizeof(float) * 7, sizeof(float) * 3);
GL.BindVertexArray(marioTestVao = GL.GenVertexArray());
using (OldGlEmulator GL = new OldGlEmulator())
{
//body
GL.Color3(1f, 0f, 0f);
GL.Vertex3(-0.5f, 2f, 0f);
GL.Vertex3(0.5f, 2f, 0f);
GL.Vertex3(0.5f, 1.25f, 0f);
GL.Vertex3(-0.5f, 1.25f, 0f);
GL.Vertex3(-1.5f, 2.5f, 0f);
GL.Vertex3(1.5f, 2.5f, 0f);
GL.Vertex3(1.5f, 2f, 0f);
GL.Vertex3(-1.5f, 2f, 0f);
//trowsers
GL.Color3(0, 0.2f, 1f);
GL.Vertex3(-0.5f, 1.25f, 0f);
GL.Vertex3(0.5f, 1.25f, 0f);
GL.Vertex3(0.5f, 0.75f, 0f);
GL.Vertex3(-0.5f, 0.75f, 0f);
GL.Vertex3(-0.5f, 0.75f, 0f);
GL.Vertex3(-0.125f, 0.75f, 0f);
GL.Vertex3(-0.125f, -0.25f, 0f);
GL.Vertex3(-0.5f, -0.25f, 0f);
GL.Vertex3(0.125f, 0.75f, 0f);
GL.Vertex3(0.5f, 0.75f, 0f);
GL.Vertex3(0.5f, -0.25f, 0f);
GL.Vertex3(0.125f, -0.25f, 0f);
//stripes
GL.Vertex3(-0.375f, 2.5f, -0.02f);
GL.Vertex3(-0.125f, 2.5f, -0.02f);
GL.Vertex3(-0.125f, 1.25f, -0.02f);
GL.Vertex3(-0.375f, 1.25f, -0.02f);
GL.Vertex3(0.125f, 2.5f, -0.02f);
GL.Vertex3(0.375f, 2.5f, -0.02f);
GL.Vertex3(0.375f, 1.25f, -0.02f);
GL.Vertex3(0.125f, 1.25f, -0.02f);
GL.Vertex3(-0.375f, 2.5f, 0.02f);
GL.Vertex3(-0.125f, 2.5f, 0.02f);
GL.Vertex3(-0.125f, 1.25f, 0.02f);
GL.Vertex3(-0.375f, 1.25f, 0.02f);
GL.Vertex3(0.125f, 2.5f, 0.02f);
GL.Vertex3(0.375f, 2.5f, 0.02f);
GL.Vertex3(0.375f, 1.25f, 0.02f);
GL.Vertex3(0.125f, 1.25f, 0.02f);
//knobs
GL.Color3(1f, 1f, 0f);
GL.Vertex3(-0.375f, 2.25f, 0.04f);
GL.Vertex3(-0.125f, 2.25f, 0.04f);
GL.Vertex3(-0.125f, 2f, 0.04f);
GL.Vertex3(-0.375f, 2f, 0.04f);
GL.Vertex3(0.125f, 2.25f, 0.04f);
GL.Vertex3(0.375f, 2.25f, 0.04f);
GL.Vertex3(0.375f, 2f, 0.04f);
GL.Vertex3(0.125f, 2f, 0.04f);
GL.WriteToBuffer(buffer = OpenTK.Graphics.OpenGL.GL.GenBuffer());
}
}
public FragmentShader GetGLShaderToOutputMerger()
{
return glShaderToOutputMerger ?? (glShaderToOutputMerger = CreateNative());
}
public static void Initialize()
{
if (initialized)
{
return;
}
//string GetCondition(int row, Vector3 vec)
//{
// if (vec.X != 0)
// return $"mtx.M{row}1=={vec.X}";
// else if (vec.Y != 0)
// return $"mtx.M{row}2=={vec.Y}";
// else
// return $"mtx.M{row}3=={vec.Z}";
//}
//string edgeCases = "";
//for (float x = -90; x <= 180; x+=90)
//{
// for (float y = -90; y <= 180; y += 90)
// {
// for (float z = -90; z <= 180; z += 90)
// {
// var mat = Mat3FromEulerAnglesDeg(new Vector3(x, y, z));
// var mat2 = Mat3FromEulerAnglesDeg(mat.ExtractDegreeEulerAngles());
// if (mat != mat2)
// {
// edgeCases += $"if({GetCondition(1,mat.Row0)} && {GetCondition(2, mat.Row1)} && {GetCondition(3, mat.Row2)})\n";
// edgeCases += $" return new Vector3({x},{y},{z});\n";
// }
// }
// }
//}
//solid shader
var solidColorFrag = new FragmentShader(
@"#version 330
uniform vec4 color;
void main(){
gl_FragColor = color;
}");
var solidColorVert = new VertexShader(
@"#version 330
layout(location = 0) in vec4 position;
uniform mat4 mtxMdl;
uniform mat4 mtxCam;
void main(){
gl_Position = mtxCam*mtxMdl*position;
}");
SolidColorShaderProgram = new ShaderProgram(solidColorFrag, solidColorVert);
//texture sheet
TextureSheet = GL.GenTexture();
GL.BindTexture(TextureTarget.Texture2D, TextureSheet);
var bmp = Properties.Resources.TextureSheet;
var bmpData = bmp.LockBits(
new Rectangle(0, 0, 128 * 4, 128 * 2),
System.Drawing.Imaging.ImageLockMode.ReadOnly,
System.Drawing.Imaging.PixelFormat.Format32bppArgb);
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba8, 128 * 4, 128 * 2, 0, PixelFormat.Bgra, PixelType.UnsignedByte, bmpData.Scan0);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
GL.GenerateMipmap(GenerateMipmapTarget.Texture2D);
bmp.UnlockBits(bmpData);
initialized = true;
}
public static void Initialize()
{
if (!Initialized)
{
var defaultFrag = new FragmentShader(
@"#version 330
uniform sampler2D tex;
in vec4 fragColor;
in vec3 fragPosition;
in vec2 uv;
void main(){
gl_FragColor = fragColor*((fragPosition.y+2)/3)*texture(tex, uv, 100);
}");
var defaultVert = new VertexShader(
@"#version 330
layout(location = 0) in vec4 position;
uniform vec4 color;
uniform mat4 mtxMdl;
uniform mat4 mtxCam;
out vec4 fragColor;
out vec3 fragPosition;
out vec2 uv;
vec2 map(vec2 value, vec2 min1, vec2 max1, vec2 min2, vec2 max2) {
return min2 + (value - min1) * (max2 - min2) / (max1 - min1);
}
void main(){
fragPosition = position.xyz;
uv = map(fragPosition.xz,vec2(-1.0625,-1.0625),vec2(1.0625,1.0625), vec2(0.5,0.5), vec2(0.75,1.0));
gl_Position = mtxCam*mtxMdl*position;
fragColor = color;
}");
DefaultShaderProgram = new ShaderProgram(defaultFrag, defaultVert);
int buffer;
#region block
buffer = GL.GenBuffer();
blockVao = new VertexArrayObject(buffer);
blockVao.AddAttribute(0, 3, VertexAttribPointerType.Float, false, sizeof(float) * 3, 0);
blockVao.Submit();
List <float> list = new List <float>();
Face(ref points, ref list, 0, 1, 2, 3);
FaceInv(ref points, ref list, 4, 5, 6, 7);
FaceInv(ref points, ref list, 0, 1, 4, 5);
Face(ref points, ref list, 2, 3, 6, 7);
Face(ref points, ref list, 0, 2, 4, 6);
FaceInv(ref points, ref list, 1, 3, 5, 7);
float[] data = list.ToArray();
GL.BufferData(BufferTarget.ArrayBuffer, sizeof(float) * data.Length, data, BufferUsageHint.StaticDraw);
#endregion
#region lines
buffer = GL.GenBuffer();
linesVao = new VertexArrayObject(buffer);
linesVao.AddAttribute(0, 3, VertexAttribPointerType.Float, false, sizeof(float) * 3, 0);
linesVao.Submit();
list = new List <float>();
LineFace(ref points, ref list, 0, 1, 2, 3);
LineFace(ref points, ref list, 4, 5, 6, 7);
Line(ref points, ref list, 0, 4);
Line(ref points, ref list, 1, 5);
Line(ref points, ref list, 2, 6);
Line(ref points, ref list, 3, 7);
data = list.ToArray();
GL.BufferData(BufferTarget.ArrayBuffer, sizeof(float) * data.Length, data, BufferUsageHint.StaticDraw);
#endregion
#region legacy lines
lineDrawList = GL.GenLists(1);
GL.NewList(lineDrawList, ListMode.Compile);
GL.Begin(PrimitiveType.LineStrip);
GL.Vertex3(points[6]);
GL.Vertex3(points[2]);
GL.Vertex3(points[3]);
GL.Vertex3(points[7]);
GL.Vertex3(points[6]);
GL.Vertex3(points[4]);
GL.Vertex3(points[5]);
GL.Vertex3(points[1]);
GL.Vertex3(points[0]);
GL.Vertex3(points[4]);
GL.End();
GL.Begin(PrimitiveType.Lines);
GL.Vertex3(points[2]);
GL.Vertex3(points[0]);
GL.Vertex3(points[3]);
GL.Vertex3(points[1]);
GL.Vertex3(points[7]);
GL.Vertex3(points[5]);
GL.End();
GL.EndList();
#endregion
Initialized = true;
}
}
public static void Initialize()
{
if (!Initialized)
{
var defaultFrag = new FragmentShader(
@"#version 330
uniform sampler2D tex;
uniform vec4 color;
in vec2 uv;
void main(){
gl_FragColor = color * texture(tex,uv);
}");
var defaultVert = new VertexShader(
@"#version 330
layout(location = 0) in vec4 position;
uniform vec2 uvTopLeft;
uniform mat4 mtxMdl;
uniform mat4 mtxCam;
out vec2 uv;
vec2 map(vec2 value, vec2 min1, vec2 max1, vec2 min2, vec2 max2) {
return min2 + (value - min1) * (max2 - min2) / (max1 - min1);
}
void main(){
uv = map(position.xy,vec2(-0.5,0.5),vec2(0.5,-0.5), uvTopLeft, uvTopLeft+vec2(0.25,0.25));
gl_Position = mtxCam*mtxMdl*position;
}");
DefaultShaderProgram = new ShaderProgram(defaultFrag, defaultVert);
int buffer;
#region block
buffer = GL.GenBuffer();
planeVao = new VertexArrayObject(buffer);
planeVao.AddAttribute(0, 3, VertexAttribPointerType.Float, false, sizeof(float) * 3, 0);
planeVao.Submit();
float[] data = new float[]
{
-0.5f, -0.5f, 0,
0.5f, -0.5f, 0,
0.5f, 0.5f, 0,
-0.5f, 0.5f, 0,
};
GL.BufferData(BufferTarget.ArrayBuffer, sizeof(float) * data.Length, data, BufferUsageHint.StaticDraw);
#endregion
//texture sheet
TextureSheet = GL.GenTexture();
GL.BindTexture(TextureTarget.Texture2D, TextureSheet);
var bmp = Properties.Resources.Gizmos;
var bmpData = bmp.LockBits(
new Rectangle(0, 0, 128 * 4, 128 * 4),
System.Drawing.Imaging.ImageLockMode.ReadOnly,
System.Drawing.Imaging.PixelFormat.Format32bppArgb);
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba8, 128 * 4, 128 * 4, 0, PixelFormat.Bgra, PixelType.UnsignedByte, bmpData.Scan0);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
GL.GenerateMipmap(GenerateMipmapTarget.Texture2D);
bmp.UnlockBits(bmpData);
Initialized = true;
}
}
// we are defining extensions for a class generated from IDL
public static WebGLProgram createProgram(this WebGLRenderingContext gl, VertexShader v, FragmentShader f)
{
var programHandle = gl.createProgram();
var vs = gl.createShader(v);
var fs = gl.createShader(f);
gl.attachShader(programHandle, vs);
gl.attachShader(programHandle, fs);
gl.deleteShader(vs);
gl.deleteShader(fs);
// http://www.seas.upenn.edu/~pcozzi/OpenGLInsights/OpenGLInsights-ANGLE.pdf
// are implicitly linked when the shaders are made active.
return(programHandle);
}
