/// <summary>
/// <see cref="ISceneRenderer.Render"/>
/// </summary>
public void Render(ICameraController cam, Dictionary<Node, List<Mesh>> visibleMeshesByNode,
bool visibleSetChanged,
bool texturesChanged,
RenderFlags flags,
Renderer renderer)
{
GL.Disable(EnableCap.Texture2D);
GL.Hint(HintTarget.PerspectiveCorrectionHint, HintMode.Nicest);
GL.Enable(EnableCap.DepthTest);
GL.FrontFace(FrontFaceDirection.Ccw);
if (flags.HasFlag(RenderFlags.Wireframe))
{
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);
}
// If textures changed, we may need to upload some of them to VRAM.
if (texturesChanged)
{
UploadTextures();
}
GL.MatrixMode(MatrixMode.Modelview);
var view = cam == null ? Matrix4.LookAt(0, 10, 5, 0, 0, 0, 0, 1, 0) : cam.GetView();
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadMatrix(ref view);
var tmp = InitposeMax.X - InitposeMin.X;
tmp = Math.Max(InitposeMax.Y - InitposeMin.Y, tmp);
tmp = Math.Max(InitposeMax.Z - InitposeMin.Z, tmp);
tmp = 2.0f / tmp;
var world = Matrix4.Scale(tmp);
world *= Matrix4.CreateTranslation(-(InitposeMin + InitposeMax) * 0.5f);
PushWorld(ref world);
//
var animated = Owner.SceneAnimator.IsAnimationActive;
var needAlpha = RecursiveRender(Owner.Raw.RootNode, visibleMeshesByNode, flags, animated);
if (flags.HasFlag(RenderFlags.ShowSkeleton) || flags.HasFlag(RenderFlags.ShowNormals))
{
//RecursiveRenderNoScale(Owner.Raw.RootNode, visibleMeshesByNode, flags, 1.0f / tmp, animated);
}
if (needAlpha)
{
// handle semi-transparent geometry
RecursiveRenderWithAlpha(Owner.Raw.RootNode, visibleMeshesByNode, flags, animated);
}
PopWorld();
// always switch back to FILL
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
GL.Disable(EnableCap.DepthTest);
GL.Disable(EnableCap.Texture2D);
GL.Disable(EnableCap.Lighting);
}
public TextOverlay(Renderer renderer)
{
_renderer = renderer;
// Create Bitmap and OpenGL texture
var cs = renderer.RenderResolution;
_textBmp = new Bitmap(cs.Width, cs.Height); // match window size
_textTexture = GL.GenTexture();
GL.BindTexture(TextureTarget.Texture2D, _textTexture);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)All.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)All.Linear);
// just allocate memory, so we can update efficiently using TexSubImage2D
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, _textBmp.Width, _textBmp.Height, 0,
PixelFormat.Bgra, PixelType.UnsignedByte, IntPtr.Zero);
}
public override void BeginScene(Renderer renderer)
{
// set fixed-function lighting parameters
GL.ShadeModel(ShadingModel.Smooth);
GL.LightModel(LightModelParameter.LightModelAmbient, new[] { 0.3f, 0.3f, 0.3f, 1 });
GL.Enable(EnableCap.Lighting);
GL.Enable(EnableCap.Light0);
// light direction
var dir = new Vector3(1, 1, 0);
var mat = renderer.LightRotation;
Vector3.TransformNormal(ref dir, ref mat, out dir);
GL.Light(LightName.Light0, LightParameter.Position, new float[] { dir.X, dir.Y, dir.Z, 0 });
// light color
var col = new Vector3(1, 1, 1);
col *= (0.25f + 1.5f * GraphicsSettings.Default.OutputBrightness / 100.0f) * 1.5f;
GL.Light(LightName.Light0, LightParameter.Diffuse, new float[] { col.X, col.Y, col.Z, 1 });
GL.Light(LightName.Light0, LightParameter.Specular, new float[] { col.X, col.Y, col.Z, 1 });
}
public override void EndScene(Renderer renderer)
{
}
public override void BeginScene(Renderer renderer)
{
}
/// <summary>
/// <see cref="ISceneRenderer.Render"/>
/// </summary>
public void Render(ICameraController cam, Dictionary<Node, List<Mesh>> visibleMeshesByNode,
bool visibleSetChanged,
bool texturesChanged,
RenderFlags flags,
Renderer renderer)
{
GL.Disable(EnableCap.Texture2D);
GL.Hint(HintTarget.PerspectiveCorrectionHint, HintMode.Nicest);
GL.Enable(EnableCap.DepthTest);
// set fixed-function lighting parameters
GL.ShadeModel(ShadingModel.Smooth);
GL.LightModel(LightModelParameter.LightModelAmbient, new[] { 0.3f, 0.3f, 0.3f, 1 });
GL.Enable(EnableCap.Lighting);
GL.Enable(EnableCap.Light0);
if (flags.HasFlag(RenderFlags.Wireframe))
{
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);
}
var tmp = InitposeMax.X - InitposeMin.X;
tmp = Math.Max(InitposeMax.Y - InitposeMin.Y, tmp);
tmp = Math.Max(InitposeMax.Z - InitposeMin.Z, tmp);
var scale = 2.0f / tmp;
// TODO: migrate general scale and this snippet to camcontroller code
if (cam != null)
{
cam.SetPivot(Owner.Pivot * (float)scale);
}
var view = cam == null ? Matrix4.LookAt(0, 10, 5, 0, 0, 0, 0, 1, 0) : cam.GetView();
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadMatrix(ref view);
// light direction
var dir = new Vector3(1, 1, 0);
var mat = renderer.LightRotation;
Vector3.TransformNormal(ref dir, ref mat, out dir);
GL.Light(LightName.Light0, LightParameter.Position, new float[] { dir.X, dir.Y, dir.Z, 0 });
// light color
var col = new Vector3(1, 1, 1);
col *= (0.25f + 1.5f * GraphicsSettings.Default.OutputBrightness / 100.0f) * 1.5f;
GL.Light(LightName.Light0, LightParameter.Diffuse, new float[] { col.X, col.Y, col.Z, 1 });
GL.Light(LightName.Light0, LightParameter.Specular, new float[] { col.X, col.Y, col.Z, 1 });
if (flags.HasFlag(RenderFlags.Shaded))
{
OverlayLightSource.DrawLightSource(dir);
}
GL.Scale(scale, scale, scale);
// If textures changed, we may need to upload some of them to VRAM.
// it is important this happens here and not accidentially while
// compiling a displist.
if (texturesChanged)
{
UploadTextures();
}
GL.PushMatrix();
// Build and cache Gl displaylists and update only when the scene changes.
// when the scene is being animated, this is bad because it changes every
// frame anyway. In this case we don't use a displist.
var animated = Owner.SceneAnimator.IsAnimationActive;
if (_displayList == 0 || visibleSetChanged || texturesChanged || flags != _lastFlags || animated)
{
_lastFlags = flags;
// handle opaque geometry
if (!animated)
{
if (_displayList == 0)
{
_displayList = GL.GenLists(1);
}
GL.NewList(_displayList, ListMode.Compile);
}
var needAlpha = RecursiveRender(Owner.Raw.RootNode, visibleMeshesByNode, flags, animated);
if (flags.HasFlag(RenderFlags.ShowSkeleton))
{
RecursiveRenderNoScale(Owner.Raw.RootNode, visibleMeshesByNode, flags, 1.0f / scale, animated);
}
if (flags.HasFlag(RenderFlags.ShowNormals))
{
RecursiveRenderNormals(Owner.Raw.RootNode, visibleMeshesByNode, flags, 1.0f / scale, animated, Matrix4.Identity);
}
if (!animated)
{
GL.EndList();
}
if (needAlpha)
{
// handle semi-transparent geometry
if (!animated)
{
if (_displayListAlpha == 0)
{
_displayListAlpha = GL.GenLists(1);
}
GL.NewList(_displayListAlpha, ListMode.Compile);
}
RecursiveRenderWithAlpha(Owner.Raw.RootNode, visibleMeshesByNode, flags, animated);
if (!animated)
{
GL.EndList();
}
}
else if (_displayListAlpha != 0)
{
GL.DeleteLists(_displayListAlpha, 1);
_displayListAlpha = 0;
}
}
if (!animated)
{
GL.CallList(_displayList);
if (_displayListAlpha != 0)
{
GL.CallList(_displayListAlpha);
}
}
GL.PopMatrix();
// always switch back to FILL
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
GL.Disable(EnableCap.DepthTest);
#if TEST
GL.Enable(EnableCap.ColorMaterial);
// TEST CODE to visualize mid point (pivot) and origin
GL.LoadMatrix(ref view);
GL.Begin(BeginMode.Lines);
GL.Vertex3((InitposeMin + InitposeMax) * 0.5f * (float)scale);
GL.Color3(0.0f, 1.0f, 0.0f);
GL.Vertex3(0,0,0);
GL.Color3(0.0f, 1.0f, 0.0f);
GL.Vertex3((InitposeMin + InitposeMax) * 0.5f * (float)scale);
GL.Color3(0.0f, 1.0f, 0.0f);
GL.Vertex3(10, 10, 10);
GL.Color3(0.0f, 1.0f, 0.0f);
GL.End();
#endif
GL.Disable(EnableCap.Texture2D);
GL.Disable(EnableCap.Lighting);
}
/// <summary>
/// Call once per frame to render the scene to the current viewport.
/// </summary>
public void Render(UiState state, ICameraController cam, Renderer target)
{
RenderFlags flags = 0;
if (state.ShowNormals)
{
flags |= RenderFlags.ShowNormals;
}
if (state.ShowBBs)
{
flags |= RenderFlags.ShowBoundingBoxes;
}
if (state.ShowSkeleton || _overrideSkeleton)
{
flags |= RenderFlags.ShowSkeleton;
}
if (state.RenderLit)
{
flags |= RenderFlags.Shaded;
}
if (state.RenderTextured)
{
flags |= RenderFlags.Textured;
}
if (state.RenderWireframe)
{
flags |= RenderFlags.Wireframe;
}
flags |= RenderFlags.ShowGhosts;
_wantSetTexturesChanged = false;
_renderer.Render(cam, _meshesToShow, _nodesToShowChanged, _texturesChanged, flags, target);
lock (_texChangeLock)
{
if (!_wantSetTexturesChanged)
{
_texturesChanged = false;
}
}
_nodesToShowChanged = false;
}
private void OnGlLoad(object sender, EventArgs e)
{
if (_renderer != null)
{
_renderer.Dispose();
}
_renderer = new Renderer(this);
#if USE_APP_IDLE
// register Idle event so we get regular callbacks for drawing
Application.Idle += ApplicationIdle;
#else
_timer = new System.Windows.Forms.Timer();
_timer.Interval = 20;
_timer.Tick += ApplicationIdle;
_timer.Start();
#endif
}
public override void EndScene(Renderer renderer)
{
GL.Disable(EnableCap.Lighting);
}
public abstract void EndScene(Renderer renderer);
public abstract void BeginScene(Renderer renderer);
public override void EndScene(Renderer renderer)
{
GL.Disable(EnableCap.Lighting);
}
