public void Render(CameraOrbit camera)
{
if (ReferenceEquals(null, shaderObject))
{
return;
}
if (ReferenceEquals(null, shaderShadow))
{
return;
}
// calculate value for candle light flickering
timeSpan = stopWatch.Elapsed;
double elapsedTime = timeSpan.TotalMilliseconds;
var factor = 1;
if (smokeState)
{
factor = 4;
}
float candleFlickering = (float)Math.Sin((elapsedTime / 1000 / factor) + (.2 + random.NextDouble())) / 30 * factor;
// setup light for shadow
cameraLight.Distance = this.lightPosition[1] + candleFlickering;
var light = cameraLight.CalcMatrix().ToOpenTK();
shaderShadow.Activate();
fboShadowMap.Activate();
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
GL.UniformMatrix4(shaderShadow.GetUniformLocation("camera"), true, ref light);
this.DrawScene(shaderShadow, cameraLight, candleFlickering);
fboShadowMap.Deactivate();
shaderShadow.Deactivate();
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
shaderObject.Activate();
fboShadowMap.Texture.Activate();
var cam = camera.CalcMatrix().ToOpenTK();
GL.UniformMatrix4(shaderObject.GetUniformLocation("camera"), true, ref cam);
GL.UniformMatrix4(shaderObject.GetUniformLocation("light"), true, ref light);
this.DrawScene(shaderObject, camera, candleFlickering);
fboShadowMap.Texture.Deactivate();
shaderObject.Deactivate();
// draw environment
shaderObject.Activate();
this.DrawEnvironment(shaderObject, camera);
shaderObject.Deactivate();
}
public override void Initialize(HostInterface CurrentHost, BaseOptions CurrentOptions)
{
base.Initialize(CurrentHost, CurrentOptions);
try
{
if (pickingShader == null)
{
pickingShader = new Shader(this, "default", "picking", true);
}
pickingShader.Activate();
pickingShader.Deactivate();
}
catch
{
Interface.AddMessage(MessageType.Error, false, "Initializing the touch shader failed- Falling back to legacy openGL.");
Interface.CurrentOptions.IsUseNewRenderer = false;
ForceLegacyOpenGL = true;
}
events = new Events(this);
overlays = new Overlays(this);
Touch = new Touch(this);
ObjectsSortedByStart = new int[] { };
ObjectsSortedByEnd = new int[] { };
Program.FileSystem.AppendToLogFile("Renderer initialised successfully.");
}
internal Touch(NewRenderer renderer)
{
this.renderer = renderer;
objectStates = new List <ObjectState>();
touchFaces = new List <FaceState>();
try
{
pickingShader = new Shader("default", "picking", true);
pickingShader.Activate();
pickingShader.Deactivate();
}
catch
{
Interface.AddMessage(MessageType.Error, false, "Initialising the touch shader failed- Falling back to legacy openGL.");
Interface.CurrentOptions.IsUseNewRenderer = false;
}
fbo = new FrameBufferObject();
fbo.Bind();
fbo.SetTextureBuffer(FrameBufferObject.TargetBuffer.Color, PixelInternalFormat.R32f, PixelFormat.Red, PixelType.Float, renderer.Screen.Width, renderer.Screen.Height);
fbo.DrawBuffers(new[] { DrawBuffersEnum.ColorAttachment0 });
fbo.UnBind();
}
private void DrawWithShader(Texture texture, Vector2 point, Vector2 size, Color128?color, Vector2 coordinates)
{
Shader.Activate();
if (texture != null && renderer.currentHost.LoadTexture(ref texture, OpenGlTextureWrapMode.ClampClamp))
{
GL.BindTexture(TextureTarget.Texture2D, texture.OpenGlTextures[(int)OpenGlTextureWrapMode.ClampClamp].Name);
renderer.LastBoundTexture = texture.OpenGlTextures[(int)OpenGlTextureWrapMode.ClampClamp];
}
else
{
Shader.DisableTexturing();
}
Shader.SetCurrentProjectionMatrix(renderer.CurrentProjectionMatrix);
Shader.SetCurrentModelViewMatrix(renderer.CurrentViewMatrix);
Shader.SetColor(color == null ? Color128.White : color.Value);
Shader.SetPoint(point);
Shader.SetSize(size);
Shader.SetCoordinates(coordinates);
/*
* In order to call GL.DrawArrays with procedural data within the shader,
* we first need to bind a dummy VAO
* If this is not done, it will generate an InvalidOperation error code
*/
renderer.dummyVao.Bind();
GL.DrawArrays(PrimitiveType.TriangleStrip, 0, 6);
}
public void Render()
{
var cameraTranslation = CameraComponent.Active.Position;
GL.Translate(cameraTranslation.X, cameraTranslation.Y, 0);
// Draw the normal stuff into the fbo
fbo.Activate();
player.GetComponent <RenderTextureComponent>().Render();
// var v = new RenderTextureComponent(Resource.heart, Player.PLAYER_SIZE * 10f, Player.PLAYER_SIZE * 10f);
// v.Render();
fbo.Deactivate();
GL.Translate(-cameraTranslation.X, -cameraTranslation.Y, 0);
// Draw the fbo
GL.Enable(EnableCap.Texture2D);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
GL.Enable(EnableCap.Blend);
fbo.Texture.Activate();
shader.Activate();
DrawWindowFillingQuad();
shader.Deactivate();
fbo.Texture.Deactivate();
GL.Disable(EnableCap.Blend);
GL.Disable(EnableCap.Texture2D);
}
public void Render(KBuild build, KAnimBank bank, int frameNumber)
{
Matrix4 modelMat = Matrix4.Identity;
Matrix4 pivotMat = Matrix4.Identity;
Matrix4 transformMat = Matrix4.Identity;
geoShader.Activate();
// Draw Origin
geoShader.SetUniform("Model", ref modelMat);
origin.Draw();
if (frameNumber < 0 || frameNumber >= bank.FrameCount)
{
frameNumber = 0;
}
KAnimFrame frame = bank.Frames[frameNumber];
Matrix4 frameMat = Matrix4.CreateTranslation(frame.X, frame.Y, 0);
spriteShader.Activate();
texture.Bind();
for (int i = frame.ElementCount - 1; i >= 0; i--)
{
KAnimElement element = frame.Elements[i];
string symbol = build.GetSymbolName(element.SymbolHash);
if (symbol == null)
{
continue;
}
KFrame sprite = build.GetFrame(symbol, element.FrameNumber);
if (sprite == null)
{
continue;
}
pivotMat = Matrix4.CreateTranslation(sprite.PivotX, sprite.PivotY, 0);
transformMat = new Matrix4(
element.M00, -element.M10, 0, 0,
element.M01, -element.M11, 0, 0,
0, 0, -1, 0,
element.M02, -element.M12, 0, 1
);
modelMat = halfScaleMat * pivotMat * transformMat;
spriteShader.SetUniform("Model", ref modelMat);
MakeQuadVBO(sprite.PivotWidth, sprite.PivotHeight, element.Red, element.Green, element.Blue, element.Alpha, sprite.GetUVRectangle(), out Vertex[] vertices, out int[] elements);
quad.SetData(OpenTK.Graphics.OpenGL.PrimitiveType.Triangles, vertices, elements);
quad.Draw();
}
}
public void Render()
{
GL.Disable(EnableCap.CullFace);
_shader.Activate();
_texture.Activate();
_geometry.Draw();
_texture.Deactivate();
_shader.Deactivate();
GL.Enable(EnableCap.CullFace);
}
private void Render()
{
if (ReferenceEquals(shader, null))
{
return;
}
GL.Clear(ClearBufferMask.ColorBufferBit);
shader.Activate();
GL.DrawArrays(PrimitiveType.Quads, 0, 4);
shader.Deactivate();
}
private void Render()
{
glTimerRender.Activate(QueryTarget.TimeElapsed);
GL.Clear(ClearBufferMask.ColorBufferBit);
shader.Activate();
GL.DrawArrays(PrimitiveType.Quads, 0, 4);
shader.Deactivate();
glTimerRender.Deactivate();
Console.Write("Rendertime:");
Console.Write(glTimerRender.ResultLong / 1e6);
Console.WriteLine("msec");
}
public void Render()
{
if (shader != null)
{
shader.Activate();
}
GL.BindVertexArray(vaoHandle);
// TODO: handle untextured materials properly
if (material != null && lastTextureBound != material.Texture.Handle)
{
material.Texture.Activate();
if (shader != null)
{
if (shader.IsUniformNameSet(ShaderCommonUniform.MaterialAmbientColor))
{
shader.SetUniform(ShaderCommonUniform.MaterialAmbientColor, material.Ambient);
}
if (shader.IsUniformNameSet(ShaderCommonUniform.MaterialDiffuseColor))
{
shader.SetUniform(ShaderCommonUniform.MaterialDiffuseColor, material.Diffuse);
}
if (shader.IsUniformNameSet(ShaderCommonUniform.MaterialSpecularColor))
{
shader.SetUniform(ShaderCommonUniform.MaterialSpecularColor, material.Specular);
}
}
lastTextureBound = material.Texture.Handle;
}
if (elementBufferHandle != -1)
{
if (lastElementBufferBound != elementBufferHandle)
{
GL.BindBuffer(BufferTarget.ElementArrayBuffer, elementBufferHandle);
lastElementBufferBound = elementBufferHandle;
}
GL.DrawElements(primitiveType, numElementsToDraw, drawElementsType, 0);
}
else
{
GL.DrawArrays(primitiveType, 0, numElementsToDraw);
}
}
/// <summary>
/// Call this once to initialise the renderer
/// </summary>
public virtual void Initialize(HostInterface CurrentHost, BaseOptions CurrentOptions)
{
currentHost = CurrentHost;
currentOptions = CurrentOptions;
Background = new Background(this);
Fog = new Fog();
OpenGlString = new OpenGlString(this);
TextureManager = new TextureManager(currentHost);
Cube = new Cube(this);
Rectangle = new Rectangle(this);
Loading = new Loading(this);
Keys = new Keys(this);
MotionBlur = new MotionBlur(this);
StaticObjectStates = new List <ObjectState>();
DynamicObjectStates = new List <ObjectState>();
VisibleObjects = new VisibleObjectLibrary(currentHost, Camera, currentOptions, this);
try
{
DefaultShader = new Shader("default", "default", true);
DefaultShader.Activate();
DefaultShader.Deactivate();
}
catch
{
CurrentHost.AddMessage(MessageType.Error, false, "Initialising the default shaders failed- Falling back to legacy openGL.");
CurrentOptions.IsUseNewRenderer = false;
}
GL.ClearColor(0.67f, 0.67f, 0.67f, 1.0f);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
GL.Enable(EnableCap.DepthTest);
GL.DepthFunc(DepthFunction.Lequal);
SetBlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
GL.Hint(HintTarget.FogHint, HintMode.Fastest);
GL.Hint(HintTarget.LineSmoothHint, HintMode.Fastest);
GL.Hint(HintTarget.PerspectiveCorrectionHint, HintMode.Fastest);
GL.Hint(HintTarget.PointSmoothHint, HintMode.Fastest);
GL.Hint(HintTarget.PolygonSmoothHint, HintMode.Fastest);
GL.Hint(HintTarget.GenerateMipmapHint, HintMode.Nicest);
GL.Enable(EnableCap.CullFace);
GL.CullFace(CullFaceMode.Front);
GL.Disable(EnableCap.Texture2D);
GL.Disable(EnableCap.Dither);
GL.Disable(EnableCap.Lighting);
GL.Disable(EnableCap.Fog);
GL.Fog(FogParameter.FogMode, (int)FogMode.Linear);
}
/// <summary>
/// Performs a reset of OpenGL to the default state
/// </summary>
public virtual void ResetOpenGlState()
{
GL.Enable(EnableCap.CullFace);
GL.Disable(EnableCap.Lighting);
GL.Disable(EnableCap.Fog);
GL.Disable(EnableCap.Texture2D);
SetBlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
UnsetBlendFunc();
GL.Enable(EnableCap.DepthTest);
GL.DepthMask(true);
SetAlphaFunc(AlphaFunction.Greater, 0.9f);
DefaultShader.Activate();
ResetShader(DefaultShader);
DefaultShader.Deactivate();
}
private void DrawWithShader(string text, OpenGlFont font, double left, double top, Color128 color)
{
Shader.Activate();
renderer.CurrentShader = Shader;
Shader.SetCurrentProjectionMatrix(renderer.CurrentProjectionMatrix);
Shader.SetCurrentModelViewMatrix(renderer.CurrentViewMatrix);
for (int i = 0; i < text.Length; i++)
{
Texture texture;
OpenGlFontChar data;
i += font.GetCharacterData(text, i, out texture, out data) - 1;
if (renderer.currentHost.LoadTexture(texture, OpenGlTextureWrapMode.ClampClamp))
{
GL.BindTexture(TextureTarget.Texture2D, texture.OpenGlTextures[(int)OpenGlTextureWrapMode.ClampClamp].Name);
Shader.SetAtlasLocation(data.TextureCoordinates);
double x = left - (data.PhysicalSize.X - data.TypographicSize.X) / 2;
double y = top - (data.PhysicalSize.Y - data.TypographicSize.Y) / 2;
/*
* In the first pass, mask off the background with pure black.
*/
GL.BlendFunc(BlendingFactor.Zero, BlendingFactor.OneMinusSrcColor);
Shader.SetColor(new Color128(color.A, color.A, color.A, 1.0f));
Shader.SetPoint(new Vector2(x, y));
Shader.SetSize(data.PhysicalSize);
/*
* In order to call GL.DrawArrays with procedural data within the shader,
* we first need to bind a dummy VAO
* If this is not done, it will generate an InvalidOperation error code
*/
renderer.dummyVao.Bind();
GL.DrawArrays(PrimitiveType.TriangleStrip, 0, 6);
GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.One);
Shader.SetColor(color);
GL.DrawArrays(PrimitiveType.TriangleStrip, 0, 6);
}
left += data.TypographicSize.X;
}
renderer.RestoreBlendFunc();
}
internal void RenderScene()
{
PreRender();
if (touchFaces.Count == 0)
{
//Drop out early if the pre-render process reveals no available touch faces for a minor boost
return;
}
renderer.ResetOpenGlState();
fbo.Bind();
GL.ClearColor(0.0f, 0.0f, 0.0f, 0.0f);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
pickingShader.Activate();
pickingShader.SetCurrentProjectionMatrix(renderer.CurrentProjectionMatrix);
foreach (FaceState face in touchFaces)
{
pickingShader.SetObjectIndex(objectStates.IndexOf(face.Object) + 1);
renderer.RenderFace(pickingShader, face);
}
//Must deactivate and unbind here
pickingShader.Deactivate();
fbo.UnBind();
// for debug
if (renderer.DebugTouchMode)
{
GL.DepthMask(false);
GL.Disable(EnableCap.DepthTest);
renderer.DefaultShader.Activate();
renderer.ResetShader(renderer.DefaultShader);
renderer.DefaultShader.SetCurrentProjectionMatrix(renderer.CurrentProjectionMatrix);
foreach (FaceState face in touchFaces)
{
renderer.RenderFace(renderer.DefaultShader, face, true);
}
renderer.DefaultShader.Deactivate();
}
}
internal void RenderScene()
{
PreRender();
renderer.ResetOpenGlState();
fbo.Bind();
GL.ClearColor(0.0f, 0.0f, 0.0f, 0.0f);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
foreach (FaceState face in touchFaces)
{
pickingShader.Activate();
renderer.ResetShader(pickingShader);
pickingShader.SetObjectIndex(objectStates.IndexOf(face.Object) + 1);
renderer.RenderFace(pickingShader, face);
pickingShader.Deactivate();
}
fbo.UnBind();
// for debug
if (renderer.DebugTouchMode)
{
GL.DepthMask(false);
GL.Disable(EnableCap.DepthTest);
foreach (FaceState face in touchFaces)
{
renderer.DefaultShader.Activate();
renderer.ResetShader(renderer.DefaultShader);
renderer.RenderFace(renderer.DefaultShader, face, true);
renderer.DefaultShader.Deactivate();
}
}
}
private void Init()
{
Shader.Activate(m_activeShader);
Texture.Bind(m_activeTexture);
}
private void RenderAll(Material overrideMaterial)
{
currentMesh = null;
currentShader = null;
foreach (var shaderPair in renderers)
{
if (!engine.shaderManager.GetShaderByHandle(shaderPair.Key).WriteMask&& overrideMaterial != null)
{
continue;
}
if (overrideMaterial != null)
{
currentShader = engine.shaderManager.GetShaderByHandle(overrideMaterial.ShaderHandle);
}
else
{
currentShader = engine.shaderManager.GetShaderByHandle(shaderPair.Key);
}
currentShader.Activate();
foreach (var materialPair in shaderPair.Value)
{
SetZWrite(materialPair.Key.Shader.ZWrite);
foreach (var texturePair in materialPair.Key.textures)
{
texturePair.Value.Activate(texturePair.Key);
}
if (overrideMaterial == null)
{
foreach (var bufferKeyPair in materialPair.Key.structuredBuffers)
{
bufferKeyPair.Value.Activate(bufferKeyPair.Key);
}
foreach (var bufferKeyPair in materialPair.Key.structuredPixelsBuffers)
{
bufferKeyPair.Value.Activate(bufferKeyPair.Key);
}
foreach (var bufferKeyPair in materialPair.Key.structuredVertexBuffers)
{
bufferKeyPair.Value.Activate(bufferKeyPair.Key);
}
}
foreach (var meshPair in materialPair.Value)
{
if (currentMesh != meshPair.Key)
{
meshPair.Key.VerticesBuffer.Activate(0);
meshPair.Key.IndicesBuffer.Activate(0);
currentMesh = meshPair.Key;
}
if (currentShader.Instancing)
{
if (instancesArray.Length < meshPair.Value.Count)
{
instancesArray = new Matrix[meshPair.Value.Count];
}
for (int i = 0; i < meshPair.Value.Count; ++i)
{
instancesArray[i] = meshPair.Value[i].LocalToWorldMatrix;
}
instancesBuffer.UpdateBuffer(instancesArray);
instancesBuffer.Activate(1);
engine.Device.DrawIndexedInstanced(meshPair.Key.IndexCount, meshPair.Value.Count, 0, 0, 0);
}
else
{
foreach (var instance in meshPair.Value)
{
objectData.WorldMatrix = instance.LocalToWorldMatrix;
objectBuffer.UpdateBuffer(ref objectData);
engine.Device.DrawIndexed(meshPair.Key.IndexCount, 0, 0);
}
}
}
}
}
}