/// <summary>
/// Build a look at view matrix.
/// transform object's coordinate from world's space to camera's space.
/// </summary>
/// <param name="eye">The eye.</param>
/// <param name="center">The center.</param>
/// <param name="up">Up.</param>
/// <returns></returns>
public static mat4 lookAt(vec3 eye, vec3 center, vec3 up)
{
// camera's back in world space coordinate system
vec3 back = (eye - center).normalize();
// camera's right in world space coordinate system
vec3 right = up.cross(back).normalize();
// camera's up in world space coordinate system
vec3 standardUp = back.cross(right);
mat4 viewMatrix = new mat4(1);
viewMatrix.col0.x = right.x;
viewMatrix.col1.x = right.y;
viewMatrix.col2.x = right.z;
viewMatrix.col0.y = standardUp.x;
viewMatrix.col1.y = standardUp.y;
viewMatrix.col2.y = standardUp.z;
viewMatrix.col0.z = back.x;
viewMatrix.col1.z = back.y;
viewMatrix.col2.z = back.z;
// Translation in world space coordinate system
viewMatrix.col3.x = -eye.dot(right);
viewMatrix.col3.y = -eye.dot(standardUp);
viewMatrix.col3.z = -eye.dot(back);
return viewMatrix;
}
/// <summary>
/// 把连续16个float值按照列优先的顺序转换为mat4
/// </summary>
/// <param name="values"></param>
/// <param name="startIndex"></param>
/// <returns></returns>
public static mat4 ToMat4(this float[] values, int startIndex = 0)
{
mat4 result = new mat4(
values.ToVec4(startIndex + 0), values.ToVec4(startIndex + 4), values.ToVec4(startIndex + 8), values.ToVec4(startIndex + 12));
return result;
}
/// <summary>
/// Move vertexes' position accroding to difference on screen.
/// <para>根据<paramref name="differenceOnScreen"/>来修改指定索引处的顶点位置。</para>
/// </summary>
/// <param name="differenceOnScreen"></param>
/// <param name="viewMatrix"></param>
/// <param name="projectionMatrix"></param>
/// <param name="viewport"></param>
/// <param name="positionIndexes"></param>
public override void MovePositions(Point differenceOnScreen,
mat4 viewMatrix, mat4 projectionMatrix, vec4 viewport, params uint[] positionIndexes)
{
base.MovePositions(differenceOnScreen, viewMatrix, projectionMatrix, viewport, positionIndexes);
this.needsUpdating = true;
}
/// <summary>
/// Move vertexes' position accroding to difference on screen.
/// <para>根据<paramref name="differenceOnScreen"/>来修改指定索引处的顶点位置。</para>
/// </summary>
/// <param name="differenceOnScreen"></param>
/// <param name="viewMatrix"></param>
/// <param name="projectionMatrix"></param>
/// <param name="viewport"></param>
/// <param name="positionIndexes"></param>
public virtual void MovePositions(Point differenceOnScreen,
mat4 viewMatrix, mat4 projectionMatrix, vec4 viewport, params uint[] positionIndexes)
{
if (positionIndexes == null) { return; }
if (positionIndexes.Length == 0) { return; }
this.innerPickableRenderer.MovePositions(differenceOnScreen, viewMatrix, projectionMatrix, viewport, positionIndexes);
}
/// <summary>
/// Move vertexes' position accroding to difference on screen.
/// <para>根据<paramref name="differenceOnScreen"/>来修改指定索引处的顶点位置。</para>
/// </summary>
/// <param name="differenceOnScreen"></param>
/// <param name="viewMatrix"></param>
/// <param name="projectionMatrix"></param>
/// <param name="viewport"></param>
/// <param name="positionIndexes"></param>
public virtual void MovePositions(Point differenceOnScreen,
mat4 viewMatrix, mat4 projectionMatrix, vec4 viewport, IEnumerable<uint> positionIndexes)
{
if (positionIndexes == null) { return; }
if (positionIndexes.Count() == 0) { return; }
this.innerPickableRenderer.MovePositions(differenceOnScreen, viewMatrix, projectionMatrix, viewport, positionIndexes);
}
mat4 IPerspectiveCamera.GetPerspectiveProjectionMatrix()
{
if (perspectiveCameraRecord.IsMarked())
{
var camera = this as IPerspectiveCamera;
perspectiveProjectionMatrix = glm.perspective(
(float)(camera.FieldOfView * Math.PI / 180.0f),
(float)camera.AspectRatio, (float)camera.Near, (float)camera.Far);
perspectiveCameraRecord.CancelMark();
}
return perspectiveProjectionMatrix;
}
/// <summary>
/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite.
/// </summary>
/// <param name="fovy">The fovy.</param>
/// <param name="aspect">The aspect.</param>
/// <param name="zNear">The z near.</param>
/// <returns></returns>
public static mat4 infinitePerspective(float fovy, float aspect, float zNear)
{
float range = tan(fovy / (2f)) * zNear;
float left = -range * aspect;
float right = range * aspect;
float bottom = -range;
float top = range;
var result = new mat4(0);
result[0, 0] = ((2f) * zNear) / (right - left);
result[1, 1] = ((2f) * zNear) / (top - bottom);
result[2, 2] = -(1f);
result[2, 3] = -(1f);
result[3, 2] = -(2f) * zNear;
return result;
}
public void CastShadow(ShdowMappingEventArgs arg)
{
if (!this.IsInitialized)
{
this.Initialize();
}
LightBase light = arg.CurrentLight;
mat4 projection = light.GetProjectionMatrix();
mat4 view = light.GetViewMatrix();
mat4 model = this.GetModelMatrix();
var method = this.RenderUnit.Methods[0]; // shadowmapBuilder
ShaderProgram program = method.Program;
program.SetUniform(mvpMatrix, projection * view * model);
method.Render();
}
/// <summary>
///
/// </summary>
/// <param name="arg"></param>
public void RenderBeforeChildren(RenderEventArgs arg)
{
if (!this.IsInitialized)
{
this.Initialize();
}
if (this.AutoRotate)
{
float delta = 6;
this.RotationAngle += delta;
var position = new vec3(
(float)Math.Cos(this.RotationAngle * Math.PI / 180.0),
(float)Math.Cos(this.RotationAngle / 5 * Math.PI / 180.0) + 2.2f,
(float)Math.Sin(this.RotationAngle * Math.PI / 180.0)) * 8;
this.light.Position = position;
if (this.light is DirectionalLight)
{
(this.light as DirectionalLight).Direction = position;
}
else if (this.light is SpotLight)
{
//(this.light as SpotLight).Target = position;
}
this.WorldPosition = position;
}
ICamera camera = arg.Camera;
mat4 projection = camera.GetProjectionMatrix();
mat4 view = camera.GetViewMatrix();
mat4 model = this.GetModelMatrix();
var method = this.RenderUnit.Methods[0]; // the only render unit in this node.
ShaderProgram program = method.Program;
program.SetUniform(projectionMatrix, projection);
program.SetUniform(viewMatrix, view);
program.SetUniform(modelMatrix, model);
program.SetUniform(color, this.light.Diffuse);
method.Render();
}
/// <summary>
///
/// </summary>
/// <param name="arg"></param>
public void RenderBeforeChildren(RenderEventArgs arg)
{
if (!this.IsInitialized) { Initialize(); }
ICamera camera = arg.Camera;
mat4 projection = camera.GetProjectionMatrix();
mat4 view = camera.GetViewMatrix();
mat4 model = this.GetModelMatrix();
var viewport = new int[4];
GL.Instance.GetIntegerv((uint)GetTarget.Viewport, viewport);
var method = this.RenderUnit.Methods[0]; // the only render unit in this node.
ShaderProgram program = method.Program;
program.SetUniform(projectionMatrix, projection);
program.SetUniform(viewMatrix, view);
program.SetUniform(modelMatrix, model);
program.SetUniform(screenSize, new ivec2(viewport[2], viewport[3]));
method.Render();
}
protected override void DoRender(RenderEventArgs arg)
{
var source = this.TextureSource;
if (source != null)
{
this.SetUniform(tex, source.BindingTexture);
}
ICamera camera = arg.CameraStack.Peek();
mat4 projection = camera.GetProjectionMatrix();
mat4 view = camera.GetViewMatrix();
mat4 model = this.GetModelMatrix();
this.SetUniform(projectionMatrix, projection);
this.SetUniform(viewMatrix, view);
this.SetUniform(modelMatrix, model);
this.SetUniform(transparentBackground, this.TransparentBackground);
base.DoRender(arg);
}
protected override void DoRender(RenderEventArgs arg)
{
this.RotationAngle += this.RotateSpeed;
//var viewport = new int[4];
//// Get the viewport, then convert the mouse point to an opengl point.
//GL.Instance.GetIntegerv((uint)GetTarget.Viewport, viewport);
////// Push matrix, set up projection, then load matrix.
//mat4 pickMatrix = glm.pickMatrix(new vec2(viewport[2] / 2, viewport[3] / 2), new vec2(viewport[2], viewport[3]), new ivec4(viewport[0], viewport[1], viewport[2], viewport[3]));
ICamera camera = arg.CameraStack.Peek();
mat4 projection = camera.GetProjectionMatrix();
mat4 view = camera.GetViewMatrix();
mat4 model = this.GetModelMatrix();
this.SetUniform("projectionMatrix", projection);
this.SetUniform("viewMatrix", view);
this.SetUniform("modelMatrix", model);
base.DoRender(arg);
}
//protected override void DoInitialize()
//{
// base.DoInitialize();
// int location;
// location = this.shaderProgram.GetUniformLocation(projection);
// if (location < 0)
// { throw new Exception(string.Format("No uniform found for the name [{0}]", projection)); }
// else
// { this.projectionLocation = (uint)location; }
// location = this.shaderProgram.GetUniformLocation(view);
// if (location < 0)
// { throw new Exception(string.Format("No uniform found for the name [{0}]", view)); }
// else
// { this.viewLocation = (uint)location; }
// location = this.shaderProgram.GetUniformLocation(model);
// if (location < 0)
// { throw new Exception(string.Format("No uniform found for the name [{0}]", model)); }
// else
// { this.modelLocation = (uint)location; }
//}
protected bool TryGetMatrix(RenderEventArgs arg,
out mat4 projection, out mat4 view, out mat4 model)
{
projection = arg.Camera.GetProjectionMat4();
view = arg.Camera.GetViewMat4();
SceneObject bindingObject = this.BindingObject;
if (bindingObject != null)
{
model = bindingObject.Transform.GetModelMatrix();
return true;
}
else
{
model = new mat4();
return false;
}
}
protected override void DoRender(RenderEventArgs arg)
{
ICamera camera = arg.CameraStack.Peek();
mat4 projection = camera.GetProjectionMatrix();
mat4 view = camera.GetViewMatrix();
mat4 model = this.GetModelMatrix();
var viewport = new int[4];
GL.Instance.GetIntegerv((uint)GetTarget.Viewport, viewport);
this.SetUniform(projectionMatrix, projection);
this.SetUniform(viewMatrix, view);
this.SetUniform(modelMatrix, model);
this.SetUniform(width, this._width);
this.SetUniform(height, this._height);
this.SetUniform(screenSize, new vec2(viewport[2], viewport[3]));
this.SetUniform(tex, this.textureSource.BindingTexture);
this.SetUniform(transparentBackground, this.TransparentBackground);
this.SetUniform(delta, this.Delta);
base.DoRender(arg);
}
/// <summary>
/// Update and Get cascade model matrix.
/// </summary>
/// <param name="parentCascadeModelMatrix"></param>
/// <returns></returns>
public mat4 GetModelMatrix(mat4 parentCascadeModelMatrix)
{
if (this.worldSpacePropertyUpdated)
{
mat4 matrix = glm.translate(mat4.identity(), this.WorldPosition);
matrix = glm.scale(matrix, this.Scale);
matrix = glm.rotate(matrix, this.RotationAngle, this.RotationAxis);
this.thisModelMatrix = matrix;
this.worldSpacePropertyUpdated = false;
matrix = parentCascadeModelMatrix * matrix;
this.cascadeModelMatrix = matrix;
}
else
{
this.cascadeModelMatrix = parentCascadeModelMatrix * this.thisModelMatrix;
}
return(this.cascadeModelMatrix);
}
public void RenderBeforeChildren(RenderEventArgs arg)
{
// gets mvpMat.
ICamera camera = arg.Camera;
mat4 projectionMat = camera.GetProjectionMatrix();
mat4 viewMat = camera.GetViewMatrix();
mat4 modelMat = this.GetModelMatrix();
mat4 mvpMat = projectionMat * viewMat * modelMat;
// a render uint wraps everything(model data, shaders, glswitches, etc.) for rendering.
ModernRenderUnit unit = this.RenderUnit;
// gets render method.
// There could be more than 1 method(vertex shader + fragment shader) to render the same model data. Thus we need an method array.
RenderMethod method = unit.Methods[0];
// shader program wraps vertex shader and fragment shader.
ShaderProgram program = method.Program;
//set value for 'uniform mat4 mvpMat'; in shader.
program.SetUniform("mvpMat", mvpMat);
// render the cube model via OpenGL.
method.Render();
}
/// <summary>
///
/// </summary>
/// <param name="arg"></param>
protected override void DoRender(CSharpGL.RenderEventArgs arg)
{
mat4 projection = arg.Camera.GetProjectionMatrix();
mat4 view = arg.Camera.GetViewMatrix();
this.SetUniform("projectionMatrix", projection);
this.SetUniform("viewMatrix", view);
if (this.modelMatrixRecord.IsMarked())
{
mat4 model = this.GetModelMatrix();
this.SetUniform("modelMatrix", model);
this.modelMatrixRecord.CancelMark();
}
if (this.pointColorRecord.IsMarked())
{
this.SetUniform("PointColor", this.pointColor);
this.pointColorRecord.CancelMark();
}
base.DoRender(arg);
}
/// <summary>
/// Move vertexes' position accroding to difference on screen.
/// <para>根据<paramref name="differenceOnScreen"/>来修改指定索引处的顶点位置。</para>
/// </summary>
/// <param name="differenceOnScreen"></param>
/// <param name="viewMatrix"></param>
/// <param name="projectionMatrix"></param>
/// <param name="viewport"></param>
/// <param name="positionIndexes"></param>
public void MovePositions(Point differenceOnScreen,
mat4 viewMatrix, mat4 projectionMatrix, vec4 viewport, params uint[] positionIndexes)
{
IntPtr pointer = this.PositionBuffer.MapBuffer(MapBufferAccess.ReadWrite);
unsafe
{
mat4 modelMatrix = this.GetModelMatrix().Value;
mat4 modelViewMatrix = viewMatrix * modelMatrix;
var array = (vec3*)pointer.ToPointer();
foreach (uint index in positionIndexes)
{
vec3 windowPos = glm.project(array[index],
modelViewMatrix, projectionMatrix, viewport);
var newWindowPos = new vec3(windowPos.x + differenceOnScreen.X,
windowPos.y + differenceOnScreen.Y, windowPos.z);
array[index] = glm.unProject(newWindowPos,
modelViewMatrix, projectionMatrix, viewport);
}
}
this.PositionBuffer.UnmapBuffer();
}
/// <summary>
/// Builds a perspective projection matrix based on a field of view.
/// </summary>
/// <param name="fov">The fov (in radians).</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="zNear">The z near.</param>
/// <param name="zFar">The z far.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentOutOfRangeException"></exception>
public static mat4 perspectiveFov(float fov, float width, float height, float zNear, float zFar)
{
if (width <= 0 || height <= 0 || fov <= 0)
{
throw new ArgumentOutOfRangeException();
}
var rad = fov;
var h = glm.cos((0.5f) * rad) / glm.sin((0.5f) * rad);
var w = h * height / width;
var result = new mat4(0);
result[0, 0] = w;
result[1, 1] = h;
result[2, 2] = -(zFar + zNear) / (zFar - zNear);
result[2, 3] = -(1f);
result[3, 2] = -((2f) * zFar * zNear) / (zFar - zNear);
return(result);
}
internal override bool SetValue(ValueType value)
{
if (value.GetType() != typeof(mat4))
{
throw new ArgumentException(string.Format("[{0}] not match [{1}]'s value.",
value.GetType().Name, this.GetType().Name));
}
var v = (mat4)value;
if (v != this.value)
{
this.value = v;
this.Updated = true;
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Define a picking region.
/// </summary>
/// <param name="center">The center.</param>
/// <param name="delta">The delta.</param>
/// <param name="viewport">The viewport.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentOutOfRangeException"></exception>
public static mat4 pickMatrix(ivec2 center, ivec2 delta, ivec4 viewport)
{
if (delta.x <= 0 || delta.y <= 0)
{
throw new ArgumentOutOfRangeException();
}
var Result = new mat4(1.0f);
if (!(delta.x > (0f) && delta.y > (0f)))
{
return(Result); // Error
}
vec3 Temp = new vec3(
((viewport[2]) - (2f) * (center.x - (viewport[0]))) / delta.x,
((viewport[3]) - (2f) * (center.y - (viewport[1]))) / delta.y,
(0f));
// Translate and scale the picked region to the entire window
Result = translate(Result, Temp);
return(scale(Result, new vec3((float)(viewport[2]) / delta.x, (float)(viewport[3]) / delta.y, (1))));
}
/// <summary>
/// render with specified index buffer.
/// </summary>
/// <param name="arg"></param>
/// <param name="temporaryIndexBuffer"></param>
private void Render4Picking(RenderEventArgs arg, IndexBuffer temporaryIndexBuffer)
{
UpdatePolygonMode(arg.PickingGeometryType);
ShaderProgram program = this.Program;
// 绑定shader
program.Bind();
program.glUniform("pickingBaseId", 0);
UniformMat4 uniformmMVP4Picking = this.uniformmMVP4Picking;
{
mat4 projection = arg.Camera.GetProjectionMatrix();
mat4 view = arg.Camera.GetViewMatrix();
mat4 model = this.GetModelMatrix().Value;
uniformmMVP4Picking.Value = projection * view * model;
}
uniformmMVP4Picking.SetUniform(program);
PickingStateesOn();
var oneIndexBuffer = temporaryIndexBuffer as OneIndexBuffer;
if (oneIndexBuffer != null)
{
PrimitiveRestartState glState = this.GetPrimitiveRestartState(oneIndexBuffer);
glState.On();
this.vertexArrayObject.Render(arg, program, temporaryIndexBuffer);
glState.Off();
}
else
{
this.vertexArrayObject.Render(arg, program, temporaryIndexBuffer);
}
PickingStateesOff();
//if (mvpUpdated) { uniformmMVP4Picking.ResetUniform(program); }
// 解绑shader
program.Unbind();
}
void IMouseHandler.canvas_MouseMove(object sender, MouseEventArgs e)
{
if (this.mouseDownFlag &&
((e.Button & this.lastBindingMouseButtons) != MouseButtons.None))
{
IViewCamera camera = this.camera;
if (camera == null)
{
return;
}
Point newPosition = e.Location;
int diffX = newPosition.X - this.lastPosition.X;
int diffY = newPosition.Y - this.lastPosition.Y;
mat4 viewMatrix = this.camera.GetViewMatrix();
mat4 projectionMatrix = this.camera.GetProjectionMatrix();
vec3 cameraPosition = this.camera.Position;
vec4 viewport;
{
int[] tmp = OpenGL.GetViewport();
viewport = new vec4(tmp[0], tmp[1], tmp[2], tmp[3]);
}
vec3 windowPos = glm.project(cameraPosition,
viewMatrix, projectionMatrix, viewport);
var newWindowPos = new vec3(windowPos.x - diffX,
windowPos.y + diffY, windowPos.z);
vec3 newCameraPosition = glm.unProject(newWindowPos,
viewMatrix, projectionMatrix, viewport);
vec3 cameraDiff = newCameraPosition - cameraPosition;
this.camera.Position = newCameraPosition;
this.camera.Target += cameraDiff;
this.lastPosition = newPosition;
if (this.canvas.RenderTrigger == RenderTrigger.Manual)
{
this.canvas.Repaint();
}
}
}
/// <summary>
/// 根据<paramref name="differenceOnScreen"/>来修改指定索引处的顶点位置。
/// </summary>
/// <param name="differenceOnScreen"></param>
/// <param name="viewMatrix"></param>
/// <param name="projectionMatrix"></param>
/// <param name="viewport"></param>
/// <param name="positionIndexes"></param>
public void MovePositions(Point differenceOnScreen,
mat4 viewMatrix, mat4 projectionMatrix, vec4 viewport, IEnumerable <uint> positionIndexes)
{
OpenGL.BindBuffer(BufferTarget.ArrayBuffer, this.positionBufferPtr.BufferId);
IntPtr pointer = OpenGL.MapBuffer(BufferTarget.ArrayBuffer, MapBufferAccess.ReadWrite);
unsafe
{
var array = (vec3 *)pointer.ToPointer();
foreach (var index in positionIndexes)
{
vec3 projected = glm.project(array[index],
viewMatrix, projectionMatrix, viewport);
vec3 newProjected = new vec3(projected.x + differenceOnScreen.X,
projected.y + differenceOnScreen.Y, projected.z);
array[index] = glm.unProject(newProjected,
viewMatrix, projectionMatrix, viewport);
}
}
OpenGL.UnmapBuffer(BufferTarget.ArrayBuffer);
OpenGL.BindBuffer(BufferTarget.ArrayBuffer, 0);
}
void IMouseHandler.canvas_MouseMove(object sender, MouseEventArgs e)
{
if (this.mouseDownFlag &&
((e.Button & this.lastBindingMouseButtons) != MouseButtons.None) &&
(e.X != this.lastPosition.X || e.Y != this.lastPosition.Y))
{
mat4 rotationMatrix = glm.rotate(this.HorizontalRotationSpeed * (e.X - this.lastPosition.X), -this.camera.UpVector);
var front = new vec4(this.camera.GetFront(), 1.0f);
vec4 front1 = rotationMatrix * front;
rotationMatrix = glm.rotate(this.VerticalRotationSpeed * (this.lastPosition.Y - e.Y), this.camera.GetRight());
vec4 front2 = rotationMatrix * front1;
front2 = front2.normalize();
this.camera.Target = this.camera.Position + new vec3(front2);
this.lastPosition = e.Location;
if (this.canvas.RenderTrigger == RenderTrigger.Manual)
{
this.canvas.Invalidate();
}
}
}
/// <summary>
/// 根据<paramref name="differenceOnWindow"/>来修改指定索引处的顶点位置。
/// </summary>
/// <param name="differenceOnWindow"></param>
/// <param name="viewMatrix"></param>
/// <param name="projectionMatrix"></param>
/// <param name="viewport"></param>
/// <param name="positionIndexes"></param>
public void MovePositions(Point differenceOnWindow,
mat4 viewMatrix, mat4 projectionMatrix, vec4 viewport, params uint[] positionIndexes)
{
OpenGL.BindBuffer(BufferTarget.ArrayBuffer, this.positionBufferPtr.BufferId);
IntPtr pointer = OpenGL.MapBuffer(BufferTarget.ArrayBuffer, MapBufferAccess.ReadWrite);
unsafe
{
var array = (vec3 *)pointer.ToPointer();
foreach (var index in positionIndexes)
{
vec3 windowPos = glm.project(array[index],
viewMatrix, projectionMatrix, viewport);
vec3 newWindowPos = new vec3(windowPos.x + differenceOnWindow.X,
windowPos.y + differenceOnWindow.Y, windowPos.z);
array[index] = glm.unProject(newWindowPos,
viewMatrix, projectionMatrix, viewport);
}
}
OpenGL.UnmapBuffer(BufferTarget.ArrayBuffer);
OpenGL.BindBuffer(BufferTarget.ArrayBuffer, 0);
}
internal override bool SetValue(ValueType value)
{
#if DEBUG
if (value.GetType() != typeof(mat4))
{
throw new ArgumentException(string.Format("[{0}] not match [{1}]'s value.",
value.GetType().Name, this.GetType().Name));
}
#endif
var v = (mat4)value;
if (v != this.value)
{
this.value = v;
this.Updated = true;
return true;
}
else
{
return false;
}
}
/// <summary>
/// Build a look at view matrix.
/// </summary>
/// <param name="eye">The eye.</param>
/// <param name="center">The center.</param>
/// <param name="up">Up.</param>
/// <returns></returns>
public static mat4 lookAt(vec3 eye, vec3 center, vec3 up)
{
vec3 forward = (center - eye).normalize();
vec3 right = forward.cross(up).normalize();
vec3 standardUp = right.cross(forward);
mat4 Result = new mat4(1);
Result[0, 0] = right.x;
Result[1, 0] = right.y;
Result[2, 0] = right.z;
Result[0, 1] = standardUp.x;
Result[1, 1] = standardUp.y;
Result[2, 1] = standardUp.z;
Result[0, 2] = -forward.x;
Result[1, 2] = -forward.y;
Result[2, 2] = -forward.z;
Result[3, 0] = -right.dot(eye); // dot(s, eye);
Result[3, 1] = -standardUp.dot(eye); // dot(u, eye);
Result[3, 2] = forward.dot(eye); // dot(f, eye);
return(Result);
}
public override void RenderBeforeChildren(RenderEventArgs arg)
{
if (!this.IsInitialized)
{
this.Initialize();
}
this.RotationAngle += this.RotateSpeed;
ICamera camera = arg.CameraStack.Peek();
mat4 projection = camera.GetProjectionMatrix();
mat4 view = camera.GetViewMatrix();
mat4 model = this.GetModelMatrix();
var method = this.RenderUnit.Methods[0]; // the only render unit in this node.
ShaderProgram program = method.Program;
program.SetUniform(projectionMatrix, projection);
program.SetUniform(viewMatrix, view);
program.SetUniform(modelMatrix, model);
if (this.RenderWireframe)
{
// render wireframe.
program.SetUniform("renderWireframe", true);
polygonMode.On();
polygonOffsetState.On();
method.Render();
polygonOffsetState.Off();
polygonMode.Off();
}
if (this.RenderBody)
{
// render solid body.
program.SetUniform("renderWireframe", false);
method.Render();
}
}
public override void RenderBeforeChildren(RenderEventArgs arg)
{
if (!this.IsInitialized) { Initialize(); }
ICamera camera = arg.CameraStack.Peek();
mat4 projection = camera.GetProjectionMatrix();
mat4 view = camera.GetViewMatrix();
mat4 model = this.GetModelMatrix();
var method = this.RenderUnit.Methods[0];
ShaderProgram program = method.Program;
program.SetUniform(model_matrix, model);
program.SetUniform(view_matrix, view);
program.SetUniform(projection_matrix, projection);
program.SetUniform(light_position, new vec3(view * new vec4(LightPosition, 1.0f)));
//program.SetUniform(material_ambient, this.Ambient);
program.SetUniform(material_diffuse, this.Diffuse);
program.SetUniform(material_specular, this.Specular);
program.SetUniform(material_specular_power, this.SpecularPower);
method.Render();
}
/// <summary>
///
/// </summary>
/// <param name="arg"></param>
protected override void DoRender(CSharpGL.RenderEventArgs arg)
{
mat4 projection = arg.Camera.GetProjectionMatrix();
mat4 view = arg.Camera.GetViewMatrix();
this.SetUniform("projectionMatrix", projection);
this.SetUniform("viewMatrix", view);
MarkableStruct <mat4> model = this.GetModelMatrix();
if (this.modelTicks != model.UpdateTicks)
{
this.SetUniform("modelMatrix", model.Value);
this.modelTicks = model.UpdateTicks;
}
if (this.pointColorRecord.IsMarked())
{
this.SetUniform("PointColor", this.pointColor);
this.pointColorRecord.CancelMark();
}
base.DoRender(arg);
}
public AdjacentCubeModel(vec3 size)
{
this.size = size;
size = size / 2;
{
var instancePositions = new vec3[positions.Length];
for (int i = 0; i < positions.Length; i++)
{
instancePositions[i] = positions[i] * size;
}
this.instancePositions = instancePositions;
}
{
mat4 matrix = glm.transpose(glm.inverse(glm.scale(mat4.identity(), size)));
var instanceNormals = new vec3[normals.Length];
for (int i = 0; i < normals.Length; i++)
{
instanceNormals[i] = new vec3((matrix * new vec4(normals[i], 0))).normalize();
}
this.instanceNormals = instanceNormals;
}
}
public override void RenderBeforeChildren(RenderEventArgs arg)
{
if (!this.IsInitialized)
{
this.Initialize();
}
ICamera camera = arg.CameraStack.Peek();
mat4 projection = camera.GetProjectionMatrix();
mat4 view = camera.GetViewMatrix();
mat4 model = this.GetModelMatrix();
var method = this.RenderUnit.Methods[0]; // the only render unit in this node.
ShaderProgram program = method.Program;
program.SetUniform(projectionMatrix, projection);
program.SetUniform(viewMatrix, view);
program.SetUniform(modelMatrix, model);
program.SetUniform(color, this.Color);
method.Render();
}
/// <summary>
/// Move vertexes' position accroding to difference on screen.
/// <para>根据<paramref name="differenceOnScreen"/>来修改指定索引处的顶点位置。</para>
/// </summary>
/// <param name="differenceOnScreen"></param>
/// <param name="viewMatrix"></param>
/// <param name="projectionMatrix"></param>
/// <param name="viewport"></param>
/// <param name="positionIndexes"></param>
public void MovePositions(Point differenceOnScreen,
mat4 viewMatrix, mat4 projectionMatrix, vec4 viewport, params uint[] positionIndexes)
{
IntPtr pointer = this.PositionBufferPtr.MapBuffer(MapBufferAccess.ReadWrite);
unsafe
{
mat4 modelMatrix = this.GetModelMatrix();
mat4 modelViewMatrix = viewMatrix * modelMatrix;
var array = (vec3 *)pointer.ToPointer();
foreach (var index in positionIndexes)
{
vec3 windowPos = glm.project(array[index],
modelViewMatrix, projectionMatrix, viewport);
var newWindowPos = new vec3(windowPos.x + differenceOnScreen.X,
windowPos.y + differenceOnScreen.Y, windowPos.z);
array[index] = glm.unProject(newWindowPos,
modelViewMatrix, projectionMatrix, viewport);
}
}
this.PositionBufferPtr.UnmapBuffer();
}
public void RenderBeforeChildren(RenderEventArgs arg)
{
if (!this.IsInitialized)
{
this.Initialize();
}
ICamera camera = arg.Camera;
mat4 projection = camera.GetProjectionMatrix();
mat4 view = camera.GetViewMatrix();
mat4 model = this.GetModelMatrix();
var method = this.RenderUnit.Methods[0]; // renderBuilder
ShaderProgram program = method.Program;
program.SetUniform(projectionMat, projection);
program.SetUniform(viewMat, view);
program.SetUniform(modelMat, model);
program.SetUniform(color, this.Color);
method.Render();
}
void IMouseHandler.canvas_MouseMove(object sender, GLMouseEventArgs e)
{
if (mouseDownFlag && ((e.Button & this.lastBindingMouseButtons) != GLMouseButtons.None))
{
if (!cameraState.IsSameState(this.camera))
{
SetCamera(this.camera.Position, this.camera.Target, this.camera.UpVector);
}
this._endPosition = GetArcBallPosition(e.X, e.Y);
var cosRadian = _startPosition.dot(_endPosition) / (_startPosition.length() * _endPosition.length());
if (cosRadian > 1.0f)
{
cosRadian = 1.0f;
}
else if (cosRadian < -1)
{
cosRadian = -1.0f;
}
float angle = MouseSensitivity * (float)(Math.Acos(cosRadian) / Math.PI * 180);
_normalVector = _startPosition.cross(_endPosition).normalize();
if (!
((_normalVector.x == 0 && _normalVector.y == 0 && _normalVector.z == 0) ||
float.IsNaN(_normalVector.x) || float.IsNaN(_normalVector.y) || float.IsNaN(_normalVector.z)))
{
_startPosition = _endPosition;
mat4 newRotation = glm.rotate(angle, _normalVector);
this.totalRotation = newRotation * totalRotation;
}
IGLCanvas canvas = this.canvas;
if (canvas != null && canvas.RenderTrigger == RenderTrigger.Manual)
{
canvas.Repaint();
}
}
}
public void RenderBeforeChildren(RenderEventArgs arg)
{
if (!this.IsInitialized)
{
this.Initialize();
}
ICamera camera = arg.Camera;
mat4 projection = camera.GetProjectionMatrix();
mat4 view = camera.GetViewMatrix();
mat4 model = this.GetModelMatrix();
var method = this.RenderUnit.Methods[0]; // the only render unit in this node.
ShaderProgram program = method.Program;
program.SetUniform(projectionMatrix, projection);
program.SetUniform(viewMatrix, view);
program.SetUniform(modelMatrix, model);
program.SetUniform(tex, this.texture);
program.SetUniform(alpha, this.Alpha);
method.Render();
}
void IMouseHandler.canvas_MouseMove(object sender, GLMouseEventArgs e)
{
if (mouseDownFlag && ((e.Button & this.lastBindingMouseButtons) != GLMouseButtons.None))
{
if (!cameraState.IsSameState(this.camera))
{
SetCamera(this.camera.Position, this.camera.Target, this.camera.UpVector);
}
Point location = new Point(e.X, this.canvas.Height - e.Y - 1);
Point differenceOnScreen = new Point(location.X - this._lastPosition.X, location.Y - this._lastPosition.Y);
mat4 model = this.renderer.GetModelMatrix();
mat4 view = this.camera.GetViewMatrix();
mat4 projection = this.camera.GetProjectionMatrix();
vec4 viewport;
{
var result = new int[4];
GL.Instance.GetIntegerv((uint)GetTarget.Viewport, result);
viewport = new vec4(result[0], result[1], result[2], result[3]);
}
var position = new vec3(0.0f);// imangine we have a point at (0, 0, 0).
vec3 windowPos = glm.project(position, view * model, projection, viewport);
var newWindowPos = new vec3(windowPos.x + differenceOnScreen.X, windowPos.y + differenceOnScreen.Y, windowPos.z);
vec3 newPosition = glm.unProject(newWindowPos, view * model, projection, viewport);
var worldPosition = new vec3(model * new vec4(position, 1.0f));
var newWorldPosition = new vec3(model * new vec4(newPosition, 1.0f));
this.renderer.WorldPosition += newWorldPosition - worldPosition;
this._lastPosition = location;
IGLCanvas canvas = this.canvas;
if (canvas != null && canvas.RenderTrigger == RenderTrigger.Manual)
{
canvas.Repaint();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="arg"></param>
protected override void DoRender(RenderEventArgs arg)
{
if (this.modelMatrixRecord.IsMarked())
{
this.SetUniform("billboardCenter_worldspace",
this.ModelMatrix.GetTranslate());
this.modelMatrixRecord.CancelMark();
}
if (labelHeightRecord.IsMarked())
{
this.SetUniform("labelHeight", this.LabelHeight);
labelHeightRecord.CancelMark();
}
if (textRecord.IsMarked())
{
if (this.model != null)
{
this.model.SetText(this.text, this.fontTexture);
}
}
if (discardTransparencyRecord.IsMarked())
{
bool discard = this.DiscardTransparency;
this.SetUniform("discardTransparency", discard);
this.blendSwitch.InUse = discard;
}
int[] viewport = OpenGL.GetViewport();
this.SetUniform("viewportSize", new vec2(viewport[2], viewport[3]));
mat4 projection = arg.Camera.GetProjectionMat4();
mat4 view = arg.Camera.GetViewMat4();
this.SetUniform("projection", projection);
this.SetUniform("view", view);
base.DoRender(arg);
}
/// <summary>
///
/// </summary>
/// <param name="arg"></param>
public void Render4Picking(RenderEventArgs arg)
{
if (!this.IsInitialized)
{
this.Initialize();
}
UpdatePolygonMode(arg.PickingGeometryType);
ShaderProgram program = this.Program;
// 绑定shader
program.Bind();
program.glUniform("pickingBaseId",
(int)this.PickingBaseId);
UniformMat4 uniformmMVP4Picking = this.uniformmMVP4Picking;
{
mat4 projection = arg.Camera.GetProjectionMatrix();
mat4 view = arg.Camera.GetViewMatrix();
mat4 model = this.GetModelMatrix().Value;
uniformmMVP4Picking.Value = projection * view * model;
}
uniformmMVP4Picking.SetUniform(program);
PickingStateesOn();
this.vertexArrayObject.Render(arg, program);
PickingStateesOff();
//if (mvpUpdated) { uniformmMVP4Picking.ResetUniform(program); }
// 解绑shader
program.Unbind();
}
void IMouseHandler.canvas_MouseMove(object sender, MouseEventArgs e)
{
if (mouseDownFlag && ((e.Button & this.lastBindingMouseButtons) != MouseButtons.None))
{
if (!cameraState.IsSameState(this.camera))
{
SetCamera(this.camera.Position, this.camera.Target, this.camera.UpVector);
}
this._endPosition = GetArcBallPosition(e.X, e.Y);
var cosRadian = _startPosition.dot(_endPosition) / (_startPosition.length() * _endPosition.length());
if (cosRadian > 1.0f) { cosRadian = 1.0f; }
else if (cosRadian < -1) { cosRadian = -1.0f; }
float angle = MouseSensitivity * (float)(Math.Acos(cosRadian) / Math.PI * 180);
_normalVector = _startPosition.cross(_endPosition).normalize();
if (!
((_normalVector.x == 0 && _normalVector.y == 0 && _normalVector.z == 0)
|| float.IsNaN(_normalVector.x) || float.IsNaN(_normalVector.y) || float.IsNaN(_normalVector.z)))
{
_startPosition = _endPosition;
mat4 newRotation = glm.rotate(angle, _normalVector);
this.totalRotation = newRotation * totalRotation;
}
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public mat4 GetViewMatrix()
{
if (this.viewMatrixRecord.IsMarked())
{
this.viewMatrix = glm.lookAt(this.position, this.target, this.upVector);
this.viewMatrixRecord.CancelMark();
}
return this.viewMatrix;
}
public bool SetUniform(string varNameInShader, mat4[] value)
{
bool gotUniform = false;
bool updated = false;
if (value.Length <= 0) { return updated; }
foreach (var item in this.uniformVariables)
{
if (item.VarName == varNameInShader)
{
(item as UniformMat4Array).Value = value;
updated = true;
gotUniform = true;
break;
}
}
if (!gotUniform)
{
int location = ShaderProgram.GetUniformLocation(varNameInShader);
if (location < 0)
{
throw new Exception(string.Format(
"uniform variable [{0}] not exists!", varNameInShader));
}
var variable = GetVariableArray(value, varNameInShader) as UniformMat4Array;
variable.Value = value;
this.uniformVariables.Add(variable);
updated = true;
}
return updated;
}
/// <summary>
/// Multiplies the <paramref name="lhs"/> matrix by the <paramref name="rhs"/> matrix.
/// </summary>
/// <param name="lhs">The LHS matrix.</param>
/// <param name="rhs">The RHS matrix.</param>
/// <returns>The product of <paramref name="lhs"/> and <paramref name="rhs"/>.</returns>
public static mat4 operator *(mat4 lhs, mat4 rhs)
{
mat4 result = new mat4(
new vec4(
lhs[0][0] * rhs[0][0] + lhs[1][0] * rhs[0][1] + lhs[2][0] * rhs[0][2] + lhs[3][0] * rhs[0][3],
lhs[0][1] * rhs[0][0] + lhs[1][1] * rhs[0][1] + lhs[2][1] * rhs[0][2] + lhs[3][1] * rhs[0][3],
lhs[0][2] * rhs[0][0] + lhs[1][2] * rhs[0][1] + lhs[2][2] * rhs[0][2] + lhs[3][2] * rhs[0][3],
lhs[0][3] * rhs[0][0] + lhs[1][3] * rhs[0][1] + lhs[2][3] * rhs[0][2] + lhs[3][3] * rhs[0][3]
),
new vec4(
lhs[0][0] * rhs[1][0] + lhs[1][0] * rhs[1][1] + lhs[2][0] * rhs[1][2] + lhs[3][0] * rhs[1][3],
lhs[0][1] * rhs[1][0] + lhs[1][1] * rhs[1][1] + lhs[2][1] * rhs[1][2] + lhs[3][1] * rhs[1][3],
lhs[0][2] * rhs[1][0] + lhs[1][2] * rhs[1][1] + lhs[2][2] * rhs[1][2] + lhs[3][2] * rhs[1][3],
lhs[0][3] * rhs[1][0] + lhs[1][3] * rhs[1][1] + lhs[2][3] * rhs[1][2] + lhs[3][3] * rhs[1][3]
),
new vec4(
lhs[0][0] * rhs[2][0] + lhs[1][0] * rhs[2][1] + lhs[2][0] * rhs[2][2] + lhs[3][0] * rhs[2][3],
lhs[0][1] * rhs[2][0] + lhs[1][1] * rhs[2][1] + lhs[2][1] * rhs[2][2] + lhs[3][1] * rhs[2][3],
lhs[0][2] * rhs[2][0] + lhs[1][2] * rhs[2][1] + lhs[2][2] * rhs[2][2] + lhs[3][2] * rhs[2][3],
lhs[0][3] * rhs[2][0] + lhs[1][3] * rhs[2][1] + lhs[2][3] * rhs[2][2] + lhs[3][3] * rhs[2][3]
),
new vec4(
lhs[0][0] * rhs[3][0] + lhs[1][0] * rhs[3][1] + lhs[2][0] * rhs[3][2] + lhs[3][0] * rhs[3][3],
lhs[0][1] * rhs[3][0] + lhs[1][1] * rhs[3][1] + lhs[2][1] * rhs[3][2] + lhs[3][1] * rhs[3][3],
lhs[0][2] * rhs[3][0] + lhs[1][2] * rhs[3][1] + lhs[2][2] * rhs[3][2] + lhs[3][2] * rhs[3][3],
lhs[0][3] * rhs[3][0] + lhs[1][3] * rhs[3][1] + lhs[2][3] * rhs[3][2] + lhs[3][3] * rhs[3][3]
)
);
return result;
}
/// <summary>
/// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates.
/// </summary>
/// <param name="windowPos">The win.</param>
/// <param name="view">The view.</param>
/// <param name="proj">The proj.</param>
/// <param name="viewport">The viewport.</param>
/// <returns></returns>
public static vec3 unProject(vec3 windowPos, mat4 view, mat4 proj, vec4 viewport)
{
mat4 Inverse = glm.inverse(proj * view);
vec4 tmp = new vec4(windowPos, (1f));
tmp.x = (tmp.x - (viewport[0])) / (viewport[2]);
tmp.y = (tmp.y - (viewport[1])) / (viewport[3]);
tmp = tmp * (2f) - new vec4(1, 1, 1, 1);// after this, tmp is normalized device coordinate.
vec4 obj = Inverse * tmp;
obj /= obj.w;// after this, tmp is model coordinate.
return new vec3(obj);
}
/// <summary>
/// Creates a matrix for a symmetric perspective-view frustum with far plane
/// at infinite for graphics hardware that doesn't support depth clamping.
/// </summary>
/// <param name="fovy">The fovy.</param>
/// <param name="aspect">The aspect.</param>
/// <param name="zNear">The z near.</param>
/// <returns></returns>
public static mat4 tweakedInfinitePerspective(float fovy, float aspect, float zNear)
{
float range = tan(fovy / (2)) * zNear;
float left = -range * aspect;
float right = range * aspect;
float bottom = -range;
float top = range;
mat4 Result = new mat4((0f));
Result[0, 0] = ((2) * zNear) / (right - left);
Result[1, 1] = ((2) * zNear) / (top - bottom);
Result[2, 2] = (0.0001f) - (1f);
Result[2, 3] = (-1);
Result[3, 2] = -((0.0001f) - (2)) * zNear;
return Result;
}
/// <summary>
/// Applies a translation transformation to matrix <paramref name="m"/> by vector <paramref name="v"/>.
/// </summary>
/// <param name="m">The matrix to transform.</param>
/// <param name="v">The vector to translate by.</param>
/// <returns><paramref name="m"/> translated by <paramref name="v"/>.</returns>
public static mat4 translate(mat4 m, vec3 v)
{
mat4 result = m;
result.col3 = m.col0 * v.x + m.col1 * v.y + m.col2 * v.z + m.col3;
return result;
}
/// <summary>
/// Applies a scale transformation to matrix <paramref name="m"/> by vector <paramref name="v"/>.
/// </summary>
/// <param name="m">The matrix to transform.</param>
/// <param name="v">The vector to scale by.</param>
/// <returns><paramref name="m"/> scaled by <paramref name="v"/>.</returns>
public static mat4 scale(mat4 m, vec3 v)
{
mat4 result = m;
result[0] = m[0] * v[0];
result[1] = m[1] * v[1];
result[2] = m[2] * v[2];
result[3] = m[3];
return result;
}
/// <summary>
/// Builds a rotation 4 * 4 matrix created from an axis vector and an angle.
/// </summary>
/// <param name="m">The m.</param>
/// <param name="angleDegree">ANgle in Degree.</param>
/// <param name="v">The v.</param>
/// <returns></returns>
public static mat4 rotate(mat4 m, float angleDegree, vec3 v)
{
float c = (float)Math.Cos(angleDegree * Math.PI / 180.0);
float s = (float)Math.Sin(angleDegree * Math.PI / 180.0);
vec3 axis = v.normalize();
vec3 temp = (1.0f - c) * axis;
mat4 rotate = mat4.identity();
rotate[0, 0] = c + temp[0] * axis[0];
rotate[0, 1] = 0 + temp[0] * axis[1] + s * axis[2];
rotate[0, 2] = 0 + temp[0] * axis[2] - s * axis[1];
rotate[1, 0] = 0 + temp[1] * axis[0] - s * axis[2];
rotate[1, 1] = c + temp[1] * axis[1];
rotate[1, 2] = 0 + temp[1] * axis[2] + s * axis[0];
rotate[2, 0] = 0 + temp[2] * axis[0] + s * axis[1];
rotate[2, 1] = 0 + temp[2] * axis[1] - s * axis[0];
rotate[2, 2] = c + temp[2] * axis[2];
mat4 result = mat4.identity();
result[0] = m[0] * rotate[0][0] + m[1] * rotate[0][1] + m[2] * rotate[0][2];
result[1] = m[0] * rotate[1][0] + m[1] * rotate[1][1] + m[2] * rotate[1][2];
result[2] = m[0] * rotate[2][0] + m[1] * rotate[2][1] + m[2] * rotate[2][2];
result[3] = m[3];
return result;
}
/// <summary>
/// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates.
/// </summary>
/// <param name="modelPosition">The object.</param>
/// <param name="view">The view.</param>
/// <param name="proj">The proj.</param>
/// <param name="viewport">The viewport.</param>
/// <returns></returns>
public static vec3 project(vec3 modelPosition, mat4 view, mat4 proj, vec4 viewport)
{
vec4 tmp = new vec4(modelPosition, (1f));
tmp = view * tmp;
tmp = proj * tmp;// this is gl_Position
tmp /= tmp.w;// after this, tmp is normalized device coordinate.
tmp = tmp * 0.5f + new vec4(0.5f, 0.5f, 0.5f, 0.5f);
tmp[0] = tmp[0] * viewport[2] + viewport[0];
tmp[1] = tmp[1] * viewport[3] + viewport[1];// after this, tmp is window coordinate.
return new vec3(tmp.x, tmp.y, tmp.z);
}
/// <summary>
///
/// </summary>
/// <param name="projection"></param>
/// <param name="view"></param>
/// <param name="model"></param>
/// <returns></returns>
public string ToString(mat4 projection, mat4 view, mat4 model)
{
StringBuilder builder = BasicInfo();
builder.AppendLine();
vec3[] positions = this.Positions;
if (positions == null) { positions = new vec3[0]; }
uint[] indexes = this.VertexIds;
var worldPos = new vec4[positions.Length];
var viewPos = new vec4[positions.Length];
var projectionPos = new vec4[positions.Length];
var normalizedPos = new vec3[positions.Length];
var screenPos = new vec3[positions.Length];
builder.Append("Positions in World Space:");
builder.AppendLine();
for (int i = 0; i < positions.Length; i++)
{
var pos4 = new vec4(positions[i], 1);
worldPos[i] = model * pos4;
builder.Append('['); builder.Append(indexes[i]); builder.Append("]: ");
builder.Append(worldPos[i]);
builder.AppendLine();
}
builder.Append("Positions in Camera/View Space:");
builder.AppendLine();
for (int i = 0; i < positions.Length; i++)
{
var pos4 = new vec4(positions[i], 1);
viewPos[i] = view * worldPos[i];
builder.Append('['); builder.Append(indexes[i]); builder.Append("]: ");
builder.Append(viewPos[i]);
builder.AppendLine();
}
builder.Append("Positions in Projection Space:");
builder.AppendLine();
for (int i = 0; i < positions.Length; i++)
{
projectionPos[i] = projection * viewPos[i];
builder.Append('['); builder.Append(indexes[i]); builder.Append("]: ");
builder.Append(projectionPos[i]);
builder.AppendLine();
}
builder.Append("Positions in Normalized Space:");
builder.AppendLine();
for (int i = 0; i < positions.Length; i++)
{
builder.Append('['); builder.Append(indexes[i]); builder.Append("]: ");
normalizedPos[i] = new vec3(projectionPos[i] / projectionPos[i].w);
builder.Append(normalizedPos[i]);
builder.AppendLine();
}
builder.Append("Positions in Screen Space:");
builder.AppendLine();
int x, y, width, height;
OpenGL.GetViewport(out x, out y, out width, out height);
float near, far;
OpenGL.GetDepthRange(out near, out far);
for (int i = 0; i < positions.Length; i++)
{
builder.Append('['); builder.Append(indexes[i]); builder.Append("]: ");
screenPos[i] = new vec3(
normalizedPos[i].x * width / 2 + (x + width / 2),
normalizedPos[i].y * height / 2 + (y + height / 2),
normalizedPos[i].z * (far - near) / 2 + ((far + near) / 2)
);
builder.Append(screenPos[i]);
builder.AppendLine();
}
return builder.ToString();
}
/// <summary>
/// Get model matrix that transform model's position from model space to world space,
/// Make sure the scene object list is traversed in pre-order.
/// </summary>
/// <returns></returns>
public mat4 GetModelMatrix()
{
SceneObject obj = this.BindingObject;
if (obj != null)
{
mat4 matrix = mat4.identity();
matrix = glm.translate(matrix, this.Position);
matrix = glm.scale(matrix, this.Scale);
matrix = glm.rotate(matrix, (float)(this.Rotation.x * Math.PI / 180.0), xAxis);
matrix = glm.rotate(matrix, (float)(this.Rotation.y * Math.PI / 180.0), yAxis);
matrix = glm.rotate(matrix, (float)(this.Rotation.z * Math.PI / 180.0), zAxis);
// matrix equals to (translate * scale * rotation) as below:
//mat4 translate = glm.translate(mat4.identity(), this.Position);
//mat4 scale = glm.scale(mat4.identity(), this.Scale);
//mat4 rotation = glm.rotate(mat4.identity(), (float)(this.Rotation.x * Math.PI / 180.0), xAxis);
//rotation = glm.rotate(rotation, (float)(this.Rotation.y * Math.PI / 180.0), yAxis);
//rotation = glm.rotate(rotation, (float)(this.Rotation.z * Math.PI / 180.0), zAxis);
this.selfMatrix = matrix;
}
return this.selfMatrix;
}
/// <summary>
///
/// </summary>
/// <param name="varNameInShader"></param>
/// <param name="value"></param>
/// <returns></returns>
public bool GetUniformMat4ArrayValue(string varNameInShader, out mat4[] value)
{
//if ((!this.Initialized) && (!this.Initializing)) { this.Initialize(); }
value = null;
bool gotUniform = false;
foreach (UniformVariable item in this.uniformVariables)
{
if (item.VarName == varNameInShader)
{
value = (item as UniformMat4Array).Value.Array;
gotUniform = true;
break;
}
}
return gotUniform;
}
/// <summary>
///
/// </summary>
/// <param name="varNameInShader"></param>
/// <param name="value"></param>
/// <returns></returns>
public bool SetUniform(string varNameInShader, mat4[] value)
{
//if ((!this.Initialized) && (!this.Initializing)) { this.Initialize(); }
bool gotUniform = false;
bool updated = false;
if (value.Length <= 0) { return updated; }
foreach (UniformVariable item in this.uniformVariables)
{
if (item.VarName == varNameInShader)
{
(item as UniformMat4Array).Value = new NoisyArray<mat4>(value);
updated = true;
gotUniform = true;
break;
}
}
if (!gotUniform)
{
//int location = Program.GetUniformLocation(varNameInShader);
//if (location < 0)
{
//throw new Exception(string.Format(
//"niform variable [{0}] not exists! Remember to invoke RendererBase.Initialize(); before this method.", varNameInShader));
}
var variable = GetVariableArray(value, varNameInShader) as UniformMat4Array;
variable.Value = new NoisyArray<mat4>(value);
this.uniformVariables.Add(variable);
updated = true;
}
return updated;
}
/// <summary>
/// Builds a perspective projection matrix based on a field of view.
/// </summary>
/// <param name="fov">The fov (in radians).</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="zNear">The z near.</param>
/// <param name="zFar">The z far.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentOutOfRangeException"></exception>
public static mat4 perspectiveFov(float fov, float width, float height, float zNear, float zFar)
{
if (width <= 0 || height <= 0 || fov <= 0)
throw new ArgumentOutOfRangeException();
var rad = fov;
var h = glm.cos((0.5f) * rad) / glm.sin((0.5f) * rad);
var w = h * height / width;
var result = new mat4(0);
result[0, 0] = w;
result[1, 1] = h;
result[2, 2] = -(zFar + zNear) / (zFar - zNear);
result[2, 3] = -(1f);
result[3, 2] = -((2f) * zFar * zNear) / (zFar - zNear);
return result;
}
/// <summary>
/// Define a picking region.
/// </summary>
/// <param name="center">The center.</param>
/// <param name="delta">The delta.</param>
/// <param name="viewport">The viewport.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentOutOfRangeException"></exception>
public static mat4 pickMatrix(vec2 center, vec2 delta, vec4 viewport)
{
if (delta.x <= 0 || delta.y <= 0)
throw new ArgumentOutOfRangeException();
var Result = new mat4(1.0f);
if (!(delta.x > (0f) && delta.y > (0f)))
return Result; // Error
vec3 Temp = new vec3(
((viewport[2]) - (2f) * (center.x - (viewport[0]))) / delta.x,
((viewport[3]) - (2f) * (center.y - (viewport[1]))) / delta.y,
(0f));
// Translate and scale the picked region to the entire window
Result = translate(Result, Temp);
return scale(Result, new vec3((viewport[2]) / delta.x, (viewport[3]) / delta.y, (1)));
}
public bool GetUniformMat4ArrayValue(string varNameInShader, out mat4[] value)
{
value = null;
bool gotUniform = false;
foreach (var item in this.uniformVariables)
{
if (item.VarName == varNameInShader)
{
value = (item as UniformMat4Array).Value;
gotUniform = true;
break;
}
}
return gotUniform;
}
public void MouseMove(int x, int y)
{
if (MouseDownFlag)
{
Debug.WriteLine(" =================>MouseMove:", listenerName);
if (!cameraState.IsSameState(this.Camera))
{
SetCamera(this.Camera.Position, this.Camera.Target, this.Camera.UpVector);
Debug.WriteLine(string.Format(
" update camera state: {0}, {1}, {2}",
this.cameraState.position, this.cameraState.target, this.cameraState.up), listenerName);
}
this._endPosition = GetArcBallPosition(x, y);
Debug.WriteLine(string.Format(
" End position: {0}", this._endPosition), listenerName);
var cosAngle = _startPosition.dot(_endPosition) / (_startPosition.length() * _endPosition.length());
if (cosAngle > 1) { cosAngle = 1; }
else if (cosAngle < -1) { cosAngle = -1; }
Debug.Write(string.Format(" cos angle: {0}", cosAngle), listenerName);
var angle = mouseSensitivity * (float)(Math.Acos(cosAngle) / Math.PI * 180);
Debug.WriteLine(string.Format(
", angle: {0}", angle), listenerName);
_normalVector = _startPosition.cross(_endPosition).normalize();
if ((_normalVector.x == 0 && _normalVector.y == 0 && _normalVector.z == 0)
|| float.IsNaN(_normalVector.x) || float.IsNaN(_normalVector.y) || float.IsNaN(_normalVector.z))
{
Debug.WriteLine(" no movement recorded.", listenerName);
}
else
{
Debug.WriteLine(string.Format(
" normal vector: {0}", _normalVector), listenerName);
_startPosition = _endPosition;
mat4 newRotation = glm.rotate(angle, _normalVector);
Debug.WriteLine(string.Format(
" new rotation matrix: {0}", newRotation), listenerName);
this.totalRotation = newRotation * totalRotation;
Debug.WriteLine(string.Format(
" total rotation matrix: {0}", totalRotation), listenerName);
}
Debug.WriteLine(" -------------------MouseMove end.", listenerName);
}
}