public void Draw(Scene scene, Matrix world, Matrix view, Matrix projection, TextureCube reflectionTexture, Vector3 cameraPosition, RenderPass pass)
{
foreach (AbstractEntity entity in scene.Entities)
{
entity.Draw(world, view, projection, reflectionTexture, cameraPosition, pass);
}
}
public override void Render(RenderPass pass)
{
foreach(Emblem emblem in emblems)
{
emblem.Render(pass);
}
base.Render (pass);
}
public override void Initialize()
{
base.Initialize();
boundingBoxPass = new RenderPass("BoundingBoxPass").KeepAliveBy(this);
heatShimmerPass = new RenderPass("HeatShimmerPass").KeepAliveBy(this);
heatShimmerComposePass = new RenderPass("HeatShimmerComposePass").KeepAliveBy(this);
}
public override void Load()
{
base.Load();
Parameters.AddSources(GBufferPlugin.MainPlugin.ViewParameters);
Lights = this.EffectSystemOld.BuildEffect("Lights").Using(new LightPlugin()).InstantiatePermutation();
// TODO: Check if released properly.
for (int i = 0; i < 2; ++i)
{
if (i == 1)
{
if (!Debug)
continue;
// Add the debug as an overlay on the main pass
debugRenderPass = new RenderPass("LightPrePassDebug").KeepAliveBy(ActiveObjects);
GBufferPlugin.MainPlugin.RenderPass.AddPass(debugRenderPass);
}
var debug = i == 1;
var renderPass = i == 1 ? debugRenderPass : RenderPass;
var lightDeferredEffectBuilder = this.EffectSystemOld.BuildEffect("LightPrePass" + (debug ? "Debug" : string.Empty)).KeepAliveBy(ActiveObjects);
foreach (var effectPlugin in BasePlugins)
{
lightDeferredEffectBuilder.Using(new BasicShaderPlugin(effectPlugin) { Services = Services, RenderPassPlugin = this, RenderPass = renderPass });
}
lightDeferredEffectBuilder.Using(new LightingPrepassShaderPlugin("LightPreShaderPass" + (debug ? "Debug" : string.Empty)) { Services = Services, RenderPassPlugin = this, RenderPass = renderPass, Debug = debug });
lightDeferredEffects[i] = lightDeferredEffectBuilder.InstantiatePermutation().KeepAliveBy(ActiveObjects);
}
if (OfflineCompilation)
return;
// Create lighting accumulation texture (that LightPlugin will use)
var mainBackBuffer = graphicsDeviceService.GraphicsDevice.BackBuffer;
var lightTexture = Texture.New2D(GraphicsDevice, mainBackBuffer.Width, mainBackBuffer.Height, PixelFormat.R16G16B16A16_Float, TextureFlags.ShaderResource | TextureFlags.RenderTarget);
lightTexture.Name = "LightTexture";
LightTexture = lightTexture.ToRenderTarget();
// Set Parameters for this plugin
Parameters.Set(LightDeferredShadingKeys.LightTexture, lightTexture);
// Set GBuffer Texture0
Parameters.Set(GBufferBaseKeys.GBufferTexture, (Texture2D)GBufferPlugin.RenderTarget.Texture);
// Set parameters for MainPlugin
GBufferPlugin.MainTargetPlugin.Parameters.Set(LightDeferredShadingKeys.LightTexture, lightTexture);
CreatePrePassMesh(RenderPass, false);
if (Debug)
CreatePrePassMesh(debugRenderPass, true);
}
public SceneNode(int actor_id, String name, RenderPass pass, Matrix? to_world, Matrix? from_world)
{
_properties = new SceneNodeProperties();
_properties.ActorId = actor_id;
_properties.Name = name;
_properties.RenderPass = pass;
_properties.Alphatype = AlphaType.AlphaOpaque;
SetTransform(to_world, from_world);
SetRadius(0);
}
public override void Render(RenderPass pass)
{
if(pass == RenderPass.Shadow )
{
if(CastShadows)
{
SetUpShadowCastMaterial();
Render(SceneManager.ShadowPassShader);
}
}
else if(pass == RenderPass.Render)
{
SetUpMaterial();
Render();
}
}
public virtual void Draw(Matrix world, Matrix view, Matrix projection, TextureCube reflectionTexture, Vector3 cameraPosition, RenderPass pass)
{
if (_visible)
{
if (_effect != null)
{
if (cameraPosition != null)
{
DrawModelWithEffect(world, view, projection, reflectionTexture, cameraPosition);
}
}
else
{
DrawModel(world, view, projection, pass);
}
}
}
public override void DrawModel(Matrix world, Matrix view, Matrix projection, RenderPass pass)
{
if (_visible)
{
if(pass == RenderPass.Opaque) {
//Draw all opaque
_device.BlendState = BlendState.Opaque;
_device.DepthStencilState = DepthStencilState.Default;
this.DrawMeshes(_opaqueMeshes, view, projection);
}
else {
//Draw all translucent
_device.BlendState = BlendState.AlphaBlend;
_device.DepthStencilState = DepthStencilState.DepthRead;
this.DrawMeshes(_translucentMeshes, view, projection);
}
//For future object
_device.BlendState = BlendState.Opaque;
_device.DepthStencilState = DepthStencilState.Default;
_device.RasterizerState = RasterizerState.CullNone;
}
}
public override void Load()
{
base.Load();
if (OfflineCompilation)
return;
var renderTargets = new RenderTarget[2];
DepthStencilBuffer depthStencilBuffer = null;
Texture2D depthStencilTexture = null;
Parameters.AddSources(MainPlugin.ViewParameters);
Parameters.RegisterParameter(EffectPlugin.BlendStateKey);
var filteredPasses = new FastList<RenderPass>();
RenderPass.UpdatePasses += updatePassesAction = (RenderPass currentRenderPass, ref FastList<RenderPass> currentPasses) =>
{
var originalPasses = currentPasses;
filteredPasses.Clear();
currentPasses = filteredPasses;
Parameters.Set(PickingFrameIndex, ++currentPickingFrameIndex);
Request[] requests;
lock (pendingRequests)
{
// No picking request or no mesh to pick?
if (pendingRequests.Count == 0)
return;
requests = pendingRequests.ToArray();
pendingRequests.Clear();
}
foreach (var request in requests)
{
requestResults.Add(request);
}
if (originalPasses == null)
return;
// Count mesh passes
int meshIndex = 0;
foreach (var pass in originalPasses)
{
meshIndex += pass.Passes.Count;
}
// No mesh to pick?
if (meshIndex == 0)
return;
// Copy mesh passes and assign indices
var meshPasses = new EffectMesh[meshIndex];
meshIndex = 0;
foreach (var pass in RenderPass.Passes)
{
throw new NotImplementedException();
//foreach (var effectMeshPass in pass.Meshes)
//{
// meshPasses[meshIndex] = (EffectMesh)effectMeshPass;
// // Prefix increment so that 0 means no rendering.
// effectMeshPass.Parameters.Set(PickingMeshIndex, ++meshIndex);
//}
}
// For now, it generates one rendering per picking.
// It would be quite easy to optimize it by make Picking shader works on multiple picking points at a time.
foreach (var request in requests)
{
var pickingRenderPass = new RenderPass("Picking");
pickingRenderPass.StartPass.AddFirst = (threadContext) =>
{
threadContext.GraphicsDevice.Clear(renderTargets[0], Color.Black);
threadContext.GraphicsDevice.Clear(renderTargets[1], Color.Black);
threadContext.Parameters.Set(PickingScreenPosition, request.Location);
threadContext.GraphicsDevice.SetViewport(new Viewport(0, 0, renderTargets[0].Description.Width, renderTargets[0].Description.Height));
threadContext.GraphicsDevice.Clear(depthStencilBuffer, DepthStencilClearOptions.DepthBuffer);
threadContext.GraphicsDevice.SetRenderTargets(depthStencilBuffer, renderTargets);
};
pickingRenderPass.EndPass.AddLast = (threadContext) =>
{
threadContext.Parameters.Reset(PickingScreenPosition);
threadContext.GraphicsDevice.Copy(renderTargets[0].Texture, request.ResultTextures[0]);
threadContext.GraphicsDevice.Copy(renderTargets[1].Texture, request.ResultTextures[1]);
};
//pickingRenderPass.PassesInternal = originalPasses;
throw new NotImplementedException();
request.MeshPasses = meshPasses;
currentPasses.Add(pickingRenderPass);
request.HasResults = true;
// Wait 2 frames before pulling the results.
request.FrameCounter = 2;
}
};
RenderSystem.GlobalPass.EndPass.AddLast = CheckPickingResults;
var backBuffer = GraphicsDevice.BackBuffer;
int pickingArea = 1 + PickingDistance * 2;
renderTargets[0] = Texture.New2D(GraphicsDevice, pickingArea, pickingArea, PixelFormat.R32_UInt, TextureFlags.ShaderResource | TextureFlags.RenderTarget).ToRenderTarget().KeepAliveBy(ActiveObjects);
renderTargets[1] = Texture.New2D(GraphicsDevice, pickingArea, pickingArea, PixelFormat.R32G32B32A32_Float, TextureFlags.ShaderResource | TextureFlags.RenderTarget).ToRenderTarget().KeepAliveBy(ActiveObjects);
depthStencilTexture = Texture.New2D(GraphicsDevice, pickingArea, pickingArea, PixelFormat.D32_Float, TextureFlags.ShaderResource | TextureFlags.DepthStencil).KeepAliveBy(ActiveObjects);
depthStencilBuffer = depthStencilTexture.ToDepthStencilBuffer(false);
Parameters.AddDynamic(PickingMatrix, ParameterDynamicValue.New(PickingScreenPosition, (ref Vector2 pickingPosition, ref Matrix picking) =>
{
// Move center to picked position, and zoom (it is supposed to stay per-pixel according to render target size)
picking = Matrix.Translation(1.0f - (pickingPosition.X) / backBuffer.Width * 2.0f, -1.0f + (pickingPosition.Y) / backBuffer.Height * 2.0f, 0.0f)
* Matrix.Scaling((float)backBuffer.Width / (float)pickingArea, (float)backBuffer.Height / (float)pickingArea, 1.0f);
}));
}
protected override void OnDraw(ModelEffectInstance modelEffect, RenderPass pass)
{
m_model.Draw(modelEffect);
}
public override void Load()
{
base.Load();
RenderPass.AddPass(boundingBoxPass, heatShimmerPass, heatShimmerComposePass);
// Use MinMax Plugin
var bbRenderTargetPlugin = new RenderTargetsPlugin("BoundingBoxRenderTargetPlugin")
{
EnableSetTargets = true,
EnableClearTarget = true,
RenderTarget = null,
RenderPass = boundingBoxPass,
Services = Services
};
bbRenderTargetPlugin.Apply();
Parameters.AddSources(ViewParameters);
Parameters.SetDefault(RenderTargetKeys.DepthStencilSource);
Parameters.SetDefault(TexturingKeys.Sampler);
bbRenderTargetPlugin.Parameters.AddSources(Parameters);
EffectOld minMaxEffect = this.EffectSystemOld.BuildEffect("MinMax")
.Using(new MinMaxShaderPlugin("MinMaxShaderPlugin")
{
RenderPassPlugin = bbRenderTargetPlugin
})
.Using(new BasicShaderPlugin("TransformationWVP")
{
RenderPassPlugin = bbRenderTargetPlugin
})
.KeepAliveBy(ActiveObjects)
.InstantiatePermutation()
.KeepAliveBy(ActiveObjects);
heatShimmerPass.Parameters = new ParameterCollection();
heatShimmerPass.Parameters.AddSources(Parameters);
heatShimmerPass.Parameters.AddSources(NoisePlugin.Parameters);
EffectOld heatShimmerEffect = this.EffectSystemOld.BuildEffect("HeatShimmer")
.Using(new PostEffectSeparateShaderPlugin()
{
RenderPass = heatShimmerPass
})
.Using(
new BasicShaderPlugin(
new ShaderMixinSource()
{
Mixins = new List <ShaderClassSource>()
{
// TODO add support for IsZReverse
//new ShaderClassSource("PostEffectHeatShimmer", Debug ? 1 : 0, effectSystemOld.IsZReverse ? 1 : 0, 3),
new ShaderClassSource("PostEffectHeatShimmer", Debug ? 1 : 0, false ? 1 : 0, 3)
},
Compositions = new Dictionary <string, ShaderSource>()
{
{ "NoiseSource", new ShaderClassSource("SimplexNoise") }
},
}
)
{
RenderPass = heatShimmerPass
})
.KeepAliveBy(ActiveObjects)
.InstantiatePermutation()
.KeepAliveBy(ActiveObjects);
EffectOld heatShimmerDisplayEffect = this.EffectSystemOld.BuildEffect("HeatShimmer")
.Using(new PostEffectSeparateShaderPlugin()
{
RenderPass = heatShimmerComposePass
})
.Using(new BasicShaderPlugin(new ShaderClassSource("PostEffectHeatShimmerDisplay", Debug ? 1 : 0))
{
RenderPass = heatShimmerComposePass
})
.KeepAliveBy(ActiveObjects)
.InstantiatePermutation()
.KeepAliveBy(ActiveObjects);
if (OfflineCompilation)
{
return;
}
Parameters.Set(RenderTargetKeys.DepthStencilSource, DepthStencil.Texture);
Parameters.Set(TexturingKeys.Sampler, GraphicsDevice.SamplerStates.PointClamp);
// ------------------------------------------
// BoundingBox prepass
// ------------------------------------------
var renderTargetDesc = RenderSource.Description;
var bbRenderTarget = Texture.New2D(GraphicsDevice, renderTargetDesc.Width, renderTargetDesc.Height, PixelFormat.R32G32_Float, TextureFlags.ShaderResource | TextureFlags.RenderTarget).KeepAliveBy(ActiveObjects);
bbRenderTargetPlugin.RenderTarget = bbRenderTarget.ToRenderTarget();
// Add meshes
foreach (var bbMeshData in BoundingBoxes)
{
// Mesh for MinPass
var bbMesh = new EffectMesh(minMaxEffect, bbMeshData).KeepAliveBy(ActiveObjects);
// Add mesh
// boundingBoxPass.AddPass(bbMesh.EffectMeshPasses[0].EffectPass);
effectMeshes.Add(bbMesh);
RenderSystem.GlobalMeshes.AddMesh(bbMesh);
}
// ------------------------------------------
// Heat Compute
// ------------------------------------------
var shimmerTexture = Texture.New2D(GraphicsDevice, renderTargetDesc.Width, renderTargetDesc.Height, PixelFormat.R8_UNorm, TextureFlags.ShaderResource | TextureFlags.RenderTarget);
var shimmerRenderTarget = shimmerTexture.ToRenderTarget();
heatShimmerPass.StartPass += context => context.GraphicsDevice.Clear(shimmerRenderTarget, Color.Black);
var quadMesh = new EffectMesh(heatShimmerEffect).KeepAliveBy(ActiveObjects);
quadMesh.Parameters.Set(TexturingKeys.Texture1, bbRenderTarget);
quadMesh.Parameters.Set(RenderTargetKeys.RenderTarget, shimmerRenderTarget);
effectMeshes.Add(quadMesh);
RenderSystem.GlobalMeshes.AddMesh(quadMesh);
// ------------------------------------------
// Heat display
// ------------------------------------------
quadMesh = new EffectMesh(heatShimmerDisplayEffect).KeepAliveBy(ActiveObjects);
quadMesh.Parameters.Set(TexturingKeys.Texture0, RenderSource);
quadMesh.Parameters.Set(TexturingKeys.Texture1, shimmerTexture);
quadMesh.Parameters.Set(RenderTargetKeys.RenderTarget, RenderTarget);
effectMeshes.Add(quadMesh);
RenderSystem.GlobalMeshes.AddMesh(quadMesh);
}
/// <summary>
/// Render Primitive
/// </summary>
/// <param name="pass">Which pass are we currently in</param>
/// <param name="pickingID">ID used to identify which object was picked</param>
/// <param name="scene">Main scene renderer</param>
/// <param name="time">Time it took to render the last frame</param>
public override void Render(RenderPass pass, int pickingID, SceneWindow scene, float time)
{
//if (!RenderSettings.AvatarRenderingEnabled && Attached) return;//hack
// Individual prim matrix
GL.PushMatrix();
// Prim roation and position and scale
GL.MultMatrix(Math3D.CreateSRTMatrix(Prim.Scale, RenderRotation, RenderPosition));
// Do we have animated texture on this face
bool animatedTexture = false;
// Initialise flags tracking what type of faces this prim has
if (pass == RenderPass.Simple)
{
HasSimpleFaces = false;
}
else if (pass == RenderPass.Alpha)
{
HasAlphaFaces = false;
}
else if (pass == RenderPass.Invisible)
{
HasInvisibleFaces = false;
}
// Draw the prim faces
for (int j = 0; j < Faces.Count; j++)
{
Primitive.TextureEntryFace teFace = Prim.Textures.GetFace((uint)j);
Face face = Faces[j];
FaceData data = (FaceData)face.UserData;
if (data == null)
{
continue;
}
if (teFace == null)
{
continue;
}
// Don't render transparent faces
Color4 RGBA = teFace.RGBA;
if (data.TextureInfo.FullAlpha || RGBA.A <= 0.01f)
{
continue;
}
bool switchedLightsOff = false;
if (pass == RenderPass.Picking)
{
data.PickingID = pickingID;
var primNrBytes = Utils.UInt16ToBytes((ushort)pickingID);
var faceColor = new byte[] { primNrBytes[0], primNrBytes[1], (byte)j, 255 };
GL.Color4(faceColor);
}
else if (pass == RenderPass.Invisible)
{
if (!data.TextureInfo.IsInvisible)
{
continue;
}
HasInvisibleFaces = true;
}
else
{
if (data.TextureInfo.IsInvisible)
{
continue;
}
bool belongToAlphaPass = (RGBA.A < 0.99f) || (data.TextureInfo.HasAlpha && !data.TextureInfo.IsMask);
if (belongToAlphaPass && pass != RenderPass.Alpha)
{
continue;
}
if (!belongToAlphaPass && pass == RenderPass.Alpha)
{
continue;
}
if (pass == RenderPass.Simple)
{
HasSimpleFaces = true;
}
else if (pass == RenderPass.Alpha)
{
HasAlphaFaces = true;
}
if (teFace.Fullbright)
{
GL.Disable(EnableCap.Lighting);
switchedLightsOff = true;
}
float shiny = 0f;
switch (teFace.Shiny)
{
case Shininess.High:
shiny = 0.96f;
break;
case Shininess.Medium:
shiny = 0.64f;
break;
case Shininess.Low:
shiny = 0.24f;
break;
}
if (shiny > 0f)
{
scene.StartShiny();
}
GL.Material(MaterialFace.Front, MaterialParameter.Shininess, shiny);
var faceColor = new float[] { RGBA.R, RGBA.G, RGBA.B, RGBA.A };
GL.Color4(faceColor);
GL.Material(MaterialFace.Front, MaterialParameter.Specular, new float[] { 0.5f, 0.5f, 0.5f, 1f });
if (data.TextureInfo.TexturePointer == 0)
{
TextureInfo teInfo;
if (scene.TryGetTextureInfo(teFace.TextureID, out teInfo))
{
data.TextureInfo = teInfo;
}
}
if (data.TextureInfo.TexturePointer == 0)
{
GL.Disable(EnableCap.Texture2D);
if (!data.TextureInfo.FetchFailed)
{
scene.DownloadTexture(new TextureLoadItem()
{
Prim = this.Prim,
TeFace = teFace,
Data = data
}, false);
}
}
else
{
// Is this face using texture animation
if ((Prim.TextureAnim.Flags & Primitive.TextureAnimMode.ANIM_ON) != 0 &&
(Prim.TextureAnim.Face == j || Prim.TextureAnim.Face == 255))
{
if (data.AnimInfo == null)
{
data.AnimInfo = new TextureAnimationInfo();
}
data.AnimInfo.PrimAnimInfo = Prim.TextureAnim;
data.AnimInfo.Step(time);
animatedTexture = true;
}
else if (data.AnimInfo != null) // Face texture not animated. Do we have previous anim setting?
{
data.AnimInfo = null;
}
GL.Enable(EnableCap.Texture2D);
GL.BindTexture(TextureTarget.Texture2D, data.TextureInfo.TexturePointer);
}
}
//hack
/*
* if (!RenderSettings.UseVBO || data.VBOFailed)
* {
* Vertex[] verts = face.Vertices.ToArray();
* ushort[] indices = face.Indices.ToArray();
*
* unsafe
* {
* fixed (float* normalPtr = &verts[0].Normal.X)
* fixed (float* texPtr = &verts[0].TexCoord.X)
* {
* GL.NormalPointer(NormalPointerType.Float, FaceData.VertexSize, (IntPtr)normalPtr);
* GL.TexCoordPointer(2, TexCoordPointerType.Float, FaceData.VertexSize, (IntPtr)texPtr);
* GL.VertexPointer(3, VertexPointerType.Float, FaceData.VertexSize, verts);
* GL.DrawElements(BeginMode.Triangles, indices.Length, DrawElementsType.UnsignedShort, indices);
* }
* }
* }
* else
* {
* if (data.CheckVBO(face))
* {
* Compat.BindBuffer(BufferTarget.ArrayBuffer, data.VertexVBO);
* Compat.BindBuffer(BufferTarget.ElementArrayBuffer, data.IndexVBO);
* GL.NormalPointer(NormalPointerType.Float, FaceData.VertexSize, (IntPtr)12);
* GL.TexCoordPointer(2, TexCoordPointerType.Float, FaceData.VertexSize, (IntPtr)(24));
* GL.VertexPointer(3, VertexPointerType.Float, FaceData.VertexSize, (IntPtr)(0));
*
* GL.DrawElements(BeginMode.Triangles, face.Indices.Count, DrawElementsType.UnsignedShort, IntPtr.Zero);
* }
* Compat.BindBuffer(BufferTarget.ArrayBuffer, 0);
* Compat.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
*
* }
*/
if (switchedLightsOff)
{
GL.Enable(EnableCap.Lighting);
switchedLightsOff = false;
}
}
GL.BindTexture(TextureTarget.Texture2D, 0);
RHelp.ResetMaterial();
// Reset texture coordinates if we modified them in texture animation
if (animatedTexture)
{
GL.MatrixMode(MatrixMode.Texture);
GL.LoadIdentity();
GL.MatrixMode(MatrixMode.Modelview);
}
// Pop the prim matrix
GL.PopMatrix();
base.Render(pass, pickingID, scene, time);
}
public RenderContext(Camera camera, RenderPass renderPass)
{
Camera = camera;
RenderPass = renderPass;
}
public void Render(RenderPass pass)
{
switch(pass)
{
case RenderPass.Render : SceneManager.DefaultFramebuffer.enable(true); break;
case RenderPass.Shadow : SceneManager.LightFramebuffer.enable(true); break;
}
foreach(VTKObject obj in objects)
{
obj.Render(pass);
}
}
private void RenderTerrain(RenderPass pass)
{
terrainTimeSinceUpdate += lastFrameTime;
if (terrainModified && terrainTimeSinceUpdate > RenderSettings.MinimumTimeBetweenTerrainUpdated)
{
if (!terrainInProgress)
{
terrainInProgress = true;
ResetTerrain(false);
UpdateTerrain();
}
}
if (terrainTextureNeedsUpdate)
{
UpdateTerrainTexture();
}
if (terrainIndices == null || terrainVertices == null) return;
GL.Color3(1f, 1f, 1f);
GL.EnableClientState(ArrayCap.VertexArray);
GL.EnableClientState(ArrayCap.TextureCoordArray);
GL.EnableClientState(ArrayCap.NormalArray);
if (pass == RenderPass.Picking)
{
GL.EnableClientState(ArrayCap.ColorArray);
GL.ShadeModel(ShadingModel.Flat);
}
if (terrainImage != null)
{
if (terrainTexture != -1)
{
GL.DeleteTexture(terrainTexture);
}
terrainTexture = RHelp.GLLoadImage(terrainImage, false);
terrainImage.Dispose();
terrainImage = null;
}
if (pass != RenderPass.Picking && terrainTexture != -1)
{
GL.Enable(EnableCap.Texture2D);
GL.BindTexture(TextureTarget.Texture2D, terrainTexture);
}
if (!RenderSettings.UseVBO || terrainVBOFailed)
{
unsafe
{
fixed (float* normalPtr = &terrainVertices[0].Vertex.Normal.X)
fixed (float* texPtr = &terrainVertices[0].Vertex.TexCoord.X)
fixed (byte* colorPtr = &terrainVertices[0].Color.R)
{
GL.NormalPointer(NormalPointerType.Float, ColorVertex.Size, (IntPtr)normalPtr);
GL.TexCoordPointer(2, TexCoordPointerType.Float, ColorVertex.Size, (IntPtr)texPtr);
GL.VertexPointer(3, VertexPointerType.Float, ColorVertex.Size, terrainVertices);
if (pass == RenderPass.Picking)
{
GL.ColorPointer(4, ColorPointerType.UnsignedByte, ColorVertex.Size, (IntPtr)colorPtr);
}
GL.DrawElements(BeginMode.Triangles, terrainIndices.Length, DrawElementsType.UnsignedShort, terrainIndices);
}
}
}
else
{
if (terrainVBO == -1)
{
Compat.GenBuffers(out terrainVBO);
Compat.BindBuffer(BufferTarget.ArrayBuffer, terrainVBO);
Compat.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(terrainVertices.Length * ColorVertex.Size), terrainVertices, BufferUsageHint.StaticDraw);
if (Compat.BufferSize(BufferTarget.ArrayBuffer) != terrainVertices.Length * ColorVertex.Size)
{
terrainVBOFailed = true;
Compat.BindBuffer(BufferTarget.ArrayBuffer, 0);
terrainVBO = -1;
}
}
else
{
Compat.BindBuffer(BufferTarget.ArrayBuffer, terrainVBO);
}
if (terrainIndexVBO == -1)
{
Compat.GenBuffers(out terrainIndexVBO);
Compat.BindBuffer(BufferTarget.ElementArrayBuffer, terrainIndexVBO);
Compat.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(terrainIndices.Length * sizeof(ushort)), terrainIndices, BufferUsageHint.StaticDraw);
if (Compat.BufferSize(BufferTarget.ElementArrayBuffer) != terrainIndices.Length * sizeof(ushort))
{
terrainVBOFailed = true;
Compat.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
terrainIndexVBO = -1;
}
}
else
{
Compat.BindBuffer(BufferTarget.ElementArrayBuffer, terrainIndexVBO);
}
if (!terrainVBOFailed)
{
GL.NormalPointer(NormalPointerType.Float, ColorVertex.Size, (IntPtr)12);
GL.TexCoordPointer(2, TexCoordPointerType.Float, ColorVertex.Size, (IntPtr)(24));
if (pass == RenderPass.Picking)
{
GL.ColorPointer(4, ColorPointerType.UnsignedByte, ColorVertex.Size, (IntPtr)32);
}
GL.VertexPointer(3, VertexPointerType.Float, ColorVertex.Size, (IntPtr)(0));
GL.DrawElements(BeginMode.Triangles, terrainIndices.Length, DrawElementsType.UnsignedShort, IntPtr.Zero);
}
Compat.BindBuffer(BufferTarget.ArrayBuffer, 0);
Compat.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
}
if (pass == RenderPass.Picking)
{
GL.DisableClientState(ArrayCap.ColorArray);
GL.ShadeModel(ShadingModel.Smooth);
}
else
{
GL.BindTexture(TextureTarget.Texture2D, 0);
}
GL.DisableClientState(ArrayCap.VertexArray);
GL.DisableClientState(ArrayCap.TextureCoordArray);
GL.DisableClientState(ArrayCap.NormalArray);
}
void Render(Queue queue, CommandPool cmdPool, VertexData vertexData, ImageData imageData, Buffer imageBuffer, RenderPass renderPass, Pipeline pipeline, Framebuffer framebuffer)
{
uint width = imageData.Width;
uint height = imageData.Height;
var cmdBuffers = AllocateCommandBuffers(cmdPool, 1);
var cmdBuffer = cmdBuffers[0];
var beginInfo = new CommandBufferBeginInfo();
cmdBuffer.Begin(beginInfo); // CommandBuffer Begin
PipelineBarrierSetLayout(cmdBuffer, imageData.Image, ImageLayout.Preinitialized, ImageLayout.ColorAttachmentOptimal, AccessFlags.HostWrite, AccessFlags.ColorAttachmentWrite);
var clearRange = new ImageSubresourceRange(ImageAspectFlags.Color, 0, 1, 0, 1);
cmdBuffer.ClearColorImage(imageData.Image, ImageLayout.TransferDstOptimal, new ClearColorValue(), new[] { clearRange });
RenderTriangle(cmdBuffer, vertexData, renderPass, pipeline, framebuffer, width, height);
// Prepare the render target for copying
PipelineBarrierSetLayout(cmdBuffer, imageData.Image, ImageLayout.ColorAttachmentOptimal, ImageLayout.TransferSrcOptimal, AccessFlags.ColorAttachmentWrite, AccessFlags.TransferRead);
// Copy the render target image to a buffer
CopyImageToBuffer(cmdBuffer, imageData, imageBuffer, width, height);
// End recording commands to the buffer
cmdBuffer.End();
SubmitForExecution(queue, cmdBuffer);
queue.WaitIdle(); // wait for execution to finish
device.FreeCommandBuffers(cmdPool, new[] { cmdBuffer });
}
public DisposableRenderPass(Vk api, Device device, RenderPass renderPass)
{
_api = api;
_device = device;
Value = renderPass;
}
public EnvironmentCube(string cubemapPath, PipelineLayout plLayout, Queue staggingQ, RenderPass renderPass, PipelineCache cache = null)
: base(renderPass, cache, "EnvCube pipeline")
{
using (GraphicPipelineConfig cfg = GraphicPipelineConfig.CreateDefault(VkPrimitiveTopology.TriangleList, renderPass.Samples, false)) {
cfg.RenderPass = renderPass;
cfg.Layout = plLayout;
cfg.AddVertexBinding(0, 3 * sizeof(float));
cfg.AddVertexAttributes(0, VkFormat.R32g32b32Sfloat);
cfg.AddShaders(
new ShaderInfo(Dev, VkShaderStageFlags.Vertex, "#EnvironmentPipeline.skybox.vert.spv"),
new ShaderInfo(Dev, VkShaderStageFlags.Fragment, STR_FRAG_PATH)
);
cfg.multisampleState.rasterizationSamples = Samples;
layout = cfg.Layout;
init(cfg);
}
using (CommandPool cmdPool = new CommandPool(staggingQ.Dev, staggingQ.index)) {
vboSkybox = new GPUBuffer <float> (staggingQ, cmdPool, VkBufferUsageFlags.VertexBuffer, box_vertices);
cubemap = KTX.KTX.Load(staggingQ, cmdPool, cubemapPath,
VkImageUsageFlags.Sampled, VkMemoryPropertyFlags.DeviceLocal, true);
cubemap.CreateView(VkImageViewType.Cube, VkImageAspectFlags.Color);
cubemap.CreateSampler(VkSamplerAddressMode.ClampToEdge);
cubemap.SetName("skybox Texture");
cubemap.Descriptor.imageLayout = VkImageLayout.ShaderReadOnlyOptimal;
generateBRDFLUT(staggingQ, cmdPool);
generateCubemaps(staggingQ, cmdPool);
}
}
public override bool NeedsRenderPass(RenderPass pass)
{
return(true);
}
protected override void InitializePermanent()
{
_renderPass = ToDispose(CreateRenderPass());
_pipelineLayout = ToDispose(CreatePipelineLayout());
}
public override void Render(RenderPass pass, int pickingID, SceneWindow scene, float time)
{
terrainTimeSinceUpdate += time;
if (Modified && terrainTimeSinceUpdate > RenderSettings.MinimumTimeBetweenTerrainUpdated)
{
if (!terrainInProgress)
{
terrainInProgress = true;
ResetTerrain(false);
UpdateTerrain();
}
}
if (terrainTextureNeedsUpdate)
{
UpdateTerrainTexture();
}
if (terrainIndices == null || terrainVertices == null)
{
return;
}
GL.Color3(1f, 1f, 1f);
GL.EnableClientState(ArrayCap.VertexArray);
GL.EnableClientState(ArrayCap.TextureCoordArray);
GL.EnableClientState(ArrayCap.NormalArray);
if (pass == RenderPass.Picking)
{
GL.EnableClientState(ArrayCap.ColorArray);
GL.ShadeModel(ShadingModel.Flat);
}
if (terrainImage != null)
{
if (terrainTexture != -1)
{
GL.DeleteTexture(terrainTexture);
}
terrainTexture = RHelp.GLLoadImage(terrainImage, false);
terrainImage.Dispose();
terrainImage = null;
}
if (pass != RenderPass.Picking && terrainTexture != -1)
{
GL.Enable(EnableCap.Texture2D);
GL.BindTexture(TextureTarget.Texture2D, terrainTexture);
}
if (!RenderSettings.UseVBO || terrainVBOFailed)
{
unsafe
{
fixed(float *normalPtr = &terrainVertices[0].Vertex.Normal.X)
fixed(float *texPtr = &terrainVertices[0].Vertex.TexCoord.X)
fixed(byte *colorPtr = &terrainVertices[0].Color.R)
{
GL.NormalPointer(NormalPointerType.Float, ColorVertex.Size, (IntPtr)normalPtr);
GL.TexCoordPointer(2, TexCoordPointerType.Float, ColorVertex.Size, (IntPtr)texPtr);
GL.VertexPointer(3, VertexPointerType.Float, ColorVertex.Size, terrainVertices);
if (pass == RenderPass.Picking)
{
GL.ColorPointer(4, ColorPointerType.UnsignedByte, ColorVertex.Size, (IntPtr)colorPtr);
}
GL.DrawElements(PrimitiveType.Triangles, terrainIndices.Length, DrawElementsType.UnsignedInt, terrainIndices);
}
}
}
else
{
if (terrainVBO == -1)
{
Compat.GenBuffers(out terrainVBO);
Compat.BindBuffer(BufferTarget.ArrayBuffer, terrainVBO);
Compat.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(terrainVertices.Length * ColorVertex.Size), terrainVertices, BufferUsageHint.StaticDraw);
if (Compat.BufferSize(BufferTarget.ArrayBuffer) != terrainVertices.Length * ColorVertex.Size)
{
terrainVBOFailed = true;
Compat.BindBuffer(BufferTarget.ArrayBuffer, 0);
terrainVBO = -1;
}
}
else
{
Compat.BindBuffer(BufferTarget.ArrayBuffer, terrainVBO);
}
if (terrainIndexVBO == -1)
{
Compat.GenBuffers(out terrainIndexVBO);
Compat.BindBuffer(BufferTarget.ElementArrayBuffer, terrainIndexVBO);
Compat.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(terrainIndices.Length * sizeof(uint)), terrainIndices, BufferUsageHint.StaticDraw);
if (Compat.BufferSize(BufferTarget.ElementArrayBuffer) != terrainIndices.Length * sizeof(uint))
{
terrainVBOFailed = true;
Compat.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
terrainIndexVBO = -1;
}
}
else
{
Compat.BindBuffer(BufferTarget.ElementArrayBuffer, terrainIndexVBO);
}
if (!terrainVBOFailed)
{
GL.NormalPointer(NormalPointerType.Float, ColorVertex.Size, (IntPtr)12);
GL.TexCoordPointer(2, TexCoordPointerType.Float, ColorVertex.Size, (IntPtr)(24));
if (pass == RenderPass.Picking)
{
GL.ColorPointer(4, ColorPointerType.UnsignedByte, ColorVertex.Size, (IntPtr)32);
}
GL.VertexPointer(3, VertexPointerType.Float, ColorVertex.Size, (IntPtr)(0));
GL.DrawElements(PrimitiveType.Triangles, terrainIndices.Length, DrawElementsType.UnsignedInt, IntPtr.Zero);
}
Compat.BindBuffer(BufferTarget.ArrayBuffer, 0);
Compat.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
}
if (pass == RenderPass.Picking)
{
GL.DisableClientState(ArrayCap.ColorArray);
GL.ShadeModel(ShadingModel.Smooth);
}
else
{
GL.BindTexture(TextureTarget.Texture2D, 0);
}
GL.DisableClientState(ArrayCap.VertexArray);
GL.DisableClientState(ArrayCap.TextureCoordArray);
GL.DisableClientState(ArrayCap.NormalArray);
}
/// <summary>
/// Render scene object
/// </summary>
/// <param name="pass">Which pass are we currently in</param>
/// <param name="pickingID">ID used to identify which object was picked</param>
/// <param name="scene">Main scene renderer</param>
/// <param name="time">Time it took to render the last frame</param>
public virtual void Render(RenderPass pass, int pickingID, SceneWindow scene, float time)
{
}
private void RenderObjects(RenderPass pass)
{
if (!PrimitiveRenderingEnabled) return;
GL.EnableClientState(ArrayCap.VertexArray);
GL.EnableClientState(ArrayCap.TextureCoordArray);
GL.EnableClientState(ArrayCap.NormalArray);
Vector3 myPos = Vector3.Zero;
RenderAvatar me;
if (Avatars.TryGetValue(Client.Self.LocalID, out me))
{
myPos = me.RenderPosition;
}
else
{
myPos = Client.Self.SimPosition;
}
int nrPrims = SortedObjects.Count;
for (int i = 0; i < nrPrims; i++)
{
//RenderBoundingBox(SortedPrims[i]);
// When rendering alpha faces, draw from back towards the camers
// otherwise from those closest to camera, to the farthest
int ix = pass == RenderPass.Alpha ? nrPrims - i - 1 : i;
SceneObject obj = SortedObjects[ix];
if (obj is RenderPrimitive)
{
// Don't render objects that are outside the draw distane
if (Vector3.DistanceSquared(myPos, obj.RenderPosition) > drawDistanceSquared) continue;
obj.StartQuery(pass);
RenderPrim((RenderPrimitive)obj, pass, ix);
obj.EndQuery(pass);
}
}
GL.Disable(EnableCap.Texture2D);
GL.DisableClientState(ArrayCap.VertexArray);
GL.DisableClientState(ArrayCap.TextureCoordArray);
GL.DisableClientState(ArrayCap.NormalArray);
}
private void RenderObjects(RenderPass pass)
{
lock (Prims)
{
int primNr = 0;
foreach (FacetedMesh mesh in Prims.Values)
{
primNr++;
Primitive prim = mesh.Prim;
// Individual prim matrix
GL.PushMatrix();
if (prim.ParentID == RootPrimLocalID)
{
FacetedMesh parent = null;
if (Prims.TryGetValue(prim.ParentID, out parent))
{
// Apply prim translation and rotation relative to the root prim
GL.MultMatrix(Math3D.CreateRotationMatrix(parent.Prim.Rotation));
//GL.MultMatrixf(Math3D.CreateTranslationMatrix(parent.Prim.Position));
}
// Prim roation relative to root
GL.MultMatrix(Math3D.CreateTranslationMatrix(prim.Position));
}
// Prim roation
GL.MultMatrix(Math3D.CreateRotationMatrix(prim.Rotation));
// Prim scaling
GL.Scale(prim.Scale.X, prim.Scale.Y, prim.Scale.Z);
// Draw the prim faces
for (int j = 0; j < mesh.Faces.Count; j++)
{
Primitive.TextureEntryFace teFace = mesh.Prim.Textures.FaceTextures[j];
Face face = mesh.Faces[j];
FaceData data = (FaceData)face.UserData;
if (teFace == null)
{
teFace = mesh.Prim.Textures.DefaultTexture;
}
if (pass == RenderPass.Picking)
{
data.PickingID = primNr;
var primNrBytes = Utils.Int16ToBytes((short)primNr);
var faceColor = new byte[] { primNrBytes[0], primNrBytes[1], (byte)j, 255 };
GL.Color4(faceColor);
}
else
{
bool belongToAlphaPass = (teFace.RGBA.A < 0.99) || data.TextureInfo.HasAlpha;
if (belongToAlphaPass && pass != RenderPass.Alpha)
{
continue;
}
if (!belongToAlphaPass && pass == RenderPass.Alpha)
{
continue;
}
// Don't render transparent faces
if (teFace.RGBA.A <= 0.01f)
{
continue;
}
switch (teFace.Shiny)
{
case Shininess.High:
GL.Material(MaterialFace.Front, MaterialParameter.Shininess, 94f);
break;
case Shininess.Medium:
GL.Material(MaterialFace.Front, MaterialParameter.Shininess, 64f);
break;
case Shininess.Low:
GL.Material(MaterialFace.Front, MaterialParameter.Shininess, 24f);
break;
case Shininess.None:
default:
GL.Material(MaterialFace.Front, MaterialParameter.Shininess, 0f);
break;
}
var faceColor = new float[] { teFace.RGBA.R, teFace.RGBA.G, teFace.RGBA.B, teFace.RGBA.A };
GL.Color4(faceColor);
GL.Material(MaterialFace.Front, MaterialParameter.AmbientAndDiffuse, faceColor);
GL.Material(MaterialFace.Front, MaterialParameter.Specular, faceColor);
if (data.TextureInfo.TexturePointer != 0)
{
GL.Enable(EnableCap.Texture2D);
}
else
{
GL.Disable(EnableCap.Texture2D);
}
// Bind the texture
GL.BindTexture(TextureTarget.Texture2D, data.TextureInfo.TexturePointer);
}
GL.TexCoordPointer(2, TexCoordPointerType.Float, 0, data.TexCoords);
GL.VertexPointer(3, VertexPointerType.Float, 0, data.Vertices);
GL.NormalPointer(NormalPointerType.Float, 0, data.Normals);
GL.DrawElements(PrimitiveType.Triangles, data.Indices.Length, DrawElementsType.UnsignedShort, data.Indices);
}
// Pop the prim matrix
GL.PopMatrix();
}
}
}
/// <summary>
/// Executes the draw calls.
/// </summary>
/// <param name="context">The GPU command context.</param>
/// <param name="task">The render task.</param>
/// <param name="output">The output texture.</param>
/// <param name="pass">The rendering pass mode.</param>
public void ExecuteDrawCalls(GPUContext context, RenderTask task, RenderTarget output, RenderPass pass)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
GPUContext.Internal_ExecuteDrawCalls(context.unmanagedPtr, task.unmanagedPtr, output.unmanagedPtr, DrawCalls, pass);
}
protected abstract void Render(T scene, RenderPass pass);
private void RenderAvatarsSkeleton(RenderPass pass)
{
if (!RenderSettings.RenderAvatarSkeleton) return;
lock (Avatars)
{
foreach (RenderAvatar av in Avatars.Values)
{
// Individual prim matrix
GL.PushMatrix();
// Prim roation and position
Vector3 pos = av.avatar.Position;
Vector3 avataroffset = av.glavatar.skel.getOffset("mPelvis");
GL.MultMatrix(Math3D.CreateSRTMatrix(new Vector3(1, 1, 1), av.RenderRotation, av.RenderPosition - avataroffset * av.RenderRotation));
GL.Begin(BeginMode.Lines);
GL.Color3(1.0, 0.0, 0.0);
foreach (Bone b in av.glavatar.skel.mBones.Values)
{
Vector3 newpos = b.getTotalOffset();
if (b.parent != null)
{
Vector3 parentpos = b.parent.getTotalOffset();
GL.Vertex3(parentpos.X, parentpos.Y, parentpos.Z);
}
else
{
GL.Vertex3(newpos.X, newpos.Y, newpos.Z);
}
GL.Vertex3(newpos.X, newpos.Y, newpos.Z);
//Mark the joints
newpos.X += 0.01f;
newpos.Y += 0.01f;
newpos.Z += 0.01f;
GL.Vertex3(newpos.X, newpos.Y, newpos.Z);
newpos.X -= 0.02f;
GL.Vertex3(newpos.X, newpos.Y, newpos.Z);
GL.Vertex3(newpos.X, newpos.Y, newpos.Z);
newpos.Y -= 0.02f;
GL.Vertex3(newpos.X, newpos.Y, newpos.Z);
GL.Vertex3(newpos.X, newpos.Y, newpos.Z);
newpos.X += 0.02f;
GL.Vertex3(newpos.X, newpos.Y, newpos.Z);
GL.Vertex3(newpos.X, newpos.Y, newpos.Z);
newpos.Y += 0.02f;
GL.Vertex3(newpos.X, newpos.Y, newpos.Z);
GL.Vertex3(newpos.X, newpos.Y, newpos.Z);
newpos.Z -= 0.02f;
GL.Vertex3(newpos.X, newpos.Y, newpos.Z);
GL.Vertex3(newpos.X, newpos.Y, newpos.Z);
newpos.Y -= 0.02f;
GL.Vertex3(newpos.X, newpos.Y, newpos.Z);
GL.Vertex3(newpos.X, newpos.Y, newpos.Z);
newpos.X -= 0.02f;
GL.Vertex3(newpos.X, newpos.Y, newpos.Z);
GL.Vertex3(newpos.X, newpos.Y, newpos.Z);
newpos.Y += 0.02f;
GL.Vertex3(newpos.X, newpos.Y, newpos.Z);
GL.Vertex3(newpos.X, newpos.Y, newpos.Z);
newpos.X += 0.02f;
GL.Vertex3(newpos.X, newpos.Y, newpos.Z);
GL.Vertex3(newpos.X, newpos.Y, newpos.Z);
newpos.Y -= 0.01f;
newpos.Z += 0.01f;
newpos.X -= 0.01f;
GL.Vertex3(newpos.X, newpos.Y, newpos.Z);
}
GL.Color3(0.0, 1.0, 0.0);
GL.End();
GL.PopMatrix();
}
}
}
public LightShaftsProcessor(MainPlugin mainPlugin, RenderTargetsPlugin mainTargetPlugin, RenderPass lightShaftsPass)
: base(new PropertyKey[] { LightShaftsComponent.Key, LightComponent.Key })
{
this.mainPlugin = mainPlugin;
this.mainTargetPlugin = mainTargetPlugin;
this.lightShaftsPass = lightShaftsPass;
}
internal void addPass(RenderPass renderModel)
{
throw new NotImplementedException();
}
public void Draw(ModelEffectInstance modelEffect, RenderPass pass)
{
// Draw the geometry for the current pass
var geometry = m_geometry[(int)pass];
if (geometry.IndexCount > 0)
{
modelEffect.ModelMatrix = Matrix4.Identity;
modelEffect.UVOffset = Vector2.Zero;
modelEffect.UVScale = Vector2.One;
modelEffect.DiffuseColour = Vector4.One;
modelEffect.DiffuseTexture = m_atlas;
modelEffect.SpecularColour = Vector3.One;
modelEffect.SpecularTexture = m_atlas;
modelEffect.NormalTexture = m_atlas;
modelEffect.EmissiveColour = Vector3.One;
modelEffect.EmissiveTexture = m_atlas;
modelEffect.Bind();
geometry.Draw();
/*
* // Wireframe test code
* modelEffect.ModelMatrix = Matrix4.Identity;
* modelEffect.DiffuseColour = Vector4.One;
* modelEffect.DiffuseTexture = Texture.White;
* modelEffect.SpecularColour = Vector3.One;
* modelEffect.SpecularTexture = Texture.White;
* modelEffect.NormalTexture = Texture.Flat;
* modelEffect.Bind();
* using( var wireframe = geometry.ToWireframe( lines:false, normals:true, tangents:true, binormals:true ) )
* {
* wireframe.Draw();
* }
*/
}
foreach (var pair in m_liquidGeometry)
{
var behaviour = pair.Key;
var liquidGeometry = pair.Value;
if (liquidGeometry.IndexCount > 0 && behaviour.Tile.RenderPass == pass)
{
bool visible;
Matrix4 modelMatrix;
Vector2 uvOffset, uvScale;
Vector4 colour;
if (behaviour.Animation != null)
{
float cameraFOV;
var anim = LuaAnimation.Get(behaviour.Animation);
anim.Animate("Liquid", m_level.TimeMachine.RealTime, out visible, out modelMatrix, out uvOffset, out uvScale, out colour, out cameraFOV);
}
else
{
visible = true;
modelMatrix = Matrix4.Identity;
uvOffset = Vector2.Zero;
uvScale = Vector2.One;
colour = Vector4.One;
}
if (visible)
{
var surface = Texture.Get(behaviour.Texture, false);
surface.Wrap = true;
modelEffect.ModelMatrix = modelMatrix;
modelEffect.UVOffset = uvOffset;
modelEffect.UVScale = uvScale;
modelEffect.DiffuseColour = colour;
modelEffect.DiffuseTexture = surface;
modelEffect.SpecularColour = Vector3.One;
modelEffect.SpecularTexture = Texture.Black;
modelEffect.NormalTexture = Texture.Flat;
modelEffect.EmissiveColour = Vector3.One;
modelEffect.EmissiveTexture = Texture.Black;
modelEffect.Bind();
liquidGeometry.Draw();
}
}
}
}
public override void Render(Shader shader, RenderPass pass, bool frontPass)
{
bool alphaPass = pass == RenderPass.Alpha;
// Set global uniforms
if (!pass.HasFlag(RenderPass.Shadow))
{
shader.LoadFloat("specularPower", 0);
shader.LoadFloat("specularIntensity", 0);
}
// Render Entities
if (!frontPass)
{
foreach (BatchGroup <VoxelObject, BatchedEntity> pair in entityBatch)
{
RenderEntityList(shader, pass, pair.List, pair.Key);
}
}
else
{
RenderEntityList(shader, pass, entityBatch.UnoptimizedBatch);
}
if (!pass.HasFlag(RenderPass.Shadow))
{
shader.LoadBool("skipLight", false);
shader.LoadColor4("colorOverlay", Color.White);
shader.LoadFloat("entityLighting", 1f);
}
StateManager.DepthFunc(DepthFunction.Less);
StateManager.DisableWireframe();
// Render raw voxel objects
if (!frontPass)
{
foreach (BatchGroup <VoxelObject, Matrix4> pair in rawBatch)
{
if (alphaPass && pair.Key.AlphaMesh == null)
{
continue;
}
Mesh mesh = alphaPass ? pair.Key.AlphaMesh : pair.Key.Mesh;
Master.PrepareMesh(mesh, pass);
foreach (Matrix4 transMatrix in pair.List)
{
// Load the transformation matrix
shader.LoadMatrix4("transformationMatrix", transMatrix);
// Draw
GL.DrawElements(mesh.BeginMode, mesh.VertexCount, DrawElementsType.UnsignedInt, IntPtr.Zero);
}
Master.EndMesh();
}
}
else
{
//StateManager.DepthFunc(DepthFunction.Always);
foreach (BatchGroup <VoxelObject, Matrix4> pair in rawBatchFront)
{
if (alphaPass && pair.Key.AlphaMesh == null)
{
continue;
}
Mesh mesh = alphaPass ? pair.Key.AlphaMesh : pair.Key.Mesh;
Master.PrepareMesh(mesh, pass);
foreach (Matrix4 transMatrix in pair.List)
{
// Load the transformation matrix
shader.LoadMatrix4("transformationMatrix", transMatrix);
// Draw
GL.DrawElements(mesh.BeginMode, mesh.VertexCount, DrawElementsType.UnsignedInt, IntPtr.Zero);
}
Master.EndMesh();
}
// StateManager.DepthFunc(DepthFunction.Less);
}
}
public void StartQuery(RenderPass pass)
{
if (!RenderSettings.OcclusionCullingEnabled) return;
if (pass == RenderPass.Simple)
{
StartSimpleQuery();
}
else if (pass == RenderPass.Alpha)
{
StartAlphaQuery();
}
}
public override bool NeedsRenderPass(RenderPass pass)
{
return(pass == m_renderPass);
}
public override void Load()
{
base.Load();
if (string.IsNullOrEmpty(StructureName) || StructureSize == 0)
throw new InvalidOperationException("StructureName and StructureSize must be setup on ParticlePlugin");
// Add passes to the render pass
RenderPass.AddPass(updatePasses, copyPass, sortPass, renderPass);
// Create effect to copy from particle buffer to sort buffer
effectCopyToSortBuffer = this.EffectSystemOld.BuildEffect("CopyToSortBuffer").Using(
new ComputeShaderPlugin(new ShaderClassSource("ParticleSortInitializer"), MaximumThreadPerGroup, 1, 1)
{
RenderPass = copyPass,
Macros = { new ShaderMacro("PARTICLE_STRUCT", StructureName) }
});
effectCopyToSortBuffer.KeepAliveBy(ActiveObjects);
effectCopyToSortBuffer.Parameters.AddSources(MainPlugin.ViewParameters);
effectMeshCopyToSortBuffer = new EffectMesh(effectCopyToSortBuffer);
// Clear the sort buffer
copyPass.StartPass.AddFirst = (context) =>
{
if (CapacityCount > 0)
{
// TODO handle progressive sorting
context.GraphicsDevice.ClearReadWrite(sortBuffer, new UInt4(0xFF7FFFFF)); // 0xFF7FFFFF = - float.MaxValue
}
};
// Create effect for bitonic sort 1 - pass 1
effectBitonicSort1Pass1 = this.EffectSystemOld.BuildEffect("ParticleBitonicSort1-Pass1").Using(
new ComputeShaderPlugin(new ShaderClassSource("ParticleBitonicSort1"), MaximumThreadPerGroup, 1, 1)
{
RenderPass = bitonicSort1Pass1,
Macros = { new ShaderMacro("PARTICLE_STRUCT", StructureName),
new ShaderMacro("PARTICLE_SORT_PASS", 0)
}
});
effectBitonicSort1Pass1.KeepAliveBy(this);
effectMeshSort1Pass1 = new EffectMesh(effectBitonicSort1Pass1);
// Create effect for bitonic sort 1 - pass 2
effectBitonicSort1Pass2 = this.EffectSystemOld.BuildEffect("ParticleBitonicSort1-Pass2").Using(
new ComputeShaderPlugin(new ShaderClassSource("ParticleBitonicSort1"), MaximumThreadPerGroup, 1, 1)
{
RenderPass = bitonicSort1Pass2,
Macros = { new ShaderMacro("PARTICLE_STRUCT", StructureName),
new ShaderMacro("PARTICLE_SORT_PASS", 1)
}
});
effectBitonicSort1Pass2.KeepAliveBy(this);
effectMeshSort1Pass2 = new EffectMesh(effectBitonicSort1Pass2);
// Creates Effect for bitonic sort 2
var currentDepth = MaximumDepthLevel;
for (int i = 0; i < bitonicSort2Passes.Length; i++)
{
var bitonicShader = new RenderPass(string.Format("Bitonic-{0}", currentDepth));
bitonicSort2Passes[i] = bitonicShader;
// Compile the new shader for this count
effectBitonicSort2[i] = this.EffectSystemOld.BuildEffect("ParticleBitonicSort2-" + currentDepth).Using(
new ComputeShaderPlugin(new ShaderClassSource("ParticleBitonicSort2", currentDepth), MaximumThreadPerGroup, 1, 1)
{
RenderPass = bitonicShader,
Macros = { new ShaderMacro("PARTICLE_STRUCT", StructureName) }
});
effectBitonicSort2[i].KeepAliveBy(this);
currentDepth /= 2;
}
effectMeshBitonicSort2 = new EffectMesh[bitonicSort2Passes.Length];
for (int i = 0; i < effectMeshBitonicSort2.Length; i++)
effectMeshBitonicSort2[i] = new EffectMesh(effectBitonicSort2[i]);
// Creates Effect for rendering
EffectOld particleRenderEffect = this.EffectSystemOld.BuildEffect("ParticleRender")
.Using(new StateShaderPlugin() { UseBlendState = true, UseDepthStencilState = true, RenderPass = renderPass })
.Using(new BasicShaderPlugin(RenderShader)
{
RenderPass = renderPass,
Macros = { new ShaderMacro("PARTICLE_STRUCT", StructureName) }
});
particleRenderEffect.KeepAliveBy(this);
particleRenderEffect.Parameters.AddSources(this.Parameters);
particleRenderEffect.Parameters.AddSources(MainPlugin.ViewParameters);
particleRenderEffect.Parameters.Set(EffectPlugin.BlendStateKey, graphicsDeviceService.GraphicsDevice.BlendStates.AlphaBlend);
particleRenderEffect.Parameters.Set(EffectPlugin.DepthStencilStateKey, MainTargetPlugin.DepthStencilState);
particleRenderEffect.Parameters.Set(RenderTargetKeys.DepthStencilSource, MainTargetPlugin.DepthStencil.Texture);
effectMeshRender = new EffectMesh(particleRenderEffect);
effectMeshRender.Render += (context) =>
{
if (currentParticleCount > 0)
{
context.GraphicsDevice.SetVertexArrayObject(null);
context.GraphicsDevice.SetViewport(MainTargetPlugin.Viewport);
//context.GraphicsDevice.SetRenderTargets(MainTargetPlugin.DepthStencil, 0, MainTargetPlugin.RenderTarget);
context.GraphicsDevice.SetRenderTargets((MainTargetPlugin.DepthStencilReadOnly != null) ? MainTargetPlugin.DepthStencilReadOnly : MainTargetPlugin.DepthStencil, RenderTarget);
// TODO HANDLE dynamic count
//context.GraphicsDevice.Draw(PrimitiveType.PointList, CapacityCount);
context.GraphicsDevice.Draw(PrimitiveType.PointList, currentParticleCount);
}
//context.GraphicsDevice.SetRenderTargets(null, 0, new ITexture2D[] { null } );
};
if (OfflineCompilation)
return;
// Allocate global buffers at register time
// Buffers can also be reallocated at runtime
OnCapacityCountChange();
// Add our local meshes to render RenderContext.RenderPassEnumerators
RenderSystem.RenderPassEnumerators.Add(meshesToRender);
// Register update per frame
RenderSystem.GlobalPass.StartPass += OnFrameUpdate;
// Register sort pass
sortPass.EndPass.Set = ComputeBitonicSort;
}
public void CmdDraw()
{
var renderPassCreateInfo = new RenderPassCreateInfo(
new[] { new SubpassDescription(new[] { new AttachmentReference(0, ImageLayout.ColorAttachmentOptimal) }) },
new[]
{
new AttachmentDescription
{
Format = Format.B8G8R8A8UNorm,
Samples = SampleCounts.Count1,
FinalLayout = ImageLayout.ColorAttachmentOptimal,
LoadOp = AttachmentLoadOp.DontCare
}
});
var imageCreateInfo = new ImageCreateInfo
{
Usage = ImageUsages.ColorAttachment,
Format = Format.B8G8R8A8UNorm,
Extent = new Extent3D(2, 2, 1),
ImageType = ImageType.Image2D,
MipLevels = 1,
ArrayLayers = 1,
Samples = SampleCounts.Count1
};
var imageViewCreateInfo = new ImageViewCreateInfo(
Format.B8G8R8A8UNorm,
new ImageSubresourceRange(ImageAspects.Color, 0, 1, 0, 1));
using (ShaderModule vertexShader = Device.CreateShaderModule(new ShaderModuleCreateInfo(ReadAllBytes("Shader.vert.spv"))))
using (ShaderModule fragmentShader = Device.CreateShaderModule(new ShaderModuleCreateInfo(ReadAllBytes("Shader.frag.spv"))))
using (PipelineLayout pipelineLayout = Device.CreatePipelineLayout())
using (RenderPass renderPass = Device.CreateRenderPass(renderPassCreateInfo))
using (Image image = Device.CreateImage(imageCreateInfo))
{
MemoryRequirements imageMemReq = image.GetMemoryRequirements();
int memTypeIndex = PhysicalDeviceMemoryProperties.MemoryTypes.IndexOf(imageMemReq.MemoryTypeBits, MemoryProperties.DeviceLocal);
using (DeviceMemory imageMemory = Device.AllocateMemory(new MemoryAllocateInfo(imageMemReq.Size, memTypeIndex)))
{
image.BindMemory(imageMemory);
using (ImageView imageView = image.CreateView(imageViewCreateInfo))
using (Framebuffer framebuffer = renderPass.CreateFramebuffer(new FramebufferCreateInfo(new[] { imageView }, 2, 2)))
using (Pipeline pipeline = Device.CreateGraphicsPipeline(new GraphicsPipelineCreateInfo(
pipelineLayout,
renderPass,
0,
new[]
{
new PipelineShaderStageCreateInfo(ShaderStages.Vertex, vertexShader, "main"),
new PipelineShaderStageCreateInfo(ShaderStages.Fragment, fragmentShader, "main")
},
new PipelineInputAssemblyStateCreateInfo(),
new PipelineVertexInputStateCreateInfo(),
new PipelineRasterizationStateCreateInfo {
RasterizerDiscardEnable = true, LineWidth = 1.0f
})))
{
CommandBuffer.Begin();
CommandBuffer.CmdBeginRenderPass(new RenderPassBeginInfo(framebuffer, new Rect2D(0, 0, 2, 2)));
CommandBuffer.CmdBindPipeline(PipelineBindPoint.Graphics, pipeline);
CommandBuffer.CmdDraw(3);
CommandBuffer.CmdEndRenderPass();
CommandBuffer.End();
}
}
}
}
public override void Unload()
{
GBufferPlugin.MainPlugin.RenderPass.RemovePass(debugRenderPass);
debugRenderPass = null;
base.Unload();
}
public void Initialize(EngineContext engineContext)
{
var renderContext = engineContext.RenderContext;
var rootRenderPass = renderContext.RootRenderPass;
var linearColorPass = new RenderPass("LinearColor");
var reinhardColorPass = new RenderPass("ReinhardColor");
var yebisPass = new RenderPass("YebisColor");
var filmicColorPass = new RenderPass("FilmicColor");
var composeColorPass = new RenderPass("ComposeColor");
rootRenderPass.AddPass(linearColorPass);
rootRenderPass.AddPass(reinhardColorPass);
rootRenderPass.AddPass(yebisPass);
rootRenderPass.AddPass(filmicColorPass);
rootRenderPass.AddPass(composeColorPass);
LinearColorPlugin = new PostEffectPlugin("LinearColor") { RenderPass = linearColorPass };
ReinhardColorPlugin = new PostEffectPlugin("ReinhardColor") { RenderPass = reinhardColorPass };
#if PARADOX_YEBIS
YebisPlugin = new YebisPlugin("ReinhardColor") { RenderPass = yebisPass };
#endif
FilmicColorPlugin = new PostEffectPlugin("FilmicColor") { RenderPass = filmicColorPass };
MainPlugin = new PostEffectPlugin("MainColor") { RenderPass = composeColorPass };
//MainDepthReadOnlyPlugin
// YebisPlugin = new YebisPlugin() { RenderPass = yebisColorPass, MainDepthReadOnlyPlugin = null };
//renderContext.Register(MainDepthReadOnlyPlugin);
//renderContext.Register(SkyBoxPlugin);
//renderContext.Register(PostEffectPlugin);
//// Create and bind depth stencil buffer
//renderContext.GraphicsResizeContext.SetupResize(
// (resizeContext) =>
// {
// MainDepthReadOnlyPlugin.DepthStencil = renderContext.GraphicsDevice.DepthStencilBuffer.New(DepthFormat.Depth32, renderContext.Width, renderContext.Height, true, "MainDepthBuffer");
// // Bind render target - comment when Yebis is off
// MainDepthReadOnlyPlugin.RenderTarget = renderContext.GraphicsDevice.RenderTarget2D.New(renderContext.Width, renderContext.Height, PixelFormat.HalfVector4, name: "MainRenderTarget");
// // Comment - when Yebis is on
// //MainDepthReadOnlyPlugin.RenderTarget = renderContext.GraphicsDevice.RenderTarget2D.New(renderContext.Width, renderContext.Height, PixelFormat.R8G8B8A8, name: "MainRenderTarget");
// //renderContext.GlobalPass.EndPass.AddFirst = threadContext => threadContext.GraphicsDevice.Copy(MainDepthReadOnlyPlugin.RenderTarget, engineContext.RenderContext.RenderTarget);
// });
//// Yebis plugin must be initialized after creating MainDepthReadOnlyPlugin.RenderTarget
//renderContext.Register(YebisPlugin);
//YebisPlugin.ToneMap.Gamma = 1.0f;
//YebisPlugin.ToneMap.Type = ToneMapType.Auto;
//YebisPlugin.ToneMap.AutoExposure.MiddleGray = 0.25f;
//YebisPlugin.ToneMap.AutoExposure.AdaptationSensitivity = 0.5f;
//YebisPlugin.ToneMap.AutoExposure.AdaptationScale = 0.8f;
//YebisPlugin.ToneMap.AutoExposure.AdaptationSpeedLimit = 4.0f;
//YebisPlugin.ToneMap.AutoExposure.DarkAdaptationSensitivity = 0.9f;
//YebisPlugin.ToneMap.AutoExposure.DarkAdaptationScale = 0.6f;
//YebisPlugin.ToneMap.AutoExposure.DarkAdaptationSpeedLimit = 4.0f;
//YebisPlugin.ToneMap.AutoExposure.LightDarkExposureBorder = 1.0f;
//YebisPlugin.Glare.Enable = true;
//YebisPlugin.Glare.RemapFactor = 1f;
//YebisPlugin.Glare.Threshold = 0f;
//YebisPlugin.Lens.Vignette.Enable = true;
//YebisPlugin.ColorCorrection.ColorTemperature = 3500;
}
void init_renderpass()
{
renderPass = new RenderPass(dev, NUM_SAMPLES);
renderPass.AddAttachment(HDR_FORMAT, VkImageLayout.ShaderReadOnlyOptimal, NUM_SAMPLES); //final outpout
renderPass.AddAttachment(dev.GetSuitableDepthFormat(), VkImageLayout.DepthStencilAttachmentOptimal, NUM_SAMPLES);
renderPass.AddAttachment(VkFormat.R8g8b8a8Unorm, VkImageLayout.ColorAttachmentOptimal, NUM_SAMPLES, VkAttachmentLoadOp.Clear, VkAttachmentStoreOp.DontCare); //GBuff0 (color + roughness) and final color before resolve
renderPass.AddAttachment(VkFormat.R8g8b8a8Unorm, VkImageLayout.ColorAttachmentOptimal, NUM_SAMPLES, VkAttachmentLoadOp.Clear, VkAttachmentStoreOp.DontCare); //GBuff1 (emit + metal)
renderPass.AddAttachment(MRT_FORMAT, VkImageLayout.ColorAttachmentOptimal, NUM_SAMPLES, VkAttachmentLoadOp.Clear, VkAttachmentStoreOp.DontCare); //GBuff2 (normals + AO)
renderPass.AddAttachment(MRT_FORMAT, VkImageLayout.ColorAttachmentOptimal, NUM_SAMPLES, VkAttachmentLoadOp.Clear, VkAttachmentStoreOp.DontCare); //GBuff3 (Pos + depth)
renderPass.ClearValues.Add(new VkClearValue {
color = new VkClearColorValue(0.0f, 0.0f, 0.0f)
});
renderPass.ClearValues.Add(new VkClearValue {
depthStencil = new VkClearDepthStencilValue(1.0f, 0)
});
renderPass.ClearValues.Add(new VkClearValue {
color = new VkClearColorValue(0.0f, 0.0f, 0.0f)
});
renderPass.ClearValues.Add(new VkClearValue {
color = new VkClearColorValue(0.0f, 0.0f, 0.0f)
});
renderPass.ClearValues.Add(new VkClearValue {
color = new VkClearColorValue(0.0f, 0.0f, 0.0f)
});
renderPass.ClearValues.Add(new VkClearValue {
color = new VkClearColorValue(0.0f, 0.0f, 0.0f)
});
SubPass[] subpass = { new SubPass(), new SubPass(), new SubPass() };
//skybox
subpass[SP_SKYBOX].AddColorReference(0, VkImageLayout.ColorAttachmentOptimal);
//models
subpass[SP_MODELS].AddColorReference(new VkAttachmentReference(2, VkImageLayout.ColorAttachmentOptimal),
new VkAttachmentReference(3, VkImageLayout.ColorAttachmentOptimal),
new VkAttachmentReference(4, VkImageLayout.ColorAttachmentOptimal),
new VkAttachmentReference(5, VkImageLayout.ColorAttachmentOptimal));
subpass[SP_MODELS].SetDepthReference(1, VkImageLayout.DepthStencilAttachmentOptimal);
subpass[SP_MODELS].AddPreservedReference(0);
//compose
subpass[SP_COMPOSE].AddColorReference(0, VkImageLayout.ColorAttachmentOptimal);
subpass[SP_COMPOSE].AddInputReference(new VkAttachmentReference(2, VkImageLayout.ShaderReadOnlyOptimal),
new VkAttachmentReference(3, VkImageLayout.ShaderReadOnlyOptimal),
new VkAttachmentReference(4, VkImageLayout.ShaderReadOnlyOptimal),
new VkAttachmentReference(5, VkImageLayout.ShaderReadOnlyOptimal));
//tone mapping
//subpass[SP_TONE_MAPPING].AddColorReference ((NUM_SAMPLES == VkSampleCountFlags.SampleCount1) ? 0u : 2u, VkImageLayout.ColorAttachmentOptimal);
//subpass[SP_TONE_MAPPING].AddInputReference (new VkAttachmentReference (6, VkImageLayout.ShaderReadOnlyOptimal));
//if (NUM_SAMPLES != VkSampleCountFlags.SampleCount1)
//subpass[SP_TONE_MAPPING].AddResolveReference (0, VkImageLayout.ColorAttachmentOptimal);
renderPass.AddSubpass(subpass);
renderPass.AddDependency(Vk.SubpassExternal, SP_SKYBOX,
VkPipelineStageFlags.BottomOfPipe, VkPipelineStageFlags.ColorAttachmentOutput,
VkAccessFlags.MemoryRead, VkAccessFlags.ColorAttachmentRead | VkAccessFlags.ColorAttachmentWrite);
renderPass.AddDependency(SP_SKYBOX, SP_MODELS,
VkPipelineStageFlags.ColorAttachmentOutput, VkPipelineStageFlags.FragmentShader,
VkAccessFlags.ColorAttachmentWrite, VkAccessFlags.ShaderRead);
renderPass.AddDependency(SP_MODELS, SP_COMPOSE,
VkPipelineStageFlags.ColorAttachmentOutput, VkPipelineStageFlags.FragmentShader,
VkAccessFlags.ColorAttachmentWrite, VkAccessFlags.ShaderRead);
//renderPass.AddDependency (SP_COMPOSE, Vk.SubpassExternal,
//VkPipelineStageFlags.ColorAttachmentOutput, VkPipelineStageFlags.Transfer,
//VkAccessFlags.ColorAttachmentWrite, VkAccessFlags.TransferRead);
//renderPass.AddDependency (SP_COMPOSE, SP_COMPOSE,
//VkPipelineStageFlags.Transfer, VkPipelineStageFlags.ComputeShader,
//VkAccessFlags.TransferWrite, VkAccessFlags.ShaderRead);
//renderPass.AddDependency (Vk.SubpassExternal, SP_TONE_MAPPING,
// VkPipelineStageFlags.ComputeShader, VkPipelineStageFlags.FragmentShader,
// VkAccessFlags.ShaderWrite, VkAccessFlags.ShaderRead);
//renderPass.AddDependency (SP_SKYBOX, SP_TONE_MAPPING,
//VkPipelineStageFlags.ColorAttachmentOutput, VkPipelineStageFlags.FragmentShader,
//VkAccessFlags.ColorAttachmentWrite, VkAccessFlags.ShaderRead);
renderPass.AddDependency(SP_COMPOSE, Vk.SubpassExternal,
VkPipelineStageFlags.ColorAttachmentOutput, VkPipelineStageFlags.Transfer,
VkAccessFlags.ColorAttachmentRead | VkAccessFlags.ColorAttachmentWrite, VkAccessFlags.TransferRead);
//renderPass.AddDependency (SP_TONE_MAPPING, Vk.SubpassExternal,
//VkPipelineStageFlags.ColorAttachmentOutput, VkPipelineStageFlags.BottomOfPipe,
//VkAccessFlags.ColorAttachmentRead | VkAccessFlags.ColorAttachmentWrite, VkAccessFlags.MemoryRead);
}
void RenderPrim(RenderPrimitive mesh, RenderPass pass, int primNr)
{
if (!AvatarRenderingEnabled && mesh.Attached) return;
Primitive prim = mesh.Prim;
// Individual prim matrix
GL.PushMatrix();
// Prim roation and position and scale
GL.MultMatrix(Math3D.CreateSRTMatrix(prim.Scale, mesh.RenderRotation, mesh.RenderPosition));
// Do we have animated texture on this face
bool animatedTexture = false;
// Initialise flags tracking what type of faces this prim has
if (pass == RenderPass.Simple)
{
mesh.HasSimpleFaces = false;
}
else if (pass == RenderPass.Alpha)
{
mesh.HasAlphaFaces = false;
}
// Draw the prim faces
for (int j = 0; j < mesh.Faces.Count; j++)
{
Primitive.TextureEntryFace teFace = mesh.Prim.Textures.GetFace((uint)j);
Face face = mesh.Faces[j];
FaceData data = (FaceData)mesh.Faces[j].UserData;
if (data == null)
continue;
if (teFace == null)
continue;
// Don't render transparent faces
if (data.TextureInfo.FullAlpha || teFace.RGBA.A <= 0.01f) continue;
bool switchedLightsOff = false;
if (pass != RenderPass.Picking)
{
bool belongToAlphaPass = (teFace.RGBA.A < 0.99f) || (data.TextureInfo.HasAlpha && !data.TextureInfo.IsMask);
if (belongToAlphaPass && pass != RenderPass.Alpha) continue;
if (!belongToAlphaPass && pass == RenderPass.Alpha) continue;
if (pass == RenderPass.Simple)
{
mesh.HasSimpleFaces = true;
}
else if (pass == RenderPass.Alpha)
{
mesh.HasAlphaFaces = true;
}
if (teFace.Fullbright)
{
GL.Disable(EnableCap.Lighting);
switchedLightsOff = true;
}
switch (teFace.Shiny)
{
case Shininess.High:
GL.Material(MaterialFace.Front, MaterialParameter.Shininess, 0.94f);
break;
case Shininess.Medium:
GL.Material(MaterialFace.Front, MaterialParameter.Shininess, 0.64f);
break;
case Shininess.Low:
GL.Material(MaterialFace.Front, MaterialParameter.Shininess, 0.24f);
break;
case Shininess.None:
default:
GL.Material(MaterialFace.Front, MaterialParameter.Shininess, 0f);
break;
}
var faceColor = new float[] { teFace.RGBA.R, teFace.RGBA.G, teFace.RGBA.B, teFace.RGBA.A };
GL.Color4(faceColor);
GL.Material(MaterialFace.Front, MaterialParameter.Specular, new float[] { 0.5f, 0.5f, 0.5f, 1f });
if (data.TextureInfo.TexturePointer == 0 && TexturesPtrMap.ContainsKey(teFace.TextureID))
{
data.TextureInfo = TexturesPtrMap[teFace.TextureID];
}
if (data.TextureInfo.TexturePointer == 0)
{
GL.Disable(EnableCap.Texture2D);
if (texturesRequestedThisFrame < 2 && !data.TextureInfo.FetchFailed)
{
texturesRequestedThisFrame++;
DownloadTexture(new TextureLoadItem()
{
Prim = prim,
TeFace = teFace,
Data = data
});
}
}
else
{
// Is this face using texture animation
if ((prim.TextureAnim.Flags & Primitive.TextureAnimMode.ANIM_ON) != 0
&& (prim.TextureAnim.Face == j || prim.TextureAnim.Face == 255))
{
if (data.AnimInfo == null)
{
data.AnimInfo = new TextureAnimationInfo();
}
data.AnimInfo.PrimAnimInfo = prim.TextureAnim;
data.AnimInfo.Step(lastFrameTime);
animatedTexture = true;
}
else if (data.AnimInfo != null) // Face texture not animated. Do we have previous anim setting?
{
data.AnimInfo = null;
}
GL.Enable(EnableCap.Texture2D);
GL.BindTexture(TextureTarget.Texture2D, data.TextureInfo.TexturePointer);
}
}
else
{
data.PickingID = primNr;
var primNrBytes = Utils.UInt16ToBytes((ushort)primNr);
var faceColor = new byte[] { primNrBytes[0], primNrBytes[1], (byte)j, 255 };
GL.Color4(faceColor);
}
if (!RenderSettings.UseVBO)
{
Vertex[] verts = face.Vertices.ToArray();
ushort[] indices = face.Indices.ToArray();
unsafe
{
fixed (float* normalPtr = &verts[0].Normal.X)
fixed (float* texPtr = &verts[0].TexCoord.X)
{
GL.NormalPointer(NormalPointerType.Float, FaceData.VertexSize, (IntPtr)normalPtr);
GL.TexCoordPointer(2, TexCoordPointerType.Float, FaceData.VertexSize, (IntPtr)texPtr);
GL.VertexPointer(3, VertexPointerType.Float, FaceData.VertexSize, verts);
GL.DrawElements(BeginMode.Triangles, indices.Length, DrawElementsType.UnsignedShort, indices);
}
}
}
else
{
data.CheckVBO(face);
GL.BindBuffer(BufferTarget.ArrayBuffer, data.VertexVBO);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, data.IndexVBO);
GL.NormalPointer(NormalPointerType.Float, FaceData.VertexSize, (IntPtr)12);
GL.TexCoordPointer(2, TexCoordPointerType.Float, FaceData.VertexSize, (IntPtr)(24));
GL.VertexPointer(3, VertexPointerType.Float, FaceData.VertexSize, (IntPtr)(0));
GL.DrawElements(BeginMode.Triangles, face.Indices.Count, DrawElementsType.UnsignedShort, IntPtr.Zero);
GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
}
if (switchedLightsOff)
{
GL.Enable(EnableCap.Lighting);
switchedLightsOff = false;
}
}
GL.BindTexture(TextureTarget.Texture2D, 0);
ResetMaterial();
// Reset texture coordinates if we modified them in texture animation
if (animatedTexture)
{
GL.MatrixMode(MatrixMode.Texture);
GL.LoadIdentity();
GL.MatrixMode(MatrixMode.Modelview);
}
// Pop the prim matrix
GL.PopMatrix();
}
/// <summary>
/// Render Primitive
/// </summary>
/// <param name="pass">Which pass are we currently in</param>
/// <param name="pickingID">ID used to identify which object was picked</param>
/// <param name="scene">Main scene renderer</param>
/// <param name="time">Time it took to render the last frame</param>
public override void Render(RenderPass pass, int pickingID, SceneWindow scene, float time)
{
if (!RenderSettings.AvatarRenderingEnabled && Attached) return;
// Individual prim matrix
GL.PushMatrix();
// Prim roation and position and scale
GL.MultMatrix(Math3D.CreateSRTMatrix(Prim.Scale, RenderRotation, RenderPosition));
// Do we have animated texture on this face
bool animatedTexture = false;
// Initialise flags tracking what type of faces this prim has
if (pass == RenderPass.Simple)
{
HasSimpleFaces = false;
}
else if (pass == RenderPass.Alpha)
{
HasAlphaFaces = false;
}
else if (pass == RenderPass.Invisible)
{
HasInvisibleFaces = false;
}
// Draw the prim faces
for (int j = 0; j < Faces.Count; j++)
{
Primitive.TextureEntryFace teFace = Prim.Textures.GetFace((uint)j);
Face face = Faces[j];
FaceData data = (FaceData)face.UserData;
if (data == null)
continue;
if (teFace == null)
continue;
// Don't render transparent faces
Color4 RGBA = teFace.RGBA;
if (data.TextureInfo.FullAlpha || RGBA.A <= 0.01f) continue;
bool switchedLightsOff = false;
if (pass == RenderPass.Picking)
{
data.PickingID = pickingID;
var primNrBytes = Utils.UInt16ToBytes((ushort)pickingID);
var faceColor = new byte[] { primNrBytes[0], primNrBytes[1], (byte)j, 255 };
GL.Color4(faceColor);
}
else if (pass == RenderPass.Invisible)
{
if (!data.TextureInfo.IsInvisible) continue;
HasInvisibleFaces = true;
}
else
{
if (data.TextureInfo.IsInvisible) continue;
bool belongToAlphaPass = (RGBA.A < 0.99f) || (data.TextureInfo.HasAlpha && !data.TextureInfo.IsMask);
if (belongToAlphaPass && pass != RenderPass.Alpha) continue;
if (!belongToAlphaPass && pass == RenderPass.Alpha) continue;
if (pass == RenderPass.Simple)
{
HasSimpleFaces = true;
}
else if (pass == RenderPass.Alpha)
{
HasAlphaFaces = true;
}
if (teFace.Fullbright)
{
GL.Disable(EnableCap.Lighting);
switchedLightsOff = true;
}
float shiny = 0f;
switch (teFace.Shiny)
{
case Shininess.High:
shiny = 0.96f;
break;
case Shininess.Medium:
shiny = 0.64f;
break;
case Shininess.Low:
shiny = 0.24f;
break;
}
if (shiny > 0f)
{
scene.StartShiny();
}
GL.Material(MaterialFace.Front, MaterialParameter.Shininess, shiny);
var faceColor = new float[] { RGBA.R, RGBA.G, RGBA.B, RGBA.A };
GL.Color4(faceColor);
GL.Material(MaterialFace.Front, MaterialParameter.Specular, new float[] { 0.5f, 0.5f, 0.5f, 1f });
if (data.TextureInfo.TexturePointer == 0)
{
TextureInfo teInfo;
if (scene.TryGetTextureInfo(teFace.TextureID, out teInfo))
{
data.TextureInfo = teInfo;
}
}
if (data.TextureInfo.TexturePointer == 0)
{
GL.Disable(EnableCap.Texture2D);
if (!data.TextureInfo.FetchFailed)
{
scene.DownloadTexture(new TextureLoadItem()
{
Prim = this.Prim,
TeFace = teFace,
Data = data
}, false);
}
}
else
{
// Is this face using texture animation
if ((Prim.TextureAnim.Flags & Primitive.TextureAnimMode.ANIM_ON) != 0
&& (Prim.TextureAnim.Face == j || Prim.TextureAnim.Face == 255))
{
if (data.AnimInfo == null)
{
data.AnimInfo = new TextureAnimationInfo();
}
data.AnimInfo.PrimAnimInfo = Prim.TextureAnim;
data.AnimInfo.Step(time);
animatedTexture = true;
}
else if (data.AnimInfo != null) // Face texture not animated. Do we have previous anim setting?
{
data.AnimInfo = null;
}
GL.Enable(EnableCap.Texture2D);
GL.BindTexture(TextureTarget.Texture2D, data.TextureInfo.TexturePointer);
}
}
if (!RenderSettings.UseVBO || data.VBOFailed)
{
Vertex[] verts = face.Vertices.ToArray();
ushort[] indices = face.Indices.ToArray();
unsafe
{
fixed (float* normalPtr = &verts[0].Normal.X)
fixed (float* texPtr = &verts[0].TexCoord.X)
{
GL.NormalPointer(NormalPointerType.Float, FaceData.VertexSize, (IntPtr)normalPtr);
GL.TexCoordPointer(2, TexCoordPointerType.Float, FaceData.VertexSize, (IntPtr)texPtr);
GL.VertexPointer(3, VertexPointerType.Float, FaceData.VertexSize, verts);
GL.DrawElements(BeginMode.Triangles, indices.Length, DrawElementsType.UnsignedShort, indices);
}
}
}
else
{
if (data.CheckVBO(face))
{
Compat.BindBuffer(BufferTarget.ArrayBuffer, data.VertexVBO);
Compat.BindBuffer(BufferTarget.ElementArrayBuffer, data.IndexVBO);
GL.NormalPointer(NormalPointerType.Float, FaceData.VertexSize, (IntPtr)12);
GL.TexCoordPointer(2, TexCoordPointerType.Float, FaceData.VertexSize, (IntPtr)(24));
GL.VertexPointer(3, VertexPointerType.Float, FaceData.VertexSize, (IntPtr)(0));
GL.DrawElements(BeginMode.Triangles, face.Indices.Count, DrawElementsType.UnsignedShort, IntPtr.Zero);
}
Compat.BindBuffer(BufferTarget.ArrayBuffer, 0);
Compat.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
}
if (switchedLightsOff)
{
GL.Enable(EnableCap.Lighting);
switchedLightsOff = false;
}
}
GL.BindTexture(TextureTarget.Texture2D, 0);
RHelp.ResetMaterial();
// Reset texture coordinates if we modified them in texture animation
if (animatedTexture)
{
GL.MatrixMode(MatrixMode.Texture);
GL.LoadIdentity();
GL.MatrixMode(MatrixMode.Modelview);
}
// Pop the prim matrix
GL.PopMatrix();
base.Render(pass, pickingID, scene, time);
}
/// <summary>
/// Render scene object
/// </summary>
/// <param name="pass">Which pass are we currently in</param>
/// <param name="pickingID">ID used to identify which object was picked</param>
/// <param name="scene">Main scene renderer</param>
/// <param name="time">Time it took to render the last frame</param>
public virtual void Render(RenderPass pass, int pickingID, SceneWindow scene, float time)
{
}
internal static extern void Internal_ExecuteDrawCalls(IntPtr obj, IntPtr task, IntPtr output, RenderTask.DrawCall[] drawCalls, RenderPass pass);
public override void Initialize()
{
base.Initialize();
graphicsDeviceService = Services.GetSafeServiceAs<IGraphicsDeviceService>();
// Create and register render passes
updatePasses = new RenderPass("Update");
copyPass = new RenderPass("Copy");
sortPass = new RenderPass("Sort");
bitonicSort1Pass1 = new RenderPass("BitonicSort1Pass1");
bitonicSort1Pass2 = new RenderPass("BitonicSort1Pass2");
bitonicSort2Passes = new RenderPass[(int)Math.Log(MaximumDepthLevel, 2) - 1];
effectBitonicSort2 = new EffectOld[bitonicSort2Passes.Length];
renderPass = new RenderPass("Render");
}
public override void Bind(Device device, RenderPass renderPass, CommandBuffer commandBuffer, Extent2D targetExtent)
{
this.aspectRatio = (float)targetExtent.Width / (float)targetExtent.Height;
this.pipeline = device.CreateGraphicsPipelines(null, new[]
{
new GraphicsPipelineCreateInfo
{
Layout = this.pipelineLayout,
RenderPass = renderPass,
Subpass = 0,
VertexInputState = new PipelineVertexInputStateCreateInfo()
{
VertexBindingDescriptions = new [] { Vertex.GetBindingDescription() },
VertexAttributeDescriptions = Vertex.GetAttributeDescriptions()
},
InputAssemblyState = new PipelineInputAssemblyStateCreateInfo
{
PrimitiveRestartEnable = false,
Topology = PrimitiveTopology.TriangleList
},
ViewportState = new PipelineViewportStateCreateInfo
{
Viewports = new[]
{
new Viewport
{
X = 0f,
Y = 0f,
Width = targetExtent.Width,
Height = targetExtent.Height,
MaxDepth = 1,
MinDepth = 0
}
},
Scissors = new[]
{
new Rect2D
{
Offset = new Offset2D(),
Extent = targetExtent
}
}
},
RasterizationState = new PipelineRasterizationStateCreateInfo
{
DepthClampEnable = false,
RasterizerDiscardEnable = false,
PolygonMode = PolygonMode.Fill,
LineWidth = 1,
CullMode = CullModeFlags.Back,
FrontFace = FrontFace.CounterClockwise,
DepthBiasEnable = false
},
MultisampleState = new PipelineMultisampleStateCreateInfo
{
SampleShadingEnable = false,
RasterizationSamples = SampleCountFlags.SampleCount1,
MinSampleShading = 1
},
ColorBlendState = new PipelineColorBlendStateCreateInfo
{
Attachments = new[]
{
new PipelineColorBlendAttachmentState
{
ColorWriteMask = ColorComponentFlags.R
| ColorComponentFlags.G
| ColorComponentFlags.B
| ColorComponentFlags.A,
BlendEnable = false,
SourceColorBlendFactor = BlendFactor.One,
DestinationColorBlendFactor = BlendFactor.Zero,
ColorBlendOp = BlendOp.Add,
SourceAlphaBlendFactor = BlendFactor.One,
DestinationAlphaBlendFactor = BlendFactor.Zero,
AlphaBlendOp = BlendOp.Add
}
},
LogicOpEnable = false,
LogicOp = LogicOp.Copy,
BlendConstants = new float[] { 0, 0, 0, 0 }
},
DepthStencilState = new PipelineDepthStencilStateCreateInfo
{
DepthTestEnable = true,
DepthWriteEnable = true,
DepthCompareOp = CompareOp.Less,
DepthBoundsTestEnable = false,
MinDepthBounds = 0,
MaxDepthBounds = 1,
StencilTestEnable = false
},
Stages = new[]
{
new PipelineShaderStageCreateInfo
{
Stage = ShaderStageFlags.Vertex,
Module = this.vertexShader,
Name = "main"
},
new PipelineShaderStageCreateInfo
{
Stage = ShaderStageFlags.Fragment,
Module = this.fragmentShader,
Name = "main"
}
}
}
}).Single();
commandBuffer.BindPipeline(PipelineBindPoint.Graphics, this.pipeline);
commandBuffer.BindVertexBuffers(0, this.vertexBuffer.Buffer, (DeviceSize)0);
commandBuffer.BindIndexBuffer(this.indexBuffer.Buffer, 0, IndexType.UInt32);
commandBuffer.BindDescriptorSets(PipelineBindPoint.Graphics, pipelineLayout, 0, descriptorSet, null);
commandBuffer.DrawIndexed((uint)indexCount, 1, 0, 0, 0);
}
private void RenderObjects(RenderPass pass)
{
lock (Prims)
{
int primNr = 0;
foreach (FacetedMesh mesh in Prims.Values)
{
primNr++;
Primitive prim = mesh.Prim;
// Individual prim matrix
GL.PushMatrix();
if (prim.ParentID == RootPrimLocalID)
{
FacetedMesh parent = null;
if (Prims.TryGetValue(prim.ParentID, out parent))
{
// Apply prim translation and rotation relative to the root prim
GL.MultMatrix(Math3D.CreateRotationMatrix(parent.Prim.Rotation));
//GL.MultMatrixf(Math3D.CreateTranslationMatrix(parent.Prim.Position));
}
// Prim roation relative to root
GL.MultMatrix(Math3D.CreateTranslationMatrix(prim.Position));
}
// Prim roation
GL.MultMatrix(Math3D.CreateRotationMatrix(prim.Rotation));
// Prim scaling
GL.Scale(prim.Scale.X, prim.Scale.Y, prim.Scale.Z);
// Draw the prim faces
for (int j = 0; j < mesh.Faces.Count; j++)
{
Primitive.TextureEntryFace teFace = mesh.Prim.Textures.FaceTextures[j];
Face face = mesh.Faces[j];
FaceData data = (FaceData)face.UserData;
if (teFace == null)
teFace = mesh.Prim.Textures.DefaultTexture;
if (pass == RenderPass.Picking)
{
data.PickingID = primNr;
var primNrBytes = Utils.Int16ToBytes((short)primNr);
var faceColor = new byte[] { primNrBytes[0], primNrBytes[1], (byte)j, 255 };
GL.Color4(faceColor);
}
else
{
bool belongToAlphaPass = (teFace.RGBA.A < 0.99) || data.TextureInfo.HasAlpha;
if (belongToAlphaPass && pass != RenderPass.Alpha) continue;
if (!belongToAlphaPass && pass == RenderPass.Alpha) continue;
// Don't render transparent faces
if (teFace.RGBA.A <= 0.01f) continue;
switch (teFace.Shiny)
{
case Shininess.High:
GL.Material(MaterialFace.Front, MaterialParameter.Shininess, 94f);
break;
case Shininess.Medium:
GL.Material(MaterialFace.Front, MaterialParameter.Shininess, 64f);
break;
case Shininess.Low:
GL.Material(MaterialFace.Front, MaterialParameter.Shininess, 24f);
break;
case Shininess.None:
default:
GL.Material(MaterialFace.Front, MaterialParameter.Shininess, 0f);
break;
}
var faceColor = new float[] { teFace.RGBA.R, teFace.RGBA.G, teFace.RGBA.B, teFace.RGBA.A };
GL.Color4(faceColor);
GL.Material(MaterialFace.Front, MaterialParameter.AmbientAndDiffuse, faceColor);
GL.Material(MaterialFace.Front, MaterialParameter.Specular, faceColor);
if (data.TextureInfo.TexturePointer != 0)
{
GL.Enable(EnableCap.Texture2D);
}
else
{
GL.Disable(EnableCap.Texture2D);
}
// Bind the texture
GL.BindTexture(TextureTarget.Texture2D, data.TextureInfo.TexturePointer);
}
GL.TexCoordPointer(2, TexCoordPointerType.Float, 0, data.TexCoords);
GL.VertexPointer(3, VertexPointerType.Float, 0, data.Vertices);
GL.NormalPointer(NormalPointerType.Float, 0, data.Normals);
GL.DrawElements(BeginMode.Triangles, data.Indices.Length, DrawElementsType.UnsignedShort, data.Indices);
}
// Pop the prim matrix
GL.PopMatrix();
}
}
}
void init()
{
renderPass = new RenderPass(dev);
renderPass.AddAttachment(swapChain.ColorFormat, VkImageLayout.ColorAttachmentOptimal, VkSampleCountFlags.SampleCount1);
renderPass.AddAttachment(dev.GetSuitableDepthFormat(), VkImageLayout.DepthStencilAttachmentOptimal, samples);
renderPass.AddAttachment(VkFormat.R8g8b8a8Unorm, VkImageLayout.ColorAttachmentOptimal);
renderPass.AddAttachment(VkFormat.R8g8b8a8Unorm, VkImageLayout.ColorAttachmentOptimal);
renderPass.AddAttachment(VkFormat.R16g16b16a16Sfloat, VkImageLayout.ColorAttachmentOptimal);
renderPass.AddAttachment(VkFormat.R16g16b16a16Sfloat, VkImageLayout.ColorAttachmentOptimal);
renderPass.ClearValues.Add(new VkClearValue {
color = new VkClearColorValue(0.0f, 0.0f, 0.0f)
});
renderPass.ClearValues.Add(new VkClearValue {
depthStencil = new VkClearDepthStencilValue(1.0f, 0)
});
renderPass.ClearValues.Add(new VkClearValue {
color = new VkClearColorValue(0.0f, 0.0f, 0.0f)
});
renderPass.ClearValues.Add(new VkClearValue {
color = new VkClearColorValue(0.0f, 0.0f, 0.0f)
});
renderPass.ClearValues.Add(new VkClearValue {
color = new VkClearColorValue(0.0f, 0.0f, 0.0f)
});
renderPass.ClearValues.Add(new VkClearValue {
color = new VkClearColorValue(0.0f, 0.0f, 0.0f)
});
SubPass[] subpass = { new SubPass(), new SubPass() };
subpass[0].AddColorReference(new VkAttachmentReference(2, VkImageLayout.ColorAttachmentOptimal),
new VkAttachmentReference(3, VkImageLayout.ColorAttachmentOptimal),
new VkAttachmentReference(4, VkImageLayout.ColorAttachmentOptimal),
new VkAttachmentReference(5, VkImageLayout.ColorAttachmentOptimal));
subpass[0].SetDepthReference(1, VkImageLayout.DepthStencilAttachmentOptimal);
subpass[1].AddColorReference(0, VkImageLayout.ColorAttachmentOptimal);
subpass[1].AddInputReference(new VkAttachmentReference(2, VkImageLayout.ShaderReadOnlyOptimal),
new VkAttachmentReference(3, VkImageLayout.ShaderReadOnlyOptimal),
new VkAttachmentReference(4, VkImageLayout.ShaderReadOnlyOptimal),
new VkAttachmentReference(5, VkImageLayout.ShaderReadOnlyOptimal));
renderPass.AddSubpass(subpass);
renderPass.AddDependency(Vk.SubpassExternal, 0,
VkPipelineStageFlags.BottomOfPipe, VkPipelineStageFlags.ColorAttachmentOutput,
VkAccessFlags.MemoryRead, VkAccessFlags.ColorAttachmentRead | VkAccessFlags.ColorAttachmentWrite);
renderPass.AddDependency(0, 1,
VkPipelineStageFlags.ColorAttachmentOutput, VkPipelineStageFlags.FragmentShader,
VkAccessFlags.ColorAttachmentWrite, VkAccessFlags.ShaderRead);
renderPass.AddDependency(1, Vk.SubpassExternal,
VkPipelineStageFlags.ColorAttachmentOutput, VkPipelineStageFlags.BottomOfPipe,
VkAccessFlags.ColorAttachmentRead | VkAccessFlags.ColorAttachmentWrite, VkAccessFlags.MemoryRead);
descriptorPool = new DescriptorPool(dev, 3,
new VkDescriptorPoolSize(VkDescriptorType.UniformBuffer, 2),
new VkDescriptorPoolSize(VkDescriptorType.CombinedImageSampler, 3),
new VkDescriptorPoolSize(VkDescriptorType.InputAttachment, 4)
);
descLayoutMain = new DescriptorSetLayout(dev,
new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Vertex | VkShaderStageFlags.Fragment, VkDescriptorType.UniformBuffer),
new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler),
new VkDescriptorSetLayoutBinding(2, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler),
new VkDescriptorSetLayoutBinding(3, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler));
descLayoutModelTextures = new DescriptorSetLayout(dev,
new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler),
new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler),
new VkDescriptorSetLayoutBinding(2, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler),
new VkDescriptorSetLayoutBinding(3, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler),
new VkDescriptorSetLayoutBinding(4, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler)
);
descLayoutGBuff = new DescriptorSetLayout(dev,
new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Fragment, VkDescriptorType.InputAttachment),
new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Fragment, VkDescriptorType.InputAttachment),
new VkDescriptorSetLayoutBinding(2, VkShaderStageFlags.Fragment, VkDescriptorType.InputAttachment),
new VkDescriptorSetLayoutBinding(3, VkShaderStageFlags.Fragment, VkDescriptorType.InputAttachment));
dsMain = descriptorPool.Allocate(descLayoutMain);
dsGBuff = descriptorPool.Allocate(descLayoutGBuff);
GraphicPipelineConfig cfg = GraphicPipelineConfig.CreateDefault(VkPrimitiveTopology.TriangleList, samples);
cfg.Layout = new PipelineLayout(dev, descLayoutMain, descLayoutModelTextures, descLayoutGBuff);
cfg.Layout.AddPushConstants(
new VkPushConstantRange(VkShaderStageFlags.Vertex, (uint)Marshal.SizeOf <Matrix4x4> ()),
new VkPushConstantRange(VkShaderStageFlags.Fragment, sizeof(int), 64)
);
cfg.RenderPass = renderPass;
cfg.blendAttachments.Add(new VkPipelineColorBlendAttachmentState(false));
cfg.blendAttachments.Add(new VkPipelineColorBlendAttachmentState(false));
cfg.blendAttachments.Add(new VkPipelineColorBlendAttachmentState(false));
cfg.AddVertexBinding <Model.Vertex> (0);
cfg.SetVertexAttributes(0, VkFormat.R32g32b32Sfloat, VkFormat.R32g32b32Sfloat, VkFormat.R32g32Sfloat);
cfg.AddShader(VkShaderStageFlags.Vertex, "shaders/pbrtest.vert.spv");
cfg.AddShader(VkShaderStageFlags.Fragment, "shaders/GBuffPbr.frag.spv");
gBuffPipeline = new GraphicPipeline(cfg);
cfg.blendAttachments.Clear();
cfg.blendAttachments.Add(new VkPipelineColorBlendAttachmentState(false));
cfg.ResetShadersAndVerticesInfos();
cfg.SubpassIndex = 1;
cfg.Layout = gBuffPipeline.Layout;
cfg.depthStencilState.depthTestEnable = false;
cfg.depthStencilState.depthWriteEnable = false;
cfg.AddShader(VkShaderStageFlags.Vertex, "shaders/FullScreenQuad.vert.spv");
cfg.AddShader(VkShaderStageFlags.Fragment, "shaders/pbrtest.frag.spv");
composePipeline = new GraphicPipeline(cfg);
envCube = new EnvironmentCube(presentQueue, renderPass);
uboMats = new HostBuffer(dev, VkBufferUsageFlags.UniformBuffer, (ulong)Marshal.SizeOf <Matrices> () * 2);
uboMats.Map(); //permanent map
DescriptorSetWrites uboUpdate = new DescriptorSetWrites(descLayoutMain);
uboUpdate.Write(dev, dsMain, uboMats.Descriptor,
envCube.lutBrdf.Descriptor,
envCube.irradianceCube.Descriptor,
envCube.prefilterCube.Descriptor);
uboMats.Descriptor.offset = (ulong)Marshal.SizeOf <Matrices> ();
envCube.WriteDesc(uboMats.Descriptor);
#if DEBUG
debugDraw = new DebugDrawPipeline(dev, descLayoutMain, swapChain.ColorFormat);
debugDraw.AddLine(Vector3.Zero, new Vector3(matrices.lightPos.X, matrices.lightPos.Y, matrices.lightPos.Z) * 3, 1, 1, 1);
debugDraw.AddLine(Vector3.Zero, Vector3.UnitX, 1, 0, 0);
debugDraw.AddLine(Vector3.Zero, Vector3.UnitY, 0, 1, 0);
debugDraw.AddLine(Vector3.Zero, Vector3.UnitZ, 0, 0, 1);
#endif
model = new Model(presentQueue, "../data/models/DamagedHelmet/glTF/DamagedHelmet.gltf");
//model = new Model (presentQueue, "../data/models/chess.gltf");
//model = new Model (presentQueue, "../data/models/Sponza/glTF/Sponza.gltf");
//model = new Model (dev, presentQueue, "../data/models/icosphere.gltf");
//model = new Model (dev, presentQueue, cmdPool, "../data/models/cube.gltf");
model.WriteMaterialsDescriptorSets(descLayoutModelTextures,
VK.AttachmentType.Color,
VK.AttachmentType.Normal,
VK.AttachmentType.AmbientOcclusion,
VK.AttachmentType.PhysicalProps,
VK.AttachmentType.Emissive);
}
private void CreatePrePassMesh(RenderPass renderPass, bool debug)
{
var lightDeferredEffect = lightDeferredEffects[debug ? 1 : 0];
Tiles = new List<LightingPrepassShaderPlugin.LightData>[TileCountX * TileCountY];
for (int i = 0; i < Tiles.Length; ++i)
{
Tiles[i] = new List<LightingPrepassShaderPlugin.LightData>();
}
renderPass.StartPass.AddLast = (threadContext) =>
{
// TODO THIS IS NOT ACCURATE TO TAKE THE CURRENT BACKBUFFER
var mainBackBuffer = graphicsDeviceService.GraphicsDevice.BackBuffer;
threadContext.GraphicsDevice.SetViewport(new Viewport(0, 0, mainBackBuffer.Width, mainBackBuffer.Height));
if (threadContext.FirstContext)
{
if (debug)
{
threadContext.GraphicsDevice.SetRenderTarget(GBufferPlugin.MainTargetPlugin.RenderTarget);
}
else
{
threadContext.GraphicsDevice.Clear(LightTexture, new Color(0.0f, 0.0f, 0.0f, 0.0f));
threadContext.GraphicsDevice.SetRenderTarget(LightTexture);
}
}
for (int i = 0; i < Tiles.Length; ++i)
Tiles[i].Clear();
var lights = Lights;
var lightAttenuationCutoff = 0.1f;
Matrix viewMatrix;
var mainParameters = GBufferPlugin.MainPlugin.ViewParameters;
mainParameters.Get(TransformationKeys.View, out viewMatrix);
Matrix projMatrix;
mainParameters.Get(TransformationKeys.Projection, out projMatrix);
for (int index = 0; index < lights.Meshes.Count; index++)
{
LightingPrepassShaderPlugin.LightData lightData;
var lightMesh = lights.Meshes[index];
Vector3 lightPos;
lightMesh.Parameters.TryGet(LightKeys.LightPosition, out lightPos);
Vector3.TransformCoordinate(ref lightPos, ref viewMatrix, out lightData.LightPosVS);
lightMesh.Parameters.TryGet(LightKeys.LightColor, out lightData.DiffuseColor);
lightMesh.Parameters.TryGet(LightKeys.LightIntensity, out lightData.LightIntensity);
lightMesh.Parameters.TryGet(LightKeys.LightRadius, out lightData.LightRadius);
// ------------------------------------------------------------------------------------------
// TEMPORARY FIX FOR DEFERRED LIGHTS
// ------------------------------------------------------------------------------------------
//lightData2[index].DiffuseColor.Pow(1 / 4.0f);
//lightData2[index].LightIntensity = (float)Math.Pow(lightData2[index].LightIntensity, 1.0f / 2.2f);
// ------------------------------------------------------------------------------------------
// Linearize color
lightData.DiffuseColor.Pow(Color.DefaultGamma);
lightData.LightIntensity = (float)Math.Pow(lightData.LightIntensity, Color.DefaultGamma);
float lightDistanceMax = CalculateMaxDistance(lightData.LightIntensity, lightData.LightRadius, lightAttenuationCutoff);
var clipRegion = ComputeClipRegion(lightData.LightPosVS, lightDistanceMax, ref projMatrix);
var tileStartX = (int)((clipRegion.X * 0.5f + 0.5f) * TileCountX);
var tileEndX = (int)((clipRegion.Z * 0.5f + 0.5f) * TileCountX);
var tileStartY = (int)((clipRegion.Y * 0.5f + 0.5f) * TileCountY);
var tileEndY = (int)((clipRegion.W * 0.5f + 0.5f) * TileCountY);
// Check if this light is really visible (not behind us)
if (lightData.LightPosVS.Z + lightDistanceMax < 0.0f)
continue;
for (int y = tileStartY; y <= tileEndY; ++y)
{
if (y < 0 || y >= TileCountY)
continue;
for (int x = tileStartX; x <= tileEndX; ++x)
{
if (x < 0 || x >= TileCountX)
continue;
Tiles[y * TileCountX + x].Add(lightData);
}
}
}
};
var lightDeferredMesh = new EffectMesh(lightDeferredEffect).KeepAliveBy(ActiveObjects);
RenderSystem.GlobalMeshes.AddMesh(lightDeferredMesh);
renderPass.EndPass.AddLast = (context) =>
{
// Clear thread context overridden variables.
context.Parameters.Reset(LightingPrepassShaderPlugin.LightCount);
context.Parameters.Reset(LightingPrepassShaderPlugin.LightInfos);
context.Parameters.Reset(LightingPrepassShaderPlugin.TileIndex);
context.Parameters.Reset(TransformationKeys.Projection);
context.Parameters.Reset(RenderTargetKeys.DepthStencilSource);
};
var tileRenderPasses = new RenderPass[TileCountX * TileCountY];
for (int i = 0; i < tileRenderPasses.Length; ++i)
{
int tileIndex = i;
tileRenderPasses[i] = new RenderPass("Lighting Tile");
tileRenderPasses[i].StartPass.AddLast = (context) => { context.Parameters.Set(LightingPrepassShaderPlugin.TileIndex, tileIndex); };
throw new NotImplementedException();
//tileRenderPasses[i].Meshes.Add(lightDeferredMesh);
}
throw new NotImplementedException();
//renderPass.UpdatePasses += (RenderPass currentRenderPass, ref FastList<RenderPass> currentPasses) =>
// {
// lightDeferredEffect.Passes[0].Passes.Clear();
// lightDeferredEffect.Passes[0].Passes.AddRange(tileRenderPasses);
// };
}
public virtual void AcceptPass(RenderPass pass)
{
pass.Visit(this);
}
private void CreateRenderPass()
{
var colorAttachmentReference = new AttachmentReference { Attachment = 0, Layout = ImageLayout.ColorAttachmentOptimal };
var depthStencilAttachmentReference = new AttachmentReference { Attachment = 1, Layout = ImageLayout.DepthStencilAttachmentOptimal };
var subpass = new SubpassDescription
{
PipelineBindPoint = PipelineBindPoint.Graphics,
ColorAttachmentCount = 1,
ColorAttachments = new IntPtr(&colorAttachmentReference),
};
var attachments = new[]
{
new AttachmentDescription
{
Format = backBufferFormat,
Samples = SampleCountFlags.Sample1,
LoadOperation = AttachmentLoadOperation.Load,
StoreOperation = AttachmentStoreOperation.Store,
StencilLoadOperation = AttachmentLoadOperation.DontCare,
StencilStoreOperation = AttachmentStoreOperation.DontCare,
InitialLayout = ImageLayout.ColorAttachmentOptimal,
FinalLayout = ImageLayout.ColorAttachmentOptimal
},
};
fixed (AttachmentDescription* attachmentsPointer = &attachments[0])
{
var createInfo = new RenderPassCreateInfo
{
StructureType = StructureType.RenderPassCreateInfo,
AttachmentCount = (uint)attachments.Length,
Attachments = new IntPtr(attachmentsPointer),
SubpassCount = 1,
Subpasses = new IntPtr(&subpass)
};
renderPass = device.CreateRenderPass(ref createInfo);
}
}
Framebuffer [] CreateFramebuffers(Image[] images, SurfaceFormatKhr surfaceFormat, SurfaceCapabilitiesKhr surfaceCapabilities, RenderPass renderPass)
{
var displayViews = new ImageView [images.Length];
for (int i = 0; i < images.Length; i++)
{
var viewCreateInfo = new ImageViewCreateInfo {
Image = images [i],
ViewType = ImageViewType.View2D,
Format = surfaceFormat.Format,
Components = new ComponentMapping {
R = ComponentSwizzle.R,
G = ComponentSwizzle.G,
B = ComponentSwizzle.B,
A = ComponentSwizzle.A
},
SubresourceRange = new ImageSubresourceRange {
AspectMask = ImageAspectFlags.Color,
LevelCount = 1,
LayerCount = 1
}
};
displayViews [i] = device.CreateImageView(viewCreateInfo);
}
var framebuffers = new Framebuffer [images.Length];
for (int i = 0; i < images.Length; i++)
{
var frameBufferCreateInfo = new FramebufferCreateInfo {
Layers = 1,
RenderPass = renderPass,
Attachments = new ImageView [] { displayViews [i] },
Width = surfaceCapabilities.CurrentExtent.Width,
Height = surfaceCapabilities.CurrentExtent.Height
};
framebuffers [i] = device.CreateFramebuffer(frameBufferCreateInfo);
}
return(framebuffers);
}
private void RenderAvatars(RenderPass pass)
{
if (!RenderSettings.AvatarRenderingEnabled) return;
lock (Avatars)
{
GL.EnableClientState(ArrayCap.VertexArray);
GL.EnableClientState(ArrayCap.TextureCoordArray);
GL.EnableClientState(ArrayCap.NormalArray);
int avatarNr = 0;
foreach (RenderAvatar av in VisibleAvatars)
{
avatarNr++;
// Whole avatar position
GL.PushMatrix();
// Prim roation and position
av.UpdateSize();
GL.MultMatrix(Math3D.CreateSRTMatrix(Vector3.One, av.RenderRotation, av.AdjustedPosition(av.RenderPosition)));
if (av.glavatar._meshes.Count > 0)
{
int faceNr = 0;
foreach (GLMesh mesh in av.glavatar._meshes.Values)
{
if (av.glavatar.skel.mNeedsMeshRebuild)
{
mesh.applyjointweights();
}
faceNr++;
if (!av.glavatar._showSkirt && mesh.Name == "skirtMesh")
continue;
// If we don't have a hair bake OR the hair bake is invisible don't render it
if (mesh.Name == "hairMesh" && (av.data[(int)AvatarTextureIndex.HairBaked] == null || av.data[(int)AvatarTextureIndex.HairBaked].TextureInfo.IsInvisible))
continue;
GL.Color3(1f, 1f, 1f);
if (pass == RenderPass.Picking)
{
GL.Disable(EnableCap.Texture2D);
for (int i = 0; i < av.data.Length; i++)
{
if (av.data[i] != null)
{
av.data[i].PickingID = avatarNr;
}
}
byte[] primNrBytes = Utils.Int16ToBytes((short)avatarNr);
byte[] faceColor = new byte[] { primNrBytes[0], primNrBytes[1], (byte)faceNr, 254 };
GL.Color4(faceColor);
}
else
{
if (av.data[mesh.teFaceID] == null)
{
GL.Disable(EnableCap.Texture2D);
}
else
{
if (mesh.teFaceID != 0)
{
GL.Enable(EnableCap.Texture2D);
GL.BindTexture(TextureTarget.Texture2D, av.data[mesh.teFaceID].TextureInfo.TexturePointer);
}
else
{
GL.Disable(EnableCap.Texture2D);
}
}
}
GL.TexCoordPointer(2, TexCoordPointerType.Float, 0, mesh.RenderData.TexCoords);
GL.VertexPointer(3, VertexPointerType.Float, 0, mesh.RenderData.Vertices);
GL.NormalPointer(NormalPointerType.Float, 0, mesh.MorphRenderData.Normals);
GL.DrawElements(BeginMode.Triangles, mesh.RenderData.Indices.Length, DrawElementsType.UnsignedShort, mesh.RenderData.Indices);
GL.BindTexture(TextureTarget.Texture2D, 0);
}
av.glavatar.skel.mNeedsMeshRebuild = false;
}
// Whole avatar position
GL.PopMatrix();
}
GL.Disable(EnableCap.Texture2D);
GL.DisableClientState(ArrayCap.NormalArray);
GL.DisableClientState(ArrayCap.VertexArray);
GL.DisableClientState(ArrayCap.TextureCoordArray);
}
}
CommandBuffer[] CreateCommandBuffers(Image[] images, Framebuffer[] framebuffers, RenderPass renderPass, SurfaceCapabilitiesKhr surfaceCapabilities)
{
var createPoolInfo = new CommandPoolCreateInfo {
Flags = CommandPoolCreateFlags.ResetCommandBuffer
};
var commandPool = device.CreateCommandPool(createPoolInfo);
var commandBufferAllocateInfo = new CommandBufferAllocateInfo {
Level = CommandBufferLevel.Primary,
CommandPool = commandPool,
CommandBufferCount = (uint)images.Length
};
var buffers = device.AllocateCommandBuffers(commandBufferAllocateInfo);
for (int i = 0; i < images.Length; i++)
{
var commandBufferBeginInfo = new CommandBufferBeginInfo();
buffers [i].Begin(commandBufferBeginInfo);
var renderPassBeginInfo = new RenderPassBeginInfo {
Framebuffer = framebuffers [i],
RenderPass = renderPass,
ClearValues = new ClearValue [] { new ClearValue {
Color = new ClearColorValue(new float [] { 0.9f, 0.7f, 0.0f, 1.0f })
} },
RenderArea = new Rect2D {
Extent = surfaceCapabilities.CurrentExtent
}
};
buffers [i].CmdBeginRenderPass(renderPassBeginInfo, SubpassContents.Inline);
buffers [i].CmdEndRenderPass();
buffers [i].End();
}
return(buffers);
}
private void RenderText(RenderPass pass)
{
lock (VisibleAvatars)
{
GL.Color4(0f, 0f, 0f, 0.4f);
foreach (RenderAvatar av in VisibleAvatars)
{
Vector3 avPos = av.RenderPosition;
if (av.DistanceSquared > 400f) continue;
byte[] faceColor = null;
OpenTK.Vector3 tagPos = RHelp.TKVector3(avPos);
tagPos.Z += 1.2f;
OpenTK.Vector3 screenPos;
if (!Math3D.GluProject(tagPos, ModelMatrix, ProjectionMatrix, Viewport, out screenPos)) continue;
string tagText = instance.Names.Get(av.avatar.ID, av.avatar.Name);
if (!string.IsNullOrEmpty(av.avatar.GroupName))
tagText = av.avatar.GroupName + "\n" + tagText;
var tSize = Printer.Measure(tagText, AvatarTagFont);
if (pass == RenderPass.Picking)
{
//Send avatar anyway, we're attached to it
int faceID = 0;
foreach (FaceData f in av.data)
{
if (f != null)
{
byte[] primNrBytes = Utils.Int16ToBytes((short)f.PickingID);
faceColor = new byte[] { primNrBytes[0], primNrBytes[1], (byte)faceID, 254 };
GL.Color4(faceColor);
break;
}
faceID++;
}
}
OpenTK.Vector3 quadPos = screenPos;
screenPos.Y = glControl.Height - screenPos.Y;
screenPos.X -= tSize.BoundingBox.Width / 2;
screenPos.Y -= tSize.BoundingBox.Height / 2 + 2;
if (screenPos.Y > 0)
{
// Render tag backround
float halfWidth = tSize.BoundingBox.Width / 2 + 12;
float halfHeight = tSize.BoundingBox.Height / 2 + 5;
RHelp.Draw2DBox(quadPos.X - halfWidth, quadPos.Y - halfHeight, halfWidth * 2, halfHeight * 2, screenPos.Z);
if (pass == RenderPass.Simple)
{
Printer.Begin();
Color textColor = pass == RenderPass.Simple ?
Color.Orange :
Color.FromArgb(faceColor[3], faceColor[0], faceColor[1], faceColor[2]);
Printer.Print(tagText, AvatarTagFont, textColor,
new RectangleF(screenPos.X, screenPos.Y, tSize.BoundingBox.Width + 2, tSize.BoundingBox.Height + 2),
OpenTK.Graphics.TextPrinterOptions.Default, OpenTK.Graphics.TextAlignment.Center);
Printer.End();
}
}
}
}
lock (SortedObjects)
{
int primNr = 0;
foreach (SceneObject obj in SortedObjects)
{
if (!(obj is RenderPrimitive)) continue;
RenderPrimitive prim = (RenderPrimitive)obj;
primNr++;
if (!string.IsNullOrEmpty(prim.BasePrim.Text))
{
string text = System.Text.RegularExpressions.Regex.Replace(prim.BasePrim.Text, "(\r?\n)+", "\n");
OpenTK.Vector3 primPos = RHelp.TKVector3(prim.RenderPosition);
// Display hovertext only on objects that are withing 12m of the camera
if (prim.DistanceSquared > (12 * 12)) continue;
primPos.Z += prim.BasePrim.Scale.Z * 0.8f;
// Convert objects world position to 2D screen position in pixels
OpenTK.Vector3 screenPos;
if (!Math3D.GluProject(primPos, ModelMatrix, ProjectionMatrix, Viewport, out screenPos)) continue;
screenPos.Y = glControl.Height - screenPos.Y;
Printer.Begin();
Color color = Color.FromArgb((int)(prim.BasePrim.TextColor.A * 255), (int)(prim.BasePrim.TextColor.R * 255), (int)(prim.BasePrim.TextColor.G * 255), (int)(prim.BasePrim.TextColor.B * 255));
var size = Printer.Measure(text, HoverTextFont);
screenPos.X -= size.BoundingBox.Width / 2;
screenPos.Y -= size.BoundingBox.Height;
if (screenPos.Y > 0)
{
if (pass == RenderPass.Picking)
{
//Send the prim anyway, we're attached to it
int faceID = 0;
foreach (Face f in prim.Faces)
{
if (f.UserData != null)
{
byte[] primNrBytes = Utils.Int16ToBytes((short)((FaceData)f.UserData).PickingID);
byte[] faceColor = new byte[] { primNrBytes[0], primNrBytes[1], (byte)faceID, 255 };
Printer.Print(text, HoverTextFont, Color.FromArgb(faceColor[3], faceColor[0], faceColor[1], faceColor[2]), new RectangleF(screenPos.X, screenPos.Y, size.BoundingBox.Width + 2, size.BoundingBox.Height + 2), OpenTK.Graphics.TextPrinterOptions.Default, OpenTK.Graphics.TextAlignment.Center);
break;
}
faceID++;
}
}
else
{
// Shadow
if (color != Color.Black)
Printer.Print(text, HoverTextFont, Color.Black, new RectangleF(screenPos.X + 1, screenPos.Y + 1, size.BoundingBox.Width + 2, size.BoundingBox.Height + 2), OpenTK.Graphics.TextPrinterOptions.Default, OpenTK.Graphics.TextAlignment.Center);
// Text
Printer.Print(text, HoverTextFont, color, new RectangleF(screenPos.X, screenPos.Y, size.BoundingBox.Width + 2, size.BoundingBox.Height + 2), OpenTK.Graphics.TextPrinterOptions.Default, OpenTK.Graphics.TextAlignment.Center);
}
}
Printer.End();
}
}
}
}
internal static Pipeline CreatePipeline(
Device logicalDevice,
RenderPass renderpass,
PipelineLayout layout,
ShaderModule vertModule,
ShaderModule fragModule,
SpecializationContainer specializationContainer,
bool depthClamp,
bool depthBias,
ReadOnlySpan <DeviceTexture> targets,
IInternalRenderObject renderObject)
{
if (logicalDevice == null)
{
throw new ArgumentNullException(nameof(logicalDevice));
}
if (renderpass == null)
{
throw new ArgumentNullException(nameof(renderpass));
}
var shaderStages = new []
{
new PipelineShaderStageCreateInfo(
stage: ShaderStages.Vertex, module: vertModule, name: "main",
specializationInfo: specializationContainer?.GetInfo()),
new PipelineShaderStageCreateInfo(
stage: ShaderStages.Fragment,
module: fragModule, name: "main",
specializationInfo: specializationContainer?.GetInfo())
};
var depthTest = new PipelineDepthStencilStateCreateInfo {
DepthTestEnable = true,
DepthWriteEnable = true,
DepthCompareOp = CompareOp.LessOrEqual,
DepthBoundsTestEnable = false,
StencilTestEnable = false
};
var rasterizer = new PipelineRasterizationStateCreateInfo(
depthClampEnable: depthClamp,
rasterizerDiscardEnable: false,
polygonMode: PolygonMode.Fill,
cullMode: CullModes.Back,
frontFace: renderObject.GetFrontFace(),
depthBiasEnable: depthBias,
depthBiasConstantFactor: .1f,
depthBiasSlopeFactor: 1.75f,
lineWidth: 1f
);
//Gather all the color targets and setup a blend-state for them
ResizeArray <PipelineColorBlendAttachmentState> blendAttachments =
new ResizeArray <PipelineColorBlendAttachmentState>();
for (int i = 0; i < targets.Length; i++)
{
if (!targets[i].DepthTexture)
{
blendAttachments.Add(new PipelineColorBlendAttachmentState(
colorWriteMask: ColorComponents.All, blendEnable: false));
}
}
var blending = new PipelineColorBlendStateCreateInfo(
attachments: blendAttachments.ToArray(),
logicOpEnable: false
);
var multisampleState = new PipelineMultisampleStateCreateInfo(
rasterizationSamples: SampleCounts.Count1,
sampleShadingEnable: false
);
//Pass the viewport and scissor-rect as dynamic so we are not tied to swapchain size
//the advantage is this is that we don't need to recreate the pipeline on swapchain
//resize
var dynamicState = new PipelineDynamicStateCreateInfo(
DynamicState.Viewport,
DynamicState.Scissor
);
return(logicalDevice.CreateGraphicsPipeline(new GraphicsPipelineCreateInfo(
layout: layout,
renderPass: renderpass,
subpass: 0,
stages: shaderStages,
inputAssemblyState: renderObject.GetInputAssemblyStateInfo(),
vertexInputState: renderObject.GetVertexInputState(),
rasterizationState: rasterizer,
tessellationState: null,
//Pass empty viewport and scissor-rect as we set them dynamically
viewportState: new PipelineViewportStateCreateInfo(new Viewport(), new Rect2D()),
multisampleState: multisampleState,
depthStencilState: depthTest,
colorBlendState: blending,
dynamicState: dynamicState,
flags: PipelineCreateFlags.None
)));
}
private void RenderAvatars(RenderPass pass)
{
if (!RenderSettings.AvatarRenderingEnabled) return;
lock (Avatars)
{
GL.EnableClientState(ArrayCap.VertexArray);
GL.EnableClientState(ArrayCap.TextureCoordArray);
GL.EnableClientState(ArrayCap.NormalArray);
int avatarNr = 0;
foreach (RenderAvatar av in VisibleAvatars)
{
avatarNr++;
// Whole avatar position
GL.PushMatrix();
Vector3 avataroffset = av.glavatar.skel.getOffset("mPelvis");
// Prim roation and position
GL.MultMatrix(Math3D.CreateSRTMatrix(Vector3.One, av.RenderRotation, av.RenderPosition - avataroffset * av.RenderRotation));
if (av.glavatar._meshes.Count > 0)
{
int faceNr = 0;
foreach (GLMesh mesh in av.glavatar._meshes.Values)
{
if (av.glavatar.skel.mNeedsMeshRebuild)
{
mesh.applyjointweights();
}
faceNr++;
if (!av.glavatar._showSkirt && mesh.Name == "skirtMesh")
continue;
if (mesh.Name == "hairMesh") // Don't render the hair mesh for the moment
continue;
GL.Color3(1f, 1f, 1f);
// Individual part mesh matrix
GL.PushMatrix();
// Special case for eyeballs we need to offset the mesh to the correct position
// We have manually added the eyeball offset based on the headbone when we
// constructed the meshes, but why are the position offsets we got when loading
// the other meshes <0,7,0> ?
if (mesh.Name == "eyeBallLeftMesh")
{
// Mesh roation and position
GL.MultMatrix(Math3D.CreateSRTMatrix(Vector3.One, av.glavatar.skel.mLeftEye.getTotalRotation(), av.glavatar.skel.mLeftEye.getTotalOffset()));
}
if (mesh.Name == "eyeBallRightMesh")
{
// Mesh roation and position
GL.MultMatrix(Math3D.CreateSRTMatrix(Vector3.One, av.glavatar.skel.mRightEye.getTotalRotation(), av.glavatar.skel.mRightEye.getTotalOffset()));
}
//Should we be offsetting the base meshs at all?
//if (mesh.Name == "headMesh")
//{
// GL.MultMatrix(Math3D.CreateTranslationMatrix(av.glavatar.skel.getDeltaOffset("mHead")));
//}
if (pass == RenderPass.Picking)
{
GL.Disable(EnableCap.Texture2D);
for (int i = 0; i < av.data.Length; i++)
{
if (av.data[i] != null)
{
av.data[i].PickingID = avatarNr;
}
}
byte[] primNrBytes = Utils.Int16ToBytes((short)avatarNr);
byte[] faceColor = new byte[] { primNrBytes[0], primNrBytes[1], (byte)faceNr, 254 };
GL.Color4(faceColor);
}
else
{
if (av.data[mesh.teFaceID] == null)
{
GL.Disable(EnableCap.Texture2D);
}
else
{
if (mesh.teFaceID != 0)
{
GL.Enable(EnableCap.Texture2D);
GL.BindTexture(TextureTarget.Texture2D, av.data[mesh.teFaceID].TextureInfo.TexturePointer);
}
else
{
GL.Disable(EnableCap.Texture2D);
}
}
}
GL.TexCoordPointer(2, TexCoordPointerType.Float, 0, mesh.RenderData.TexCoords);
GL.VertexPointer(3, VertexPointerType.Float, 0, mesh.RenderData.Vertices);
GL.NormalPointer(NormalPointerType.Float, 0, mesh.RenderData.Normals);
GL.DrawElements(BeginMode.Triangles, mesh.RenderData.Indices.Length, DrawElementsType.UnsignedShort, mesh.RenderData.Indices);
GL.BindTexture(TextureTarget.Texture2D, 0);
GL.PopMatrix();
}
av.glavatar.skel.mNeedsMeshRebuild = false;
}
// Whole avatar position
GL.PopMatrix();
}
GL.Disable(EnableCap.Texture2D);
GL.DisableClientState(ArrayCap.NormalArray);
GL.DisableClientState(ArrayCap.VertexArray);
GL.DisableClientState(ArrayCap.TextureCoordArray);
}
}
public override void Load()
{
base.Load();
if (OfflineCompilation)
{
return;
}
var renderTargets = new RenderTarget[2];
DepthStencilBuffer depthStencilBuffer = null;
Texture2D depthStencilTexture = null;
Parameters.AddSources(MainPlugin.ViewParameters);
Parameters.RegisterParameter(EffectPlugin.BlendStateKey);
var filteredPasses = new FastList <RenderPass>();
RenderPass.UpdatePasses += updatePassesAction = (RenderPass currentRenderPass, ref FastList <RenderPass> currentPasses) =>
{
var originalPasses = currentPasses;
filteredPasses.Clear();
currentPasses = filteredPasses;
Parameters.Set(PickingFrameIndex, ++currentPickingFrameIndex);
Request[] requests;
lock (pendingRequests)
{
// No picking request or no mesh to pick?
if (pendingRequests.Count == 0)
{
return;
}
requests = pendingRequests.ToArray();
pendingRequests.Clear();
}
foreach (var request in requests)
{
requestResults.Add(request);
}
if (originalPasses == null)
{
return;
}
// Count mesh passes
int meshIndex = 0;
foreach (var pass in originalPasses)
{
meshIndex += pass.Passes.Count;
}
// No mesh to pick?
if (meshIndex == 0)
{
return;
}
// Copy mesh passes and assign indices
var meshPasses = new EffectMesh[meshIndex];
meshIndex = 0;
foreach (var pass in RenderPass.Passes)
{
throw new NotImplementedException();
//foreach (var effectMeshPass in pass.Meshes)
//{
// meshPasses[meshIndex] = (EffectMesh)effectMeshPass;
// // Prefix increment so that 0 means no rendering.
// effectMeshPass.Parameters.Set(PickingMeshIndex, ++meshIndex);
//}
}
// For now, it generates one rendering per picking.
// It would be quite easy to optimize it by make Picking shader works on multiple picking points at a time.
foreach (var request in requests)
{
var pickingRenderPass = new RenderPass("Picking");
pickingRenderPass.StartPass.AddFirst = (threadContext) =>
{
threadContext.GraphicsDevice.Clear(renderTargets[0], Color.Black);
threadContext.GraphicsDevice.Clear(renderTargets[1], Color.Black);
threadContext.Parameters.Set(PickingScreenPosition, request.Location);
threadContext.GraphicsDevice.SetViewport(new Viewport(0, 0, renderTargets[0].Description.Width, renderTargets[0].Description.Height));
threadContext.GraphicsDevice.Clear(depthStencilBuffer, DepthStencilClearOptions.DepthBuffer);
threadContext.GraphicsDevice.SetRenderTargets(depthStencilBuffer, renderTargets);
};
pickingRenderPass.EndPass.AddLast = (threadContext) =>
{
threadContext.Parameters.Reset(PickingScreenPosition);
threadContext.GraphicsDevice.Copy(renderTargets[0].Texture, request.ResultTextures[0]);
threadContext.GraphicsDevice.Copy(renderTargets[1].Texture, request.ResultTextures[1]);
};
//pickingRenderPass.PassesInternal = originalPasses;
throw new NotImplementedException();
request.MeshPasses = meshPasses;
currentPasses.Add(pickingRenderPass);
request.HasResults = true;
// Wait 2 frames before pulling the results.
request.FrameCounter = 2;
}
};
RenderSystem.GlobalPass.EndPass.AddLast = CheckPickingResults;
var backBuffer = GraphicsDevice.BackBuffer;
int pickingArea = 1 + PickingDistance * 2;
renderTargets[0] = Texture.New2D(GraphicsDevice, pickingArea, pickingArea, PixelFormat.R32_UInt, TextureFlags.ShaderResource | TextureFlags.RenderTarget).ToRenderTarget().KeepAliveBy(ActiveObjects);
renderTargets[1] = Texture.New2D(GraphicsDevice, pickingArea, pickingArea, PixelFormat.R32G32B32A32_Float, TextureFlags.ShaderResource | TextureFlags.RenderTarget).ToRenderTarget().KeepAliveBy(ActiveObjects);
depthStencilTexture = Texture.New2D(GraphicsDevice, pickingArea, pickingArea, PixelFormat.D32_Float, TextureFlags.ShaderResource | TextureFlags.DepthStencil).KeepAliveBy(ActiveObjects);
depthStencilBuffer = depthStencilTexture.ToDepthStencilBuffer(false);
Parameters.AddDynamic(PickingMatrix, ParameterDynamicValue.New(PickingScreenPosition, (ref Vector2 pickingPosition, ref Matrix picking) =>
{
// Move center to picked position, and zoom (it is supposed to stay per-pixel according to render target size)
picking = Matrix.Translation(1.0f - (pickingPosition.X) / backBuffer.Width * 2.0f, -1.0f + (pickingPosition.Y) / backBuffer.Height * 2.0f, 0.0f)
* Matrix.Scaling((float)backBuffer.Width / (float)pickingArea, (float)backBuffer.Height / (float)pickingArea, 1.0f);
}));
}
private void RenderObjects(RenderPass pass)
{
if (!RenderSettings.PrimitiveRenderingEnabled) return;
GL.EnableClientState(ArrayCap.VertexArray);
GL.EnableClientState(ArrayCap.TextureCoordArray);
GL.EnableClientState(ArrayCap.NormalArray);
Vector3 myPos = Vector3.Zero;
if (myself != null)
{
myPos = myself.RenderPosition;
}
else
{
myPos = Client.Self.SimPosition;
}
if (pass == RenderPass.Invisible)
{
GL.Disable(EnableCap.Texture2D);
GL.StencilFunc(StencilFunction.Always, 1, 1);
GL.StencilOp(StencilOp.Keep, StencilOp.Keep, StencilOp.Replace);
GL.ColorMask(false, false, false, false);
GL.StencilMask(0);
}
int nrPrims = SortedObjects.Count;
for (int i = 0; i < nrPrims; i++)
{
//RenderBoundingBox(SortedPrims[i]);
// When rendering alpha faces, draw from back towards the camers
// otherwise from those closest to camera, to the farthest
int ix = pass == RenderPass.Alpha ? nrPrims - i - 1 : i;
SceneObject obj = SortedObjects[ix];
if (obj is RenderPrimitive)
{
// Don't render objects that are outside the draw distane
if (FindClosestDistanceSquared(myPos, obj) > drawDistanceSquared) continue;
if (pass == RenderPass.Simple || pass == RenderPass.Alpha)
{
obj.StartQuery(pass);
obj.Render(pass, ix, this, lastFrameTime);
obj.EndQuery(pass);
}
else
{
obj.Render(pass, ix, this, lastFrameTime);
}
}
}
if (pass == RenderPass.Invisible)
{
GL.StencilOp(StencilOp.Keep, StencilOp.Keep, StencilOp.Keep);
GL.ColorMask(true, true, true, true);
GL.StencilFunc(StencilFunction.Notequal, 1, 1);
GL.StencilMask(uint.MaxValue);
}
GL.Disable(EnableCap.Texture2D);
GL.DisableClientState(ArrayCap.VertexArray);
GL.DisableClientState(ArrayCap.TextureCoordArray);
GL.DisableClientState(ArrayCap.NormalArray);
}
public void Initialize(EngineContext engineContext)
{
var renderContext = engineContext.RenderContext;
var rootRenderPass = renderContext.RootRenderPass;
var linearColorPass = new RenderPass("LinearColor");
var reinhardColorPass = new RenderPass("ReinhardColor");
var yebisPass = new RenderPass("YebisColor");
var filmicColorPass = new RenderPass("FilmicColor");
var composeColorPass = new RenderPass("ComposeColor");
rootRenderPass.AddPass(linearColorPass);
rootRenderPass.AddPass(reinhardColorPass);
rootRenderPass.AddPass(yebisPass);
rootRenderPass.AddPass(filmicColorPass);
rootRenderPass.AddPass(composeColorPass);
LinearColorPlugin = new PostEffectPlugin("LinearColor")
{
RenderPass = linearColorPass
};
ReinhardColorPlugin = new PostEffectPlugin("ReinhardColor")
{
RenderPass = reinhardColorPass
};
#if XENKO_YEBIS
YebisPlugin = new YebisPlugin("ReinhardColor")
{
RenderPass = yebisPass
};
#endif
FilmicColorPlugin = new PostEffectPlugin("FilmicColor")
{
RenderPass = filmicColorPass
};
MainPlugin = new PostEffectPlugin("MainColor")
{
RenderPass = composeColorPass
};
//MainDepthReadOnlyPlugin
// YebisPlugin = new YebisPlugin() { RenderPass = yebisColorPass, MainDepthReadOnlyPlugin = null };
//renderContext.Register(MainDepthReadOnlyPlugin);
//renderContext.Register(SkyBoxPlugin);
//renderContext.Register(PostEffectPlugin);
//// Create and bind depth stencil buffer
//renderContext.GraphicsResizeContext.SetupResize(
// (resizeContext) =>
// {
// MainDepthReadOnlyPlugin.DepthStencil = renderContext.GraphicsDevice.DepthStencilBuffer.New(DepthFormat.Depth32, renderContext.Width, renderContext.Height, true, "MainDepthBuffer");
// // Bind render target - comment when Yebis is off
// MainDepthReadOnlyPlugin.RenderTarget = renderContext.GraphicsDevice.RenderTarget2D.New(renderContext.Width, renderContext.Height, PixelFormat.HalfVector4, name: "MainRenderTarget");
// // Comment - when Yebis is on
// //MainDepthReadOnlyPlugin.RenderTarget = renderContext.GraphicsDevice.RenderTarget2D.New(renderContext.Width, renderContext.Height, PixelFormat.R8G8B8A8, name: "MainRenderTarget");
// //renderContext.GlobalPass.EndPass.AddFirst = threadContext => threadContext.GraphicsDevice.Copy(MainDepthReadOnlyPlugin.RenderTarget, engineContext.RenderContext.RenderTarget);
// });
//// Yebis plugin must be initialized after creating MainDepthReadOnlyPlugin.RenderTarget
//renderContext.Register(YebisPlugin);
//YebisPlugin.ToneMap.Gamma = 1.0f;
//YebisPlugin.ToneMap.Type = ToneMapType.Auto;
//YebisPlugin.ToneMap.AutoExposure.MiddleGray = 0.25f;
//YebisPlugin.ToneMap.AutoExposure.AdaptationSensitivity = 0.5f;
//YebisPlugin.ToneMap.AutoExposure.AdaptationScale = 0.8f;
//YebisPlugin.ToneMap.AutoExposure.AdaptationSpeedLimit = 4.0f;
//YebisPlugin.ToneMap.AutoExposure.DarkAdaptationSensitivity = 0.9f;
//YebisPlugin.ToneMap.AutoExposure.DarkAdaptationScale = 0.6f;
//YebisPlugin.ToneMap.AutoExposure.DarkAdaptationSpeedLimit = 4.0f;
//YebisPlugin.ToneMap.AutoExposure.LightDarkExposureBorder = 1.0f;
//YebisPlugin.Glare.Enable = true;
//YebisPlugin.Glare.RemapFactor = 1f;
//YebisPlugin.Glare.Threshold = 0f;
//YebisPlugin.Lens.Vignette.Enable = true;
//YebisPlugin.ColorCorrection.ColorTemperature = 3500;
}
public override void Load()
{
base.Load();
if (OfflineCompilation)
return;
// Declare post render pass
PostPass = new RenderPass("PostPass").KeepAliveBy(ActiveObjects);
RenderPass.AddPass(PostPass);
var depthStencilTexture = Texture.New2D(GraphicsDevice, AtlasSize, AtlasSize, PixelFormat.D32_Float, TextureFlags.DepthStencil | TextureFlags.ShaderResource).KeepAliveBy(ActiveObjects);
var depthStencilBuffer = depthStencilTexture.ToDepthStencilBuffer(false);
ShadowMapDepth = depthStencilBuffer;
//MainTargetPlugin.Parameters.Set(ShadowMapKeys.Texture0, ShadowMapDepth);
// Setup clear of this target
var renderTargetPlugin = new RenderTargetsPlugin
{
Services = Services,
EnableClearDepth = true,
EnableSetTargets = false,
RenderPass = RenderPass,
RenderTarget = null,
DepthStencil = depthStencilBuffer,
};
renderTargetPlugin.Apply();
// Use Default ZTest for GBuffer
depthStencilStateZStandard = DepthStencilState.New(GraphicsDevice, new DepthStencilStateDescription().Default()).KeepAliveBy(ActiveObjects);
depthStencilStateZStandard.Name = "ZStandard";
Parameters.Set(EffectPlugin.DepthStencilStateKey, depthStencilStateZStandard);
casterRasterizerState = RasterizerState.New(GraphicsDevice, new RasterizerStateDescription(CullMode.Back)).KeepAliveBy(ActiveObjects);
// Variance Shadow Mapping
// Create the blur temporary texture
var shadowMapTextureDesc = ShadowMapDepth.Description;
var shadowMapBlurH = Texture.New2D(GraphicsDevice, shadowMapTextureDesc.Width, shadowMapTextureDesc.Height, PixelFormat.R32G32_Float, TextureFlags.ShaderResource | TextureFlags.RenderTarget).KeepAliveBy(ActiveObjects);
var shadowMapBlurV = Texture.New2D(GraphicsDevice, shadowMapTextureDesc.Width, shadowMapTextureDesc.Height, PixelFormat.R32G32_Float, TextureFlags.ShaderResource | TextureFlags.RenderTarget).KeepAliveBy(ActiveObjects);
Texture2D textureSourceH = ShadowMapDepth.Texture;
Texture2D textureSourceV = shadowMapBlurH;
RenderTarget renderTargetH = shadowMapBlurH.ToRenderTarget();
RenderTarget renderTargetV = shadowMapBlurV.ToRenderTarget();
var blurQuadMesh = new EffectMesh[2];
for (int j = 0; j < BlurCount; j++)
{
for (int i = 0; i < 2; ++i)
{
blurQuadMesh[i] = new EffectMesh(j > 0 ? blurEffects[1] : blurEffects[i]).KeepAliveBy(ActiveObjects);
blurQuadMesh[i].Parameters.Set(PostEffectBlurKeys.Coefficients, new[] { 0.2270270270f, 0.3162162162f, 0.3162162162f, 0.0702702703f, 0.0702702703f });
var unit = i == 0 ? Vector2.UnitX : Vector2.UnitY;
blurQuadMesh[i].Parameters.Set(PostEffectBlurKeys.Offsets, new[] { Vector2.Zero, unit * -1.3846153846f, unit * +1.3846153846f, unit * -3.2307692308f, unit * +3.2307692308f });
PostPass.AddPass(blurQuadMesh[i].EffectPass);
RenderSystem.GlobalMeshes.AddMesh(blurQuadMesh[i]);
}
blurQuadMesh[0].Parameters.Set(TexturingKeys.Texture0, textureSourceH);
blurQuadMesh[1].Parameters.Set(TexturingKeys.Texture0, textureSourceV);
blurQuadMesh[0].Parameters.Set(RenderTargetKeys.RenderTarget, renderTargetH);
blurQuadMesh[1].Parameters.Set(RenderTargetKeys.RenderTarget, renderTargetV);
textureSourceH = shadowMapBlurV;
textureSourceV = shadowMapBlurH;
}
ShadowMapVsm = shadowMapBlurV;
// Final texture for VSM is result of blur
//MainTargetPlugin.Parameters.Set(ShadowMapKeys.Texture0, shadowMapBlurV);
}
void RenderEntityList(Shader shader, RenderPass pass, List <BatchedEntity> list, VoxelObject commonVO = null)
{
// Pre-load mesh
Mesh mesh = null;
if (commonVO != null)
{
mesh = PrepareVO(commonVO, pass);
if (mesh == null)
{
return;
}
}
// Go through batch
foreach (BatchedEntity ent in list)
{
if (ent.OnlyRenderFor.HasValue && !ent.OnlyRenderFor.Value.HasFlag(pass))
{
continue;
}
// Load mesh if were not using a common vo
if (commonVO == null)
{
mesh = PrepareVO(ent.VoxelObject, pass);
if (mesh == null)
{
continue;
}
}
// Determine the world matrix
Matrix4 worldMatrix = ent.CustomMatrix
?? Maths.CreateTransformationMatrix(ent.Position, ent.MeshRotation, ent.VoxelObject.MeshScale);
shader.LoadMatrix4("transformationMatrix", worldMatrix);
// Prepare the entity
//if (ent.RenderFront && pass != RenderPass.Shadow) StateManager.DepthFunc(DepthFunction.Always);
//else StateManager.DepthFunc(DepthFunction.Less);
StateManager.ToggleWireframe(ent.RenderAsWireframe);
if (!pass.HasFlag(RenderPass.Shadow))
{
shader.LoadBool("skipLight", ent.ApplyNoLighting);
shader.LoadColor4("colorOverlay", ent.ColorOverlay);
shader.LoadFloat("entityLighting", 1f);
}
// Render the entity
GL.DrawElements(mesh.BeginMode, mesh.VertexCount, DrawElementsType.UnsignedInt, IntPtr.Zero);
// If we're not using a common vo, end it's mesh
if (commonVO == null)
{
Master.EndMesh();
}
}
// If we are using a common vo, end it's mesh last
if (commonVO != null)
{
Master.EndMesh();
}
}
