/// <summary>
/// This method draws a model mesh, with the given worldMatrix as viewed by the camera.
/// </summary>
/// <param name="mesh">The mesh to draw</param>
/// <param name="worldMatrix">The matrix holding the position, rotation and scale of the mesh</param>
/// <param name="camera">The camera which represents the user's current view</param>
public void DrawModelMesh(ModelMesh mesh, Matrix worldMatrix, bool applyCustomEffects)
{
Cameras.Camera currentCamera = DisplayController.Display.CurrentView.Camera;
// setup effect parameters for each effect
foreach (BasicEffect effect in mesh.Effects)
{
// use default settings for now.
effect.EnableDefaultLighting();
effect.PreferPerPixelLighting = true;
// the view, projection and world matrices must be setup for each effect, each frame.
effect.View = currentCamera.ViewMatrix;
effect.Projection = currentCamera.ProjectionMatrix;
effect.World = worldMatrix;
// apply custom effects (if any):
if (applyCustomEffects)
{
this.ApplyCustomEffects(effect);
}
// propagate changes. Any changes to parameters are not applied until CommitChanges() is called.
effect.CommitChanges();
}
// actually draw the model, now that all effects have been setup:
mesh.Draw();
}
public void MoveObjectToInFrontOfCamera(SceneGraph Node)
{
Cameras.Camera SceneCamera = OutsideSimulatorApp.GetInstance().SceneCamera;
Vector3 lav = (SceneCamera.LookAt - SceneCamera.Position);
lav.Normalize();
Node.Translation = OutsideSimulatorApp.GetInstance().SceneCamera.Position + lav * frontDist;
}
public void NewPlaceAction()
{
if (IsPlacing)
{
PlacingID++;
PlacingID %= RenderableList.Count;
IRenderable CreatedRenderable;
CreatedRenderable = System.Activator.CreateInstance(RenderableList[PlacingID]) as IRenderable;
CreateObject.Undo();
OutsideSimulatorApp.GetInstance().ObjectPicker.ClickedNode = LastPickedObject;
Cameras.Camera SceneCamera = OutsideSimulatorApp.GetInstance().SceneCamera;
Vector3 lav = (SceneCamera.LookAt - SceneCamera.Position);
lav.Normalize();
CreateObject = new CreateObject(
CreatedRenderable,
Matrix.Translation(SceneCamera.Position
+ lav * ObjectMover.frontDist));
CreateObject.Redo();
OutsideSimulatorApp.GetInstance().ObjectPicker.ClickedNode = CreateObject.ParentNode.Children[CreateObject.ChildName];
}
else
{
IsPlacing = true;
PlacingID = 0;
IRenderable CreatedRenderable;
CreatedRenderable = System.Activator.CreateInstance(RenderableList[PlacingID]) as IRenderable;
Cameras.Camera SceneCamera = OutsideSimulatorApp.GetInstance().SceneCamera;
Vector3 lav = (SceneCamera.LookAt - SceneCamera.Position);
lav.Normalize();
LastPickedObject = OutsideSimulatorApp.GetInstance().ObjectPicker.ClickedNode;
CreateObject = new CreateObject(
CreatedRenderable,
Matrix.Translation(SceneCamera.Position
+ lav * ObjectMover.frontDist));
CreateObject.Redo();
OutsideSimulatorApp.GetInstance().ObjectPicker.ClickedNode = CreateObject.ParentNode.Children[CreateObject.ChildName];
}
}
/// <summary>
/// This is the main function of the class, it'll create a triangulated polygon
/// from and SceneObject.
/// </summary>
/// <param name="sourceObject">The object to convert.</param>
/// <param name="guarenteedView">A camera that can see the whole object.</param>
/// <returns>A polygon created from 'sourceObject'.</returns>
public Polygon CreatePolygon(OpenGL gl, SceneObject sourceObject, Cameras.Camera guarenteedView)
{
// Save the current camera data.
gl.MatrixMode(OpenGL.PROJECTION);
gl.PushMatrix();
// Look through the camera that can see the object.
guarenteedView.Project(gl);
// Start triangulation.
Begin(gl);
// Draw the object.
sourceObject.Draw(gl);
// End triangulation.
End(gl);
Polygon newPoly = Triangle;
newPoly.Name = sourceObject.Name + " (Triangulated Poly)";
return(newPoly);
}
public virtual void DrawGameScene(GameTime gameTime, Cameras.Camera camera)
{
}
public virtual void Remove(Cameras.Camera value)
{
List.Remove(value);
}
public virtual int Add(Cameras.Camera value)
{
return(List.Add(value));
}
protected internal override void Render(Scenes.Scene scene, Cameras.Camera camera, int viewportWidth, int viewportHeight)
{
throw new NotImplementedException();
}
protected internal override void Render(Scenes.Scene scene, Cameras.Camera camera, int viewportWidth, int viewportHeight)
{
sprites.Clear();
scene.TraverseVisible(c =>
{
var sprite = c as Sprite;
if (sprite != null)
{
sprites.Add(sprite);
}
});
if (sprites.Count == 0)
{
return;
}
// setup gl
GL.UseProgram(program);
GL.EnableVertexAttribArray(attributes.position);
GL.EnableVertexAttribArray(attributes.uv);
GL.Disable(EnableCap.CullFace);
GL.Enable(EnableCap.Blend);
GL.BindBuffer(BufferTarget.ArrayBuffer, vertexBuffer);
GL.VertexAttribPointer(attributes.position, 2, VertexAttribPointerType.Float, false, 2 * 8, 0);
GL.VertexAttribPointer(attributes.uv, 2, VertexAttribPointerType.Float, false, 2 * 8, 8);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, elementBuffer);
GL.UniformMatrix4(uniforms.projectionMatrix, 16, false, camera.projectionMatrix.elements);
GL.ActiveTexture(TextureUnit.Texture0);
GL.Uniform1(uniforms.map, 0);
var oldFogType = 0;
var sceneFogType = 0;
var fog = scene.Fog;
if (fog != null)
{
GL.Uniform3(uniforms.fogColor, scene.Fog.Color.R, scene.Fog.Color.G, scene.Fog.Color.B);
var linear = fog as FogLinear;
var exp2 = fog as FogExp2;
if (linear != null)
{
GL.Uniform1(uniforms.fogNear, linear.Near);
GL.Uniform1(uniforms.fogFar, linear.Far);
GL.Uniform1(uniforms.fogType, 1);
oldFogType = 1;
sceneFogType = 1;
}
else if (exp2 != null)
{
GL.Uniform1(uniforms.fogDensity, exp2.Density);
GL.Uniform1(uniforms.fogType, 2);
oldFogType = 2;
sceneFogType = 2;
}
}
else
{
GL.Uniform1(uniforms.fogType, 0);
oldFogType = 0;
sceneFogType = 0;
}
// update positions and sort
foreach (var sprite in sprites)
{
var material = sprite.Material;
sprite.modelViewMatrix.MultiplyMatrices(camera.matrixWorldInverse, sprite.matrixWorld);
sprite.Zdepth = -sprite.modelViewMatrix.elements[14];
}
sprites.Sort(PainterSortStable);
// render all sprites
foreach (var sprite in sprites)
{
var material = sprite.Material as SpriteMaterial;
GL.Uniform1(uniforms.alphaTest, material.ShouldAlphaTest);
GL.UniformMatrix4((int)uniforms.modelViewMatrix, 16, false, sprite.modelViewMatrix.elements);
var fogType = 0;
if (scene.Fog != null && material.UseFog)
{
fogType = sceneFogType;
}
if (oldFogType != fogType)
{
GL.Uniform1(uniforms.fogType, fogType);
oldFogType = fogType;
}
if (material.DiffuseMap != null)
{
GL.Uniform2(uniforms.uvOffset, material.DiffuseMap.Offset.x, material.DiffuseMap.Offset.y);
GL.Uniform2(uniforms.uvScale, material.DiffuseMap.Repeat.x, material.DiffuseMap.Repeat.y);
}
else
{
GL.Uniform2(uniforms.uvOffset, 0, 0);
GL.Uniform2(uniforms.uvScale, 1, 1);
}
GL.Uniform1(uniforms.opacity, material.Opacity);
GL.Uniform3(uniforms.color, material.Diffuse.R, material.Diffuse.G, material.Diffuse.B);
GL.Uniform1(uniforms.rotation, material.Rotation);
GL.Uniform2(uniforms.scale, sprite.Scale.x, sprite.Scale.y);
renderer.SetBlending(material.Blending, material.BlendEquation, material.BlendSource, material.BlendDestination);
renderer.DepthTest = material.ShouldDepthTest;
renderer.DepthWrite = material.ShouldDepthWrite;
if (material.DiffuseMap != null && material.DiffuseMap.Resolution.Width > 0)
{
renderer.SetTexture(material.DiffuseMap, 0);
}
else
{
renderer.SetTexture(texture, 0);
}
GL.DrawElements(BeginMode.TriangleFan, 6, DrawElementsType.UnsignedShort, 0);
}
// restore gl
GL.Enable(EnableCap.CullFace);
}
