public Sun(string dataBaseName, PlanetParameters param, Planet parent, MeshVBOs vbos, Texture t, ShaderProgram shader, ShaderProgram lineShader)
: base(dataBaseName, param, parent, vbos, t, shader, lineShader)
{
bufferVerts = new VBO<float>(new float[] { -1, 1, 0, 1, 1, 0, 1, -1, 0, -1, -1, 0 }, BufferTarget.ArrayBuffer, VBO<float>.PointerType.vertex);
bufferElems = new VBO<ushort>(new ushort[] { 0, 1, 2, 3 }, BufferTarget.ElementArrayBuffer, VBO<ushort>.PointerType.element);
squareUvs = new VBO<float>(new float[] { 0, 1, 1, 1, 1, 0, 0, 0 }, BufferTarget.ArrayBuffer, VBO<float>.PointerType.texCoord);
squareVerts = new VBO<float>(new float[] { -2, 2, 0, 2f, 2f, 0, 2f, -2f, 0, -2f, -2f, 0 }, BufferTarget.ArrayBuffer, VBO<float>.PointerType.vertex);
squareElems = new VBO<ushort>(new ushort[] { 0, 1, 2, 3 }, BufferTarget.ElementArrayBuffer, VBO<ushort>.PointerType.element);
this.coronaShader = new ShaderProgram(File.ReadAllText("content/shaders/coronaShader.vert"), File.ReadAllText("content/shaders/coronaShader.frag"), "coronaShader");
Console.WriteLine(coronaShader.ProgramInfoLog);
coronaShader.setUniform("proj", Form1.projectionMatrix);
coronaShader.setUniform("model", Matrix4.Identity);
this.billboardShader = new ShaderProgram(File.ReadAllText("content/shaders/billboardShader.vert"), File.ReadAllText("content/shaders/billboardShader.frag"), "billboardShader");
Console.WriteLine(billboardShader.ProgramInfoLog);
billboardShader.setUniform("proj", Form1.projectionMatrix);
billboardShader.setUniform("model", Matrix4.Identity);
frameBufferTime = 0;
bufferResolution = new Vector2(1024, 1024);
bufferTexture = GL.GenTexture();
GL.BindTexture(TextureTarget.Texture2D, bufferTexture);
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, (int)bufferResolution.X, (int)bufferResolution.Y, 0, PixelFormat.Rgba, PixelType.UnsignedByte, IntPtr.Zero);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
frameBuffer = GL.GenFramebuffer();
GL.BindFramebuffer(FramebufferTarget.Framebuffer, frameBuffer);
GL.FramebufferTexture2D(FramebufferTarget.Framebuffer, FramebufferAttachment.ColorAttachment0, TextureTarget.Texture2D, bufferTexture, 0);
GL.BindFramebuffer(FramebufferTarget.Framebuffer, 0); // make sure to set the framebuffer back to the default, or else bugs,
//bugs that take two hours to debug
}
protected override void DoInitialize()
{
{
// particleSimulator-fountain.comp is also OK.
var shaderCode = new ShaderCode(File.ReadAllText(@"shaders\ParticleSimulatorRenderer\particleSimulator.comp"), ShaderType.ComputeShader);
this.computeProgram = shaderCode.CreateProgram();
}
{
Buffer buffer = this.positionBuffer;
Texture texture = buffer.DumpBufferTexture(OpenGL.GL_RGBA32F, autoDispose: false);
texture.Initialize();
this.positionTexture = texture;
}
{
Buffer buffer = this.velocityBuffer;
Texture texture = buffer.DumpBufferTexture(OpenGL.GL_RGBA32F, autoDispose: false);
texture.Initialize();
this.velocityTexture = texture;
}
{
const int length = 64;
UniformBuffer buffer = UniformBuffer.Create(typeof(vec4), length, BufferUsage.DynamicCopy);
buffer.Bind();
OpenGL.BindBufferBase((BindBufferBaseTarget)BufferTarget.UniformBuffer, 0, buffer.BufferId);
buffer.Unbind();
this.attractorBuffer = buffer;
OpenGL.CheckError();
}
}
public Viewport(Resolution resolution, Vector2? position = null, Camera camera = null)
{
this.Resolution = resolution;
this.Position = position ?? Vector2.Zero;
var pos = new Vector3[] {
new Vector3 (this.Resolution.Width, 0, 0),
new Vector3 (this.Resolution.Width, this.Resolution.Height, 0),
new Vector3 (0, this.Resolution.Height, 0),
new Vector3 (0, 0, 0),
};
var tex = new Vector2[] {
new Vector2 (1.0f, 0.0f),
new Vector2 (1.0f, 1.0f),
new Vector2 (0.0f, 1.0f),
new Vector2 (0.0f, 0.0f),
};
ViewportShader = Game.ContentManager.Load<ShaderProgram> ("viewport");
this.ViewportTarget = new Model (new Geometry (BeginMode.Quads)
.AddBuffer ("v_pos", new GLBuffer<Vector3> (GLBufferSettings.StaticDraw3FloatArray, pos))
.AddBuffer ("v_tex", new GLBuffer<Vector2> (GLBufferSettings.StaticDraw2FloatArray, tex)));
Matrix = Matrix4.CreateOrthographicOffCenter (0, this.Resolution.Width, 0, this.Resolution.Height, 0, 16);
}
public Grid(Renderer renderer, ShaderProgram shader)
{
// Render state for grid
RenderState = renderer.RenderFactory.CreateRenderState();
RenderState.DepthTest = true;
RenderState.DepthMask = true;
this.Shader = shader;
// Define the format of the control point to render the line
VertexDeclaration vd = new VertexDeclaration();
vd.AddField(VertexFieldDataType.FVector3, VertexFieldSemantic.Position);
// and create a vertex buffer for storing this kind of data
this.VertexBuffer = renderer.RenderFactory.CreateVertexBuffer(vd);
// Draw the primitive as lines
this.DrawOperation = DrawOperation.Lines;
this.RenderGroup = RenderQueueGroupId.Geometries;
List<FVector3> lines = new List<FVector3>();
for (int i = -10; i <= 10; i++)
{
// Draw - line
lines.Add(new FVector3(i, 0, -10));
lines.Add(new FVector3(i,0, 10));
// Draw | line
lines.Add(new FVector3(-10, 0, i));
lines.Add(new FVector3(10, 0, i));
}
// Put it to vertex buffer
VertexBuffer.LoadData(lines.ToArray());
}
/// <summary>
/// Set uniform's value to GPU.(And maybe alsoe reset <see cref="Updated"/> property.)
/// </summary>
/// <param name="program"></param>
public void SetUniform(ShaderProgram program)
{
if (this.Updated)
{
this.DoSetUniform(program);
}
}
/// シェーダのセット
public static void Init( string vshName, string fshName )
{
// vertex color shader
debShader = new ShaderProgram( vshName, fshName );
debShader.SetAttributeBinding( 0, "a_Position" );
debUIdWVP = debShader.FindUniform( "WorldViewProj" );
}
public DebugString(GraphicsContext graphics, Texture2D texture, int charaWidth, int charaHeight)
{
if(shaderProgram == null)
{
shaderProgram=CreateSimpleSpriteShader();
}
this.graphics = graphics;
this.texture = texture;
this.charaWidth = charaWidth;
this.charaHeight = charaHeight;
charaPositions = new float[maxNumOfCharactor * 4 * 3];
charaTexcoords = new float[maxNumOfCharactor * 4 * 2];
charaColors = new float[maxNumOfCharactor * 4 * 4];
charaIndices = new ushort[maxNumOfCharactor * indexSize];
vertices = new VertexBuffer(maxNumOfCharactor * 4, maxNumOfCharactor * indexSize,
VertexFormat.Float3, VertexFormat.Float2, VertexFormat.Float4);
PixelScreenPosition = new Vector3(0.0f, 0.0f, 0.0f);
ImageRect rectPixelScreen = graphics.GetViewport();
//@j ピクセルの座標系をスクリーンの座標系に変換する行列。
//@e Line to convert a pixel coordinate system into a screen coordinate system.
unitScreenMatrix = new Matrix4(
2.0f/rectPixelScreen.Width, 0.0f, 0.0f, 0.0f,
0.0f, -2.0f/rectPixelScreen.Height, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
-1.0f, 1.0f, 0.0f, 1.0f
);
}
public static void init()
{
if (shaderUniversal == null){
shaderUniversal = new ShaderProgram("/Application/shaders/Universal.cgx");
shaderUniversal.SetAttributeBinding(0, "a_Position");
shaderUniversal.SetAttributeBinding(1, "a_VertexColor");
shaderUniversal.SetAttributeBinding(2, "a_TexCoord");
shaderUniversal.SetUniformBinding(0, "u_SceneMatrix");
shaderUniversal.SetUniformBinding(1, "u_ScreenMatrix");
shaderUniversal.SetUniformBinding(2, "u_Alpha");
texture = new Texture2D("/Application/assets/texturepack/rymdkapsel-hd.png", false);
texture.SetFilter(TextureFilterMode.Disabled);
texture.SetWrap(TextureWrapMode.ClampToEdge);
texture.SetMaxAnisotropy(0);
}
if (shaderColored == null){
shaderColored = new ShaderProgram("/Application/shaders/Colored.cgx");
shaderColored.SetAttributeBinding(0, "a_Position");
shaderColored.SetAttributeBinding(1, "a_VertexColor");
shaderColored.SetUniformBinding(0, "u_SceneMatrix");
shaderColored.SetUniformBinding(1, "u_ScreenMatrix");
shaderColored.SetUniformBinding(2, "u_Alpha");
}
}
/// シェーダの解放
public static void Term()
{
if( debShader != null ){
debShader.Dispose();
}
debShader = null;
}
public PatternGrid(GraphicsContext graphics, Texture2D texture, Vector2 position, Vector2 size)
{
if(shaderProgram == null)
{
//shaderProgram=CreateSimpleSpriteShader();
shaderProgram = new ShaderProgram("/Application/shaders/Sprite.cgx");
shaderProgram.SetUniformBinding(0, "u_WorldMatrix");
}
//if (texture == null)
//{
// throw new Exception("ERROR: texture is null.");
//}
this.graphics = graphics;
//this.texture = texture;
this.texture = new Texture2D("/Application/resources/textures512.png", false);
this.width = size.X;
this.height = size.Y;
this.origin = position;
//@e Vertex coordinate, Texture coordinate, Vertex color
//vertexBuffer = new VertexBuffer(4, indexSize, VertexFormat.Float3, VertexFormat.Float2, VertexFormat.Float4);
vertexBuffer = new VertexBuffer(NUMVERTICES, VertexFormat.Float3, VertexFormat.Float2, VertexFormat.Float4);
}
internal void SetConstantBuffers(GraphicsDevice device, ShaderProgram shaderProgram)
#endif
{
// If there are no constant buffers then skip it.
if (_valid == 0)
return;
var valid = _valid;
for (var i = 0; i < _buffers.Length; i++)
{
var buffer = _buffers[i];
if (buffer != null && !buffer.IsDisposed)
{
#if DIRECTX
buffer.PlatformApply(device, _stage, i);
#elif OPENGL || WEB
buffer.PlatformApply(device, shaderProgram);
#endif
}
// Early out if this is the last one.
valid &= ~(1 << i);
if (valid == 0)
return;
}
}
/// <summary>
/// Initialises the scene.
/// </summary>
/// <param name="gl">The OpenGL instance.</param>
/// <param name="width">The width of the screen.</param>
/// <param name="height">The height of the screen.</param>
public void Initialise(OpenGL gl, float width, float height)
{
// Set a blue clear colour.
gl.ClearColor(0.4f, 0.6f, 0.9f, 0.0f);
// Create the shader program.
var vertexShaderSource = ManifestResourceLoader.LoadTextFile("Shader.vert");
var fragmentShaderSource = ManifestResourceLoader.LoadTextFile("Shader.frag");
shaderProgram = new ShaderProgram();
shaderProgram.Create(gl, vertexShaderSource, fragmentShaderSource, null);
shaderProgram.BindAttributeLocation(gl, attributeIndexPosition, "in_Position");
shaderProgram.BindAttributeLocation(gl, attributeIndexColour, "in_Color");
shaderProgram.AssertValid(gl);
// Create a perspective projection matrix.
const float rads = (60.0f / 360.0f) * (float)Math.PI * 2.0f;
projectionMatrix = glm.perspective(rads, width / height, 0.1f, 100.0f);
// Create a view matrix to move us back a bit.
viewMatrix = glm.translate(new mat4(1.0f), new vec3(0.0f, 0.0f, -5.0f));
// Create a model matrix to make the model a little bigger.
modelMatrix = glm.scale(new mat4(1.0f), new vec3(2.5f));
// Now create the geometry for the square.
CreateVerticesForSquare(gl);
}
/// <summary>コンストラクタ。</summary>
public SimpleSprite(GraphicsContext graphics, Texture2D texture)
{
if(shaderProgram == null)
{
shaderProgram=CreateSimpleSpriteShader();
}
if (texture == null)
{
throw new Exception("ERROR: texture is null.");
}
this.graphics = graphics;
this.texture = texture;
this.width = texture.Width;
this.height = texture.Height;
indices = new ushort[indexSize];
indices[0] = 0;
indices[1] = 1;
indices[2] = 2;
indices[3] = 3;
//@e Vertex coordinate, Texture coordinate, Vertex color
//@j 頂点座標, テクスチャ座標, 頂点色
vertexBuffer = new VertexBuffer(4, indexSize, VertexFormat.Float3, VertexFormat.Float2, VertexFormat.Float4);
}
public static void Initialize ()
{
// Set up the graphics system
graphics = new GraphicsContext ();
#if BUILD_FOR_PSV
program = new ShaderProgram("/Application/shaders/Texture.cgx");
#else
program = new ShaderProgram("/Application/shaders/Texture_sim.cgx");
#endif
program.SetUniformBinding(0, "WorldViewProj");
program.SetAttributeBinding(0, "a_Position");
program.SetAttributeBinding(1, "a_TexCoord");
vertices = new VertexBuffer(4, VertexFormat.Float3, VertexFormat.Float2);
float[] positions = {
-1.0f, 1.0f, 0.0f,
-1.0f, -1.0f, 0.0f,
1.0f, 1.0f, 0.0f,
1.0f, -1.0f, 0.0f,
};
float[] texcoords = {
0.0f, 0.0f,
0.0f, 1.0f,
1.0f, 0.0f,
1.0f, 1.0f,
};
vertices.SetVertices(0, positions);
vertices.SetVertices(1, texcoords);
texture = new Texture2D(256, 224, false, PixelFormat.Rgb565);
SampleDraw.Init(graphics);
}
public virtual void Load(int width, int height)
{
Width = width;
Height = height;
_page = new Texture();
GUIShader = Assets.Fetch<ShaderProgram>("GUI");
GUIShader.AddUniform("scale");
VBO = new VBO<VertexPositionNormalTexture>();
VAO = new VAO<VertexPositionNormalTexture>();
VBO.Buffer(new[]{
new VertexPositionNormalTexture{Position = new Vector3(0, Height, 0f),Normal = Vector3.UnitZ,TexCoord = new Vector2(0, Height)},
new VertexPositionNormalTexture{Position = new Vector3(Width, Height, 0f),Normal = Vector3.UnitZ,TexCoord = new Vector2(Width, Height)},
new VertexPositionNormalTexture{Position = new Vector3(Width, 0, 0f),Normal = Vector3.UnitZ,TexCoord = new Vector2(Width, 0)},
new VertexPositionNormalTexture{Position = new Vector3(0, 0, 0),Normal = Vector3.UnitZ,TexCoord = new Vector2(0,0)}
});
VAO.Setup(GUIShader, VBO);
_webView = WebCore.CreateWebView(Width, Height);
WebCore.BaseDirectory = Path.Combine(Directory.GetCurrentDirectory(), "GUI");
_webView.FlushAlpha = false;
_webView.IsTransparent = true;
_webView.CreateObject("console");
_webView.SetObjectCallback("console", "log", (sender, e) => Bus.Add(new DebugMessage(Timer.LastTickTime, e.Arguments[0].ToString())));
_webView.CreateObject("GUI");
_webView.CreateObject("Bus");
_webView.LoadFile("index.htm");
}
protected override void DoInitialize()
{
{
// Initialize our compute program
var shaderCode = new ShaderCode(File.ReadAllText(@"shaders\SimpleComputeRenderer\compute.comp"), ShaderType.ComputeShader);
this.computeProgram = shaderCode.CreateProgram();
}
{
// Initialize our resetProgram
var shaderCode = new ShaderCode(File.ReadAllText(@"shaders\SimpleComputeRenderer\computeReset.comp"), ShaderType.ComputeShader);
this.computeResetProgram = shaderCode.CreateProgram();
}
{
// This is the texture that the compute program will write into
var texture = new Texture(TextureTarget.Texture2D,
new TexStorage2DImageFiller(8, OpenGL.GL_RGBA32F, 256, 256),
new NullSampler());
texture.Initialize();
this.outputImage = texture;
}
{
this.GroupX = 1;
this.GroupY = 1;
this.GroupZ = 1;
}
base.DoInitialize();
this.SetUniform("output_image", this.outputImage);
}
public Sprite(GraphicsContext graphics, Texture2D texture)
{
if(shaderProgram == null)
{
shaderProgram = new ShaderProgram("/Application/shaders/Sprite.cgx");
shaderProgram.SetUniformBinding(0, "u_WorldMatrix");
}
if (texture == null)
{
throw new Exception("ERROR: texture is null.");
}
this.graphics = graphics;
this.texture = texture;
this.width = texture.Width;
this.height = texture.Height;
indices = new ushort[indexSize];
indices[0] = 0;
indices[1] = 1;
indices[2] = 2;
indices[3] = 3;
vertexBuffer = new VertexBuffer(4, indexSize, VertexFormat.Float3,
VertexFormat.Float2, VertexFormat.Float4);
}
public Planet(string dataBaseName, PlanetParameters param, Planet parent, MeshVBOs vbos, Texture t, ShaderProgram shader, ShaderProgram lineShader)
: base(vbos, t, shader)
{
this.parent = parent;
this.lineShader = lineShader;
this.RevolutionOrientation = -1;
this.AxisTilt = Matrix4.Identity;
this.DrawAxisTilt = true;
this.ScenicDistance = param.DFSScenic[dataBaseName];
this.HoursPerRotation = param.RotationPeriod[dataBaseName];
this.AxisTilt = Matrix4.CreateFromAxisAngle(new Vector3(0, 0, -1), (float)MathHelper.DegreesToRadians(param.AxialTilt[dataBaseName]));
this.RealisticRadius = param.RadiusRealistic[dataBaseName];
this.ScenicRadius = param.RadiusScenic[dataBaseName];
this.Scale = (float)ScenicRadius;
this.OrbitalPeriod = param.OrbitalPeriod[dataBaseName];
this.inclinationAngle = param.InclinationAngle[dataBaseName];
this.longitudeAscendingNode = param.LongitudeAscendingNode[dataBaseName];
this.longitudePerihelion = param.LongitudePerihelion[dataBaseName];
this.eccentricity = param.Eccentricity[dataBaseName];
this.longitudeAscendingNodeRadians = MathHelper.DegreesToRadians(longitudeAscendingNode);
this.longitudePerihelionRadians = MathHelper.DegreesToRadians(longitudePerihelion);
this.inclinationAngleRadians = MathHelper.DegreesToRadians(inclinationAngle);
this.newRadius = 0;
this.PeriodAngle = longitudePerihelionRadians;
this.eccentricAnomaly = 0;
this.createTransform();
if (parent != null)
this.Orbit = new Orbit(this, parent.Position, this.ScenicDistance, 360, lineShader, this.inclinationAngle, this.longitudeAscendingNode, this.longitudePerihelion, this.eccentricity);
float[] axisVerts = { 0, -2, 0, 0, 2, 0 };
this.axisLine = new VBO<float>(axisVerts, BufferTarget.ArrayBuffer, VBO<float>.PointerType.vertex);
}
/// コンストラクタ
public TextureRenderer()
{
shaderTexture = new ShaderProgram( "/Application/shaders/Texture.cgx" );
shaderTexture.SetAttributeBinding( 0, "a_Position" );
shaderTexture.SetAttributeBinding( 1, "a_TexCoord" );
idWVP = shaderTexture.FindUniform( "WorldViewProj" );
shaderCurrent = shaderTexture;
vertices = new VertexBuffer( 4, VertexFormat.Float3, VertexFormat.Float2 );
float[] positions = {
0.0f, 0.0f, 0.0f,
0.0f, -1.0f, 0.0f,
1.0f, 0.0f, 0.0f,
1.0f, -1.0f, 0.0f,
};
float[] texcoords = {
0.0f, 1.0f,
0.0f, 0.0f,
1.0f, 1.0f,
1.0f, 0.0f,
};
vertices.SetVertices( 0, positions );
vertices.SetVertices( 1, texcoords );
}
//@e Initialization of shader program
//@j シェーダープログラムの初期化。
public static ShaderProgram CreateLineShader()
{
Byte[] dataBuffer=Utility.ReadEmbeddedFile("TutoLib.shaders.Line.cgx");
ShaderProgram shaderProgram = new ShaderProgram(dataBuffer);
shaderProgram.SetUniformBinding(0, "u_WorldMatrix");
return shaderProgram;
}
protected override void DoInitialize()
{
var shaderCode = new ShaderCode(File.ReadAllText(
@"shaders\ImageProcessingRenderer\ImageProcessing.comp"), ShaderType.ComputeShader);
ShaderProgram computeProgram = shaderCode.CreateProgram();
this.computeProgram = computeProgram;
}
protected void InitializeShader(out ShaderProgram shaderProgram)
{
var vertexShaderSource = ManifestResourceLoader.LoadTextFile(@"Renderers.Cloud.vert");
var fragmentShaderSource = ManifestResourceLoader.LoadTextFile(@"Renderers.Cloud.frag");
shaderProgram = new ShaderProgram();
shaderProgram.Create(vertexShaderSource, fragmentShaderSource, null);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="graphics">Handle to the GraphicsContext.</param>
public SolidColorBrush(GraphicsContext graphics)
: base(graphics)
{
this.shader = typeof(SolidColorBrush).Assembly.LoadShaderProgram(
graphics,
"Samurai.Graphics.Canvas2D.BasicCanvasShader.vert",
"Samurai.Graphics.Canvas2D.SolidColorBrush.frag");
}
public Orbit(Planet parent, Vector3 center, double radius, int sides, ShaderProgram shader, double ia, double lan, double lp, double ecc)
{
this.eccentricAnomaly = 0;
this.shader = shader;
this.parent = parent;
this.Positon = center;
this.Radius = (float)radius;
this.Sides = sides;
this.inclinationAngleRadians = MathHelper.DegreesToRadians(ia);
this.longitudeAscendingNodeRadians = MathHelper.DegreesToRadians(lan);
this.longitudePerihelionRadians = MathHelper.DegreesToRadians(lp);
this.eccentricity = ecc;
float step = MathHelper.DegreesToRadians(360f / sides);
List<float> verts = new List<float>();
List<float> angles = new List<float>();
List<ushort> elements = new List<ushort>();
float alpha = (float)longitudePerihelionRadians;
ushort count = 0;
while (alpha < Math.PI * 2f + longitudePerihelionRadians)
{
if (alpha < Math.PI + longitudePerihelionRadians)
this.eccentricAnomaly += step;
if (alpha > Math.PI + longitudePerihelionRadians)
this.eccentricAnomaly -= step;
this.newRadius = (float)((radius / (1 - this.eccentricity)) * (1 - (this.eccentricity * Math.Cos(this.eccentricAnomaly))));
//verts.Add((float)Math.Cos(alpha) * Radius + center.X);
//verts.Add(0f + center.Y);
//verts.Add((float)Math.Sin(alpha) * Radius + center.Z);
//verts.Add(Radius * ((float)Math.Cos(alpha + longitudeAscendingNodeRadians) - (float)Math.Sin(alpha + longitudeAscendingNodeRadians) * (float)Math.Cos(inclinationAngleRadians)) + center.Z);
//verts.Add(Radius * ((float)Math.Sin(alpha + longitudeAscendingNodeRadians) * (float)Math.Sin(inclinationAngleRadians)) + center.Y);
//verts.Add(Radius * ((float)Math.Sin(alpha + longitudeAscendingNodeRadians) + (float)Math.Cos(alpha + longitudeAscendingNodeRadians) * (float)Math.Cos(inclinationAngleRadians)) + center.X);
//verts.Add(newRadius * ((float)Math.Cos(alpha) * (float)Math.Cos(longitudeAscendingNodeRadians) - (float)Math.Sin(longitudeAscendingNodeRadians) * (float)Math.Sin(alpha) * (float)Math.Sin(inclinationAngleRadians) ) + center.X);
//verts.Add(newRadius * ((float)Math.Sin(alpha) * (float)Math.Sin(inclinationAngleRadians)) + center.Y);
//verts.Add(newRadius * ((float)Math.Sin(alpha) * (float)Math.Cos(longitudeAscendingNodeRadians) + (float)Math.Cos(longitudeAscendingNodeRadians) * (float)Math.Sin(alpha) * (float)Math.Cos(inclinationAngleRadians)) + center.Z);
verts.Add(newRadius * (float)Math.Cos(alpha) + center.X);
verts.Add(newRadius * (float)inclinationAngleRadians * (float)Math.Sin(alpha - longitudeAscendingNodeRadians) + center.Y);
verts.Add(newRadius * (float)Math.Sin(alpha) + center.Z);
elements.Add(count);
angles.Add(alpha);
alpha += step;
count++;
}
float[] vertsf = verts.ToArray();
float[] anglesf = angles.ToArray();
ushort[] elementsf = elements.ToArray();
this.vertsBuffer = new VBO<float>(vertsf, BufferTarget.ArrayBuffer, VBO<float>.PointerType.vertex);
this.anglesBuffer = new VBO<float>(anglesf, BufferTarget.ArrayBuffer, VBO<float>.PointerType.color);
this.elementsBuffer = new VBO<ushort>(elementsf, BufferTarget.ElementArrayBuffer, VBO<ushort>.PointerType.element);
}
public ShaderVariable(ShaderProgram program, int index, string name)
{
this.program = program;
this.index = index;
this.Name = name;
Apply = setNothing;
valueArrayObject = new WeakReference(null);
}
public override void Dispose()
{
if( shaderGaussianY != null ){
shaderGaussianY.Dispose();
shaderGaussianY = null;
}
gaussianWeightTable = null;
}
public static void Add(string name, string[] uniformBindings, string[] attributeBindings)
{
ShaderProgram sp=new ShaderProgram("/Application/shaders/"+name+".cgx");
for (int i = 0; i < uniformBindings.Length; i++)
sp.SetUniformBinding(i, uniformBindings[i]);
for (int i = 0; i < attributeBindings.Length; i++)
sp.SetAttributeBinding(i, uniformBindings[i]);
_shaders[name]=sp;
}
/// コンストラクタ
public GaussianYFilter()
{
texRenderer = new TextureRenderer();
// gaussian y
shaderGaussianY = new ShaderProgram( "/Application/shaders/GaussianY.cgx" );
shaderGaussianY.SetAttributeBinding( 0, "a_Position" );
shaderGaussianY.SetAttributeBinding( 1, "a_TexCoord" );
}
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void SetUniformValues(ShaderProgram program)
{
//var updatedUniforms = (from item in this.uniformVariables where item.Updated select item).ToArray();
//foreach (var item in updatedUniforms) { item.DoSetUniform(program); uniformVariableStack.Push(item); }
UniformVariable[] array = this.uniformVariables.ToArray();
foreach (UniformVariable item in array)
{
item.SetUniform(program);
}
}
public override void Dispose()
{
disposeChilderen();
if (program != null)
{
program.Dispose();
program = null;
}
base.Dispose();
}
/// <summary>
/// Translates the binary Maxwell shader code to something that the host API accepts.
/// </summary>
/// <param name="state">Current GPU state</param>
/// <param name="gpuVa">GPU virtual address of the binary shader code</param>
/// <param name="localSizeX">Local group size X of the computer shader</param>
/// <param name="localSizeY">Local group size Y of the computer shader</param>
/// <param name="localSizeZ">Local group size Z of the computer shader</param>
/// <param name="localMemorySize">Local memory size of the compute shader</param>
/// <param name="sharedMemorySize">Shared memory size of the compute shader</param>
/// <returns>Compiled compute shader code</returns>
private CachedShader TranslateComputeShader(
GpuState state,
ulong gpuVa,
int localSizeX,
int localSizeY,
int localSizeZ,
int localMemorySize,
int sharedMemorySize)
{
if (gpuVa == 0)
{
return null;
}
int index = 0;
for (int stage = 0; stage < programs.Length; stage++)
{
ShaderProgram program = programs[stage];
if (program != null)
{
QueryInfoName.ComputeLocalSizeX
=> localSizeX,
QueryInfoName.ComputeLocalSizeY
=> localSizeY,
QueryInfoName.ComputeLocalSizeZ
=> localSizeZ,
QueryInfoName.ComputeLocalMemorySize
=> localMemorySize,
QueryInfoName.ComputeSharedMemorySize
=> sharedMemorySize,
QueryInfoName.IsTextureBuffer
=> Convert.ToInt32(QueryIsTextureBuffer(state, 0, index, compute: true)),
QueryInfoName.IsTextureRectangle
=> Convert.ToInt32(QueryIsTextureRectangle(state, 0, index, compute: true)),
QueryInfoName.TextureFormat
=> (int)QueryTextureFormat(state, 0, index, compute: true),
_
=> QueryInfoCommon(info)
};
shaders[index++] = _context.Renderer.CompileShader(program);
}
}
IProgram hostProgram = _context.Renderer.CreateProgram(shaders);
ShaderProgramInfo[] info = programs.Select(x => x?.Info).ToArray();
gs = new Shader(hostProgram, new ShaderMeta(hostProgram, info));
int insertIndex = _cache.Add(hash, gs, pack);
if (Configuration.Enabled)
{
ShaderCacheFile.Save(Configuration.ShaderPath, info, pack, hostProgram.GetGpuBinary(), hash, insertIndex);
}
return gs;
}
static void Main(string[] args)
{
Glut.glutInit();
Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);
Glut.glutInitWindowSize(width, height);
Glut.glutCreateWindow("OpenGL Tutorial");
Glut.glutIdleFunc(OnRenderFrame);
Glut.glutDisplayFunc(OnDisplay);
Glut.glutKeyboardFunc(OnKeyboardDown);
Glut.glutKeyboardUpFunc(OnKeyboardUp);
Glut.glutCloseFunc(OnClose);
Glut.glutReshapeFunc(OnReshape);
// enable blending and set to accumulate the star colors
Gl.Enable(EnableCap.DepthTest);
Gl.Enable(EnableCap.Blend);
// create our shader program
program = new ShaderProgram(VertexShader, FragmentShader);
// set up the projection and view matrix
program.Use();
program["projection_matrix"].SetValue(Matrix4.CreatePerspectiveFieldOfView(0.45f, (float)width / height, 0.1f, 1000f));
program["view_matrix"].SetValue(Matrix4.LookAt(new Vector3(0, 0, 20), Vector3.Zero, new Vector3(0, 1, 0)));
program["model_matrix"].SetValue(Matrix4.Identity);
// load the flag texture
flagTexture = new Texture("flag.png");
// create the flag, which is just a plane with a certain number of segments
List <Vector3> vertices = new List <Vector3>();
List <Vector2> uvs = new List <Vector2>();
List <int> triangles = new List <int>();
for (int x = 0; x < 40; x++)
{
for (int y = 0; y < 40; y++)
{
vertices.Add(new Vector3((x - 20) / 5.0f, (y - 20) / 10.0f, 0));
uvs.Add(new Vector2(x / 39.0f, 1 - y / 39.0f));
if (y == 39 || x == 39)
{
continue;
}
triangles.Add(x * 40 + y);
triangles.Add((x + 1) * 40 + y);
triangles.Add((x + 1) * 40 + y + 1);
triangles.Add(x * 40 + y);
triangles.Add((x + 1) * 40 + y + 1);
triangles.Add(x * 40 + y + 1);
}
}
flagVertices = new VBO <Vector3>(vertices.ToArray());
flagUVs = new VBO <Vector2>(uvs.ToArray());
flagTriangles = new VBO <int>(triangles.ToArray(), BufferTarget.ElementArrayBuffer);
// load the bitmap font for this tutorial
font = new BMFont("font24.fnt", "font24.png");
fontProgram = new ShaderProgram(BMFont.FontVertexSource, BMFont.FontFragmentSource);
fontProgram.Use();
fontProgram["ortho_matrix"].SetValue(Matrix4.CreateOrthographic(width, height, 0, 1000));
fontProgram["color"].SetValue(new Vector3(1, 1, 1));
information = font.CreateString(fontProgram, "OpenGL C# Tutorial 11");
watch = System.Diagnostics.Stopwatch.StartNew();
Glut.glutMainLoop();
}
public string GetGeoShader(int ProgramIndex, string[] VtxShaderOutputs, out ShaderNameBlock Names)
{
ShaderProgram Program = SHBin.Programs[ProgramIndex];
Initialize(Program);
StringBuilder Output = new StringBuilder();
Output.AppendLine("//SPICA auto-generated code");
Output.AppendLine("//This code was translated from a MAESTRO Geometry Shader");
Output.AppendLine("#version 330 core");
Output.AppendLine();
GenVec4Uniforms(Output, Program.Vec4Uniforms);
GenIVec4Uniforms(Output, Program.IVec4Uniforms);
GenBoolUniforms(Output, Program.BoolUniforms);
Output.AppendLine();
Output.AppendLine($"vec4 {TempRegName}[16];");
Output.AppendLine($"bvec2 {CmpRegName};");
Output.AppendLine($"ivec2 {A0RegName};");
Output.AppendLine($"int {ALRegName};");
Output.AppendLine("int geo_i;");
Output.AppendLine();
Output.AppendLine("layout(triangles) in;");
Output.AppendLine("layout(triangle_strip, max_vertices = 12) out;");
Output.AppendLine();
for (int i = 0; i < VtxShaderOutputs.Length; i++)
{
if (VtxShaderOutputs[i] != null)
{
InputNames[i] = $"{VtxShaderOutputs[i]}[geo_i]";
Output.AppendLine($"in vec4 {VtxShaderOutputs[i]}[];");
}
}
Output.AppendLine();
GenOutputs(Output, Program.OutputRegs);
int FuncStart = Output.Length;
while (Procs.Count > 0)
{
SB = new StringBuilder(Environment.NewLine);
GenProc(Program, Procs.Dequeue());
Output.Insert(FuncStart, SB.ToString());
}
Names = GetNameBlock();
return(Output.ToString());
}
public BlockModel(EnumBlock block, ShaderProgram shader, AxisAlignedBB bb, bool canBeInteractedWith) : this(block, shader, canBeInteractedWith)
{
boundingBox = bb;
}
public override void Draw(Camera cam, ShaderProgram shader)
{
base.Draw(cam, shader);
}
static void Main(string[] args)
{
Glut.glutInit();
Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH | Glut.GLUT_MULTISAMPLE); // multisampling makes things beautiful!
Glut.glutInitWindowSize(width, height);
Glut.glutCreateWindow("OpenGL Tutorial");
Glut.glutIdleFunc(OnRenderFrame);
Glut.glutDisplayFunc(OnDisplay);
Glut.glutKeyboardFunc(OnKeyboardDown);
Glut.glutKeyboardUpFunc(OnKeyboardUp);
Glut.glutCloseFunc(OnClose);
Glut.glutReshapeFunc(OnReshape);
// add our mouse callbacks for this tutorial
Glut.glutMouseFunc(OnMouse);
Glut.glutMotionFunc(OnMove);
Gl.Enable(EnableCap.DepthTest);
Gl.Enable(EnableCap.Blend);
Gl.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
// create our shader program
program = new ShaderProgram(VertexShader, FragmentShader);
// create our camera
camera = new Camera(new Vector3(0, 0, 0), Quaternion.Identity);
camera.SetDirection(new Vector3(0, 0, -1));
// set up the projection and view matrix
program.Use();
program["projection_matrix"].SetValue(Matrix4.CreatePerspectiveFieldOfView(0.45f, (float)width / height, 0.1f, 1000f));
//program["view_matrix"].SetValue(Matrix4.LookAt(new Vector3(0, 0, 10), Vector3.Zero, Vector3.Up));
program["light_direction"].SetValue(new Vector3(0, 0, 1));
program["normalTexture"].SetValue(1);
brickDiffuse = new Texture("333.jpg");
var sphereCoordinates = CoordinatesManager.GetSphereCoordinates().ToArray();
var UVcoordinates = new List <Vector2>();
for (int i = 0; i < sphereCoordinates.Length / 4; i++)
{
UVcoordinates.Add(new Vector2(0, 0));
UVcoordinates.Add(new Vector2(1, 0));
UVcoordinates.Add(new Vector2(1, 1));
UVcoordinates.Add(new Vector2(0, 1));
}
var sphereUV = new VBO <Vector2>(UVcoordinates.ToArray());
Vector3[] vertices = new Vector3[] {
new Vector3(1, 1, -1), new Vector3(-1, 1, -1), new Vector3(-1, 1, 1), new Vector3(1, 1, 1), // top
new Vector3(1, -1, 1), new Vector3(-1, -1, 1), new Vector3(-1, -1, -1), new Vector3(1, -1, -1), // bottom
new Vector3(1, 1, 1), new Vector3(-1, 1, 1), new Vector3(-1, -1, 1), new Vector3(1, -1, 1), // front face
new Vector3(1, -1, -1), new Vector3(-1, -1, -1), new Vector3(-1, 1, -1), new Vector3(1, 1, -1), // back face
new Vector3(-1, 1, 1), new Vector3(-1, 1, -1), new Vector3(-1, -1, -1), new Vector3(-1, -1, 1), // left
new Vector3(1, 1, -1), new Vector3(1, 1, 1), new Vector3(1, -1, 1), new Vector3(1, -1, -1)
};
cube = new VBO <Vector3>(sphereCoordinates);
Vector2[] uvs = new Vector2[] {
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1)
};
cubeUV = CoordinatesManager.GetSphereUVCoordinates();
List <uint> triangles = new List <uint>();
for (uint i = 0; i < 6; i++)
{
triangles.Add(i * 4);
triangles.Add(i * 4 + 1);
triangles.Add(i * 4 + 2);
triangles.Add(i * 4);
triangles.Add(i * 4 + 2);
triangles.Add(i * 4 + 3);
}
//cubeTriangles = new VBO<uint>(triangles.ToArray(), BufferTarget.ElementArrayBuffer);
cubeTriangles =
new VBO <uint>(Enumerable.Range(0, sphereCoordinates.Length * 4).Select(t => (uint)t).ToArray(),
BufferTarget.ElementArrayBuffer);
// Vector3[] normals = Geometry.CalculateNormals(vertices, triangles.ToArray());
//cubeNormals = new VBO<Vector3>(normals);
// load the bitmap font for this tutorial
font = new BMFont("font24.fnt", "font24.png");
fontProgram = new ShaderProgram(BMFont.FontVertexSource, BMFont.FontFragmentSource);
fontProgram.Use();
fontProgram["ortho_matrix"].SetValue(Matrix4.CreateOrthographic(width, height, 0, 1000));
fontProgram["color"].SetValue(new Vector3(1, 1, 1));
information = font.CreateString(fontProgram, "OpenGL C# Tutorial 15");
watch = System.Diagnostics.Stopwatch.StartNew();
Glut.glutMainLoop();
}
public void AddGeometry(ShaderProgram program)
{
_GeometryInstances.Add(new Geometry(program));
}
protected override void DoInitialize()
{
this.shaderProgram = InitializeShader();
InitVAO();
}
static void Main(string[] args)
{
//Open GL init
#region
Glut.glutInit();
Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);
Glut.glutInitWindowSize(1280, 720);
Glut.glutCreateWindow("Tu mama es maraca");
Glut.glutIdleFunc(OnRenderFrame);
Glut.glutDisplayFunc(OnDisplay);
Glut.glutCloseFunc(OnClose);
Glut.glutReshapeFunc(OnReshape);
//Keyboard functions
Glut.glutKeyboardFunc(OnKeyboardDown);
Glut.glutKeyboardUpFunc(OnKeyboardUp);
//Gl.ClearColor(0,0,0,1);
//Alpha enabled
Gl.Disable(EnableCap.DepthTest);
Gl.Enable(EnableCap.Blend);
Gl.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.One);
#endregion
//Load shader
program = new ShaderProgram(VertexShader, FragmentShader);
//Create perspective
program.Use();
program["projection_matrix"].SetValue(
Matrix4.CreatePerspectiveFieldOfView(0.45f,
(float)width / height, 0.1f, 1000f));
program["view_matrix"].SetValue(
Matrix4.LookAt(new Vector3(0, 0, 10),
new Vector3(0, 0, 0),
new Vector3(0, 1, 0)));
starTexture = new Texture("star.bmp");
playerTexture = new Texture("crate.jpg");
enemyTexture = new Texture("tile.jpg");
playerColor = new Vector3(1, 1, 1);
//start vertices and uv
#region
start = new VBO <Vector3>(
new Vector3[] {
new Vector3(-1, 1, 0), new Vector3(1, 1, 0),
new Vector3(1, -1, 0), new Vector3(-1, -1, 0)
}
);
startElements = new VBO <int>(
new int[] { 0, 1, 2, 3 },
BufferTarget.ElementArrayBuffer
);
startUV = new VBO <Vector2>(
new Vector2[] {
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1)
}
);
#endregion
//Player
player = new VBO <Vector3>(
new Vector3[] {
new Vector3(0, 0.7, 0), new Vector3(1, 0, 0), new Vector3(0, -0.7, 0), new Vector3(-0.5, 0, 0)
}
);
playerElements = new VBO <int>(
new int[] { 0, 1, 2, 3 },
BufferTarget.ElementArrayBuffer
);
playerUV = new VBO <Vector2>(
new Vector2[] {
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1)
}
);
watch = System.Diagnostics.Stopwatch.StartNew();
Glut.glutMainLoop();
}
public Mesh GetMesh(ShaderProgram shader) => mesh ?? (mesh = new Mesh(BuildMesh(), shader));
public static void Unbind()
{
ShaderProgram.Unbind();
GL.BindTexture(GL.TEXTURE_2D_ARRAY, 0);
}
private void SetRenderSettings(ShaderProgram shader)
{
shader.SetBoolToInt("renderVertColor", Runtime.renderVertColor);
GL.Uniform1(defaultShaderProgram["renderType"], (int)Runtime.viewportShading);
}
//static OpenGLDevice NuklearDev;
static void Main(string[] args)
{
/*IBWFile F = IBWLoader.Load("dataset/ibw/Image0018.ibw");
*
* for (int i = 0; i < F.Depth; i++) {
* Bitmap Bmp = new Bitmap(F.Width, F.Height);
*
* int D_Dim = i;
*
* float Min = float.MaxValue;
* float Max = float.MinValue;
*
* for (int y = 0; y < F.Height; y++) {
* for (int x = 0; x < F.Width; x++) {
* float Flt = (float)F.GetData(x, y, D_Dim) * 1000000000;
*
* Min = Math.Min(Min, Flt);
* Max = Math.Max(Max, Flt);
* }
* }
*
* float Offset = -Min;
* float OffsetMax = Max + Offset;
* float ScaleVal = 255.0f / OffsetMax;
*
* Min = float.MaxValue;
* Max = float.MinValue;
*
* for (int y = 0; y < F.Height; y++) {
* for (int x = 0; x < F.Width; x++) {
* float Flt = ((float)F.GetData(x, y, D_Dim) * 1000000000 + Offset) * ScaleVal;
*
* int Clr = (int)Flt;
* Bmp.SetPixel(x, F.Height - y - 1, System.Drawing.Color.FromArgb(255, Clr, Clr, Clr));
* }
* }
*
* Bmp.Save("test_" + i + ".png");
* }
*
*
* File.WriteAllText("text_data.txt", F.NoteData);
*
*
* Console.WriteLine("Done!");
* Console.ReadLine();
* return;//*/
const float Scale = 0.9f;
ClearColor = new FishGfx.Color(60, 80, 100);
RenderAPI.GetDesktopResolution(out int W, out int H);
RWind = new RenderWindow((int)(W * Scale), (int)(H * Scale), "Vector PFM");
Console.WriteLine("OpenGL {0}", RenderAPI.Version);
Console.WriteLine("Running on {0}", RenderAPI.Renderer);
// Load shader programs
Shader_DrawRayCast = new ShaderProgram(new ShaderStage(ShaderType.VertexShader, "data/default3d.vert"),
new ShaderStage(ShaderType.FragmentShader, "data/defaultRayCast.frag"));
Shader_DrawRayCast.Uniforms.Camera.SetPerspective(RWind.GetWindowSizeVec());
Shader_DrawRayCast.Uniforms.Camera.Position = new Vector3(0, 300, 0);
Shader_DrawRayCast.Uniforms.Camera.PitchClamp = new Vector2(-80, 80);
Shader_DrawFlat = new ShaderProgram(new ShaderStage(ShaderType.VertexShader, "data/default3d.vert"),
new ShaderStage(ShaderType.FragmentShader, "data/defaultFlatColor.frag"));
Shader_DrawFlat.Uniforms.Camera = Shader_DrawRayCast.Uniforms.Camera;
Shader_Screen = new ShaderProgram(new ShaderStage(ShaderType.VertexShader, "data/default.vert"),
new ShaderStage(ShaderType.FragmentShader, "data/default.frag"));
Shader_Screen.Uniforms.Camera.SetOrthogonal(0, 0, 1, 1);
Shader_Textured = new ShaderProgram(new ShaderStage(ShaderType.VertexShader, "data/default3d.vert"),
new ShaderStage(ShaderType.FragmentShader, "data/default.frag"));
Shader_Textured.Uniforms.Camera = Shader_DrawRayCast.Uniforms.Camera;
//NuklearDev = new OpenGLDevice(RWind.GetWindowSizeVec());
//NuklearAPI.Init(NuklearDev);
RWind.OnMouseMoveDelta += (Wnd, X, Y) => Shader_DrawRayCast.Uniforms.Camera.Update(new Vector2(-X, -Y));
RWind.OnKey += OnKey;
//RWind.OnMouseMove += (Wnd, X, Y) => NuklearDev.OnMouseMove((int)X, (int)Y);
RWind.OnMouseMoveDelta += (Wnd, X, Y) => {
if (LeftMouse)
{
const float MoveSpeed = 1.0f;
if (X != 0 || Y != 0)
{
Camera Cam = Shader_DrawRayCast.Uniforms.Camera;
if (X != 0)
{
Cam.Position -= Cam.WorldRightNormal * MoveSpeed * -X;
}
if (Y != 0)
{
Cam.Position += Cam.WorldUpNormal * MoveSpeed * -Y;
}
RecalcCamera();
}
}
else if (RightMouse)
{
DesiredPivotDistance += Y;
RecalcCamera();
}
};
HMap = new Terrain();
HMap.LoadFromImage(Image.FromFile("dataset/data2/heightmap.png"), 100);
//HMap.LoadFromImage(Image.FromFile("dataset/height_test.png"), 10);
//HMap.LoadFromImage(Image.FromFile("dataset/owl.png"), 100);
DesiredPivotDistance = float.PositiveInfinity;
CameraPivot = new Vector3(HMap.Width / 2, HMap.GetHeight(HMap.Width / 2, HMap.Height / 2), HMap.Height / 2);
RecalcCamera();
PinMesh = new Mesh3D {
PrimitiveType = PrimitiveType.Triangles
};
PinMesh.SetVertices(GfxUtils.LoadObj("data/models/pin/pin.obj"));
PinTexture = Texture.FromFile("data/models/pin/pin_mat.png");
Mesh3D Vectors = new Mesh3D {
PrimitiveType = PrimitiveType.Lines
};
{
//Vertex3[] Verts = new Vertex3[HMap.Width * HMap.Height * 2];
List <Vertex3> Verts = new List <Vertex3>();
for (int i = 0; i < HMap.Width * HMap.Height * 2; i += 2)
{
int X = (i / 2) % HMap.Width;
int Y = (i / 2) / HMap.Width;
const int Density = 2;
if (X % Density != 0 || Y % Density != 0)
{
continue;
}
float Height = HMap.GetHeight(X, Y);
Verts.Add(new Vertex3(new Vector3(X, Height - 0.5f, Y), FishGfx.Color.Black));
Verts.Add(new Vertex3(new Vector3(X, Height + 20, Y), FishGfx.Color.White));
}
Vectors.SetVertices(Verts.ToArray());
}
RWind.GetWindowSize(out int WindowWidth, out int WindowHeight);
RenderTexture Screen = new RenderTexture(WindowWidth, WindowHeight);
RayCastingTexture = Screen.CreateNewColorAttachment(1);
Background = Texture.FromFile("data/background.png");
Mesh2D ScreenQuad = new Mesh2D();
ScreenQuad.SetVertices(new Vertex2[] {
new Vertex2(new Vector2(0, 0), new Vector2(0, 0)),
new Vertex2(new Vector2(0, 1), new Vector2(0, 1)),
new Vertex2(new Vector2(1, 1), new Vector2(1, 1)),
new Vertex2(new Vector2(1, 0), new Vector2(1, 0))
});
ScreenQuad.SetElements(new uint[] { 0, 1, 2, 0, 2, 3 }.Reverse().ToArray());
Stopwatch SWatch = Stopwatch.StartNew();
float Dt = 0;
while (!RWind.ShouldClose)
{
Update(Dt);
// Draw the world onto a render texture including the ray casting buffer
Screen.Bind(0, 1);
{
Shader_DrawRayCast.Bind();
Gfx.Clear(FishGfx.Color.Transparent);
/*Gfx.EnableCullFace(false);
* HMap.Draw();
* Gfx.EnableCullFace(true);*/
// Draw back face
Gfx.CullFront();
Texture Orig = HMap.OverlayTexture;
HMap.OverlayTexture = Background;
HMap.Draw();
// Draw front face
Gfx.CullBack();
HMap.OverlayTexture = Orig;
HMap.Draw();
Shader_DrawRayCast.Unbind();
}
Screen.Unbind();
// Draw other stuff
Screen.Bind(0);
{
Shader_DrawFlat.Bind();
Vectors.Draw();
Shader_DrawFlat.Unbind();
Shader_Textured.Bind();
Shader_Textured.SetModelMatrix(Matrix4x4.CreateScale(2) * Matrix4x4.CreateTranslation(CameraPivot));
PinTexture.BindTextureUnit();
PinMesh.Draw();
PinTexture.UnbindTextureUnit();
Shader_Textured.Unbind();
}
Screen.Unbind();
// Draw render texture and GUI to screen
Shader_Screen.Bind();
{
Gfx.Clear(ClearColor);
Gfx.EnableDepthDest(false);
if (FunctionMode == 1)
{
Screen.Color.BindTextureUnit();
}
else if (FunctionMode == 2)
{
RayCastingTexture.BindTextureUnit();
}
ScreenQuad.Draw();
//NuklearAPI.Frame(DrawGUI);
Gfx.EnableDepthDest(true);
}
Shader_Screen.Unbind();
// Swap buffers, do magic
RWind.SwapBuffers();
Events.Poll();
while (SWatch.ElapsedMilliseconds / 1000.0f < 1.0f / 60.0f)
{
;
}
Dt = SWatch.ElapsedMilliseconds / 1000.0f;
SWatch.Restart();
}
}
/// <summary>
/// Construct an Geometry.
/// </summary>
/// <param name="vertexArray">
///
/// </param>
/// <param name="state"></param>
/// <param name="program"></param>
public Geometry(VertexArrayObject vertexArray, State.GraphicsStateSet state, ShaderProgram program) :
base(vertexArray, state, program)
{
}
static void Main(string[] args)
{
Glut.glutInit();
Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH | Glut.GLUT_MULTISAMPLE); // multisampling makes things beautiful!
Glut.glutInitWindowSize(width, height);
Glut.glutCreateWindow("OpenGL Tutorial");
Glut.glutIdleFunc(OnRenderFrame);
Glut.glutDisplayFunc(OnDisplay);
Glut.glutKeyboardFunc(OnKeyboardDown);
Glut.glutKeyboardUpFunc(OnKeyboardUp);
Glut.glutCloseFunc(OnClose);
Glut.glutReshapeFunc(OnReshape);
Gl.Enable(EnableCap.DepthTest);
Gl.Enable(EnableCap.Multisample);
// create our shader program
program = new ShaderProgram(VertexShader, FragmentShader);
// set up the projection and view matrix
program.Use();
program["projection_matrix"].SetValue(Matrix4.CreatePerspectiveFieldOfView(0.45f, (float)width / height, 0.1f, 1000f));
program["view_matrix"].SetValue(Matrix4.LookAt(new Vector3(0, 0, 10), Vector3.Zero, new Vector3(0, 1, 0)));
program["light_direction"].SetValue(new Vector3(0, 0, 1));
program["enable_lighting"].SetValue(lighting);
program["normalTexture"].SetValue(1);
program["enable_mapping"].SetValue(normalMapping);
brickDiffuse = new Texture("AlternatingBrick-ColorMap.png");
brickNormals = new Texture("AlternatingBrick-NormalMap.png");
Vector3[] vertices = new Vector3[] {
new Vector3(1, 1, -1), new Vector3(-1, 1, -1), new Vector3(-1, 1, 1), new Vector3(1, 1, 1), // top
new Vector3(1, -1, 1), new Vector3(-1, -1, 1), new Vector3(-1, -1, -1), new Vector3(1, -1, -1), // bottom
new Vector3(1, 1, 1), new Vector3(-1, 1, 1), new Vector3(-1, -1, 1), new Vector3(1, -1, 1), // front face
new Vector3(1, -1, -1), new Vector3(-1, -1, -1), new Vector3(-1, 1, -1), new Vector3(1, 1, -1), // back face
new Vector3(-1, 1, 1), new Vector3(-1, 1, -1), new Vector3(-1, -1, -1), new Vector3(-1, -1, 1), // left
new Vector3(1, 1, -1), new Vector3(1, 1, 1), new Vector3(1, -1, 1), new Vector3(1, -1, -1)
};
cube = new VBO <Vector3>(vertices);
Vector2[] uvs = new Vector2[] {
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1)
};
cubeUV = new VBO <Vector2>(uvs);
List <int> triangles = new List <int>();
for (int i = 0; i < 6; i++)
{
triangles.Add(i * 4);
triangles.Add(i * 4 + 1);
triangles.Add(i * 4 + 2);
triangles.Add(i * 4);
triangles.Add(i * 4 + 2);
triangles.Add(i * 4 + 3);
}
cubeTriangles = new VBO <int>(triangles.ToArray(), BufferTarget.ElementArrayBuffer);
Vector3[] normals = Geometry.CalculateNormals(vertices, triangles.ToArray());
cubeNormals = new VBO <Vector3>(normals);
Vector3[] tangents = CalculateTangents(vertices, normals, triangles.ToArray(), uvs);
cubeTangents = new VBO <Vector3>(tangents);
// load the bitmap font for this tutorial
font = new BMFont("font24.fnt", "font24.png");
fontProgram = new ShaderProgram(BMFont.FontVertexSource, BMFont.FontFragmentSource);
fontProgram.Use();
fontProgram["ortho_matrix"].SetValue(Matrix4.CreateOrthographic(width, height, 0, 1000));
fontProgram["color"].SetValue(new Vector3(1, 1, 1));
information = font.CreateString(fontProgram, "OpenGL C# Tutorial 13");
watch = System.Diagnostics.Stopwatch.StartNew();
Glut.glutMainLoop();
}
/// <summary>
/// Apply this MaterialState
/// </summary>
/// <param name="ctx">
/// A <see cref="GraphicsContext"/> which has defined the shader program <paramref name="shaderProgram"/>.
/// </param>
/// <param name="shaderProgram">
/// The <see cref="ShaderProgram"/> which has the state set.
/// </param>
public void ApplyState(GraphicsContext ctx, ShaderProgram shaderProgram, string prefix)
{
shaderProgram.SetUniform(ctx, prefix + ".AmbientLighting", AmbientLighting);
}
/// <summary>
/// Initialize the cache.
/// </summary>
internal void Initialize()
{
if (GraphicsConfig.EnableShaderCache && GraphicsConfig.TitleId != null)
{
_cacheManager = new CacheManager(CacheGraphicsApi.OpenGL, CacheHashType.XxHash128, "glsl", GraphicsConfig.TitleId, ShaderCodeGenVersion);
bool isReadOnly = _cacheManager.IsReadOnly;
HashSet <Hash128> invalidEntries = null;
if (isReadOnly)
{
Logger.Warning?.Print(LogClass.Gpu, "Loading shader cache in read-only mode (cache in use by another program!)");
}
else
{
invalidEntries = new HashSet <Hash128>();
}
ReadOnlySpan <Hash128> guestProgramList = _cacheManager.GetGuestProgramList();
for (int programIndex = 0; programIndex < guestProgramList.Length; programIndex++)
{
Hash128 key = guestProgramList[programIndex];
Logger.Info?.Print(LogClass.Gpu, $"Compiling shader {key} ({programIndex + 1} / {guestProgramList.Length})");
byte[] hostProgramBinary = _cacheManager.GetHostProgramByHash(ref key);
bool hasHostCache = hostProgramBinary != null;
IProgram hostProgram = null;
// If the program sources aren't in the cache, compile from saved guest program.
byte[] guestProgram = _cacheManager.GetGuestProgramByHash(ref key);
if (guestProgram == null)
{
Logger.Error?.Print(LogClass.Gpu, $"Ignoring orphan shader hash {key} in cache (is the cache incomplete?)");
// Should not happen, but if someone messed with the cache it's better to catch it.
invalidEntries?.Add(key);
continue;
}
ReadOnlySpan <byte> guestProgramReadOnlySpan = guestProgram;
ReadOnlySpan <GuestShaderCacheEntry> cachedShaderEntries = GuestShaderCacheEntry.Parse(ref guestProgramReadOnlySpan, out GuestShaderCacheHeader fileHeader);
if (cachedShaderEntries[0].Header.Stage == ShaderStage.Compute)
{
Debug.Assert(cachedShaderEntries.Length == 1);
GuestShaderCacheEntry entry = cachedShaderEntries[0];
HostShaderCacheEntry[] hostShaderEntries = null;
// Try loading host shader binary.
if (hasHostCache)
{
hostShaderEntries = HostShaderCacheEntry.Parse(hostProgramBinary, out ReadOnlySpan <byte> hostProgramBinarySpan);
hostProgramBinary = hostProgramBinarySpan.ToArray();
hostProgram = _context.Renderer.LoadProgramBinary(hostProgramBinary);
}
bool isHostProgramValid = hostProgram != null;
ShaderProgram program;
ShaderProgramInfo shaderProgramInfo;
// Reconstruct code holder.
if (isHostProgramValid)
{
program = new ShaderProgram(entry.Header.Stage, "", entry.Header.Size, entry.Header.SizeA);
shaderProgramInfo = hostShaderEntries[0].ToShaderProgramInfo();
}
else
{
IGpuAccessor gpuAccessor = new CachedGpuAccessor(_context, entry.Code, entry.Header.GpuAccessorHeader, entry.TextureDescriptors);
program = Translator.CreateContext(0, gpuAccessor, DefaultFlags | TranslationFlags.Compute).Translate(out shaderProgramInfo);
}
ShaderCodeHolder shader = new ShaderCodeHolder(program, shaderProgramInfo, entry.Code);
// If the host program was rejected by the gpu driver or isn't in cache, try to build from program sources again.
if (hostProgram == null)
{
Logger.Info?.Print(LogClass.Gpu, $"Host shader {key} got invalidated, rebuilding from guest...");
// Compile shader and create program as the shader program binary got invalidated.
shader.HostShader = _context.Renderer.CompileShader(ShaderStage.Compute, shader.Program.Code);
hostProgram = _context.Renderer.CreateProgram(new IShader[] { shader.HostShader }, null);
// As the host program was invalidated, save the new entry in the cache.
hostProgramBinary = HostShaderCacheEntry.Create(hostProgram.GetBinary(), new ShaderCodeHolder[] { shader });
if (!isReadOnly)
{
if (hasHostCache)
{
_cacheManager.ReplaceHostProgram(ref key, hostProgramBinary);
}
else
{
Logger.Warning?.Print(LogClass.Gpu, $"Add missing host shader {key} in cache (is the cache incomplete?)");
_cacheManager.AddHostProgram(ref key, hostProgramBinary);
}
}
}
_cpProgramsDiskCache.Add(key, new ShaderBundle(hostProgram, shader));
}
else
{
Debug.Assert(cachedShaderEntries.Length == Constants.ShaderStages);
ShaderCodeHolder[] shaders = new ShaderCodeHolder[cachedShaderEntries.Length];
List <ShaderProgram> shaderPrograms = new List <ShaderProgram>();
TransformFeedbackDescriptor[] tfd = CacheHelper.ReadTransformationFeedbackInformations(ref guestProgramReadOnlySpan, fileHeader);
TranslationFlags flags = DefaultFlags;
if (tfd != null)
{
flags = TranslationFlags.Feedback;
}
TranslationCounts counts = new TranslationCounts();
HostShaderCacheEntry[] hostShaderEntries = null;
// Try loading host shader binary.
if (hasHostCache)
{
hostShaderEntries = HostShaderCacheEntry.Parse(hostProgramBinary, out ReadOnlySpan <byte> hostProgramBinarySpan);
hostProgramBinary = hostProgramBinarySpan.ToArray();
hostProgram = _context.Renderer.LoadProgramBinary(hostProgramBinary);
}
bool isHostProgramValid = hostProgram != null;
// Reconstruct code holder.
for (int i = 0; i < cachedShaderEntries.Length; i++)
{
GuestShaderCacheEntry entry = cachedShaderEntries[i];
if (entry == null)
{
continue;
}
ShaderProgram program;
if (entry.Header.SizeA != 0)
{
ShaderProgramInfo shaderProgramInfo;
if (isHostProgramValid)
{
program = new ShaderProgram(entry.Header.Stage, "", entry.Header.Size, entry.Header.SizeA);
shaderProgramInfo = hostShaderEntries[i].ToShaderProgramInfo();
}
else
{
IGpuAccessor gpuAccessor = new CachedGpuAccessor(_context, entry.Code, entry.Header.GpuAccessorHeader, entry.TextureDescriptors);
program = Translator.CreateContext((ulong)entry.Header.Size, 0, gpuAccessor, flags, counts).Translate(out shaderProgramInfo);
}
// NOTE: Vertex B comes first in the shader cache.
byte[] code = entry.Code.AsSpan().Slice(0, entry.Header.Size).ToArray();
byte[] code2 = entry.Code.AsSpan().Slice(entry.Header.Size, entry.Header.SizeA).ToArray();
shaders[i] = new ShaderCodeHolder(program, shaderProgramInfo, code, code2);
}
else
{
ShaderProgramInfo shaderProgramInfo;
if (isHostProgramValid)
{
program = new ShaderProgram(entry.Header.Stage, "", entry.Header.Size, entry.Header.SizeA);
shaderProgramInfo = hostShaderEntries[i].ToShaderProgramInfo();
}
else
{
IGpuAccessor gpuAccessor = new CachedGpuAccessor(_context, entry.Code, entry.Header.GpuAccessorHeader, entry.TextureDescriptors);
program = Translator.CreateContext(0, gpuAccessor, flags, counts).Translate(out shaderProgramInfo);
}
shaders[i] = new ShaderCodeHolder(program, shaderProgramInfo, entry.Code);
}
shaderPrograms.Add(program);
}
// If the host program was rejected by the gpu driver or isn't in cache, try to build from program sources again.
if (!isHostProgramValid)
{
Logger.Info?.Print(LogClass.Gpu, $"Host shader {key} got invalidated, rebuilding from guest...");
List <IShader> hostShaders = new List <IShader>();
// Compile shaders and create program as the shader program binary got invalidated.
for (int stage = 0; stage < Constants.ShaderStages; stage++)
{
ShaderProgram program = shaders[stage]?.Program;
if (program == null)
{
continue;
}
IShader hostShader = _context.Renderer.CompileShader(program.Stage, program.Code);
shaders[stage].HostShader = hostShader;
hostShaders.Add(hostShader);
}
hostProgram = _context.Renderer.CreateProgram(hostShaders.ToArray(), tfd);
// As the host program was invalidated, save the new entry in the cache.
hostProgramBinary = HostShaderCacheEntry.Create(hostProgram.GetBinary(), shaders);
if (!isReadOnly)
{
if (hasHostCache)
{
_cacheManager.ReplaceHostProgram(ref key, hostProgramBinary);
}
else
{
Logger.Warning?.Print(LogClass.Gpu, $"Add missing host shader {key} in cache (is the cache incomplete?)");
_cacheManager.AddHostProgram(ref key, hostProgramBinary);
}
}
}
_gpProgramsDiskCache.Add(key, new ShaderBundle(hostProgram, shaders));
}
}
if (!isReadOnly)
{
// Remove entries that are broken in the cache
_cacheManager.RemoveManifestEntries(invalidEntries);
_cacheManager.FlushToArchive();
_cacheManager.Synchronize();
}
Logger.Info?.Print(LogClass.Gpu, "Shader cache loaded.");
}
}
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 Geometry(ShaderProgram program) :
base(program)
{
}
/// <summary>
/// Gets a graphics shader program from the shader cache.
/// This includes all the specified shader stages.
/// </summary>
/// <remarks>
/// This automatically translates, compiles and adds the code to the cache if not present.
/// </remarks>
/// <param name="state">Current GPU state</param>
/// <param name="addresses">Addresses of the shaders for each stage</param>
/// <returns>Compiled graphics shader code</returns>
public ShaderBundle GetGraphicsShader(GpuState state, ShaderAddresses addresses)
{
bool isCached = _gpPrograms.TryGetValue(addresses, out List <ShaderBundle> list);
if (isCached)
{
foreach (ShaderBundle cachedGpShaders in list)
{
if (IsShaderEqual(cachedGpShaders, addresses))
{
return(cachedGpShaders);
}
}
}
TranslatorContext[] shaderContexts = new TranslatorContext[Constants.ShaderStages];
TransformFeedbackDescriptor[] tfd = GetTransformFeedbackDescriptors(state);
TranslationFlags flags = DefaultFlags;
if (tfd != null)
{
flags |= TranslationFlags.Feedback;
}
TranslationCounts counts = new TranslationCounts();
if (addresses.VertexA != 0)
{
shaderContexts[0] = DecodeGraphicsShader(state, counts, flags, ShaderStage.Vertex, addresses.Vertex, addresses.VertexA);
}
else
{
shaderContexts[0] = DecodeGraphicsShader(state, counts, flags, ShaderStage.Vertex, addresses.Vertex);
}
shaderContexts[1] = DecodeGraphicsShader(state, counts, flags, ShaderStage.TessellationControl, addresses.TessControl);
shaderContexts[2] = DecodeGraphicsShader(state, counts, flags, ShaderStage.TessellationEvaluation, addresses.TessEvaluation);
shaderContexts[3] = DecodeGraphicsShader(state, counts, flags, ShaderStage.Geometry, addresses.Geometry);
shaderContexts[4] = DecodeGraphicsShader(state, counts, flags, ShaderStage.Fragment, addresses.Fragment);
bool isShaderCacheEnabled = _cacheManager != null;
bool isShaderCacheReadOnly = false;
Hash128 programCodeHash = default;
GuestShaderCacheEntry[] shaderCacheEntries = null;
if (isShaderCacheEnabled)
{
isShaderCacheReadOnly = _cacheManager.IsReadOnly;
// Compute hash and prepare data for shader disk cache comparison.
shaderCacheEntries = CacheHelper.CreateShaderCacheEntries(_context.MemoryManager, shaderContexts);
programCodeHash = CacheHelper.ComputeGuestHashFromCache(shaderCacheEntries, tfd);
}
ShaderBundle gpShaders;
// Search for the program hash in loaded shaders.
if (!isShaderCacheEnabled || !_gpProgramsDiskCache.TryGetValue(programCodeHash, out gpShaders))
{
if (isShaderCacheEnabled)
{
Logger.Debug?.Print(LogClass.Gpu, $"Shader {programCodeHash} not in cache, compiling!");
}
// The shader isn't currently cached, translate it and compile it.
ShaderCodeHolder[] shaders = new ShaderCodeHolder[Constants.ShaderStages];
shaders[0] = TranslateShader(shaderContexts[0]);
shaders[1] = TranslateShader(shaderContexts[1]);
shaders[2] = TranslateShader(shaderContexts[2]);
shaders[3] = TranslateShader(shaderContexts[3]);
shaders[4] = TranslateShader(shaderContexts[4]);
List <IShader> hostShaders = new List <IShader>();
for (int stage = 0; stage < Constants.ShaderStages; stage++)
{
ShaderProgram program = shaders[stage]?.Program;
if (program == null)
{
continue;
}
IShader hostShader = _context.Renderer.CompileShader(program.Stage, program.Code);
shaders[stage].HostShader = hostShader;
hostShaders.Add(hostShader);
}
IProgram hostProgram = _context.Renderer.CreateProgram(hostShaders.ToArray(), tfd);
byte[] hostProgramBinary = HostShaderCacheEntry.Create(hostProgram.GetBinary(), shaders);
gpShaders = new ShaderBundle(hostProgram, shaders);
if (isShaderCacheEnabled)
{
_gpProgramsDiskCache.Add(programCodeHash, gpShaders);
if (!isShaderCacheReadOnly)
{
_cacheManager.SaveProgram(ref programCodeHash, CacheHelper.CreateGuestProgramDump(shaderCacheEntries, tfd), hostProgramBinary);
}
}
}
if (!isCached)
{
list = new List <ShaderBundle>();
_gpPrograms.Add(addresses, list);
}
list.Add(gpShaders);
return(gpShaders);
}
/// <summary>
/// Apply this TransformState.
/// </summary>
/// <param name="ctx">
/// A <see cref="GraphicsContext"/> which has defined the shader program <paramref name="shaderProgram"/>.
/// </param>
/// <param name="shaderProgram">
/// The <see cref="ShaderProgram"/> which has the state set.
/// </param>
public override void Apply(GraphicsContext ctx, ShaderProgram shaderProgram)
{
GraphicsResource.CheckCurrentContext(ctx);
if (!ctx.Extensions.UniformBufferObject_ARB)
{
if (shaderProgram == null)
{
// Fixed pipeline rendering requires server state
throw new NotImplementedException();
}
else
{
// Custom implementation
ctx.Bind(shaderProgram);
if (shaderProgram.IsActiveUniform("glo_LightModel"))
{
LightModel.ApplyState(ctx, shaderProgram, "glo_LightModel");
}
for (int i = 0; i < Lights.Count; i++)
{
string uniformName = "glo_Light[" + i + "]";
if (shaderProgram.IsActiveUniform(uniformName) == false)
{
break;
}
Lights[i].ApplyState(ctx, shaderProgram, uniformName);
}
shaderProgram.SetUniform(ctx, "glo_LightsCount", LightsCount);
}
}
else
{
base.Apply(ctx, shaderProgram); // Uniform block
}
// Dummy shadow map: Texture2d
// Note: necessary to avoid undefined behavior on glo_ShadowMap2D samplers
string resourceClassId = "OpenGL.Objects.ShadowMap.DummyTexture2d";
Texture2d dummyShadowMap = (Texture2d)ctx.GetSharedResource(resourceClassId);
if (dummyShadowMap == null)
{
dummyShadowMap = new Texture2d(1, 1, PixelLayout.Depth16);
dummyShadowMap.SamplerParams.CompareMode = true;
dummyShadowMap.SamplerParams.CompareFunc = DepthFunction.Never;
dummyShadowMap.Create(ctx);
ctx.SetSharedResource(resourceClassId, dummyShadowMap);
}
// Dummy shadow map: TextureCube
// Apply depth maps
bool[] tex2dSet = new bool[4];
for (int i = 0; i < tex2dSet.Length; i++)
{
if (i >= Lights.Count || Lights[i].ShadowMap2D == null)
{
continue;
}
int shadowMapIndex = Lights[i].ShadowMapIndex;
shaderProgram.SetUniform(ctx, "glo_ShadowMap2D[" + shadowMapIndex + "]", Lights[i].ShadowMap2D);
tex2dSet[shadowMapIndex] = true;
}
// Avoid undefined behavior
for (int i = 0; i < tex2dSet.Length; i++)
{
if (tex2dSet[i] == false)
{
shaderProgram.SetUniform(ctx, "glo_ShadowMap2D[" + i + "]", dummyShadowMap);
}
}
}
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;
in vec3 normal;
in vec3 viewPosition;
void main(){
vec3 xTangent = dFdx( viewPosition );
vec3 yTangent = dFdy( viewPosition );
vec3 faceNormal = normalize( cross( xTangent, yTangent ) );
vec3 displayNormal = (faceNormal.xyz * 0.5) + 0.5;
float shading = max(displayNormal.y,0.5);
gl_FragColor = color;
}");
var solidColorVert = 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(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(10, 2, 15, 32);
for (int i = 0; i < Vertices.Length; i++)
{
var mat = Matrix4.CreateRotationX(MathHelper.DegreesToRadians(90));
Vertices[i].Position = Vector3.TransformPosition(Vertices[i].Position, mat);
Vertices[i].Normal = Vector3.TransformNormal(Vertices[i].Normal, mat);
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);
}
}
/// <summary>
/// Construye los Buffers correspondientes de OpenGL para dibujar este objeto.
/// </summary>
/// <param name="sProgram"></param>
public void Build(ShaderProgram sProgram)
{
CrearVBOs();
CrearVAO(sProgram);
}
public void Parse(ShaderProgram prog, string line, bool ignoreMin)
{
//Debug.Log("Parsing instruction count: line = " + line);
// String style:
// "// opengl - ALU: 29 to 35"
// "// opengl - ALU: 7 to 15, TEX: 1 to 3"
string[] split = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (split.Length != 7 && split.Length != 11 && split.Length != 15)
{
Debug.LogError("Error parsing instruction count. Line did not have 7, 11 or 15 elements [" + line + "]. Length is: " + split.Length);
return;
}
if (split[1] == "flash")
{
Debug.LogWarning("Flash is no longer supported by Unity, and was removed from the shader");
return;
}
if (split[1] == "ps3")
{
Debug.LogWarning("PS3 is no longer supported by Unity since 5.5, and was removed from the shader");
return;
}
if (split[1] == "xbox360")
{
Debug.LogWarning("Xbox 360 is no longer supported by Unity since 5.5, and was removed from the shader");
return;
}
if (split[1] == "opengl")
{
split[1] = "glcore";
}
bool hasTex = (split.Length == 11);
object enumObj = Enum.Parse(typeof(RenderPlatform), split[1]);
int enumID;
if (enumObj != null)
{
enumID = (int)enumObj;
}
else
{
return;
}
if (prog == ShaderProgram.Frag)
{
if (!ignoreMin)
{
plats[enumID].frag.min = IntParse(split[4]);
}
plats[enumID].frag.max = IntParse(split[6]);
if (hasTex)
{
if (!ignoreMin)
{
plats[enumID].fTex.min = IntParse(split[8]);
}
plats[enumID].fTex.max = IntParse(split[10]);
}
}
else if (prog == ShaderProgram.Vert)
{
if (!ignoreMin)
{
plats[enumID].vert.min = IntParse(split[4]);
}
plats[enumID].vert.max = IntParse(split[6]);
if (hasTex)
{
if (!ignoreMin)
{
plats[enumID].vTex.min = IntParse(split[8]);
}
plats[enumID].vTex.max = IntParse(split[10]);
}
}
else
{
Debug.LogError("Tried to parse things in invalid program [" + prog + "]");
}
//Debug.Log("Instr: " + split[1] + " "+ prog + " " + line + " ig: " + ignoreMin);
}
/// <summary>
/// Initialize the cache.
/// </summary>
internal void Initialize()
{
if (GraphicsConfig.EnableShaderCache && GraphicsConfig.TitleId != null)
{
_cacheManager = new CacheManager(CacheGraphicsApi.OpenGL, CacheHashType.XxHash128, "glsl", GraphicsConfig.TitleId, ShaderCodeGenVersion);
bool isReadOnly = _cacheManager.IsReadOnly;
HashSet <Hash128> invalidEntries = null;
if (isReadOnly)
{
Logger.Warning?.Print(LogClass.Gpu, "Loading shader cache in read-only mode (cache in use by another program!)");
}
else
{
invalidEntries = new HashSet <Hash128>();
}
ReadOnlySpan <Hash128> guestProgramList = _cacheManager.GetGuestProgramList();
using AutoResetEvent progressReportEvent = new AutoResetEvent(false);
_shaderCount = 0;
_totalShaderCount = guestProgramList.Length;
ShaderCacheStateChanged?.Invoke(ShaderCacheState.Start, _shaderCount, _totalShaderCount);
Thread progressReportThread = null;
if (guestProgramList.Length > 0)
{
progressReportThread = new Thread(ReportProgress)
{
Name = "ShaderCache.ProgressReporter",
Priority = ThreadPriority.Lowest,
IsBackground = true
};
progressReportThread.Start(progressReportEvent);
}
// Make sure these are initialized before doing compilation.
Capabilities caps = _context.Capabilities;
int maxTaskCount = Math.Min(Environment.ProcessorCount, 8);
int programIndex = 0;
List <ShaderCompileTask> activeTasks = new List <ShaderCompileTask>();
AutoResetEvent taskDoneEvent = new AutoResetEvent(false);
// This thread dispatches tasks to do shader translation, and creates programs that OpenGL will link in the background.
// The program link status is checked in a non-blocking manner so that multiple shaders can be compiled at once.
while (programIndex < guestProgramList.Length || activeTasks.Count > 0)
{
if (activeTasks.Count < maxTaskCount && programIndex < guestProgramList.Length)
{
// Begin a new shader compilation.
Hash128 key = guestProgramList[programIndex];
byte[] hostProgramBinary = _cacheManager.GetHostProgramByHash(ref key);
bool hasHostCache = hostProgramBinary != null;
IProgram hostProgram = null;
// If the program sources aren't in the cache, compile from saved guest program.
byte[] guestProgram = _cacheManager.GetGuestProgramByHash(ref key);
if (guestProgram == null)
{
Logger.Error?.Print(LogClass.Gpu, $"Ignoring orphan shader hash {key} in cache (is the cache incomplete?)");
// Should not happen, but if someone messed with the cache it's better to catch it.
invalidEntries?.Add(key);
_shaderCount = ++programIndex;
continue;
}
ReadOnlySpan <byte> guestProgramReadOnlySpan = guestProgram;
ReadOnlySpan <GuestShaderCacheEntry> cachedShaderEntries = GuestShaderCacheEntry.Parse(ref guestProgramReadOnlySpan, out GuestShaderCacheHeader fileHeader);
if (cachedShaderEntries[0].Header.Stage == ShaderStage.Compute)
{
Debug.Assert(cachedShaderEntries.Length == 1);
GuestShaderCacheEntry entry = cachedShaderEntries[0];
HostShaderCacheEntry[] hostShaderEntries = null;
// Try loading host shader binary.
if (hasHostCache)
{
hostShaderEntries = HostShaderCacheEntry.Parse(hostProgramBinary, out ReadOnlySpan <byte> hostProgramBinarySpan);
hostProgramBinary = hostProgramBinarySpan.ToArray();
hostProgram = _context.Renderer.LoadProgramBinary(hostProgramBinary);
}
ShaderCompileTask task = new ShaderCompileTask(taskDoneEvent);
activeTasks.Add(task);
task.OnCompiled(hostProgram, (bool isHostProgramValid, ShaderCompileTask task) =>
{
ShaderProgram program = null;
ShaderProgramInfo shaderProgramInfo = null;
if (isHostProgramValid)
{
// Reconstruct code holder.
program = new ShaderProgram(entry.Header.Stage, "");
shaderProgramInfo = hostShaderEntries[0].ToShaderProgramInfo();
ShaderCodeHolder shader = new ShaderCodeHolder(program, shaderProgramInfo, entry.Code);
_cpProgramsDiskCache.Add(key, new ShaderBundle(hostProgram, shader));
return(true);
}
else
{
// If the host program was rejected by the gpu driver or isn't in cache, try to build from program sources again.
Task compileTask = Task.Run(() =>
{
IGpuAccessor gpuAccessor = new CachedGpuAccessor(_context, entry.Code, entry.Header.GpuAccessorHeader, entry.TextureDescriptors);
var options = CreateTranslationOptions(DefaultFlags | TranslationFlags.Compute);
program = Translator.CreateContext(0, gpuAccessor, options).Translate(out shaderProgramInfo);
});
task.OnTask(compileTask, (bool _, ShaderCompileTask task) =>
{
ShaderCodeHolder shader = new ShaderCodeHolder(program, shaderProgramInfo, entry.Code);
Logger.Info?.Print(LogClass.Gpu, $"Host shader {key} got invalidated, rebuilding from guest...");
// Compile shader and create program as the shader program binary got invalidated.
shader.HostShader = CompileShader(shader.Program, shader.Info);
hostProgram = _context.Renderer.CreateProgram(new IShader[] { shader.HostShader }, null);
task.OnCompiled(hostProgram, (bool isNewProgramValid, ShaderCompileTask task) =>
{
// As the host program was invalidated, save the new entry in the cache.
hostProgramBinary = HostShaderCacheEntry.Create(hostProgram.GetBinary(), new ShaderCodeHolder[] { shader });
if (!isReadOnly)
{
if (hasHostCache)
{
_cacheManager.ReplaceHostProgram(ref key, hostProgramBinary);
}
else
{
Logger.Warning?.Print(LogClass.Gpu, $"Add missing host shader {key} in cache (is the cache incomplete?)");
_cacheManager.AddHostProgram(ref key, hostProgramBinary);
}
}
_cpProgramsDiskCache.Add(key, new ShaderBundle(hostProgram, shader));
return(true);
});
return(false); // Not finished: still need to compile the host program.
});
return(false); // Not finished: translating the program.
}
});
}
else
{
Debug.Assert(cachedShaderEntries.Length == Constants.ShaderStages);
ShaderCodeHolder[] shaders = new ShaderCodeHolder[cachedShaderEntries.Length];
List <ShaderProgram> shaderPrograms = new List <ShaderProgram>();
TransformFeedbackDescriptor[] tfd = CacheHelper.ReadTransformFeedbackInformation(ref guestProgramReadOnlySpan, fileHeader);
TranslationFlags flags = DefaultFlags;
if (tfd != null)
{
flags |= TranslationFlags.Feedback;
}
HostShaderCacheEntry[] hostShaderEntries = null;
// Try loading host shader binary.
if (hasHostCache)
{
hostShaderEntries = HostShaderCacheEntry.Parse(hostProgramBinary, out ReadOnlySpan <byte> hostProgramBinarySpan);
hostProgramBinary = hostProgramBinarySpan.ToArray();
hostProgram = _context.Renderer.LoadProgramBinary(hostProgramBinary);
}
ShaderCompileTask task = new ShaderCompileTask(taskDoneEvent);
activeTasks.Add(task);
GuestShaderCacheEntry[] entries = cachedShaderEntries.ToArray();
task.OnCompiled(hostProgram, (bool isHostProgramValid, ShaderCompileTask task) =>
{
Task compileTask = Task.Run(() =>
{
// Reconstruct code holder.
for (int i = 0; i < entries.Length; i++)
{
GuestShaderCacheEntry entry = entries[i];
if (entry == null)
{
continue;
}
ShaderProgram program;
if (entry.Header.SizeA != 0)
{
ShaderProgramInfo shaderProgramInfo;
if (isHostProgramValid)
{
program = new ShaderProgram(entry.Header.Stage, "");
shaderProgramInfo = hostShaderEntries[i].ToShaderProgramInfo();
}
else
{
IGpuAccessor gpuAccessor = new CachedGpuAccessor(_context, entry.Code, entry.Header.GpuAccessorHeader, entry.TextureDescriptors);
var options = CreateTranslationOptions(flags);
var options2 = CreateTranslationOptions(flags | TranslationFlags.VertexA);
TranslatorContext translatorContext = Translator.CreateContext(0, gpuAccessor, options);
TranslatorContext translatorContext2 = Translator.CreateContext((ulong)entry.Header.Size, gpuAccessor, options2);
program = translatorContext.Translate(out shaderProgramInfo, translatorContext2);
}
// NOTE: Vertex B comes first in the shader cache.
byte[] code = entry.Code.AsSpan().Slice(0, entry.Header.Size).ToArray();
byte[] code2 = entry.Code.AsSpan().Slice(entry.Header.Size, entry.Header.SizeA).ToArray();
shaders[i] = new ShaderCodeHolder(program, shaderProgramInfo, code, code2);
}
else
{
ShaderProgramInfo shaderProgramInfo;
if (isHostProgramValid)
{
program = new ShaderProgram(entry.Header.Stage, "");
shaderProgramInfo = hostShaderEntries[i].ToShaderProgramInfo();
}
else
{
IGpuAccessor gpuAccessor = new CachedGpuAccessor(_context, entry.Code, entry.Header.GpuAccessorHeader, entry.TextureDescriptors);
var options = CreateTranslationOptions(flags);
program = Translator.CreateContext(0, gpuAccessor, options).Translate(out shaderProgramInfo);
}
shaders[i] = new ShaderCodeHolder(program, shaderProgramInfo, entry.Code);
}
shaderPrograms.Add(program);
}
});
task.OnTask(compileTask, (bool _, ShaderCompileTask task) =>
{
// If the host program was rejected by the gpu driver or isn't in cache, try to build from program sources again.
if (!isHostProgramValid)
{
Logger.Info?.Print(LogClass.Gpu, $"Host shader {key} got invalidated, rebuilding from guest...");
List <IShader> hostShaders = new List <IShader>();
// Compile shaders and create program as the shader program binary got invalidated.
for (int stage = 0; stage < Constants.ShaderStages; stage++)
{
ShaderProgram program = shaders[stage]?.Program;
if (program == null)
{
continue;
}
IShader hostShader = CompileShader(program, shaders[stage].Info);;
shaders[stage].HostShader = hostShader;
hostShaders.Add(hostShader);
}
hostProgram = _context.Renderer.CreateProgram(hostShaders.ToArray(), tfd);
task.OnCompiled(hostProgram, (bool isNewProgramValid, ShaderCompileTask task) =>
{
// As the host program was invalidated, save the new entry in the cache.
hostProgramBinary = HostShaderCacheEntry.Create(hostProgram.GetBinary(), shaders);
if (!isReadOnly)
{
if (hasHostCache)
{
_cacheManager.ReplaceHostProgram(ref key, hostProgramBinary);
}
else
{
Logger.Warning?.Print(LogClass.Gpu, $"Add missing host shader {key} in cache (is the cache incomplete?)");
_cacheManager.AddHostProgram(ref key, hostProgramBinary);
}
}
_gpProgramsDiskCache.Add(key, new ShaderBundle(hostProgram, shaders));
return(true);
});
return(false); // Not finished: still need to compile the host program.
}
else
{
_gpProgramsDiskCache.Add(key, new ShaderBundle(hostProgram, shaders));
return(true);
}
});
return(false); // Not finished: translating the program.
});
}
_shaderCount = ++programIndex;
}
// Process the queue.
for (int i = 0; i < activeTasks.Count; i++)
{
ShaderCompileTask task = activeTasks[i];
if (task.IsDone())
{
activeTasks.RemoveAt(i--);
}
}
if (activeTasks.Count == maxTaskCount)
{
// Wait for a task to be done, or for 1ms.
// Host shader compilation cannot signal when it is done,
// so the 1ms timeout is required to poll status.
taskDoneEvent.WaitOne(1);
}
}
if (!isReadOnly)
{
// Remove entries that are broken in the cache
_cacheManager.RemoveManifestEntries(invalidEntries);
_cacheManager.FlushToArchive();
_cacheManager.Synchronize();
}
progressReportEvent.Set();
progressReportThread?.Join();
ShaderCacheStateChanged?.Invoke(ShaderCacheState.Loaded, _shaderCount, _totalShaderCount);
Logger.Info?.Print(LogClass.Gpu, $"Shader cache loaded {_shaderCount} entries.");
}
}
public ObjLoader(string filename, ShaderProgram program)
{
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
this.shaderProgram = program; //Przypisanie programu(cieniujacego) do programu obecnego w tej klasie
ObjMaterial defaultMaterial = new ObjMaterial(program); //Stworzenie materialy na podstawie przekazanego programu
using (StreamReader stream = new StreamReader(filename)) //dzieki using mamy pewnosc ze po wyjsciu z tego bloku, obiekt stream zostanie zwolniony
{
List <string> lines = new List <string>(); //tworzenie listy stringow
List <string> objLines = new List <string>(); //tworzenie listy stringow
int vertexOffset = 1, vertexCount = 0; //liczniki vertexow
int uvOffset = 1, uvCount = 0; //liczniki uv
while (!stream.EndOfStream) //czytanie pliku az do jego konca
{
string line = stream.ReadLine(); //kazda kolejna linia
if (line.Trim().Length == 0)
{
continue; //jesli w lini po usunieciu bialych znakow, liczba znakow jest rowna 0 to przejdz do nastepnego obrotu petli
}
if ((line[0] == 'o' && lines.Count != 0) || (line[0] == 'g' && objLines.Count != 0))
{
List <string> combinedLines = new List <string>(objLines);
combinedLines.AddRange(lines);
ObjObject newObject = new ObjObject(combinedLines, materials, vertexOffset, uvOffset);
if (newObject.VertexCount != 0)
{
objects.Add(newObject);
}
if (newObject.Material == null)
{
newObject.Material = defaultMaterial;
}
lines.Clear();
if (line[0] == 'o')
{
objLines.Clear();
vertexOffset += vertexCount;
uvOffset += uvCount;
vertexCount = 0;
uvCount = 0;
}
}
if (line[0] == 'v') //zliczenie wystapien vertexow lub uv
{
if (line[1] == ' ')
{
vertexCount++;
}
else
{
uvCount++;
}
objLines.Add(line);
}
else if (line[0] != '#')
{
lines.Add(line); //Pomijanie komenatrzy
}
if (line[0] == 'm' && line[1] == 't')
{
LoadMaterials(CreateFixedPath(filename, line.Split(' ')[1])); //sprawdzenie czy obiekt korzysta z pliku z materialem
}
}
if (lines != null) //Sprawdzenie czy na pewno wszystko zostalo zaimportowane
{
List <string> combinedLines = new List <string>(objLines);
combinedLines.AddRange(lines);
ObjObject newObject = new ObjObject(combinedLines, materials, vertexOffset, uvOffset);
objects.Add(newObject);
}
}
Console.WriteLine("Wykonano funckje ObjLoader");
}
protected override void GenEmit(ShaderProgram Program, uint InstOp)
{
SB.AppendLine($"{Ident}gl_Position = {ShaderOutputRegName.Position};");
SB.AppendLine($"{Ident}EmitVertex();");
}
public Shader GetComputeShader(
ulong gpuVa,
int localSizeX,
int localSizeY,
int localSizeZ,
int localMemorySize,
int sharedMemorySize)
{
if (gpuVa == 0)
{
return null;
}
ShaderPack pack = new ShaderPack();
ReadOnlySpan<byte> code = GetShaderCodeHeaderless(gpuVa);
pack.Add(code);
Shader cs = _cache.Get(pack, out int hash);
if (cs != null)
{
return cs;
}
_dumper.Dump(code, compute: true, out string fullPath, out string codePath);
int QueryInfo(QueryInfoName info, int index)
{
return info switch
{
QueryInfoName.ComputeLocalSizeX => localSizeX,
QueryInfoName.ComputeLocalSizeY => localSizeY,
QueryInfoName.ComputeLocalSizeZ => localSizeZ,
QueryInfoName.ComputeLocalMemorySize => localMemorySize,
QueryInfoName.ComputeSharedMemorySize => sharedMemorySize,
_ => QueryInfoCommon(info)
};
}
CachedShader shader = TranslateComputeShader(
state,
gpuVa,
localSizeX,
localSizeY,
localSizeZ,
localMemorySize,
sharedMemorySize);
TranslatorCallbacks callbacks = new TranslatorCallbacks(QueryInfo, PrintLog);
ShaderProgram program = Translator.Translate(code, callbacks, DefaultFlags | TranslationFlags.Compute);
if (fullPath != null && codePath != null)
{
program.Prepend("// " + codePath);
program.Prepend("// " + fullPath);
}
IShader shader = _context.Renderer.CompileShader(program);
IProgram hostProgram = _context.Renderer.CreateProgram(new IShader[] { shader });
cs = new Shader(hostProgram, new ShaderMeta(hostProgram, program.Info));
int insertIndex = _cache.Add(hash, cs, pack);
if (Configuration.Enabled)
{
ShaderProgramInfo[] info = new ShaderProgramInfo[] { program.Info };
ShaderCacheFile.Save(Configuration.ShaderPath, info, pack, hostProgram.GetGpuBinary(), hash, insertIndex);
}
return cs;
}
static void Main(string[] args)
{
Glut.glutInit();
Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);
Glut.glutInitWindowSize(width, height);
Glut.glutCreateWindow("Project");
Glut.glutIdleFunc(OnRenderFrame);
Glut.glutDisplayFunc(OnDisplay);
Glut.glutKeyboardFunc(OnKeyboardDown);
Glut.glutKeyboardFunc(OnKeyboardUp);
Glut.glutCloseFunc(OnClose);
Glut.glutReshapeFunc(OnReshape);
Gl.Enable(EnableCap.DepthTest);
//program = new ShaderProgram(VertexShader, FragmentShader);
program = new ShaderProgram(VertexShaderTexture, FragmentShaderTexture);
program.Use();
program["projection_matrix"].SetValue(Matrix4.CreatePerspectiveFieldOfView(0.45f, (float)width / height, 0.1f, 1000f));
program["view_matrix"].SetValue(Matrix4.LookAt(new Vector3(0, 0, 10), Vector3.Zero, new Vector3(0, 1, 0)));
program["light_direction"].SetValue(new Vector3(0, 1, 1));
//program["light_direction2"].SetValue(new Vector3(0, 0, 1));
program["enable_lighting"].SetValue(lighting);
//load texture
crateTexture = new Texture("texture2.jpg");
//create cube vertices
cube = new VBO <Vector3>(new Vector3[] {
new Vector3(1, 1, -1), new Vector3(-1, 1, -1), new Vector3(-1, 1, 1), new Vector3(1, 1, 1), //top
new Vector3(1, -1, 1), new Vector3(-1, -1, 1), new Vector3(-1, -1, -1), new Vector3(1, -1, -1), //bottom
new Vector3(1, 1, 1), new Vector3(-1, 1, 1), new Vector3(-1, -1, 1), new Vector3(1, -1, 1), //front
new Vector3(1, -1, -1), new Vector3(-1, -1, -1), new Vector3(-1, 1, -1), new Vector3(1, 1, -1), //back
new Vector3(-1, 1, 1), new Vector3(-1, 1, -1), new Vector3(-1, -1, -1), new Vector3(-1, -1, 1), //left
new Vector3(1, 1, -1), new Vector3(1, 1, 1), new Vector3(1, -1, 1), new Vector3(1, -1, -1) //right
});
//cube normals
cubeNormals = new VBO <Vector3>(new Vector3[] {
new Vector3(0, 1, 0), new Vector3(0, 1, 0), new Vector3(0, 1, 0), new Vector3(0, 1, 0),
new Vector3(0, -1, 0), new Vector3(0, -1, 0), new Vector3(0, -1, 0), new Vector3(0, -1, 0),
new Vector3(0, 0, 1), new Vector3(0, 0, 1), new Vector3(0, 0, 1), new Vector3(0, 0, 1),
new Vector3(0, 0, -1), new Vector3(0, 0, -1), new Vector3(0, 0, -1), new Vector3(0, 0, -1),
new Vector3(-1, 0, 0), new Vector3(-1, 0, 0), new Vector3(-1, 0, 0), new Vector3(-1, 0, 0),
new Vector3(1, 0, 0), new Vector3(1, 0, 0), new Vector3(1, 0, 0), new Vector3(1, 0, 0)
});
//texture for cube
cubeUV = new VBO <Vector2>(new Vector2[] {
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1)
});
cubeElements = new VBO <int>(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23 }, BufferTarget.ElementArrayBuffer);
Glut.glutMainLoop();
}
public void RenderBeforeChildren(RenderEventArgs arg)
{
{
int width = arg.Param.Viewport.width, height = arg.Param.Viewport.height;
if (width != this.canvasWidth || height != this.canvasHeight)
{
UpdateResources(width, height);
this.canvasWidth = width;
this.canvasHeight = height;
}
}
{
this.cullFaceState.On();
this.depthTestState.On();
}
{
// Clear head-pointer image
this.headClearBuffer.Bind();
this.headTexture.Bind();
int width = this.canvasWidth, height = this.canvasHeight;
uint format = GL.GL_RED_INTEGER, type = GL.GL_UNSIGNED_BYTE;
GL.Instance.TexSubImage2D((uint)GL.GL_TEXTURE_2D, 0, 0, 0, width, height, format, type, IntPtr.Zero);
this.headTexture.Unbind();
this.headClearBuffer.Unbind();
}
uint imageUnit0 = 0, imageUnit1 = 1;
{
// Bind head-pointer image for read-write
glBindImageTexture(imageUnit0, this.headTexture.Id, 0, false, 0, GL.GL_READ_WRITE, GL.GL_R32UI);
// Bind linked-list buffer for write
glBindImageTexture(imageUnit1, this.linkedListTexture.Id, 0, false, 0, GL.GL_WRITE_ONLY, GL.GL_RGBA32UI);
}
{
ICamera camera = arg.Camera;
mat4 projection = camera.GetProjectionMatrix();
mat4 view = camera.GetViewMatrix();
mat4 model = this.GetModelMatrix();
{
// first pass
RenderMethod method = this.RenderUnit.Methods[buildLists];
ShaderProgram program = method.Program;
program.SetUniform(mvpMatrix, projection * view * model);
method.Render();
}
{
// second pass
RenderMethod method = this.RenderUnit.Methods[resolveLists];
ShaderProgram program = method.Program;
program.SetUniform(mvpMatrix, projection * view * model);
method.Render();
}
}
{
glBindImageTexture(imageUnit1, 0, 0, false, 0, GL.GL_WRITE_ONLY, GL.GL_RGBA32UI);
glBindImageTexture(imageUnit0, 0, 0, false, 0, GL.GL_READ_WRITE, GL.GL_R32UI);
}
{
this.cullFaceState.Off();
this.depthTestState.Off();
}
}
