一个简单的旋转控制器与固定屏幕位置 – 天天不在

  如下是初步效果图,后面会用在前面的Ogre编辑器中.

  开始旋转控制写的比较简单,直接根据鼠标x,y调用yaw与pitch,虽然可用,但是不好用,有时要调到自己想要的方向搞一会,一点都不专业,记的以前好像看过那个软件使用的就是如上这种,分别给出三个方向的圆环,根据鼠标最开始点击的圆环,分别单独调用pitch,yaw,roll,今天花了些时间模仿了下这个,本文记录下.

  用的是Axiom,Ogre的C#版,代码差不多可以直接换成MOgre的.

  先生成模型,调用了本项目的一些代码,给出相关位置关键代码.箭头模型.

public void AddArrow(Vector3 Vector21, Vector3 Vector22, double diameter, double headLength = 3, int thetaDiv = 18)
{
var dir = Vector22 – Vector21;
double length = dir.Length;
double r = diameter / 2;

var pc = new List<Vector2>
{
new Vector2(0, 0),
new Vector2(0, r),
new Vector2(length – (diameter * headLength), r),
new Vector2(length – (diameter * headLength), r * 2),
new Vector2(length, 0)
};

this.AddRevolvedGeometry(pc, null, Vector21, dir, thetaDiv);
}

public void AddRevolvedGeometry(IList<Vector2> Vector2s, IList<double> textureValues, Vector3 origin, Vector3 direction, int thetaDiv)
{
direction.Normalize();

// Find two unit vectors orthogonal to the specified direction
var u = direction.FindAnyPerpendicular();
var v = direction.Cross(u);

u.Normalize();
v.Normalize();

var circle = GetCircle(thetaDiv);

int index0 = this.positions.Count;
int n = Vector2s.Count;

int totalNodes = (Vector2s.Count – 1) * 2 * thetaDiv;
int rowNodes = (Vector2s.Count – 1) * 2;

for (int i = 0; i < thetaDiv; i++)
{
var w = (v * circle[i].x) + (u * circle[i].y);

for (int j = 0; j + 1 < n; j++)
{
// Add segment
var q1 = origin + (direction * Vector2s[j].x) + (w * Vector2s[j].y);
var q2 = origin + (direction * Vector2s[j + 1].x) + (w * Vector2s[j + 1].y);

// TODO: should not add segment if q1==q2 (corner Vector2)
// const double eps = 1e-6;
// if (Vector3.Subtract(q1, q2).LengthSquared < eps)
// continue;
this.positions.Add(q1);
this.positions.Add(q2);

if (this.normals != null)
{
double tx = Vector2s[j + 1].x – Vector2s[j].x;
double ty = Vector2s[j + 1].y – Vector2s[j].y;
var normal = (-direction * ty) + (w * tx);
normal.Normalize();

this.normals.Add(normal);
this.normals.Add(normal);
}

if (this.textureCoordinates != null)
{
this.textureCoordinates.Add(new Vector2((double)i / (thetaDiv – 1), textureValues == null ? (double)j / (n – 1) : textureValues[j]));
this.textureCoordinates.Add(new Vector2((double)i / (thetaDiv – 1), textureValues == null ? (double)(j + 1) / (n – 1) : textureValues[j + 1]));
}

int i0 = index0 + (i * rowNodes) + (j * 2);
int i1 = i0 + 1;
int i2 = index0 + ((((i + 1) * rowNodes) + (j * 2)) % totalNodes);
int i3 = i2 + 1;

this.triangleIndices.Add(i1);
this.triangleIndices.Add(i0);
this.triangleIndices.Add(i2);

this.triangleIndices.Add(i1);
this.triangleIndices.Add(i2);
this.triangleIndices.Add(i3);
}
}
}

  这里的代码主要是用到开源项目HelixToolkit里的,我稍微有些改动些以用于Axiom中,大意是先得到圆面控制点,然后按顺序连接圆环面,如上面箭头有五个圆面控制点,第一个和第二个点之间画一个箭头底部面,第二个和第三个点画圆柱体,第三个和第四个点画一个内圈,就是连接圆柱面最上面与箭头底面那个圆圈,第四个与第五个画最前面的箭头部分.通过他的这种,可以画出很多复杂的模型.

  然后是画外面的三个圆环.如下代码.

public class Torus
{
float innerRadius = 0.2f;
float outerRadius = 5.0f;

/// <summary>
/// Initializes a new instance of the <see cref=”Torus”/> class.
/// </summary>
public Torus(float diameter, float innerDiameter)
{
innerRadius
= innerDiameter;
outerRadius
= diameter;
InitialiseTorus();
}

/// <summary>
/// Initialises the torus.
/// </summary>
/// <returns></returns>
private bool InitialiseTorus()
{
// Calculate the number of vertices and indices.
numVertices = (torusPrecision + 1) * (torusPrecision + 1);
numIndices
= 2 * torusPrecision * torusPrecision * 3;

// Create the vertices and indices.
vertices = new Vector3[numVertices];
indices
= new uint[numIndices];

// Calculate the first ring – inner radius 4, outer radius 1.5
for (int i = 0; i < torusPrecision + 1; i++)
{
vertices[i]
= new Vector3(innerRadius, 0.0f, 0.0f).GetRotatedZ(i * 360.0f / torusPrecision)
+ new Vector3(outerRadius, 0.0f, 0.0f);
//vertices[i].s = 0.0f;
//vertices[i].t = (float)i / torusPrecision;

//vertices[i].sTangent.Set(0.0f, 0.0f, -1.0f);
//vertices[i].tTangent = (new Vertex(0.0f, -1.0f, 0.0f)).GetRotatedZ(i * 360.0f / torusPrecision);
//vertices[i].normal = vertices[i].tTangent.VectorProduct(vertices[i].sTangent);
}

// Rotate the first ring to get the other rings
for (uint ring = 1; ring < torusPrecision + 1; ring++)
{
for (uint i = 0; i < torusPrecision + 1; i++)
{
vertices[ring
* (torusPrecision + 1) + i] =
vertices[i].GetRotatedY(ring
* 360.0f / torusPrecision);

//vertices[ring * (torusPrecision + 1) + i].s = 2.0f * ring / torusPrecision;
//vertices[ring * (torusPrecision + 1) + i].t = vertices[i].t;

//vertices[ring * (torusPrecision + 1) + i].sTangent =
// vertices[i].sTangent.GetRotatedY(ring * 360.0f / torusPrecision);
//vertices[ring * (torusPrecision + 1) + i].tTangent =
// vertices[i].tTangent.GetRotatedY(ring * 360.0f / torusPrecision);
//vertices[ring * (torusPrecision + 1) + i].normal =
// vertices[i].normal.GetRotatedY(ring * 360.0f / torusPrecision);
}
}
// Calculate the indices
for (uint ring = 0; ring < torusPrecision; ring++)
{
for (uint i = 0; i < torusPrecision; i++)
{
indices[((ring
* torusPrecision + i) * 2) * 3 + 0] = ring * (torusPrecision + 1) + i;
indices[((ring
* torusPrecision + i) * 2) * 3 + 1] = (ring + 1) * (torusPrecision + 1) + i;
indices[((ring
* torusPrecision + i) * 2) * 3 + 2] = ring * (torusPrecision + 1) + i + 1;
indices[((ring
* torusPrecision + i) * 2 + 1) * 3 + 0] = ring * (torusPrecision + 1) + i + 1;
indices[((ring
* torusPrecision + i) * 2 + 1) * 3 + 1] = (ring + 1) * (torusPrecision + 1) + i;
indices[((ring
* torusPrecision + i) * 2 + 1) * 3 + 2] = (ring + 1) * (torusPrecision + 1) + i + 1;
}
}

// OK, that’s the torus done!
return true;
}

/// <summary>
/// The number of vertices.
/// </summary>
private uint numVertices = 0;

/// <summary>
/// The number of indices.
/// </summary>
private uint numIndices = 0;

/// <summary>
/// The torus indices.
/// </summary>
private uint[] indices;

/// <summary>
/// The torus vertices.
/// </summary>
private Vector3[] vertices;

/// <summary>
/// We define our torus to have a precision of 48.
/// This means that there are 48 vertices per ring when we construct it.
/// </summary>
private const uint torusPrecision = 48;

/// <summary>
/// Gets the num vertices.
/// </summary>
public uint NumVertices
{
get { return numVertices; }
}

/// <summary>
/// Gets the num indices.
/// </summary>
public uint NumIndices
{
get { return numIndices; }
}

/// <summary>
/// Gets the vertices.
/// </summary>
public Vector3[] Vertices
{
get { return vertices; }
}

/// <summary>
/// Gets the indices.
/// </summary>
public uint[] Indices
{
get { return indices; }
}
}
public static class VertexExtensions
{
public static Vector3 GetRotatedX(this Vector3 me, float angle)
{
if (angle == 0.0)
return new Vector3(me.x, me.y, me.z);

float sinAngle = (float)Math.Sin(Math.PI * angle / 180);
float cosAngle = (float)Math.Cos(Math.PI * angle / 180);

return new Vector3(me.x,
me.y
* cosAngle – me.z * sinAngle,
me.y
* sinAngle + me.z * cosAngle);
}

public static Vector3 GetRotatedY(this Vector3 me, float angle)
{
if (angle == 0.0)
return new Vector3(me.x, me.y, me.z);

float sinAngle = (float)Math.Sin(Math.PI * angle / 180);
float cosAngle = (float)Math.Cos(Math.PI * angle / 180);

return new Vector3(me.x * cosAngle + me.z * sinAngle,
me.y,
-me.x * sinAngle + me.z * cosAngle);
}

public static Vector3 GetRotatedZ(this Vector3 me, float angle)
{
if (angle == 0.0)
return new Vector3(me.x, me.y, me.z);

float sinAngle = (float)Math.Sin(Math.PI * angle / 180);
float cosAngle = (float)Math.Cos(Math.PI * angle / 180);

return new Vector3(me.x * cosAngle – me.y * sinAngle,
me.x
* sinAngle + me.y * cosAngle,
me.z);
}

public static Vector3 GetPackedTo01(this Vector3 me)
{
Vector3 temp
= new Vector3(me.x, me.y, me.z);
temp.Normalize();

temp = (temp * 0.5f) + new Vector3(0.5f, 0.5f, 0.5f);

return temp;
}

public static List<Vector3> GetRotatedX(this IList<Vector3> ms, float angle)
{
List
<Vector3> result = new List<Vector3>(ms.Count);
foreach (var m in ms)
{
result.Add(m.GetRotatedX(angle));
}
return result;
}

public static List<Vector3> GetRotatedY(this IList<Vector3> ms, float angle)
{
List
<Vector3> result = new List<Vector3>(ms.Count);
foreach (var m in ms)
{
result.Add(m.GetRotatedY(angle));
}
return result;
}

public static List<Vector3> GetRotatedZ(this IList<Vector3> ms, float angle)
{
List
<Vector3> result = new List<Vector3>(ms.Count);
foreach (var m in ms)
{
result.Add(m.GetRotatedZ(angle));
}
return result;
}
}

  这部分代码主要取自SharpGL,改动一些代码然后用于现在的项目,另外也有一些,但是不是用的Triangles的方式画的,那种也就差不多只能用在opengl立即模式下,现在的引擎应该都用不了.

  如下是重点了,绘制与相关鼠标点击算法.

public enum EulerRotate
{
None,
Yaw,
//y
Pitch,//x
Roll,//z
}
public class DrawRotate : RenderBasic
{
private float diameter;
private float headLength;
private int thetaDiv;
private float length;
private bool bChange = false;

public float Diameter
{
get
{
return diameter;
}
set
{
if (diameter != value)
{
diameter
= value;
bChange
= true;
}
}
}
public float HeadLength
{
get
{
return headLength;
}
set
{
if (headLength != value)
{
headLength
= value;
bChange
= true;
}
}
}
public int ThetaDiv
{
get
{
return thetaDiv;
}
set
{
if (thetaDiv != value)
{
thetaDiv
= value;
bChange
= true;
}
}
}
public float Lenght
{
get
{
return length;
}
set
{
length
= value;
}
}

public EulerRotate rotate = EulerRotate.None;

public DrawRotate()
:
this(5.0f, 0.1f)
{
}

public DrawRotate(float length, float diameter, float headLength = 3, int thetaDiv = 18)
{
this.length = length;
this.diameter = diameter;
this.headLength = headLength;
this.thetaDiv = thetaDiv;
this.bChange = true;
this.MaterialName = Material_Base;
this.Update();
}

public void Update()
{
if (bChange && this.isVisible)
{
this.Vertexs.Reset();

var builder = new MeshBuilder(false, false);
builder.AddArrow(Vector3.Zero, Vector3.UnitX
* this.length, this.diameter, this.headLength, this.thetaDiv);
this.Vertexs.AddBatch(builder.Positions, builder.TriangleIndices, ColorEx.Red);

builder = new MeshBuilder(false, false);
builder.AddArrow(Vector3.Zero, Vector3.UnitY
* this.length, this.diameter, this.headLength, this.thetaDiv);
this.Vertexs.AddBatch(builder.Positions, builder.TriangleIndices, ColorEx.Green);

builder = new MeshBuilder(false, false);
builder.AddArrow(Vector3.Zero, Vector3.UnitZ
* this.length, this.diameter, this.headLength, this.thetaDiv);
this.Vertexs.AddBatch(builder.Positions, builder.TriangleIndices, ColorEx.Blue);

MeshGeometry3D cube = MeshHelper.CreateCube(Vector3.UnitScale * 0.125, 0.25f);
this.Vertexs.AddBatch(cube.Positions, cube.TriangleIndices, ColorEx.White);

Torus torus = new Torus(length + 1, 0.2f);
this.Vertexs.AddUBatch(torus.Vertices, torus.Indices, ColorEx.Green);
this.Vertexs.AddUBatch(torus.Vertices.GetRotatedX(90), torus.Indices, ColorEx.Blue);
this.Vertexs.AddUBatch(torus.Vertices.GetRotatedZ(90), torus.Indices, ColorEx.Red);
this.UpdateBuffer();
bChange
= false;
}
}

public void HitTest(Ray ray)
{
Sphere sphere
= new Sphere(this.ParentNode.DerivedPosition, length + 1);
var result = ray.IntersectsRay(sphere);
if (result.Item1)
{
var h1 = ray.Origin + result.Item2 * ray.Direction – this.ParentNode.DerivedPosition;
var h2 = ray.Origin + result.Item3 * ray.Direction – this.ParentNode.DerivedPosition;
var inverseRotate = this.ParentNode.DerivedOrientation.Inverse();
h1
= inverseRotate * h1;
h2
= inverseRotate * h2;
float x1 = Math.Abs(h1.x);
float y1 = Math.Abs(h1.y);
float z1 = Math.Abs(h1.z);
float x2 = Math.Abs(h2.x);
float y2 = Math.Abs(h2.y);
float z2 = Math.Abs(h2.z);
float min1 = Math.Min(x1, Math.Min(y1, z1));
float min2 = Math.Min(x2, Math.Min(y2, z2));
float min = Math.Min(min1, min2);
if (min == x1 || min == x2)
rotate
= EulerRotate.Pitch;
else if (min == y1 || min == y2)
rotate
= EulerRotate.Yaw;
else if (min == z1 || min == z2)
rotate
= EulerRotate.Roll;
}
}

public void Rotate(float value)
{
if (rotate == EulerRotate.Pitch)
{
this.ParentNode.Pitch(value);
}
else if (rotate == EulerRotate.Yaw)
{
this.ParentNode.Yaw(value);
}
else if (rotate == EulerRotate.Roll)
{
this.ParentNode.Roll(-value);
}
}
}

  RenderBasic是一个简单实现Renderable与MovableObject的类,差不多和SimpleRenderable一样,因为这个项目里的模型有些特殊,所以没有用SimpleRenderable,我简单自己重新写了个,在这不影响,换成SimpleRenderable也差不多.

  Update就是收集模型数据,交给RenderBasic的UpdateBuffer生成缓冲区数据,简单来说,是一个三float顶点,一int颜色的缓冲区,这里Vertexs.AddBatch会自动更新里面的索引数据,这样做主要是整合成一个Pass渲染,提高效率.

  主要部分来了,HitTest这个函数就是用于检测你点击在那个圆环上.因为Ogre/Axiom自己给的Intersects算法只给出了最近的那个交点,在这我们需要得到这二个交点,简单修改下.  

public static System.Tuple<bool, float, float> IntersectsRay(this Ray ray, Sphere sphere)
{
var rayDir = ray.Direction;
//Adjust ray origin relative to sphere center
var rayOrig = ray.Origin – sphere.Center;
var radius = sphere.Radius;

// mmm…sweet quadratics
// Build coeffs which can be used with std quadratic solver
// ie t = (-b +/- sqrt(b*b* + 4ac)) / 2a
var a = rayDir.Dot(rayDir);
var b = 2 * rayOrig.Dot(rayDir);
var c = rayOrig.Dot(rayOrig) – (radius * radius);

// calc determinant
var d = (b * b) – (4 * a * c);

if (d < 0)
{
// no intersection
return Tuple.Create(false, 0.0f, 0.0f);
}
else
{
// BTW, if d=0 there is one intersection, if d > 0 there are 2
// But we only want the closest one, so that’s ok, just use the
// ‘-‘ version of the solver
float t1 = (-b – Utility.Sqrt(d)) / (2 * a);
float t2 = (-b + Utility.Sqrt(d)) / (2 * a);
return Tuple.Create(true, t1, t2);
}
}

  返回的t1与t2分别是射线与球的交点在射线上的位置,现在我们只知道这二个点在球上,如何确定他在那个圆环上了,我们稍微想一下,还是很容易想到的,点击垂直x轴面的圆环时,他的x值必定在0附近,或者这样说,是x,y,z这三个绝对值中最小的.这样我们拿到最少值就可以知道点击的那个环了.

  注意二点,ray相交后的点是世界坐标系下的,我们比较x,y,z的大小应该是在模型坐标系下,所以我们把点转化,第一个是位置,第二是方向,方向把父方向的逆求出然后相剩就可以了.还有一个位置就是上面所说,二个交点都要求出,因为我们是不管外面还是里面的.

  刚看到图,发现有个位置还可以说下,右上角有个固定在屏幕位置的模型,这个当时我还走了点弯路,开始是准备如UI那样,去掉视图与透视矩阵,试验发现后面要根据摄像机来转化顶点位置,这样一来,一是比较麻烦,二是每点都通过CPU计算,降低效率.后面发现没必要,直接更新模型的模型矩阵就行,看如下代码.

this.renderWindow.BeforeViewportUpdate += renderWindow_BeforeViewportUpdate;
void renderWindow_BeforeViewportUpdate(Axiom.Graphics.RenderTargetViewportEventArgs e)
{
var currentView = e.Viewport;
var camera = e.Viewport.Camera;

var node = EngineCore.Instance.AxisNode;
var corners = camera.WorldSpaceCorners;

var p1 = corners[0] + (corners[4] – corners[0]) * 0.02;
var p2 = corners[2] + (corners[6] – corners[2]) * 0.02;

var pos = p1 + (p2 – p1) * 0.1;

node.Position = pos;
node.Orientation
= elementNode.Orientation;
}

  这个BeforeViewportUpdate的插入渲染的位置可以看我前文Ogre 监听类与渲染流程中有详细说明.在这里,直接根据视截体,直接定位在视截体的右上面,camera.WorldSpaceCorners是视截体的八个点(世界坐标下),0-3索引分别对应近视面的右上,左上,左下,右下,4-7索引对应远视面的这四个位置.根据线性式取右上角的位置.因为我这边axisNode是直接在根节点下的,所以直接用position就行,他的方向用模型的方向,这样这个节点就可以显示模型现在的方向.这样不管摄像机如何变换,这个节点始终在位置右上角.

  如果有用Axiom的同学要注意点,node.Position设置值有一个BUG,主要是因为MovableObject.cs中的如下代码.

public override AxisAlignedBox GetWorldBoundingBox( bool derive )
{
if ( derive )
{
this.worldAABB = BoundingBox;
this.worldAABB.Transform( ParentNodeFullTransform );
}

return this.worldAABB;
}

  把this.wordAABB = BoundingBox改成this.worldAABB = BoundingBox.Clone() as AxisAlignedBox就可,可能是因为原来AxisAlignedBox在C#中是结构体,后面变成类了,这样每次更新节点位置会调用这个函数,然后更新SceneNode时就会更新MovableObject的AABB,这样就导致AABB又Transform了节点矩阵一次,AABB是错误的了,这样在添加前渲染通道前的摄像机可见检测就可能检测不到了.MOgre应该没有这问题.

本文链接:一个简单的旋转控制器与固定屏幕位置,转载请注明。



You must enable javascript to see captcha here!

Copyright © All Rights Reserved · Green Hope Theme by Sivan & schiy · Proudly powered by WordPress

无觅相关文章插件,快速提升流量