private void TestToStringWithCulture(CultureInfo culture)
{
CultureInfo originalCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = culture;
try
{
string listSeparator = culture.TextInfo.ListSeparator;
string decimalSeparator = culture.NumberFormat.NumberDecimalSeparator;
var o = new Matrix4F(
1.1f, 2.2f, 3.3f, 4.4f,
5.5f, 6.6f, 7.7f, 8.8f,
9.9f, 10.10f, 11.11f, 12.12f,
13.13f, 14.14f, 15.15f, 16.16f);
string s = o.ToString(null, null);
TestToStringResults(o, s, listSeparator, decimalSeparator);
s = o.ToString();
Assert.True(s.Contains(listSeparator));
s = o.ToString("G", culture);
TestToStringResults(o, s, listSeparator, decimalSeparator);
s = o.ToString("R", culture);
TestToStringResults(o, s, listSeparator, decimalSeparator);
}
finally
{
Thread.CurrentThread.CurrentCulture = originalCulture;
}
}
/// <summary>
/// Renders the control</summary>
/// <param name="action">Render action</param>
/// <param name="camera">Camera</param>
/// <param name="state">Render state</param>
/// <param name="transform">Transform</param>
public void Render(IRenderAction action, Camera camera, RenderState state, Matrix4F transform)
{
float s1, s2, s3;
// apply xform
Gl.glPushMatrix();
Util3D.glMultMatrixf(transform);
CalcAxisLengths(camera, transform, out s1, out s2, out s3);
bool drawX, drawY, drawZ;
DecideArrowDrawing(transform, camera, out drawX, out drawY, out drawZ);
if (drawX)
{
RenderXArrow(s1);
RenderXAxis(s1);
}
if (drawY)
{
RenderYArrow(s2);
RenderYAxis(s2);
}
if (drawZ)
{
RenderZArrow(s3);
RenderZAxis(s3);
}
RenderXYSquare(s1 * SquareLength, s2 * SquareLength, true);
RenderYZSquare(s2 * SquareLength, s3 * SquareLength, true);
RenderXZSquare(s1 * SquareLength, s3 * SquareLength, true);
Gl.glPopMatrix();
}
/// <summary>
/// Constructor</summary>
/// <param name="renderObject">RenderObject. A reference is held to this, so that IRenderObject.Dispatch
/// can be called.</param>
/// <param name="transform">Transform to use when dispatching the RenderObject; a reference is held</param>
/// <param name="graphPath">Graph path leading to RenderObject; a reference is held</param>
/// <param name="renderState">RenderState to use for RenderObject; is copied</param>
public TraverseNode(
IRenderObject renderObject,
Matrix4F transform,
Stack<SceneNode> graphPath,
RenderState renderState)
{
Init(renderObject, transform, graphPath, renderState);
}
/// <summary>
/// Decomposes the given matrix to translation, scale,
/// and rotation and set them to given Transformable node.
/// </summary>
public static void SetTransform(ITransformable xform, Matrix4F mtrx)
{
xform.Translation = mtrx.Translation;
xform.Scale = mtrx.GetScale();
Vec3F rot = new Vec3F();
mtrx.GetEulerAngles(out rot.X, out rot.Y, out rot.Z);
xform.Rotation = rot;
xform.UpdateTransform();
}
public static void DrawUnitSquare(GUILayer.SimpleRenderingContext context, Matrix4F xform, Color color)
{
GameEngine.DrawPrimitive(context, PrimitiveType.LineList,
s_linesVertId,
s_unitSquareStartVertex,
s_unitSquareVertexCount,
color,
xform);
}
public static void DrawCircle(GUILayer.SimpleRenderingContext context, Matrix4F xform, Color color)
{
GameEngine.DrawPrimitive(context, PrimitiveType.LineStrip,
s_circleVerts,
0,
s_circleVertexCount,
color,
xform);
}
public static void DrawPivot(GUILayer.SimpleRenderingContext context, Matrix4F xform, Color c)
{
GameEngine.DrawPrimitive(context, PrimitiveType.LineStrip,
s_pivotVerts,
0,
s_pivotVertexCount,
c,
xform);
}
/// <summary>
/// Initializes instance</summary>
/// <param name="renderObject">RenderObject. A reference is held to this, so that IRenderObject.Dispatch
/// can be called.</param>
/// <param name="transform">Transform to use when dispatching the RenderObject; a reference is held</param>
/// <param name="graphPath">Graph path leading to RenderObject; a reference is held</param>
/// <param name="renderState">RenderState to use for RenderObject; is copied</param>
public void Init(
IRenderObject renderObject,
Matrix4F transform,
Stack<SceneNode> graphPath,
RenderState renderState)
{
m_renderObject = renderObject;
m_transform = transform;
m_renderState.Init(renderState);
m_graphPath = graphPath.ToArray();//faster to create every time than to cache!
}
public static void DrawUnitSquare(Matrix4F xform, Color color)
{
GameEngine.DrawPrimitive(PrimitiveType.LineList,
s_linesVertId,
s_unitSquareStartVertex,
s_unitSquareVertexCount,
color,
xform,
RenderFlag
);
}
public static void DrawCircle(Matrix4F xform, Color color)
{
GameEngine.DrawPrimitive(PrimitiveType.LineStrip,
s_circleVerts,
0,
s_circleVertexCount,
color,
xform,
RenderFlag
);
}
public static void DrawPivot(Matrix4F xform, Color c)
{
GameEngine.DrawPrimitive(PrimitiveType.LineStrip,
s_pivotVerts,
0,
s_pivotVertexCount,
c,
xform,
RenderFlag
);
}
private void TestToStringResults(Matrix4F o, string s, string listSeparator, string decimalSeparator)
{
string[] results = s.Split(new[] { listSeparator }, StringSplitOptions.RemoveEmptyEntries);
Assert.AreEqual(results.Length, 16);
for (int i = 0; i < 16; i++)
{
Assert.True(results[i].Contains(decimalSeparator));
float result = float.Parse(results[i]);
Assert.AreEqual(result, o[i]);
}
}
public override void OnBeginDrag()
{
if (m_hitRegion == HitRegion.None || !CanManipulate(m_node))
return;
var transactionContext = DesignView.Context.As<ITransactionContext>();
transactionContext.Begin("Move".Localize());
m_originalPivot = m_node.Pivot;
Path<DomNode> path = new Path<DomNode>(m_node.Cast<DomNode>().GetPath());
Matrix4F localToWorld = TransformUtils.CalcPathTransform(path, path.Count - 1);
m_worldToLocal = new Matrix4F();
m_worldToLocal.Invert(localToWorld);
}
/// <summary>
/// Computes world transformation matrix for the given
/// Transformable node.</summary>
public static Matrix4F ComputeWorldTransform(ITransformable xform)
{
Matrix4F world = new Matrix4F();
DomNode node = xform.As<DomNode>();
foreach (DomNode n in node.Lineage)
{
ITransformable xformNode = n.As<ITransformable>();
if (xformNode != null)
{
world.Mul(world, xformNode.Transform);
}
}
return world;
}
/// <summary>
/// Calculates the world space matrix of the given path</summary>
/// <param name="path">The path</param>
/// <param name="start">Starting index</param>
/// <param name="M">the world matrix</param>
public static void CalcPathTransform(Matrix4F M, Path<DomNode> path, int start)
{
for (int i = start; i >= 0; i--)
{
if (path[i] != null)
{
ITransformable renderable =
path[i].As<ITransformable>();
if (renderable != null)
{
M.Mul(M, renderable.Transform);
}
}
}
}
/// <summary>
/// Calculates the world space matrix of the given path
/// </summary>
/// <param name="path">The path</param>
/// <param name="start">Starting index</param>
/// <returns>The world space matrix</returns>
public static Matrix4F CalcPathTransform(Path<DomNode> path, int start)
{
Matrix4F M = new Matrix4F();
for (int i = start; i >= 0; i--)
{
if (path[i] != null)
{
ITransformable renderable =
path[i].As<ITransformable>();
if (renderable != null)
{
M.Mul(M, renderable.Transform);
}
}
}
return M;
}
/// <summary>
/// Calculates the world space matrix of the given SceneNode path, starting from a given index</summary>
/// <param name="path">The SceneNode path</param>
/// <param name="start">Starting index within the path</param>
/// <returns>The world space matrix</returns>
public static Matrix4F CalcPathTransform(SceneNode[] path, int start)
{
Matrix4F M = new Matrix4F();
for (int i = start; i < path.Length; i++)
{
if (path[i].Source != null)
{
ITransformable renderable =
path[i].Source.As<ITransformable>();
if (renderable != null)
{
M.Mul(M, renderable.Transform);
}
}
}
return M;
}
public IControlPoint InsertPoint(uint index, float x, float y, float z)
{
IControlPoint cpt = CreateControlPoint();
int numSteps = GetAttribute<int>(Schema.curveType.stepsAttribute);
int interpolationType = GetAttribute<int>(Schema.curveType.interpolationTypeAttribute);
if (interpolationType != 0 && numSteps > 0)
{
index = index / (uint)numSteps;
}
Path<DomNode> path = new Path<DomNode>(DomNode.GetPath());
Matrix4F toworld = TransformUtils.CalcPathTransform(path, path.Count - 1);
Matrix4F worldToLocal = new Matrix4F();
worldToLocal.Invert(toworld);
Vec3F pos = new Vec3F(x, y, z);
worldToLocal.Transform(ref pos);
cpt.Translation = pos;
ControlPoints.Insert((int)index + 1, cpt);
return cpt;
}
public override void Render(ViewControl vc)
{
Matrix4F normWorld = GetManipulatorMatrix();
if (normWorld == null) return;
Camera camera = vc.Camera;
float s;
Util.CalcAxisLengths(camera, normWorld.Translation, out s);
m_translatorControl.Render(normWorld, s);
Matrix4F sc = new Matrix4F();
Vec3F pos = normWorld.Translation;
s /= 12.0f;
sc.Scale(s);
Matrix4F bl = new Matrix4F();
Util.CreateBillboard(bl, pos, camera.WorldEye, camera.Up, camera.LookAt);
Matrix4F recXform = new Matrix4F();
Matrix4F.Multiply(sc, bl, recXform);
Util3D.DrawPivot(recXform, Color.Yellow);
}
public override bool Pick(ViewControl vc, Point scrPt)
{
m_hitRegion = HitRegion.None;
if (base.Pick(vc, scrPt) == false)
return false;
Camera camera = vc.Camera;
Matrix4F view = camera.ViewMatrix;
Matrix4F vp = view * camera.ProjectionMatrix;
Matrix4F wvp = HitMatrix * vp;
Ray3F rayL = vc.GetRay(scrPt,wvp);
float s = Util.CalcAxisScale(vc.Camera, HitMatrix.Translation, AxisLength, vc.Height);
// There's only one hot-spot for this manipulator:
// a square at the manipulator origin.
Vec3F min = new Vec3F(-0.5f, -0.5f, -0.5f);
Vec3F max = new Vec3F(0.5f, 0.5f, 0.5f);
AABB box = new AABB(min, max);
float centerCubeScale = s * CenterCubeSize;
Matrix4F centerCubeXform = new Matrix4F();
centerCubeXform.Scale(centerCubeScale);
centerCubeXform.Invert(centerCubeXform);
Ray3F ray = rayL;
ray.Transform(centerCubeXform);
if (box.Intersect(ray))
{
m_hitRegion = HitRegion.XYSquare;
return true;
}
m_hitRegion = HitRegion.None;
return false;
}
public BoneGlobalTransformItem(bool hasValue, ref Matrix4F value)
{
HasValue = hasValue;
Value = value;
}
protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
{
base.OnRender(context, frameData, ref actualTexture);
var pipeline = context.RenderingPipeline as Component_RenderingPipeline_Basic;
if (pipeline == null)
{
return;
}
var frameData2 = frameData as Component_RenderingPipeline_Basic.FrameData;
if (frameData2 == null)
{
return;
}
if (Intensity.Value == 0)
{
return;
}
bool skip = true;
foreach (var lightIndex in frameData2.LightsInFrustumSorted)
{
var lightItem = frameData2.Lights[lightIndex];
if (lightItem.data.children != null)
{
foreach (var child in lightItem.data.children)
{
var lensFlares = child as Component_LensFlares;
if (lensFlares != null)
{
skip = false;
break;
}
}
}
}
if (skip)
{
return;
}
//init context data
ViewportRenderingContextData contextData;
if (context.anyData.TryGetValue("LensEffects", out var contextData2))
{
contextData = (ViewportRenderingContextData)contextData2;
}
else
{
contextData = new ViewportRenderingContextData();
context.anyData["LensEffects"] = contextData;
}
//update context data light items
contextData.Update(context.Owner.LastUpdateTimeStep, Intensity, FadeSpeed);
//create copy
var newTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, actualTexture.Result.ResultFormat, createSimple3DRenderer: true, createCanvasRenderer: true);
var viewport = newTexture.Result.GetRenderTarget().Viewports[0];
//!!!!double precision
Matrix4F viewMatrix = context.Owner.CameraSettings.ViewMatrix.ToMatrix4F();
Matrix4F projectionMatrix = context.Owner.CameraSettings.ProjectionMatrix.ToMatrix4F();
context.SetViewport(viewport, viewMatrix, projectionMatrix);
pipeline.CopyToCurrentViewport(context, actualTexture);
var simple3DRenderer = viewport.Simple3DRenderer;
var canvasRenderer = viewport.CanvasRenderer;
//render
foreach (var lightIndex in frameData2.LightsInFrustumSorted)
{
var lightItem = frameData2.Lights[lightIndex];
if (lightItem.data.children != null)
{
foreach (var child in lightItem.data.children)
{
var lensFlares = child as Component_LensFlares;
if (lensFlares != null)
{
var light = lightItem.data.Creator as Component_Light;
if (light != null)
{
CheckVisibilityScreenPosition(context, lightItem.data.Position, out var gotScreenPosition, out var insideScreen);
if (gotScreenPosition)
{
//update
{
switch (CheckVisibilityMethod.Value)
{
case CheckVisibilityMethodEnum.OcclusionQuery:
{
var parameter = (contextData, light);
if (RenderingSystem.TryCreateOcclusionQuery(OcclusionQueryCallback, parameter, out var query))
{
var thickness = context.Owner.Simple3DRenderer.GetThicknessByPixelSize(lightItem.data.Position, 5);
var bounds = new Bounds(lightItem.data.Position);
bounds.Expand(thickness * 0.5);
simple3DRenderer.SetColor(new ColorValue(1, 0, 0));
simple3DRenderer.SetOcclusionQuery(query);
simple3DRenderer.AddBounds(bounds, true);
//simple3DRenderer.AddSphere( new Sphere( lightItem.data.Position, 0.5 ), 4, true );
simple3DRenderer.SetOcclusionQuery(null);
}
}
break;
case CheckVisibilityMethodEnum.PhysicsRayCast:
if (CheckVisibilityPhysics(context, lightItem.data.Position))
{
contextData.UpdateLastTimeVisible(light);
}
break;
}
}
//render
var intensity = contextData.GetIntensity(light);
if (intensity > 0)
{
//simple3DRenderer.SetColor( new ColorValue( 1, 0, 0 ) );
//simple3DRenderer.AddSphere( new Sphere( lightItem.data.Position, 0.5 ), 10, true );
lensFlares.RenderUI(canvasRenderer, lightItem.data, context.Owner, intensity);
}
}
else
{
contextData.Remove(light);
}
}
}
}
}
}
//render
if (simple3DRenderer._ViewportRendering_PrepareRenderables())
{
simple3DRenderer._ViewportRendering_RenderToCurrentViewport(context);
simple3DRenderer._Clear();
}
canvasRenderer._ViewportRendering_RenderToCurrentViewport(context, true, context.Owner.LastUpdateTime);
//free old textures
context.DynamicTexture_Free(actualTexture);
//update actual texture
actualTexture = newTexture;
}
public override ManipulatorPickResult Pick(ViewControl vc, Point scrPt)
{
m_hitRegion = HitRegion.None;
if (base.Pick(vc, scrPt) == ManipulatorPickResult.Miss)
{
return(ManipulatorPickResult.Miss);
}
Camera camera = vc.Camera;
float RingDiameter = 2 * AxisLength;
float s = Util.CalcAxisScale(vc.Camera, HitMatrix.Translation, RingDiameter, vc.Height);
float rad = s * Util3D.RingCenterRadias;
float lrad = rad * LookRingScale;
float tolerance = s * Util3D.RingThickness;
Matrix4F billboard
= Util.CreateBillboard(HitMatrix.Translation, vc.Camera.WorldEye, vc.Camera.Up, vc.Camera.LookAt);
m_lookAxisHitMtrx = billboard;
// compute ray in object space space.
Matrix4F vp = camera.ViewMatrix * camera.ProjectionMatrix;
Matrix4F wvp = HitMatrix * vp;
Ray3F rayL = vc.GetRay(scrPt, wvp);
Matrix4F wvp2 = billboard * vp;
Ray3F rayL2 = vc.GetRay(scrPt, wvp2);
Plane3F xplane = new Plane3F(Vec3F.XAxis, Vec3F.ZeroVector);
Plane3F yplane = new Plane3F(Vec3F.YAxis, Vec3F.ZeroVector);
Plane3F zplane = new Plane3F(Vec3F.ZAxis, Vec3F.ZeroVector);
Vec3F pt;
float xdelta = float.MaxValue;
float ydelta = float.MaxValue;
float zdelta = float.MaxValue;
float lookdelta = float.MaxValue;
if (rayL.IntersectPlane(xplane, out pt))
{
xdelta = Math.Abs(pt.Length - rad);
}
if (rayL.IntersectPlane(yplane, out pt))
{
ydelta = Math.Abs(pt.Length - rad);
}
if (rayL.IntersectPlane(zplane, out pt))
{
zdelta = Math.Abs(pt.Length - rad);
}
if (rayL2.IntersectPlane(zplane, out pt))
{
lookdelta = Math.Abs(pt.Length - lrad);
}
if (xdelta < tolerance && xdelta < ydelta && xdelta < zdelta &&
xdelta < lookdelta)
{
m_hitRegion = HitRegion.XAxis;
}
else if (ydelta < tolerance && ydelta < zdelta &&
ydelta < lookdelta)
{
m_hitRegion = HitRegion.YAxis;
}
else if (zdelta < tolerance && zdelta < lookdelta)
{
m_hitRegion = HitRegion.ZAxis;
}
else if (lookdelta < tolerance)
{
m_hitRegion = HitRegion.LookAxis;
}
if (m_hitRegion != HitRegion.None)
{
return(ManipulatorPickResult.DeferredBeginDrag);
}
return(ManipulatorPickResult.Miss);
}
unsafe public override void Render(Component_RenderingPipeline pipeline, ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData)
{
UpdateProcessedCubemaps();
if (mesh != null)
{
////!!!!
//CreatedCubemapUpdate();
//!!!!double
Matrix4F worldMatrix = Matrix4.FromTranslate(context.Owner.CameraSettings.Position).ToMatrix4F();
foreach (var item in mesh.Result.MeshData.RenderOperations)
{
ParameterContainer generalContainer = new ParameterContainer();
generalContainer.Set("multiplier", Multiplier.Value.ToColorValue());
GetRotationMatrix(out var rotation);
generalContainer.Set("rotation", rotation); // Matrix3.FromRotateByZ( Rotation.Value.InRadians() ).ToMatrix3F() );
generalContainer.Set("stretch", (float)Stretch.Value);
Component_Image tex = null;
////!!!!hack. by idea need mirror 6-sided loaded cubemaps
//bool flipCubemap = false;
if (AlwaysUseProcessedCubemap)
{
tex = processedEnvironmentCubemap;
}
if (tex == null)
{
tex = Cubemap;
//if( tex != null && tex.AnyCubemapSideIsSpecified() )
// flipCubemap = true;
}
if (tex == null)
{
tex = processedEnvironmentCubemap;
}
if (tex == null)
{
tex = ResourceUtility.BlackTextureCube;
}
//generalContainer.Set( "flipCubemap", new Vector4F( flipCubemap ? -1 : 1, 0, 0, 0 ) );
////!!!!сделать GetResultEnvironmentCubemap()?
////!!!!!!где еще его использовать
//if( processedEnvironmentCubemap != null )
// tex = processedEnvironmentCubemap;
////else if( AnyCubemapSideIsSpecified() )
//// tex = createdCubemap;
//else
// tex = Cubemap;
//if( tex == null )
// tex = ResourceUtility.BlackTextureCube;
if (tex.Result != null)
{
var cube = tex.Result.TextureType == Component_Image.TypeEnum.Cube;
var pass = GetMaterialPass(cube);
if (pass != null)
{
TextureAddressingMode addressingMode;
if (cube)
{
addressingMode = TextureAddressingMode.Wrap;
}
else
{
addressingMode = TextureAddressingMode.WrapU | TextureAddressingMode.ClampV;
}
context.BindTexture(new ViewportRenderingContext.BindTextureData(0 /*"skyboxTexture"*/, tex, addressingMode, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));
var containers = new List <ParameterContainer>();
containers.Add(generalContainer);
Bgfx.SetTransform((float *)&worldMatrix);
((Component_RenderingPipeline_Basic)pipeline).RenderOperation(context, item, pass, containers);
}
}
}
}
}
/// <summary>
/// Renders control for picking</summary>
/// <param name="action">Render action</param>
/// <param name="camera">Camera</param>
/// <param name="renderState">Render state</param>
/// <param name="transform">Transform, local to world</param>
public void RenderPick(IRenderAction action, Camera camera, RenderState renderState, Matrix4F transform)
{
action.RenderStateGuardian.Commit(renderState);
// apply xform
Gl.glPushMatrix();
Util3D.glMultMatrixf(transform);
float s1, s2, s3;
CalcAxisLengths(camera, transform, out s1, out s2, out s3);
float squareSideX = s1 * SquareLength;
float squareSideY = s2 * SquareLength;
float squareSideZ = s3 * SquareLength;
bool drawX, drawY, drawZ;
DecideArrowDrawing(transform, camera, out drawX, out drawY, out drawZ);
// Mark each axis with a different name.
// Since the OpenGl selection buffer does a bad job in detecting lines we'll use
// triangles instead.
Gl.glPushName(m_nameBase);
if (drawX)
{
Gl.glPushName((int)HitElement.X_ARROW);
Gl.glBegin(Gl.GL_TRIANGLES);
Gl.glVertex3f(squareSideX, 0, 0);
Gl.glVertex3f(s1, 0, 0);
Gl.glVertex3f(squareSideX, 0, 0);
Gl.glEnd();
RenderXArrow(s1);
Gl.glPopName();
}
if (drawY)
{
Gl.glPushName((int)HitElement.Y_ARROW);
Gl.glBegin(Gl.GL_TRIANGLES);
Gl.glVertex3f(0, squareSideY, 0);
Gl.glVertex3f(0, s2, 0);
Gl.glVertex3f(0, squareSideY, 0);
Gl.glEnd();
RenderYArrow(s2);
Gl.glPopName();
}
if (drawZ)
{
Gl.glPushName((int)HitElement.Z_ARROW);
Gl.glBegin(Gl.GL_TRIANGLES);
Gl.glVertex3f(0, 0, squareSideZ);
Gl.glVertex3f(0, 0, s3);
Gl.glVertex3f(0, 0, squareSideZ);
Gl.glEnd();
RenderZArrow(s3);
Gl.glPopName();
}
if (drawX && drawY)
{
Gl.glPushName((int)HitElement.XY_SQUARE);
RenderXYSquare(squareSideX, squareSideY, true);
Gl.glPopName();
}
if (drawY && drawZ)
{
Gl.glPushName((int)HitElement.YZ_SQUARE);
RenderYZSquare(squareSideY, squareSideZ, true);
Gl.glPopName();
}
if (drawX && drawZ)
{
Gl.glPushName((int)HitElement.XZ_SQUARE);
RenderXZSquare(squareSideX, squareSideZ, true);
Gl.glPopName();
}
Gl.glPopMatrix();
Gl.glPopName();
}
private void RenderProperties(IEnumerable <object> objects, bool renderCaption, bool renderBound, bool renderPivot)
{
bool renderAny = renderCaption || renderBound || renderPivot;
if (renderAny == false)
{
return;
}
Util3D.RenderFlag = BasicRendererFlags.WireFrame;
Matrix4F vp = Camera.ViewMatrix * Camera.ProjectionMatrix;
foreach (object obj in objects)
{
IBoundable bnode = obj.As <IBoundable>();
if (bnode == null || bnode.BoundingBox.IsEmpty || obj.Is <IGameObjectFolder>())
{
continue;
}
INameable nnode = obj.As <INameable>();
ITransformable trans = obj.As <ITransformable>();
if (renderBound)
{
Util3D.DrawAABB(bnode.BoundingBox);
}
if (renderCaption && nnode != null)
{
Vec3F topCenter = bnode.BoundingBox.Center;
topCenter.Y = bnode.BoundingBox.Max.Y;
Point pt = Project(vp, topCenter);
GameEngine.DrawText2D(nnode.Name, Util3D.CaptionFont, pt.X, pt.Y, Color.White);
}
}
if (renderPivot)
{
Util3D.RenderFlag = BasicRendererFlags.WireFrame
| BasicRendererFlags.DisableDepthTest;
// create few temp matrics to
Matrix4F toWorld = new Matrix4F();
Matrix4F PV = new Matrix4F();
Matrix4F sc = new Matrix4F();
Matrix4F bl = new Matrix4F();
Matrix4F recXform = new Matrix4F();
foreach (object obj in objects)
{
ITransformable trans = obj.As <ITransformable>();
IBoundable bnode = obj.As <IBoundable>();
if (trans == null || bnode == null || bnode.BoundingBox.IsEmpty || obj.Is <IGameObjectFolder>())
{
continue;
}
Path <DomNode> path = new Path <DomNode>(trans.Cast <DomNode>().GetPath());
toWorld.Set(Vec3F.ZeroVector);
TransformUtils.CalcPathTransform(toWorld, path, path.Count - 1);
// Offset by pivot
PV.Set(trans.Pivot);
toWorld.Mul(PV, toWorld);
Vec3F pos = toWorld.Translation;
float s;
Util.CalcAxisLengths(Camera, pos, out s);
s /= 12.0f;
sc.Scale(s);
Util.CreateBillboard(bl, pos, Camera.WorldEye, Camera.Up, Camera.LookAt);
Matrix4F.Multiply(sc, bl, recXform);
Util3D.DrawPivot(recXform, Color.Yellow);
}
}
}
unsafe protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
{
base.OnRender(context, frameData, ref actualTexture);
//is not supported
if (!context.RenderingPipeline.GetUseMultiRenderTargets())
{
return;
}
//downscale for SSAA
var actualTextureSource = actualTexture;
if (actualTexture.Result.ResultSize != context.Owner.SizeInPixels)
{
actualTexture = context.RenderTarget2D_Alloc(context.Owner.SizeInPixels, actualTextureSource.Result.ResultFormat);
//copy to scene texture with downscale
context.SetViewport(actualTexture.Result.GetRenderTarget().Viewports[0]);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\Downscale2_fs.sc";
shader.Parameters.Set("sourceSizeInv", new Vector2F(1, 1) / actualTextureSource.Result.ResultSize.ToVector2F());
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/,
actualTextureSource, TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.None));
context.RenderQuadToCurrentViewport(shader);
}
// Setup Constants:
Vector2F viewportPixelSize = new Vector2F(1.0f / (float)actualTexture.Result.ResultSize.X, 1.0f / (float)actualTexture.Result.ResultSize.Y);
Vector2F halfViewportPixelSize = new Vector2F(1.0f / ((float)actualTexture.Result.ResultSize.X * 0.5f), 1.0f / ((float)actualTexture.Result.ResultSize.Y * 0.5f));
Vector4F quarterViewportPixelSize = new Vector4F(1.0f / ((float)actualTexture.Result.ResultSize.X * 0.25f), 1.0f / ((float)actualTexture.Result.ResultSize.Y * 0.25f), (float)((actualTexture.Result.ResultSize.X / 4) * (actualTexture.Result.ResultSize.Y / 4)), 0.0f);
Vector2F viewport2xPixelSize = new Vector2F(viewportPixelSize.X * 2.0f, viewportPixelSize.Y * 2.0f);
Matrix4F projectionMatrix = context.Owner.CameraSettings.ProjectionMatrix.ToMatrix4F();
float depthLinearizeMul = -projectionMatrix[3][2];
float depthLinearizeAdd = projectionMatrix[2][2];
if (depthLinearizeMul * depthLinearizeAdd < 0.0f)
{
depthLinearizeAdd = -depthLinearizeAdd;
}
Vector2F depthUnpackConsts = new Vector2F(depthLinearizeMul, depthLinearizeAdd);
float tanHalfFOVY = 1.0f / projectionMatrix[1][1];
float tanHalfFOVX = 1.0F / projectionMatrix[0][0];
Vector2F cameraTanHalfFOV = new Vector2F(tanHalfFOVX, tanHalfFOVY);
Vector2F NDCToViewMul = new Vector2F(cameraTanHalfFOV.X * 2.0f, cameraTanHalfFOV.Y * -2.0f);
Vector2F NDCToViewAdd = new Vector2F(cameraTanHalfFOV.X * -1.0f, cameraTanHalfFOV.Y * 1.0f);
Matrix4F itViewMatrix = (context.Owner.CameraSettings.ViewMatrix.GetInverse().ToMatrix4F()).GetTranspose();
// Effect Params:
float effectSamplingRadiusNearLimit = (float)Radius * 1.2f;
if (Quality.Value == QualityEnum.Low)
{
effectSamplingRadiusNearLimit *= 1.50f;
}
effectSamplingRadiusNearLimit /= tanHalfFOVY;
float effectSamplingRadiusNearLimitRec = 1.0f / effectSamplingRadiusNearLimit;
Vector4F effectRadiusParams = new Vector4F((float)Radius, -1.0f / (float)Radius, effectSamplingRadiusNearLimitRec, 0.0f);
float effectFadeOutMul = -1.0f / ((float)FadeOutTo - (float)FadeOutFrom);
float effectFadeOutAdd = (float)FadeOutFrom / ((float)FadeOutTo - (float)FadeOutFrom) + 1.0f;
float detailAOStrength = (float)DetailStrength;
float effectShadowStrength = (float)Multiplier;
float effectShadowClamp = 1.0f;
float effectShadowPow = (float)Power;
float invSharpness = 1.0f - (float)Sharpness;
if (invSharpness < 0.0f)
{
invSharpness = 0.0f;
}
if (invSharpness > 1.0f)
{
invSharpness = 1.0f;
}
// First Pass: Prepare 4 Depth half-Buffers:
Component_Image[] halfDepths = new Component_Image[4];
for (int i = 0; i < 4; i++)
{
halfDepths[i] = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize / 2, PixelFormat.Float16R);
}
var fourDepthsMRT = context.MultiRenderTarget_Create(new[] {
new MultiRenderTarget.Item(halfDepths[0]),
new MultiRenderTarget.Item(halfDepths[1]),
new MultiRenderTarget.Item(halfDepths[2]),
new MultiRenderTarget.Item(halfDepths[3])
});
{
context.SetViewport(fourDepthsMRT.Viewports[0], Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\PrepareDepths_fs.sc";
context.objectsDuringUpdate.namedTextures.TryGetValue("depthTexture", out Component_Image depthTexture);
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, depthTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set("depthUnpackConsts", depthUnpackConsts);
//!!!!use actualTextureSource size?
shader.Parameters.Set("viewportPixelSize", viewportPixelSize);
context.RenderQuadToCurrentViewport(shader);
}
// Second Pass: prepare 4 Mip-Maps for each Half-Depth-Map:
Component_Image[,] depthMipMaps = null;
if (Quality.Value > QualityEnum.Medium)
{
Vector2I[] mipMapSizes = new Vector2I[4]; // Setup Mip-Map sizes:
mipMapSizes[0] = new Vector2I(actualTexture.Result.ResultSize / 2);
for (int m = 1; m < 4; m++)
{
mipMapSizes[m] = new Vector2I(mipMapSizes[m - 1] / 2);
}
// Prepare MipMaps textures:
depthMipMaps = new Component_Image[4, 4];
for (int d = 0; d < 4; d++)
{
depthMipMaps[d, 0] = halfDepths[d]; // MipMaps 0 is original halfDepthMaps
for (int m = 1; m < 4; m++)
{
depthMipMaps[d, m] = context.RenderTarget2D_Alloc(mipMapSizes[m], PixelFormat.Float16R);
}
}
for (int m = 1; m < 4; m++) // Mip-Maps loop
{
var fourDepthsMipsMRT = context.MultiRenderTarget_Create(new[] {
new MultiRenderTarget.Item(depthMipMaps[0, m]),
new MultiRenderTarget.Item(depthMipMaps[1, m]),
new MultiRenderTarget.Item(depthMipMaps[2, m]),
new MultiRenderTarget.Item(depthMipMaps[3, m])
});
context.SetViewport(fourDepthsMipsMRT.Viewports[0], Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\PrepareDepthMips_fs.sc";
// For current Mip-Map generation using previous Mip-Map:
float prevMipLevel = (float)(m - 1);
var prevMipSize = mipMapSizes[m - 1];
Vector4F prevMipParams = new Vector4F(1.0f / (float)prevMipSize.X, 1.0f / (float)prevMipSize.Y, prevMipLevel, 0.0f);
for (int i = 0; i < 4; i++)
{
// previous MipMap as input:
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(i, depthMipMaps[i, m - 1],
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
}
shader.Parameters.Set("prevMipParams", prevMipParams);
shader.Parameters.Set("effectRadiusParams", effectRadiusParams);
context.RenderQuadToCurrentViewport(shader);
}
}
Component_Image SSAOTextureArray = new Component_Image();
Component_Image SSAOBaseTextureArray = null;
if (Quality.Value == QualityEnum.HighestAdaptive)
{
SSAOBaseTextureArray = new Component_Image();
SSAOBaseTextureArray = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize / 2, PixelFormat.R8G8_UInt, 0, false, /*0,*/ 4);
}
Component_Image importanceMap = null;
Component_Image averageImportance = null;
// Generate Importance Map for Highest/Adaptive Quality mode:
if (Quality.Value == QualityEnum.HighestAdaptive)
{
// 4 SSAO passes:
for (int pass = 0; pass < 4; pass++)
{
Vector4F[] patternRotScaleMatrices;
GeneratePatternRotScaleMatrices(pass, out patternRotScaleMatrices);
Vector2F perPassFullResCoordOffset = new Vector2F((float)(pass % 2), (float)(pass / 2));
{
context.SetViewport(SSAOBaseTextureArray.Result.GetRenderTarget(0, pass).Viewports[0],
Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\GenerateSSAO_AdaptiveBase_fs.sc";
context.objectsDuringUpdate.namedTextures.TryGetValue("normalTexture", out Component_Image normalTexture);
for (int m = 0; m < 4; m++)
{
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(m, depthMipMaps[pass, m],
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
}
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(4, halfDepths[pass],
TextureAddressingMode.Mirror, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(5, normalTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set("NDCToViewMul", NDCToViewMul);
shader.Parameters.Set("NDCToViewAdd", NDCToViewAdd);
shader.Parameters.Set("effectRadiusParams", effectRadiusParams);
shader.Parameters.Set("viewportPixelSize", viewportPixelSize);
shader.Parameters.Set("viewport2xPixelSize", viewport2xPixelSize);
shader.Parameters.Set("halfViewportPixelSize", halfViewportPixelSize);
shader.Parameters.Set("perPassFullResCoordOffset", perPassFullResCoordOffset);
shader.Parameters.Set("patternRotScaleMatrices", patternRotScaleMatrices);
shader.Parameters.Set("effectFadeOutMul", effectFadeOutMul);
shader.Parameters.Set("effectFadeOutAdd", effectFadeOutAdd);
shader.Parameters.Set("effectShadowStrength", effectShadowStrength);
shader.Parameters.Set("effectShadowClamp", effectShadowClamp);
shader.Parameters.Set("effectShadowPow", effectShadowPow);
shader.Parameters.Set("detailAOStrength", detailAOStrength);
shader.Parameters.Set("itViewMatrix", itViewMatrix);
context.RenderQuadToCurrentViewport(shader);
}
}
// Importance Map Generation:
importanceMap = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize / 4, PixelFormat.L8);
{
context.SetViewport(importanceMap.Result.GetRenderTarget().Viewports[0],
Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\GenerateImportanceMap_fs.sc";
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, SSAOBaseTextureArray,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set("halfViewportPixelSize", halfViewportPixelSize);
shader.Parameters.Set("effectShadowStrength", effectShadowStrength);
shader.Parameters.Set("effectShadowPow", effectShadowPow);
context.RenderQuadToCurrentViewport(shader);
}
// Importance Map Post-Process A:
var importanceMapPong = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize / 4, PixelFormat.L8);
{
context.SetViewport(importanceMapPong.Result.GetRenderTarget().Viewports[0],
Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\PostProcessImportanceMapA_fs.sc";
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, importanceMap,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.None));
shader.Parameters.Set("quarterViewportPixelSize", quarterViewportPixelSize);
context.RenderQuadToCurrentViewport(shader);
}
// Importance Map Post-Process B:
{
context.SetViewport(importanceMap.Result.GetRenderTarget().Viewports[0],
Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\PostProcessImportanceMapB_fs.sc";
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, importanceMapPong,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.None));
shader.Parameters.Set("quarterViewportPixelSize", quarterViewportPixelSize);
context.RenderQuadToCurrentViewport(shader);
}
context.DynamicTexture_Free(importanceMapPong);
// Get Average Importance Pass:
averageImportance = context.RenderTarget2D_Alloc(new Vector2I(1, 1), PixelFormat.L8);
{
context.SetViewport(averageImportance.Result.GetRenderTarget().Viewports[0],
Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\GetAverageImportance_fs.sc";
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, importanceMap,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set("quarterViewportPixelSize", quarterViewportPixelSize);
context.RenderQuadToCurrentViewport(shader);
}
}
// Third Pass: Generate 4 SSAO buffers:
Component_Image blurPingTexture = null, blurPongTexture = null;
if (BlurAmount.Value > 0)
{
blurPingTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize / 2, PixelFormat.R8G8_UInt);
blurPongTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize / 2, PixelFormat.R8G8_UInt);
}
SSAOTextureArray = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize / 2, PixelFormat.R8G8_UInt, 0, false, /*0,*/ 4);
for (int pass = 0; pass < 4; pass++)
{
Vector4F[] patternRotScaleMatrices;
GeneratePatternRotScaleMatrices(pass, out patternRotScaleMatrices);
Vector2F perPassFullResCoordOffset = new Vector2F((float)(pass % 2), (float)(pass / 2));
{
if (BlurAmount.Value == 0)
{
context.SetViewport(SSAOTextureArray.Result.GetRenderTarget(0, pass).Viewports[0],
Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);
}
else
{
context.SetViewport(blurPingTexture.Result.GetRenderTarget().Viewports[0],
Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);
}
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
if (Quality.Value == QualityEnum.Low)
{
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\GenerateSSAO_LQ_fs.sc";
}
else if (Quality.Value == QualityEnum.Medium)
{
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\GenerateSSAO_MQ_fs.sc";
}
else if (Quality.Value == QualityEnum.High)
{
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\GenerateSSAO_HQ_fs.sc";
}
else if (Quality.Value == QualityEnum.HighestAdaptive)
{
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\GenerateSSAO_HAQ_fs.sc";
}
context.objectsDuringUpdate.namedTextures.TryGetValue("normalTexture", out Component_Image normalTexture);
if (Quality.Value > QualityEnum.Medium)
{
for (int m = 0; m < 4; m++)
{
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(m, depthMipMaps[pass, m],
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
}
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(4, halfDepths[pass],
TextureAddressingMode.Mirror, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(5, normalTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
if (Quality.Value == QualityEnum.HighestAdaptive)
{
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(6, importanceMap,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(7, averageImportance,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(8, SSAOBaseTextureArray,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
}
}
else
{
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, halfDepths[pass],
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1, halfDepths[pass],
TextureAddressingMode.Mirror, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(2, normalTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
}
shader.Parameters.Set("NDCToViewMul", NDCToViewMul);
shader.Parameters.Set("NDCToViewAdd", NDCToViewAdd);
shader.Parameters.Set("effectRadiusParams", effectRadiusParams);
shader.Parameters.Set("viewportPixelSize", viewportPixelSize);
shader.Parameters.Set("viewport2xPixelSize", viewport2xPixelSize);
shader.Parameters.Set("halfViewportPixelSize", halfViewportPixelSize);
shader.Parameters.Set("perPassFullResCoordOffset", perPassFullResCoordOffset);
shader.Parameters.Set("patternRotScaleMatrices", patternRotScaleMatrices);
shader.Parameters.Set("effectFadeOutMul", effectFadeOutMul);
shader.Parameters.Set("effectFadeOutAdd", effectFadeOutAdd);
shader.Parameters.Set("effectShadowStrength", effectShadowStrength);
shader.Parameters.Set("effectShadowClamp", effectShadowClamp);
shader.Parameters.Set("effectShadowPow", effectShadowPow);
shader.Parameters.Set("detailAOStrength", detailAOStrength);
shader.Parameters.Set("itViewMatrix", itViewMatrix);
if (Quality.Value == QualityEnum.HighestAdaptive)
{
shader.Parameters.Set("adaptiveSampleCountLimit", (float)AdaptiveQualityLimit);
shader.Parameters.Set("passNumber", (float)pass);
}
context.RenderQuadToCurrentViewport(shader);
}
if (Quality.Value > QualityEnum.Medium)
{
// Free Mip-Maps Targets for this Pass:
for (int m = 0; m < 4; m++)
{
context.DynamicTexture_Free(depthMipMaps[pass, m]);
}
}
else
{
context.DynamicTexture_Free(halfDepths[pass]);
}
// Blur SSAO Texture:
if (BlurAmount.Value > 0)
{
int wideBlursRemaining = Math.Max(0, BlurAmount.Value - 2);
for (int i = 0; i < BlurAmount.Value; i++)
{
if (i == (BlurAmount.Value - 1))
{
context.SetViewport(SSAOTextureArray.Result.GetRenderTarget(0, pass).Viewports[0],
Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);
}
else
{
context.SetViewport(blurPongTexture.Result.GetRenderTarget().Viewports[0],
Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);
}
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
if (Quality.Value > QualityEnum.Low)
{
if (wideBlursRemaining > 0)
{
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\SmartBlurWide_fs.sc";
wideBlursRemaining--;
}
else
{
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\SmartBlur_fs.sc";
}
}
else
{
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\NonSmartBlur_fs.sc";
}
if (Quality.Value > QualityEnum.Low)
{
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, blurPingTexture,
TextureAddressingMode.Mirror, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set("invSharpness", invSharpness);
}
else
{
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, blurPingTexture,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.None));
}
shader.Parameters.Set("halfViewportPixelSize", halfViewportPixelSize);
context.RenderQuadToCurrentViewport(shader);
// Swap Ping-Pong Blur textures:
var tmp_tex = blurPingTexture;
blurPingTexture = blurPongTexture;
blurPongTexture = tmp_tex;
}
}
}
if (Quality.Value == QualityEnum.HighestAdaptive)
{
context.DynamicTexture_Free(SSAOBaseTextureArray);
}
if (Quality.Value == QualityEnum.HighestAdaptive)
{
context.DynamicTexture_Free(importanceMap);
context.DynamicTexture_Free(averageImportance);
}
if (BlurAmount.Value > 0)
{
// Free Blur ping/pong Targets:
context.DynamicTexture_Free(blurPingTexture);
context.DynamicTexture_Free(blurPongTexture);
}
// 4th Pass: Apply 4 SSAO Textures to Final SSAO Result:
var FullSSAOTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, PixelFormat.R8G8_UInt);
{
context.SetViewport(FullSSAOTexture.Result.GetRenderTarget().Viewports[0],
Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
if (Quality.Value > QualityEnum.Low)
{
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\Apply_fs.sc";
}
else
{
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\Apply_noSmart_fs.sc";
}
if (Quality.Value > QualityEnum.Low)
{
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, SSAOTextureArray,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1, SSAOTextureArray,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.None));
}
else
{
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, SSAOTextureArray,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.None));
}
if (Quality.Value > QualityEnum.Low)
{
shader.Parameters.Set("invSharpness", invSharpness);
shader.Parameters.Set("halfViewportPixelSize", halfViewportPixelSize);
}
context.RenderQuadToCurrentViewport(shader);
}
// Free SSAO Texture Array Target:
context.DynamicTexture_Free(SSAOTextureArray);
// 5th Final Pass:
var finalTexture = context.RenderTarget2D_Alloc(actualTextureSource.Result.ResultSize, actualTextureSource.Result.ResultFormat);
{
context.SetViewport(finalTexture.Result.GetRenderTarget().Viewports[0]);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\Final_fs.sc";
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, actualTextureSource,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1, FullSSAOTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set("intensity", (float)Intensity);
shader.Parameters.Set("showAO", ShowAO ? 1.0f : -1.0f);
context.RenderQuadToCurrentViewport(shader);
}
// Free Targets:
context.DynamicTexture_Free(actualTexture);
if (actualTextureSource != actualTexture)
{
context.DynamicTexture_Free(actualTextureSource);
}
context.DynamicTexture_Free(FullSSAOTexture);
// Update actual Texture:
actualTexture = finalTexture;
}
public override void Render(object opaqueContext, ViewControl vc)
{
Matrix4F normWorld = GetManipulatorMatrix();
if (normWorld == null) return;
var context = opaqueContext as GUILayer.SimpleRenderingContext;
if (context == null) return;
float RingDiameter = 2 * AxisLength;
Color xcolor = (m_hitRegion == HitRegion.XAxis) ? Color.Gold : XAxisColor;
Color ycolor = (m_hitRegion == HitRegion.YAxis ) ? Color.Gold : YAxisColor;
Color Zcolor = (m_hitRegion == HitRegion.ZAxis ) ? Color.Gold : ZAxisColor;
Color lColor = (m_hitRegion == HitRegion.LookAxis) ? Color.Gold : Color.Cyan;
float s = Util.CalcAxisScale(vc.Camera, normWorld.Translation, RingDiameter, vc.Height);
Vec3F axScale = new Vec3F(s, s, s);
Matrix4F rot = new Matrix4F();
Matrix4F scale = new Matrix4F();
scale.Scale(axScale);
rot.RotX(MathHelper.PiOver2);
Matrix4F xform = scale * rot * normWorld;
Util3D.DrawRing(context, xform, Zcolor);
rot.RotZ(-MathHelper.PiOver2);
xform = scale * rot * normWorld;
Util3D.DrawRing(context, xform, xcolor);
xform = scale * normWorld;
Util3D.DrawRing(context, xform, ycolor);
Matrix4F billboard
= Util.CreateBillboard(normWorld.Translation, vc.Camera.WorldEye, vc.Camera.Up, vc.Camera.LookAt);
rot.RotX(MathHelper.PiOver2);
scale.Scale(s * LookRingScale);
xform = scale * rot * billboard;
Util3D.DrawRing(context, xform, lColor);
}
public override void OnDragging(ViewControl vc, Point scrPt)
{
if (m_hitRegion == HitRegion.None || m_activeOp == null || m_activeOp.NodeList.Count == 0)
return;
Camera cam = vc.Camera;
Matrix4F view = cam.ViewMatrix;
Matrix4F proj = cam.ProjectionMatrix;
Matrix4F axisMtrx = HitMatrix * view;
Ray3F hitRay = HitRayV;
Ray3F dragRay = vc.GetRay(scrPt, proj);
Vec3F xAxis = axisMtrx.XAxis;
Vec3F yAxis = axisMtrx.YAxis;
Vec3F zAxis = axisMtrx.ZAxis;
Vec3F origin = axisMtrx.Translation;
Vec3F rotAxis = new Vec3F();
float theta = 0;
float snapAngle = ((ISnapSettings)DesignView).SnapAngle;
switch (m_hitRegion)
{
case HitRegion.XAxis:
{
Plane3F xplane = new Plane3F(xAxis, origin);
theta = CalcAngle(origin, xplane, hitRay, dragRay, snapAngle);
rotAxis = HitMatrix.XAxis;
}
break;
case HitRegion.YAxis:
{
Plane3F yplane = new Plane3F(yAxis, origin);
theta = CalcAngle(origin, yplane, hitRay, dragRay, snapAngle);
rotAxis = HitMatrix.YAxis;
}
break;
case HitRegion.ZAxis:
{
Plane3F zplane = new Plane3F(zAxis, origin);
theta = CalcAngle(origin, zplane, hitRay, dragRay, snapAngle);
rotAxis = HitMatrix.ZAxis;
}
break;
case HitRegion.LookAxis:
{
// for billboard objects the look vector is object's negative position in viewspace.
Vec3F lookAxis = Vec3F.Normalize(-origin);
Plane3F plane = new Plane3F(lookAxis, origin);
theta = CalcAngle(origin, plane, hitRay, dragRay, snapAngle);
rotAxis = m_lookAxisHitMtrx.ZAxis;
}
break;
default:
throw new ArgumentOutOfRangeException();
}
AngleAxisF axf = new AngleAxisF(-theta, rotAxis);
Matrix4F deltaMtrx = new Matrix4F(axf);
Matrix4F rotMtrx = new Matrix4F();
for (int i = 0; i < m_activeOp.NodeList.Count; i++)
{
ITransformable node = m_activeOp.NodeList[i];
rotMtrx.Mul(m_rotations[i], deltaMtrx);
float ax, ay, az;
rotMtrx.GetEulerAngles(out ax, out ay, out az);
node.Rotation = new Vec3F(ax, ay, az);
}
}
/// <summary>
/// Sets up the view matrix given a Camera</summary>
/// <param name="camera">Camera to get view matrix for</param>
protected override void SetupView(Camera camera)
{
m_viewMatrix = new Matrix4F(camera.ViewMatrix);
base.SetupView(camera);
}
public override bool Pick(ViewControl vc, Point scrPt)
{
m_hitRegion = HitRegion.None;
if (base.Pick(vc, scrPt) == false)
return false;
Camera camera = vc.Camera;
float s = Util.CalcAxisScale(vc.Camera, HitMatrix.Translation, AxisLength, vc.Height);
Matrix4F vp = camera.ViewMatrix * camera.ProjectionMatrix;
Matrix4F wvp = HitMatrix * vp;
// get ray in object space space.
Ray3F rayL = vc.GetRay(scrPt, wvp);
m_scale = new Vec3F(1, 1, 1);
m_hitScale = s;
Vec3F min = new Vec3F(-0.5f, -0.5f, -0.5f);
Vec3F max = new Vec3F(0.5f, 0.5f, 0.5f);
AABB box = new AABB(min, max);
Matrix4F boxScale = new Matrix4F();
Matrix4F boxTrans = new Matrix4F();
Matrix4F BoxMtrx = new Matrix4F();
float handleScale = s * AxisHandle;
// +X axis
boxScale.Scale(new Vec3F(s, handleScale, handleScale));
boxTrans.Translation = new Vec3F(s / 2, 0, 0);
BoxMtrx = boxScale * boxTrans;
Ray3F ray = rayL;
BoxMtrx.Invert(BoxMtrx);
ray.Transform(BoxMtrx);
if (box.Intersect(ray))
{
m_hitRegion = HitRegion.XAxis;
return true;
}
// -X
boxTrans.Translation = new Vec3F(-s / 2, 0, 0);
BoxMtrx = boxScale * boxTrans;
ray = rayL;
BoxMtrx.Invert(BoxMtrx);
ray.Transform(BoxMtrx);
if (box.Intersect(ray))
{
m_hitRegion = HitRegion.NegXAxis;
return true;
}
// y axis
boxScale.Scale(new Vec3F(handleScale, s, handleScale));
boxTrans.Translation = new Vec3F(0, s / 2, 0);
BoxMtrx = boxScale * boxTrans;
ray = rayL;
BoxMtrx.Invert(BoxMtrx);
ray.Transform(BoxMtrx);
if (box.Intersect(ray))
{
m_hitRegion = HitRegion.YAxis;
return true;
}
// -Y
boxTrans.Translation = new Vec3F(0, -s / 2, 0);
BoxMtrx = boxScale * boxTrans;
ray = rayL;
BoxMtrx.Invert(BoxMtrx);
ray.Transform(BoxMtrx);
if (box.Intersect(ray))
{
m_hitRegion = HitRegion.NegYAxis;
return true;
}
// z axis
boxScale.Scale(new Vec3F(handleScale, handleScale, s));
boxTrans.Translation = new Vec3F(0, 0, s / 2);
BoxMtrx = boxScale * boxTrans;
ray = rayL;
BoxMtrx.Invert(BoxMtrx);
ray.Transform(BoxMtrx);
if (box.Intersect(ray))
{
m_hitRegion = HitRegion.ZAxis;
return true;
}
// -Z
boxTrans.Translation = new Vec3F(0, 0, -s / 2);
BoxMtrx = boxScale * boxTrans;
ray = rayL;
BoxMtrx.Invert(BoxMtrx);
ray.Transform(BoxMtrx);
if (box.Intersect(ray))
{
m_hitRegion = HitRegion.NegZAxis;
return true;
}
return false;
}
public void Render(object opaqueContext, ViewControl vc, Matrix4F normWorld)
{
var context = opaqueContext as GUILayer.SimpleRenderingContext;
if (context == null)
{
return;
}
float s = Util.CalcAxisScale(vc.Camera, normWorld.Translation, Manipulator.AxisLength, vc.Height);
Color xcolor = (m_hitRegion == HitRegion.XAxis || m_hitRegion == HitRegion.XYSquare || m_hitRegion == HitRegion.XZSquare) ? Color.Gold : Manipulator.XAxisColor;
Color ycolor = (m_hitRegion == HitRegion.YAxis || m_hitRegion == HitRegion.XYSquare || m_hitRegion == HitRegion.YZSquare) ? Color.Gold : Manipulator.YAxisColor;
Color Zcolor = (m_hitRegion == HitRegion.ZAxis || m_hitRegion == HitRegion.XZSquare || m_hitRegion == HitRegion.YZSquare) ? Color.Gold : Manipulator.ZAxisColor;
Color XYx = m_hitRegion == HitRegion.XYSquare ? Color.Gold : Manipulator.XAxisColor;
Color XYy = m_hitRegion == HitRegion.XYSquare ? Color.Gold : Manipulator.YAxisColor;
Color XZx = m_hitRegion == HitRegion.XZSquare ? Color.Gold : Manipulator.XAxisColor;
Color XZz = m_hitRegion == HitRegion.XZSquare ? Color.Gold : Manipulator.ZAxisColor;
Color YZy = m_hitRegion == HitRegion.YZSquare ? Color.Gold : Manipulator.YAxisColor;
Color YZz = m_hitRegion == HitRegion.YZSquare ? Color.Gold : Manipulator.ZAxisColor;
var axisScale = new Matrix4F();
axisScale.Scale(new Vec3F(s * Manipulator.AxisThickness, s * (1 - ConeHeight), s * Manipulator.AxisThickness));
var axisrot = new Matrix4F();
// Draw X axis
axisrot.RotZ(-MathHelper.PiOver2);
Matrix4F scaleRot = axisScale * axisrot;
Matrix4F axisXform = scaleRot * normWorld;
Util3D.DrawCylinder(context, axisXform, xcolor);
// draw y
axisXform = axisScale * normWorld;
Util3D.DrawCylinder(context, axisXform, ycolor);
// draw z
axisrot.RotX(MathHelper.PiOver2);
scaleRot = axisScale * axisrot;
axisXform = scaleRot * normWorld;
Util3D.DrawCylinder(context, axisXform, Zcolor);
// draw center cube.
Matrix4F cubeScale = new Matrix4F();
cubeScale.Scale(CenterCube * s);
var cubexform = cubeScale * normWorld;
Util3D.DrawCube(context, cubexform, Color.White);
Matrix4F arrowHead = ComputeXhead(normWorld, s);
Util3D.DrawCone(context, arrowHead, xcolor);
arrowHead = ComputeYhead(normWorld, s);
Util3D.DrawCone(context, arrowHead, ycolor);
arrowHead = ComputeZhead(normWorld, s);
Util3D.DrawCone(context, arrowHead, Zcolor);
// draw xy rect.
Matrix4F scale = new Matrix4F();
scale.Scale(s * Manipulator.AxisThickness, s * SquareLength, s * Manipulator.AxisThickness);
Matrix4F trans = new Matrix4F();
trans.Translation = new Vec3F(0, s * SquareLength, 0);
Matrix4F rot = new Matrix4F();
rot.RotZ(-MathHelper.PiOver2);
Matrix4F squareXform = scale * rot * trans * normWorld;
Util3D.DrawCylinder(context, squareXform, XYy);
trans.Translation = new Vec3F(s * SquareLength, 0, 0);
squareXform = scale * trans * normWorld;
Util3D.DrawCylinder(context, squareXform, XYx);
// draw xz rect.
trans.Translation = new Vec3F(0, 0, s * SquareLength);
rot.RotZ(-MathHelper.PiOver2);
squareXform = scale * rot * trans * normWorld;
Util3D.DrawCylinder(context, squareXform, XZz);
trans.Translation = new Vec3F(s * SquareLength, 0, 0);
rot.RotX(MathHelper.PiOver2);
squareXform = scale * rot * trans * normWorld;
Util3D.DrawCylinder(context, squareXform, XZx);
// draw yz
trans.Translation = new Vec3F(0, s * SquareLength, 0);
rot.RotX(MathHelper.PiOver2);
squareXform = scale * rot * trans * normWorld;
Util3D.DrawCylinder(context, squareXform, YZy);
trans.Translation = new Vec3F(0, 0, s * SquareLength);
squareXform = scale * trans * normWorld;
Util3D.DrawCylinder(context, squareXform, YZz);
}
/// <summary>
/// Performs actions during control drag</summary>
/// <param name="hit">Hit record</param>
/// <param name="x">Mouse x position</param>
/// <param name="y">Mouse y position</param>
/// <param name="action">Render action</param>
/// <param name="camera">Camera</param>
/// <param name="transform">Transform</param>
/// <returns>Translation, in world coordinates</returns>
public Vec3F OnDrag(HitRecord hit, float x, float y, IRenderAction action, Camera camera, Matrix4F transform)
{
float a1, a2;
Matrix4F W = new Matrix4F();
W.Mul(transform, camera.ViewMatrix);
// Setup rays, in view space. (-z goes into the screen.)
Ray3F ray0 = camera.CreateRay(m_iX, m_iY);
Ray3F ray = camera.CreateRay(x, y);
// Build axis and origin in view space
Vec3F xAxis = W.XAxis;
Vec3F yAxis = W.YAxis;
Vec3F zAxis = W.ZAxis;
Vec3F origin = W.Translation;
Vec3F trans = new Vec3F();
// Choose the best projection plane according to the projection angle
switch ((HitElement)hit.RenderObjectData[1])
{
case HitElement.X_ARROW:
{
a1 = Math.Abs(Vec3F.Dot(ray0.Direction, yAxis));
a2 = Math.Abs(Vec3F.Dot(ray0.Direction, zAxis));
Vec3F axis = (a1 > a2 ? yAxis : zAxis);
Vec3F p0 = ray0.IntersectPlane(axis, -Vec3F.Dot(axis, origin));
Vec3F p1 = ray.IntersectPlane(axis, -Vec3F.Dot(axis, origin));
float dragAmount = Vec3F.Dot(xAxis, p1 - p0);
Vec3F xLocal = transform.XAxis;
trans = dragAmount * xLocal;
}
break;
case HitElement.Y_ARROW:
{
a1 = Math.Abs(Vec3F.Dot(ray0.Direction, zAxis));
a2 = Math.Abs(Vec3F.Dot(ray0.Direction, xAxis));
Vec3F axis = (a1 > a2 ? zAxis : xAxis);
Vec3F p0 = ray0.IntersectPlane(axis, -Vec3F.Dot(axis, origin));
Vec3F p1 = ray.IntersectPlane(axis, -Vec3F.Dot(axis, origin));
float dragAmount = Vec3F.Dot(yAxis, p1 - p0);
Vec3F yLocal = transform.YAxis;
trans = dragAmount * yLocal;
}
break;
case HitElement.Z_ARROW:
{
a1 = Math.Abs(Vec3F.Dot(ray0.Direction, xAxis));
a2 = Math.Abs(Vec3F.Dot(ray0.Direction, yAxis));
Vec3F axis = (a1 > a2 ? xAxis : yAxis);
Vec3F p0 = ray0.IntersectPlane(axis, -Vec3F.Dot(axis, origin));
Vec3F p1 = ray.IntersectPlane(axis, -Vec3F.Dot(axis, origin));
float dragAmount = Vec3F.Dot(zAxis, p1 - p0);
Vec3F zLocal = transform.ZAxis;
trans = dragAmount * zLocal;
}
break;
case HitElement.XY_SQUARE:
{
Vec3F p0 = ray0.IntersectPlane(zAxis, -Vec3F.Dot(zAxis, origin));
Vec3F p1 = ray.IntersectPlane(zAxis, -Vec3F.Dot(zAxis, origin));
Vec3F deltaLocal = p1 - p0;
float dragX = Vec3F.Dot(xAxis, deltaLocal);
float dragY = Vec3F.Dot(yAxis, deltaLocal);
Vec3F xLocal = transform.XAxis;
Vec3F yLocal = transform.YAxis;
trans = dragX * xLocal + dragY * yLocal;
}
break;
case HitElement.YZ_SQUARE:
{
Vec3F p0 = ray0.IntersectPlane(xAxis, -Vec3F.Dot(xAxis, origin));
Vec3F p1 = ray.IntersectPlane(xAxis, -Vec3F.Dot(xAxis, origin));
Vec3F deltaLocal = p1 - p0;
float dragY = Vec3F.Dot(yAxis, deltaLocal);
float dragZ = Vec3F.Dot(zAxis, deltaLocal);
Vec3F yLocal = transform.YAxis;
Vec3F zLocal = transform.ZAxis;
trans = dragY * yLocal + dragZ * zLocal;
}
break;
case HitElement.XZ_SQUARE:
{
Vec3F p0 = ray0.IntersectPlane(yAxis, -Vec3F.Dot(yAxis, origin));
Vec3F p1 = ray.IntersectPlane(yAxis, -Vec3F.Dot(yAxis, origin));
Vec3F deltaLocal = p1 - p0;
float dragX = Vec3F.Dot(xAxis, deltaLocal);
float dragZ = Vec3F.Dot(zAxis, deltaLocal);
Vec3F xLocal = transform.XAxis;
Vec3F zLocal = transform.ZAxis;
trans = dragX * xLocal + dragZ * zLocal;
}
break;
}
return(trans);
}
/// <summary>
/// Performs actions at the beginning of control drag</summary>
/// <param name="hit">Hit record</param>
/// <param name="x">Mouse x position</param>
/// <param name="y">Mouse y position</param>
/// <param name="action">Render action</param>
/// <param name="camera">Camera</param>
/// <param name="transform">Transform</param>
/// <returns>Code for control element under mouse x, y</returns>
public HitElement OnHit(HitRecord hit, float x, float y, IRenderAction action, Camera camera, Matrix4F transform)
{
// Store pick coords
m_iX = x;
m_iY = y;
return((HitElement)hit.RenderObjectData[1]);
}
void Update(Component_Skeleton skeleton, Component_SkeletonAnimationTrack animationTrack, double time)
{
if (time != calculatedForTime)
{
//update general data
calculatedForTime = time;
bones = skeleton.GetBones();
//calculate bone transforms
if (boneTransforms == null || boneTransforms.Length != bones.Length)
{
boneTransforms = new Component_SkeletonAnimationTrack.CalculateBoneTransformsItem[bones.Length];
}
animationTrack?.CalculateBoneTransforms(time, boneTransforms);
CalculateBoneTransforms?.Invoke(this, boneTransforms);
//calculate transformMatrixRelativeToSkin, transformRelativeToSkin, boneGlobalTransforms, hasScale
if (transformMatrixRelativeToSkin == null || transformMatrixRelativeToSkin.Length != bones.Length)
{
transformMatrixRelativeToSkin = new Matrix4F[bones.Length];
}
if (transformRelativeToSkin == null || transformRelativeToSkin.Length != bones.Length)
{
transformRelativeToSkin = new Component_SkeletonAnimationTrack.CalculateBoneTransformsItem[bones.Length];
}
if (boneGlobalTransforms == null || boneGlobalTransforms.Length != bones.Length)
{
boneGlobalTransforms = new BoneGlobalTransformItem[bones.Length];
}
var matrixZero = Matrix4F.Zero;
for (int i = 0; i < bones.Length; i++)
{
boneGlobalTransforms[i] = new BoneGlobalTransformItem(false, ref matrixZero);
}
foreach (var b in bones)
{
GetBoneGlobalTransformRecursive(skeleton, b);
}
hasScale = false;
for (int i = 0; i < bones.Length; i++)
{
var bone = bones[i];
Matrix4F m;
if (bone != null)
{
Matrix4F.Multiply(ref GetBoneGlobalTransformRecursive(skeleton, bone), ref bone.GetTransformMatrixInverse(), out m);
}
else
{
m = Matrix4F.Identity;
}
transformMatrixRelativeToSkin[i] = m;
m.Decompose(out Vector3F t, out QuaternionF r, out Vector3F s);
transformRelativeToSkin[i] = new Component_SkeletonAnimationTrack.CalculateBoneTransformsItem {
Position = t, Rotation = r, Scale = s
};
//if the scale differs from 1.0 more than this value, then the scaling is present and DualQuaternionSkinning can not be used.
const float EpsilonForScale = 1e-3f;
if (Math.Abs(1.0f - s.X) > EpsilonForScale || Math.Abs(1.0f - s.Y) > EpsilonForScale || Math.Abs(1.0f - s.Y) > EpsilonForScale)
{
hasScale = true;
}
}
}
}
/// <summary>
/// Synchronizes the camera to the controller's current state</summary>
/// <param name="camera">Camera</param>
protected override void ControllerToCamera(Camera camera)
{
Vec3F lookAt = Camera.LookAt;
Vec3F up = Camera.Up;
if (camera.ViewType == ViewTypes.Perspective)
{
QuatF rotation = m_rotation * m_currentRotation;
rotation = rotation.Inverse;
Matrix4F transform = new Matrix4F(rotation);
lookAt = new Vec3F(0, 0, -1);
up = new Vec3F(0, 1, 0);
transform.Transform(ref lookAt);
transform.Transform(ref up);
}
float eyeOffset = m_distanceFromLookAt;
float lookAtOffset = 0;
if (m_distanceFromLookAt < m_dollyThreshold) // do we need to start dollying?
{
eyeOffset = m_distanceFromLookAt;
lookAtOffset = m_distanceFromLookAt - m_dollyThreshold;
}
Camera.Set(
m_lookAtPoint - (eyeOffset * lookAt), // eye
m_lookAtPoint - (lookAtOffset * lookAt), // lookAt
up); // up
base.ControllerToCamera(camera);
}
/// <summary>
/// Sets the view matrix for the alpha-sorted phase</summary>
/// <param name="viewMatrix">View matrix for the alpha-sorted phase</param>
public void SetViewMatrix(Matrix4F viewMatrix)
{
m_viewMatrix.Set(viewMatrix);
}
void ProcessVertex(ref Vector3F position, out Vector3F result)
{
Matrix4? nullable = new Matrix4?(PosCenter.Value.ToMatrix4());
Matrix4 matrix4 = nullable ?? Matrix4.Identity;
Matrix4F matrix4f = matrix4.ToMatrix4F();
bool inv = matrix4f.Inverse();
MatrixInv = inv;
ResPosVec1 = matrix4f * Pos1n.Value.Position.ToVector3F();
result = position;
var sc = new Vector3F(0.2f, 0.2f, 0.2f);
var rposition = position * sc;
var l_r01 = (float)Pos01n.Value.Scale.X;
var relp01 = (Pos01n.Value.Position).ToVector3F();
var l_dist1 = (rposition - relp01);
float l_l01 = l_dist1.Length();
var l_r02 = (float)Pos02n.Value.Scale.X;
var relp02 = (Pos02n.Value.Position).ToVector3F();
var l_dist2 = (rposition - relp02);
float l_l02 = l_dist2.Length();
var l_r03 = (float)Pos03n.Value.Scale.X;
var relp03 = (Pos03n.Value.Position).ToVector3F();
var l_dist3 = (rposition - relp03);
float l_l03 = l_dist3.Length();
var l_r04 = (float)Pos04n.Value.Scale.X;
var relp04 = (Pos04n.Value.Position).ToVector3F();
var l_dist4 = (rposition - relp04);
float l_l04 = l_dist4.Length();
var f = ((ResPos1.Value.Position - PosCenter.Value.Position) / sc).ToVector3F().GetNormalize();
SphericalDirectionF sd = new SphericalDirectionF(f.X, f.Y);
float ax = MathEx.Acos(f.X);
float ay = MathEx.Asin(f.X);
QuaternionF q = new AnglesF().ToQuaternion();
if (l_l01 <= l_r01)
{
var relp1 = matrix4f * Pos1n.Value.Position.ToVector3F();
result = relp1;
}
if (l_l02 <= l_r02)
{
var relp2 = matrix4f * Pos2n.Value.Position.ToVector3F();;
result = relp2;
}
if (l_l03 <= l_r03)
{
var relp3 = matrix4f * Pos3n.Value.Position.ToVector3F();;
result = relp3;
}
if (l_l04 <= l_r04)
{
var relp4 = matrix4f * Pos4n.Value.Position.ToVector3F();;
result = relp4;
}
}
//public static void Convert( ref OgreMatrix4 mat, out Mat4 result )
//{
// result = new Mat4( mat.mat0, mat.mat1, mat.mat2, mat.mat3 );
// result.Transpose();
//}
public static unsafe void Convert(OgreMatrix4 *mat, out Matrix4F result)
{
result = new Matrix4F(mat->mat0, mat->mat1, mat->mat2, mat->mat3);
result.Transpose();
}
/// <summary>
/// Computes transformation matrix from transformation related atrributes.</summary>
public void ComputeTransform()
{
Matrix4F xform = TransformUtils.CalcTransform(m_transformable);
SetAttribute(Schema.gameObjectType.transformAttribute, xform.ToArray());
}
protected Matrix4F mul(Matrix4F matrix1, Matrix4F matrix2)
{
return(matrix1 * matrix2);
}
/// <summary>
/// Sets the DomNode attribute to the given Matrix4F</summary>
/// <param name="domNode">DomNode holding attribute</param>
/// <param name="attribute">Attribute of the DomNode that contains the data</param>
/// <param name="m">Matrix4F value to be set</param>
public static void SetMatrix(DomNode domNode, AttributeInfo attribute, Matrix4F m)
{
domNode.SetAttribute(attribute, m.ToArray());
}
protected Vector4F mul(Vector4F vector, Matrix4F transform)
{
return(Matrix4F.Transform(transform, vector));
//return Vector4F.Transform(vector, transform);
}
//private void Pipeline_RenderBegin( Component_RenderingPipeline_Basic sender, ViewportRenderingContext context, Component_RenderingPipeline_Basic.FrameData frameData )
//{
// if( EnabledInHierarchy && sender.UseRenderTargets )
// {
// //frameData.GenerateIBLSpecularTexture = true;
// //frameData.DeferredSpecularIBLItensity = 1.0 - Intensity;
// }
//}
private void Pipeline_RenderDeferredShadingEnd(Component_RenderingPipeline_Basic sender, ViewportRenderingContext context, Component_RenderingPipeline_Basic.FrameData frameData, ref Component_Image sceneTexture)
{
if (EnabledInHierarchy && sender.GetUseMultiRenderTargets())
{
var actualTexture = sceneTexture;
var pipeline = (Component_RenderingPipeline_Basic)context.RenderingPipeline;
Vector3 cameraPos = context.Owner.CameraSettings.Position;
//!!!!double
Vector3F cameraPosition = cameraPos.ToVector3F();
//!!!!double
Matrix4F projectionMatrix = context.Owner.CameraSettings.ProjectionMatrix.ToMatrix4F();
Matrix4F viewMatrix = context.Owner.CameraSettings.ViewMatrix.ToMatrix4F();
Matrix4F viewProjMatrix = projectionMatrix * viewMatrix;
Matrix4F invViewProjMatrix = viewProjMatrix.GetInverse();
float aspectRatio = (float)context.Owner.CameraSettings.AspectRatio;
float fov = (float)context.Owner.CameraSettings.FieldOfView;
float zNear = (float)context.Owner.CameraSettings.NearClipDistance;
float zFar = (float)context.Owner.CameraSettings.FarClipDistance;
var ambientLight = frameData.Lights[frameData.LightsInFrustumSorted[0]];
var ambientLightPower = ambientLight.data.Power;
var reflectionTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, actualTexture.Result.ResultFormat);
{
context.SetViewport(reflectionTexture.Result.GetRenderTarget().Viewports[0]);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ScreenSpaceReflection\SSR_fs.sc";
int maxSteps = 50;
switch (Quality.Value)
{
case QualityEnum.Lowest: maxSteps = 15; break;
case QualityEnum.Low: maxSteps = 25; break;
case QualityEnum.Medium: maxSteps = 40; break;
case QualityEnum.High: maxSteps = 60; break;
case QualityEnum.Highest: maxSteps = 100; break;
}
//int maxSteps = 50;
//switch( Quality.Value )
//{
//case QualityEnum.Lowest: maxSteps = 20; break;
//case QualityEnum.Low: maxSteps = 50; break;
//case QualityEnum.Medium: maxSteps = 80; break;
//case QualityEnum.High: maxSteps = 120; break;
//case QualityEnum.Highest: maxSteps = 160; break;
//}
shader.Defines.Add(new CanvasRenderer.ShaderItem.DefineItem("MAX_STEPS", maxSteps.ToString()));
context.objectsDuringUpdate.namedTextures.TryGetValue("gBuffer0Texture", out var gBuffer0Texture);
context.objectsDuringUpdate.namedTextures.TryGetValue("depthTexture", out var depthTexture);
context.objectsDuringUpdate.namedTextures.TryGetValue("normalTexture", out var normalTexture);
context.objectsDuringUpdate.namedTextures.TryGetValue("gBuffer2Texture", out var gBuffer2Texture);
//!!!!reflection probes?
pipeline.GetBackgroundEnvironmentTextures(context, frameData, /*true, */ out var environmentTexture, out var environmentTextureIBL);
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, depthTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1, actualTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(2, normalTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
//!!!!rotation, multiplier
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(3, environmentTexture.Value.texture,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(4, environmentTextureIBL.Value.texture,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(5, Component_RenderingPipeline_Basic.BrdfLUT,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(6, gBuffer2Texture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(7, gBuffer0Texture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point));
//!!!часть параметров есть UniformsGeneral.sh
shader.Parameters.Set("viewProj", viewProjMatrix);
shader.Parameters.Set("invViewProj", invViewProjMatrix);
shader.Parameters.Set("cameraPosition", cameraPosition);
shader.Parameters.Set("edgeFactorPower", (float)EdgeFactorPower);
shader.Parameters.Set("initialStepScale", (float)InitialStepScale.Value);
shader.Parameters.Set("worldThickness", (float)WorldThickness.Value);
shader.Parameters.Set("colorTextureSize", new Vector4F((float)actualTexture.Result.ResultSize.X, (float)actualTexture.Result.ResultSize.Y, 0.0f, 0.0f));
shader.Parameters.Set("zNear", zNear);
shader.Parameters.Set("zFar", zFar);
shader.Parameters.Set("fov", fov);
shader.Parameters.Set("aspectRatio", aspectRatio);
context.RenderQuadToCurrentViewport(shader);
}
var min = BlurRoughnessMin.Value;
var max = BlurRoughnessMax.Value;
if (min > max)
{
min = max;
}
var blurRoughnessMin = pipeline.GaussianBlur(context, this, reflectionTexture, min, BlurDownscalingMode, BlurDownscalingValue);
var blurRoughnessMax = pipeline.GaussianBlur(context, this, reflectionTexture, max, BlurDownscalingMode, BlurDownscalingValue);
//// Blur Pass:
//var bluredReflection = pipeline.GaussianBlur( context, this, reflectionTexture, BlurFactorOnMaxRoughness, BlurDownscalingMode, BlurDownscalingValue );
// Final Pass:
var finalTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, actualTexture.Result.ResultFormat);
{
context.SetViewport(finalTexture.Result.GetRenderTarget().Viewports[0]);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ScreenSpaceReflection\SSR_Apply_fs.sc";
context.objectsDuringUpdate.namedTextures.TryGetValue("gBuffer0Texture", out var gBuffer0Texture);
context.objectsDuringUpdate.namedTextures.TryGetValue("depthTexture", out var depthTexture);
context.objectsDuringUpdate.namedTextures.TryGetValue("normalTexture", out var normalTexture);
context.objectsDuringUpdate.namedTextures.TryGetValue("gBuffer2Texture", out var gBuffer2Texture);
//!!!!reflection probes?
pipeline.GetBackgroundEnvironmentTextures(context, frameData, /*true, */ out var environmentTexture, out var environmentTextureIBL);
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, actualTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1, blurRoughnessMin,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(2, blurRoughnessMax,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
//shader.Parameters.Set( "1", new GpuMaterialPass.TextureParameterValue( reflectionTexture,
// TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None ) );
//shader.Parameters.Set( "2", new GpuMaterialPass.TextureParameterValue( bluredReflection,
// TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None ) );
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(3, depthTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(4, normalTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
//!!!!rotation, multiplier
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(5, environmentTexture.Value.texture,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(6, environmentTextureIBL.Value.texture,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(7, Component_RenderingPipeline_Basic.BrdfLUT,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(8, gBuffer2Texture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(9, gBuffer0Texture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point));
shader.Parameters.Set("invViewProj", invViewProjMatrix);
shader.Parameters.Set("cameraPosition", cameraPosition);
shader.Parameters.Set("intensity", (float)Intensity);
shader.Parameters.Set("ambientLightPower", ambientLightPower);
context.RenderQuadToCurrentViewport(shader);
}
// Free Targets:
context.DynamicTexture_Free(reflectionTexture);
context.DynamicTexture_Free(blurRoughnessMin);
context.DynamicTexture_Free(blurRoughnessMax);
//context.RenderTarget_Free( bluredReflection );
context.DynamicTexture_Free(actualTexture);
// Update actual Texture:
actualTexture = finalTexture;
//result
sceneTexture = actualTexture;
}
}
public override void OnDragging(ViewControl vc, Point scrPt)
{
if (m_cancelDrag || m_hitRegion == HitRegion.None || NodeList.Count == 0)
{
return;
}
bool hitAxis = m_hitRegion == HitRegion.XAxis ||
m_hitRegion == HitRegion.YAxis ||
m_hitRegion == HitRegion.ZAxis;
Matrix4F view = vc.Camera.ViewMatrix;
Matrix4F proj = vc.Camera.ProjectionMatrix;
Matrix4F vp = view * proj;
// create ray in world space.
Ray3F rayW = vc.GetRay(scrPt, vp);
// create ray in view space.
Ray3F rayV = vc.GetRay(scrPt, proj);
Vec3F translate = m_translatorControl.OnDragging(rayV);
ISnapSettings snapSettings = (ISnapSettings)DesignView;
bool snapToGeom = Control.ModifierKeys == m_snapGeometryKey;
if (snapToGeom)
{
Vec3F manipPos = HitMatrix.Translation;
Vec3F manipMove;
if (hitAxis)
{
//Make rayw to point toward moving axis and starting
// from manipulator’s world position.
rayW.Direction = Vec3F.Normalize(translate);
rayW.Origin = manipPos;
manipMove = Vec3F.ZeroVector;
m_cancelDrag = true; //stop further snap-to's
}
else
{
manipMove = rayW.ProjectPoint(manipPos) - manipPos;
}
for (int i = 0; i < NodeList.Count; i++)
{
ITransformable node = NodeList[i];
Vec3F snapOffset = TransformUtils.CalcSnapFromOffset(node, snapSettings.SnapFrom);
Path <DomNode> path = new Path <DomNode>(Adapters.Cast <DomNode>(node).GetPath());
Matrix4F parentLocalToWorld = TransformUtils.CalcPathTransform(path, path.Count - 2);
Vec3F orgPosW;
parentLocalToWorld.Transform(m_originalValues[i], out orgPosW);
Matrix4F parentWorldToLocal = new Matrix4F();
parentWorldToLocal.Invert(parentLocalToWorld);
rayW.MoveToIncludePoint(orgPosW + snapOffset + manipMove);
HitRecord[] hits = GameEngine.RayPick(view, proj, rayW, true);
bool cansnap = false;
HitRecord target = new HitRecord();
if (hits.Length > 0)
{
// find hit record.
foreach (var hit in hits)
{
if (m_snapFilter.CanSnapTo(node, GameEngine.GetAdapterFromId(hit.instanceId)))
{
target = hit;
cansnap = true;
break;
}
}
}
if (cansnap)
{
Vec3F pos;
if (target.hasNearestVert && snapSettings.SnapVertex)
{
pos = target.nearestVertex;
}
else
{
pos = target.hitPt;
}
pos -= snapOffset;
parentWorldToLocal.Transform(ref pos);
Vec3F diff = pos - node.Transform.Translation;
node.Translation += diff;
bool rotateOnSnap = snapSettings.RotateOnSnap &&
target.hasNormal &&
(node.TransformationType & TransformationTypes.Rotation) != 0;
if (rotateOnSnap)
{
Vec3F localSurfaceNormal;
parentWorldToLocal.TransformNormal(target.normal, out localSurfaceNormal);
node.Rotation = TransformUtils.RotateToVector(
m_originalRotations[i],
localSurfaceNormal,
AxisSystemType.YIsUp);
}
}
}
}
else
{
IGrid grid = DesignView.Context.Cast <IGame>().Grid;
bool snapToGrid = Control.ModifierKeys == m_snapGridKey &&
grid.Visible &&
vc.Camera.ViewType == ViewTypes.Perspective;
float gridHeight = grid.Height;
// translate.
for (int i = 0; i < NodeList.Count; i++)
{
ITransformable node = NodeList[i];
Path <DomNode> path = new Path <DomNode>(Adapters.Cast <DomNode>(node).GetPath());
Matrix4F parentLocalToWorld = TransformUtils.CalcPathTransform(path, path.Count - 2);
Matrix4F parentWorldToLocal = new Matrix4F();
parentWorldToLocal.Invert(parentLocalToWorld);
Vec3F localTranslation;
parentWorldToLocal.TransformVector(translate, out localTranslation);
Vec3F trans = m_originalValues[i] + localTranslation;
if (snapToGrid)
{
if (grid.Snap)
{
trans = grid.SnapPoint(trans);
}
else
{
trans.Y = gridHeight;
}
}
node.Translation = trans;
}
}
}
internal void Draw(DeviceContext graphics, ref Matrix4F matrix, Entity avatar, Universe universe,
AvatarController avatarController, Vector2 mouseLocation)
{
if (_spriteBatch == null)
{
_spriteBatch = new SpriteBatch(graphics.Graphics.GraphicsDevice);
}
else if (_spriteBatch.IsDisposed)
{
_spriteBatch = new SpriteBatch(graphics.Graphics.GraphicsDevice);
}
if (_escape)
{
if (!graphics.IsActive())
{
Dispose();
return;
}
}
try {
_spriteBatch.End();
} catch {
// ignore
}
_spriteBatch.Begin();
var size = Container.GetSize();
Vector2 origin;
ViewPort = graphics.Graphics.GraphicsDevice.Viewport;
switch (Alignment)
{
case UiAlignment.TopLeft:
origin = new Vector2(0, 0);
break;
case UiAlignment.TopCenter:
origin = new Vector2((ViewPort.Width / 2) - (size.X / 2), 0);
break;
case UiAlignment.TopRight:
origin = new Vector2(ViewPort.Width - size.X, 0);
break;
case UiAlignment.MiddleLeft:
origin = new Vector2(0, (ViewPort.Height / 2) - (size.Y / 2));
break;
case UiAlignment.MiddleCenter:
default:
origin = new Vector2((ViewPort.Width / 2) - (size.X / 2), (ViewPort.Height / 2) - (size.Y / 2));
break;
case UiAlignment.MiddleRight:
origin = new Vector2(ViewPort.Width - size.X, (ViewPort.Height / 2) - (size.Y / 2));
break;
case UiAlignment.BottomLeft:
origin = new Vector2(0, ViewPort.Height - size.Y);
break;
case UiAlignment.BottomCenter:
origin = new Vector2((ViewPort.Width / 2) - (size.X / 2), ViewPort.Height - size.Y);
break;
case UiAlignment.BottomRight:
origin = new Vector2(ViewPort.Width - size.X, ViewPort.Height - size.Y);
break;
}
Container.Draw(graphics, avatar, universe, origin, _spriteBatch, mouseLocation, _spriteBatch.GraphicsDevice.ScissorRectangle);
if (!_spriteBatch.IsDisposed)
{
try {
_spriteBatch.End();
} catch {
_spriteBatch.Dispose();
}
}
}
public override void OnDragging(ViewControl vc, Point scrPt)
{
if (m_hitRegion == HitRegion.None || NodeList.Count == 0)
{
return;
}
Camera cam = vc.Camera;
Matrix4F view = cam.ViewMatrix;
Matrix4F mtrx = cam.ProjectionMatrix;
Matrix4F axisMtrx = HitMatrix * view;
Ray3F hitRay = HitRayV;
Ray3F dragRay = vc.GetRay(scrPt, mtrx);
Vec3F xAxis = axisMtrx.XAxis;
Vec3F yAxis = axisMtrx.YAxis;
Vec3F zAxis = axisMtrx.ZAxis;
Vec3F origin = axisMtrx.Translation;
Vec3F rotAxis = new Vec3F();
float theta = 0;
float snapAngle = ((ISnapSettings)DesignView).SnapAngle;
switch (m_hitRegion)
{
case HitRegion.XAxis:
{
Plane3F xplane = new Plane3F(xAxis, origin);
theta = CalcAngle(origin, xplane, hitRay, dragRay, snapAngle);
rotAxis = HitMatrix.XAxis;
}
break;
case HitRegion.YAxis:
{
Plane3F yplane = new Plane3F(yAxis, origin);
theta = CalcAngle(origin, yplane, hitRay, dragRay, snapAngle);
rotAxis = HitMatrix.YAxis;
}
break;
case HitRegion.ZAxis:
{
Plane3F zplane = new Plane3F(zAxis, origin);
theta = CalcAngle(origin, zplane, hitRay, dragRay, snapAngle);
rotAxis = HitMatrix.ZAxis;
}
break;
default:
throw new ArgumentOutOfRangeException();
}
AngleAxisF axf = new AngleAxisF(-theta, rotAxis);
Matrix4F deltaMtrx = new Matrix4F(axf);
Matrix4F rotMtrx = new Matrix4F();
for (int i = 0; i < NodeList.Count; i++)
{
ITransformable node = NodeList[i];
rotMtrx.Set(m_rotations[i]);
rotMtrx.Mul(rotMtrx, deltaMtrx);
float ax, ay, az;
rotMtrx.GetEulerAngles(out ax, out ay, out az);
node.Rotation = new Vec3F(ax, ay, az);
}
}
public override void OnDragging(ViewControl vc, Point scrPt)
{
if (m_hitRegion == HitRegion.None || m_activeOp == null || m_activeOp.NodeList.Count == 0)
{
return;
}
Camera cam = vc.Camera;
Matrix4F view = cam.ViewMatrix;
Matrix4F proj = cam.ProjectionMatrix;
Matrix4F axisMtrx = HitMatrix * view;
Ray3F hitRay = HitRayV;
Ray3F dragRay = vc.GetRay(scrPt, proj);
Vec3F xAxis = axisMtrx.XAxis;
Vec3F yAxis = axisMtrx.YAxis;
Vec3F zAxis = axisMtrx.ZAxis;
Vec3F origin = axisMtrx.Translation;
Vec3F rotAxis = new Vec3F();
float theta = 0;
float snapAngle = ((ISnapSettings)DesignView).SnapAngle;
switch (m_hitRegion)
{
case HitRegion.XAxis:
{
Plane3F xplane = new Plane3F(xAxis, origin);
theta = CalcAngle(origin, xplane, hitRay, dragRay, snapAngle);
rotAxis = HitMatrix.XAxis;
}
break;
case HitRegion.YAxis:
{
Plane3F yplane = new Plane3F(yAxis, origin);
theta = CalcAngle(origin, yplane, hitRay, dragRay, snapAngle);
rotAxis = HitMatrix.YAxis;
}
break;
case HitRegion.ZAxis:
{
Plane3F zplane = new Plane3F(zAxis, origin);
theta = CalcAngle(origin, zplane, hitRay, dragRay, snapAngle);
rotAxis = HitMatrix.ZAxis;
}
break;
case HitRegion.LookAxis:
{
// for billboard objects the look vector is object's negative position in viewspace.
Vec3F lookAxis = Vec3F.Normalize(-origin);
Plane3F plane = new Plane3F(lookAxis, origin);
theta = CalcAngle(origin, plane, hitRay, dragRay, snapAngle);
rotAxis = m_lookAxisHitMtrx.ZAxis;
}
break;
default:
throw new ArgumentOutOfRangeException();
}
AngleAxisF axf = new AngleAxisF(-theta, rotAxis);
Matrix4F deltaMtrx = new Matrix4F(axf);
Matrix4F rotMtrx = new Matrix4F();
for (int i = 0; i < m_activeOp.NodeList.Count; i++)
{
ITransformable node = m_activeOp.NodeList[i];
rotMtrx.Mul(m_rotations[i], deltaMtrx);
float ax, ay, az;
rotMtrx.GetEulerAngles(out ax, out ay, out az);
node.Rotation = new Vec3F(ax, ay, az);
}
}
public HitRegion Pick(ViewControl vc, Matrix4F world, Matrix4F view, Ray3F rayL, Ray3F rayV)
{
float s = Util.CalcAxisScale(vc.Camera, world.Translation, Manipulator.AxisLength, vc.Height);
m_hitRegion = HitRegion.None;
m_hitRayV = rayV;
m_hitMatrix.Set(world);
m_hitWorldView = world * view;
float sl = s * SquareLength;
// test xy square.
Vec3F p1 = new Vec3F(0, 0, 0);
Vec3F p2 = new Vec3F(sl, 0, 0);
Vec3F p3 = new Vec3F(sl, sl, 0);
Vec3F p4 = new Vec3F(0, sl, 0);
Plane3F plane = new Plane3F(p1, p2, p3);
Vec3F p;
if (rayL.IntersectPlane(plane, out p))
{
// test point in 2d rectangle.
if (p.X > p1.X && p.X < p2.X &&
p.Y > p1.Y && p.Y < p4.Y)
{
m_hitRegion = HitRegion.XYSquare;
return(m_hitRegion);
}
}
// test xz square
p1 = new Vec3F(0, 0, 0);
p2 = new Vec3F(sl, 0, 0);
p3 = new Vec3F(sl, 0, sl);
p4 = new Vec3F(0, 0, sl);
plane = new Plane3F(p1, p2, p3);
if (rayL.IntersectPlane(plane, out p))
{
// test point in 2d rectangle.
if (p.X > p1.X && p.X < p2.X &&
p.Z > p1.Z && p.Z < p4.Z)
{
m_hitRegion = HitRegion.XZSquare;
return(m_hitRegion);
}
}
// test yz square
p1 = new Vec3F(0, 0, 0);
p2 = new Vec3F(0, 0, sl);
p3 = new Vec3F(0, sl, sl);
p4 = new Vec3F(0, sl, 0);
plane = new Plane3F(p1, p2, p3);
if (rayL.IntersectPlane(plane, out p))
{
// test point in 2d rectangle.
if (p.Z > p1.Z && p.Z < p2.Z &&
p.Y > p1.Z && p.Y < p4.Y)
{
m_hitRegion = HitRegion.YZSquare;
return(m_hitRegion);
}
}
Vec3F min = new Vec3F(-0.5f, -0.5f, -0.5f);
Vec3F max = new Vec3F(0.5f, 0.5f, 0.5f);
AABB box = new AABB(min, max);
Matrix4F boxScale = new Matrix4F();
Matrix4F boxTrans = new Matrix4F();
Matrix4F BoxMtrx = new Matrix4F();
// X axis
boxScale.Scale(new Vec3F(s, s * ConeDiameter, s * ConeDiameter));
boxTrans.Translation = new Vec3F(s / 2, 0, 0);
BoxMtrx = boxScale * boxTrans;
Ray3F ray = rayL;
BoxMtrx.Invert(BoxMtrx);
ray.Transform(BoxMtrx);
if (box.Intersect(ray))
{
m_hitRegion = HitRegion.XAxis;
return(m_hitRegion);
}
// y axis
boxScale.Scale(new Vec3F(s * ConeDiameter, s, s * ConeDiameter));
boxTrans.Translation = new Vec3F(0, s / 2, 0);
BoxMtrx = boxScale * boxTrans;
ray = rayL;
BoxMtrx.Invert(BoxMtrx);
ray.Transform(BoxMtrx);
if (box.Intersect(ray))
{
m_hitRegion = HitRegion.YAxis;
return(m_hitRegion);
}
// z axis
boxScale.Scale(new Vec3F(s * ConeDiameter, s * ConeDiameter, s));
boxTrans.Translation = new Vec3F(0, 0, s / 2);
BoxMtrx = boxScale * boxTrans;
ray = rayL;
BoxMtrx.Invert(BoxMtrx);
ray.Transform(BoxMtrx);
if (box.Intersect(ray))
{
m_hitRegion = HitRegion.ZAxis;
}
return(m_hitRegion);
}
public Manipulator()
{
HitMatrix = new Matrix4F();
DesignView = null;
}
public override void OnDragging(ViewControl vc, Point scrPt)
{
if (m_hitRegion == HitRegion.None || m_activeOp == null || m_activeOp.NodeList.Count == 0)
return;
Matrix4F view = vc.Camera.ViewMatrix;
// compute world * view
Matrix4F wv = new Matrix4F();
wv.Mul(HitMatrix, view);
// create ray in view space.
Ray3F rayV = vc.GetRay(scrPt, vc.Camera.ProjectionMatrix);
Vec3F xAxis = wv.XAxis;
Vec3F yAxis = wv.YAxis;
Vec3F zAxis = wv.ZAxis;
Vec3F origin = wv.Translation;
m_scale = new Vec3F(1, 1, 1);
float scale = 1;
float a1, a2;
switch (m_hitRegion)
{
case HitRegion.XAxis:
case HitRegion.NegXAxis:
{
a1 = Math.Abs(Vec3F.Dot(HitRayV.Direction, yAxis));
a2 = Math.Abs(Vec3F.Dot(HitRayV.Direction, zAxis));
Vec3F axis = (a1 > a2 ? yAxis : zAxis);
Vec3F p0 = HitRayV.IntersectPlane(axis, -Vec3F.Dot(axis, origin));
Vec3F p1 = rayV.IntersectPlane(axis, -Vec3F.Dot(axis, origin));
float dragAmount = Vec3F.Dot((p1 - p0), xAxis);
if (m_hitRegion == HitRegion.NegXAxis)
{
dragAmount *= -1;
}
m_scale.X = 1.0f + dragAmount / m_hitScale;
scale = m_scale.X;
}
break;
case HitRegion.YAxis:
case HitRegion.NegYAxis:
{
a1 = Math.Abs(Vec3F.Dot(HitRayV.Direction, zAxis));
a2 = Math.Abs(Vec3F.Dot(HitRayV.Direction, xAxis));
Vec3F axis = (a1 > a2 ? zAxis : xAxis);
Vec3F p0 = HitRayV.IntersectPlane(axis, -Vec3F.Dot(axis, origin));
Vec3F p1 = rayV.IntersectPlane(axis, -Vec3F.Dot(axis, origin));
float dragAmount = Vec3F.Dot((p1 - p0), yAxis);
if (m_hitRegion == HitRegion.NegYAxis)
{
dragAmount *= -1;
}
m_scale.Y = 1.0f + dragAmount / m_hitScale;
scale = m_scale.Y;
}
break;
case HitRegion.ZAxis:
case HitRegion.NegZAxis:
{
a1 = Math.Abs(Vec3F.Dot(HitRayV.Direction, xAxis));
a2 = Math.Abs(Vec3F.Dot(HitRayV.Direction, yAxis));
Vec3F axis = (a1 > a2 ? xAxis : yAxis);
Vec3F p0 = HitRayV.IntersectPlane(axis, -Vec3F.Dot(axis, origin));
Vec3F p1 = rayV.IntersectPlane(axis, -Vec3F.Dot(axis, origin));
float dragAmount = Vec3F.Dot((p1 - p0), zAxis);
if (m_hitRegion == HitRegion.NegZAxis)
{
dragAmount *= -1;
}
m_scale.Z = 1.0f + dragAmount / m_hitScale;
scale = m_scale.Z;
}
break;
default:
throw new ArgumentOutOfRangeException();
}
if(m_isUniformScaling)
m_scale = new Vec3F(scale,scale,scale);
// scale
for (int i = 0; i < m_activeOp.NodeList.Count; i++)
{
ITransformable node = m_activeOp.NodeList[i];
node.Scale = Vec3F.Mul(m_originalScales[i], m_scale);
Matrix4F mtrx = TransformUtils.CalcTransform(
Vec3F.ZeroVector,
node.Rotation,
node.Scale,
m_pivotOffset[i]);
node.Translation = m_originalTranslations[i] + mtrx.Translation;
}
}
/// <summary>
/// Adjusts child transform, making it relative to new parent node's transform.
/// Is recursive, looking for parents that also implement IRenderableNode.</summary>
/// <param name="parent">Parent node</param>
/// <param name="child">Child node</param>
public static void AddChild(ITransformable parent, ITransformable child)
{
Path <DomNode> path = new Path <DomNode>(parent.Cast <DomNode>().GetPath());
Matrix4F parentToWorld = TransformUtils.CalcPathTransform(path, path.Count - 1);
// We want 'child' to appear in the same place in the world after adding to 'parent'.
// local-point * original-local-to-world = world-point
// new-local-point * new-local-to-parent * parent-to-world = world-point
// ==> new-local-to-parent * parent-to-world = original-local-to-world
// (multiply both sides by inverse of parent-to-world; call it world-to-parent)
// ==> new-local-to-parent = original-local-to-world * world-to-parent
Matrix4F worldToParent = new Matrix4F();
worldToParent.Invert(parentToWorld);
Matrix4F originalLocalToWorld = child.Transform;
Matrix4F newLocalToParent = Matrix4F.Multiply(originalLocalToWorld, worldToParent);
// The translation component of newLocalToParent consists of pivot translation
// as well as the child.Translation. So, start with the original child.Translation
// and transform it into our new space.
Vec3F newTranslation = child.Translation;
worldToParent.Transform(ref newTranslation);
// There's only one way of getting rotation info, so get it straight from matrix.
Vec3F newRotation = new Vec3F();
newLocalToParent.GetEulerAngles(out newRotation.X, out newRotation.Y, out newRotation.Z);
child.Rotation = newRotation;
// Likewise with scale.
Vec3F newScale = newLocalToParent.GetScale();
child.Scale = newScale;
// We can compose together all of the separate transformations now.
Matrix4F newTransform = CalcTransform(
newTranslation,
newRotation,
newScale,
child.ScalePivot,
child.ScalePivotTranslation,
child.RotatePivot,
child.RotatePivotTranslation);
// However, the composed matrix may not equal newLocalToParent due to rotating
// or scaling around a pivot. In the general case, it may be impossible to
// decompose newLocalToParent into all of these separate components. For example,
// a sheer transformation cannot be reproduced by a single rotation and scale.
// But for common cases, only the translation is out-of-sync now, so apply a fix.
Vec3F desiredTranslation = newLocalToParent.Translation;
Vec3F currentTranslation = newTransform.Translation;
Vec3F fixupTranslation = desiredTranslation - currentTranslation;
Matrix4F fixupTransform = new Matrix4F(fixupTranslation);
newTransform.Mul(newTransform, fixupTransform);
// Save the fix and the final transform. Storing the fix in RotatePivotTranslation
// is done elsewhere, as well.
child.Translation = newTranslation + fixupTranslation;
child.Transform = newTransform;
}
public override void Render(ViewControl vc)
{
Matrix4F normWorld = GetManipulatorMatrix();
if (normWorld == null) return;
int axis = (int)m_hitRegion;
// axis colors
Color saveColor = m_axisColor[axis];
m_axisColor[axis] = m_highlightColor;
Color xcolor = m_axisColor[(int)HitRegion.XAxis];
Color ycolor = m_axisColor[(int)HitRegion.YAxis];
Color zcolor = m_axisColor[(int)HitRegion.ZAxis];
Color nxcolor = m_axisColor[(int)HitRegion.NegXAxis];
Color nycolor = m_axisColor[(int)HitRegion.NegYAxis];
Color nzcolor = m_axisColor[(int)HitRegion.NegZAxis];
m_axisColor[axis] = saveColor;
if (m_hitRegion != HitRegion.None)
{
normWorld.Translation = HitMatrix.Translation;
}
Vec3F pos = normWorld.Translation;
float s = Util.CalcAxisScale(vc.Camera, pos, AxisLength, vc.Height);
Vec3F sv = new Vec3F(s, s, s);
Vec3F axscale = new Vec3F(s*AxisThickness, s, s*AxisThickness);
bool negativeAxis = m_hitRegion == HitRegion.NegXAxis || m_hitRegion == HitRegion.NegYAxis || m_hitRegion == HitRegion.NegZAxis;
Vec3F dragScale = new Vec3F(Math.Abs(m_scale.X),
Math.Abs(m_scale.Y), Math.Abs(m_scale.Z));
Matrix4F rot = new Matrix4F();
Matrix4F scale = new Matrix4F();
axscale.Y = negativeAxis ? s : s * dragScale.X;
scale.Scale(axscale);
rot.RotZ(-MathHelper.PiOver2);
Matrix4F xform = scale * rot * normWorld;
Util3D.DrawCylinder(xform, xcolor);
axscale.Y = negativeAxis ? s : s * dragScale.Y;
scale.Scale(axscale);
xform = scale * normWorld;
Util3D.DrawCylinder(xform, ycolor);
axscale.Y = negativeAxis ? s : s * dragScale.Z;
scale.Scale(axscale);
rot.RotX(MathHelper.PiOver2);
xform = scale * rot * normWorld;
Util3D.DrawCylinder(xform, zcolor);
rot.RotZ(MathHelper.PiOver2);
axscale.Y = negativeAxis ? s * dragScale.X : s;
scale.Scale(axscale);
xform = scale * rot * normWorld;
Util3D.DrawCylinder(xform, nxcolor);
rot.RotZ(MathHelper.Pi);
axscale.Y = negativeAxis ? s * dragScale.Y : s;
scale.Scale(axscale);
xform = scale * rot * normWorld;
Util3D.DrawCylinder(xform, nycolor);
rot.RotX(-MathHelper.PiOver2);
axscale.Y = negativeAxis ? s * dragScale.Z : s;
scale.Scale(axscale);
xform = scale * rot * normWorld;
Util3D.DrawCylinder(xform, nzcolor);
// draw center cube
scale.Scale(s*(1.0f / 16.0f));
xform = scale * normWorld;
Util3D.DrawCube(xform, Color.White);
Vec3F handle = sv*AxisHandle;
float handleWidth = handle.X/2;
scale.Scale(handle);
Matrix4F trans = new Matrix4F();
// X handle
float drag = m_hitRegion == HitRegion.XAxis ? dragScale.X : 1.0f;
trans.Translation = new Vec3F(drag * sv.X - handleWidth, 0, 0);
xform = scale * trans * normWorld;
Util3D.DrawCube(xform, xcolor);
// y handle
drag = m_hitRegion == HitRegion.YAxis ? dragScale.Y : 1.0f;
trans.Translation = new Vec3F(0, drag * sv.Y - handleWidth, 0);
xform = scale * trans * normWorld;
Util3D.DrawCube(xform, ycolor);
// z handle
drag = m_hitRegion == HitRegion.ZAxis ? dragScale.Z : 1.0f;
trans.Translation = new Vec3F(0, 0, drag * sv.Z - handleWidth);
xform = scale * trans * normWorld;
Util3D.DrawCube(xform, zcolor);
// -x handle
drag = m_hitRegion == HitRegion.NegXAxis ? dragScale.X : 1.0f;
trans.Translation = new Vec3F(-sv.X * drag + handleWidth, 0, 0);
xform = scale * trans * normWorld;
Util3D.DrawCube(xform, nxcolor);
// -y handle
drag = m_hitRegion == HitRegion.NegYAxis ? dragScale.Y : 1.0f;
trans.Translation = new Vec3F(0, -sv.Y * drag + handleWidth, 0);
xform = scale * trans * normWorld;
Util3D.DrawCube(xform, nycolor);
// -z handle
drag = m_hitRegion == HitRegion.NegZAxis ? dragScale.Z : 1.0f;
trans.Translation = new Vec3F(0, 0, -sv.Z * drag + handleWidth);
xform = scale * trans * normWorld;
Util3D.DrawCube(xform, nzcolor);
}
//
static SimpleTypes()
{
//string
RegisterType(typeof(string), delegate(string value)
{
if (value == null)
{
return("");
//throw new Exception( "GetSimpleTypeValue: string type, value = null" );
}
return(value);
}, "");
//bool
RegisterType(typeof(bool), delegate(string value)
{
string lower = value.ToLower();
if (value == "1" || lower == "yes" || lower == "true")
{
return(true);
}
else if (value == "0" || lower == "no" || lower == "false")
{
return(false);
}
else
{
return(bool.Parse(value));
}
}, false);
//sbyte
RegisterType(typeof(sbyte), delegate(string value) { return(sbyte.Parse(value)); }, 0);
//byte
RegisterType(typeof(byte), delegate(string value) { return(byte.Parse(value)); }, 0);
//char
RegisterType(typeof(char), delegate(string value) { return(char.Parse(value)); }, 0);
//short
RegisterType(typeof(short), delegate(string value) { return(short.Parse(value)); }, 0);
//ushort
RegisterType(typeof(ushort), delegate(string value) { return(ushort.Parse(value)); }, 0);
//int
RegisterType(typeof(int), delegate(string value) { return(int.Parse(value)); }, 0);
//uint
RegisterType(typeof(uint), delegate(string value) { return(uint.Parse(value)); }, (uint)0);
//long
RegisterType(typeof(long), delegate(string value) { return(long.Parse(value)); }, (long)0);
//ulong
RegisterType(typeof(ulong), delegate(string value) { return(ulong.Parse(value)); }, (ulong)0);
//float
RegisterType(typeof(float), delegate(string value) { return(float.Parse(value)); }, 0.0f);
//double
RegisterType(typeof(double), delegate(string value) { return(double.Parse(value)); }, 0.0);
//decimal
RegisterType(typeof(decimal), delegate(string value) { return(decimal.Parse(value)); }, (decimal)0.0);
//Vec2
RegisterType(typeof(Vector2F), delegate(string value) { return(Vector2F.Parse(value)); }, Vector2F.Zero);
//Range
RegisterType(typeof(RangeF), delegate(string value) { return(RangeF.Parse(value)); }, RangeF.Zero);
//Vec3
RegisterType(typeof(Vector3F), delegate(string value) { return(Vector3F.Parse(value)); }, Vector3F.Zero);
//Vec4
RegisterType(typeof(Vector4F), delegate(string value) { return(Vector4F.Parse(value)); }, Vector4F.Zero);
//Bounds
RegisterType(typeof(BoundsF), delegate(string value) { return(BoundsF.Parse(value)); }, BoundsF.Zero);
//Quat
RegisterType(typeof(QuaternionF), delegate(string value) { return(QuaternionF.Parse(value)); }, QuaternionF.Identity);
//ColorValue
RegisterType(typeof(ColorValue), delegate(string value) { return(ColorValue.Parse(value)); }, ColorValue.Zero);
//ColorValuePowered
RegisterType(typeof(ColorValuePowered), delegate(string value) { return(ColorValuePowered.Parse(value)); }, ColorValuePowered.Zero);
//ColorPacked
RegisterType(typeof(ColorByte), delegate(string value) { return(ColorByte.Parse(value)); }, ColorByte.Zero);
//SphereDir
RegisterType(typeof(SphericalDirectionF), delegate(string value) { return(SphericalDirectionF.Parse(value)); }, SphericalDirectionF.Zero);
//Vec2I
RegisterType(typeof(Vector2I), delegate(string value) { return(Vector2I.Parse(value)); }, Vector2I.Zero);
//Vec3I
RegisterType(typeof(Vector3I), delegate(string value) { return(Vector3I.Parse(value)); }, Vector3I.Zero);
//Vec4I
RegisterType(typeof(Vector4I), delegate(string value) { return(Vector4I.Parse(value)); }, Vector4I.Zero);
//Rect
RegisterType(typeof(RectangleF), delegate(string value) { return(RectangleF.Parse(value)); }, RectangleF.Zero);
//RectI
RegisterType(typeof(RectangleI), delegate(string value) { return(RectangleI.Parse(value)); }, RectangleI.Zero);
//Degree
RegisterType(typeof(DegreeF), delegate(string value) { return(DegreeF.Parse(value)); }, DegreeF.Zero);
//Radian
RegisterType(typeof(RadianF), delegate(string value) { return(RadianF.Parse(value)); }, RadianF.Zero);
//Vec2D
RegisterType(typeof(Vector2), delegate(string value) { return(Vector2.Parse(value)); }, Vector2.Zero);
//RangeD
RegisterType(typeof(Range), delegate(string value) { return(Range.Parse(value)); }, Range.Zero);
//RangeI
RegisterType(typeof(RangeI), delegate(string value) { return(RangeI.Parse(value)); }, RangeI.Zero);
//Vec3D
RegisterType(typeof(Vector3), delegate(string value) { return(Vector3.Parse(value)); }, Vector3.Zero);
//Vec4D
RegisterType(typeof(Vector4), delegate(string value) { return(Vector4.Parse(value)); }, Vector4.Zero);
//BoundsD
RegisterType(typeof(Bounds), delegate(string value) { return(Bounds.Parse(value)); }, Bounds.Zero);
//QuatD
RegisterType(typeof(Quaternion), delegate(string value) { return(Quaternion.Parse(value)); }, Quaternion.Identity);
//SphereDirD
RegisterType(typeof(SphericalDirection), delegate(string value) { return(SphericalDirection.Parse(value)); }, SphericalDirection.Zero);
//RectD
RegisterType(typeof(Rectangle), delegate(string value) { return(Rectangle.Parse(value)); }, Rectangle.Zero);
//DegreeD
RegisterType(typeof(Degree), delegate(string value) { return(Degree.Parse(value)); }, Degree.Zero);
//RadianD
RegisterType(typeof(Radian), delegate(string value) { return(Radian.Parse(value)); }, Radian.Zero);
//Angles
RegisterType(typeof(AnglesF), delegate(string value) { return(AnglesF.Parse(value)); }, AnglesF.Zero);
//AnglesD
RegisterType(typeof(Angles), delegate(string value) { return(Angles.Parse(value)); }, Angles.Zero);
//Mat2F
RegisterType(typeof(Matrix2F), delegate(string value) { return(Matrix2F.Parse(value)); }, Matrix2F.Zero);
//Mat2D
RegisterType(typeof(Matrix2), delegate(string value) { return(Matrix2.Parse(value)); }, Matrix2.Zero);
//Mat3F
RegisterType(typeof(Matrix3F), delegate(string value) { return(Matrix3F.Parse(value)); }, Matrix3F.Zero);
//Mat3D
RegisterType(typeof(Matrix3), delegate(string value) { return(Matrix3.Parse(value)); }, Matrix3.Zero);
//Mat4F
RegisterType(typeof(Matrix4F), delegate(string value) { return(Matrix4F.Parse(value)); }, Matrix4F.Zero);
//Mat4D
RegisterType(typeof(Matrix4), delegate(string value) { return(Matrix4.Parse(value)); }, Matrix4.Zero);
//PlaneF
RegisterType(typeof(PlaneF), delegate(string value) { return(PlaneF.Parse(value)); }, PlaneF.Zero);
//PlaneD
RegisterType(typeof(Plane), delegate(string value) { return(Plane.Parse(value)); }, Plane.Zero);
//Transform
RegisterType(typeof(Transform), delegate(string value) { return(Transform.Parse(value)); }, Transform.Identity);
//UIMeasureValueDouble
RegisterType(typeof(UIMeasureValueDouble), delegate(string value) { return(UIMeasureValueDouble.Parse(value)); }, new UIMeasureValueDouble());
//UIMeasureValueVec2
RegisterType(typeof(UIMeasureValueVector2), delegate(string value) { return(UIMeasureValueVector2.Parse(value)); }, new UIMeasureValueVector2());
//UIMeasureValueRect
RegisterType(typeof(UIMeasureValueRectangle), delegate(string value) { return(UIMeasureValueRectangle.Parse(value)); }, new UIMeasureValueRectangle());
RegisterType(typeof(RangeVector3F), delegate(string value) { return(RangeVector3F.Parse(value)); }, RangeVector3F.Zero);
RegisterType(typeof(RangeColorValue), delegate(string value) { return(RangeColorValue.Parse(value)); }, RangeColorValue.Zero);
//no Parse methods. This is complex structures. This is not simple types? or just can't parse?
//Box
//Capsule
//Cone
//Line3
//Line2
//Ray
//Frustum?
RegisterConvertDoubleToFloatTypes();
}
public override void OnBeginDrag()
{
if (m_hitRegion == HitRegion.None)
return;
var selectionCntx = DesignView.Context.As<ISelectionContext>();
var selection = selectionCntx.Selection;
var transactionContext = DesignView.Context.As<ITransactionContext>();
m_activeOp = null;
var op = new ManipulatorActiveOperation(
"Rotate", DesignView.Context.As<ISelectionContext>(),
(ITransformable node) => (node.TransformationType & TransformationTypes.Rotation) != 0,
false);
m_rotations = new Matrix4F[op.NodeList.Count];
for (int k = 0; k < op.NodeList.Count; k++)
{
ITransformable node = op.NodeList[k];
Matrix4F m = new Matrix4F(node.Transform);
m.Translation = new Vec3F(0, 0, 0);
m.Normalize(m);
m_rotations[k] = m;
}
m_activeOp = op;
}
/// <summary>
/// Performs initialization when the adapter's node is set.
/// This method is called each time the adapter is connected to its underlying node.
/// Typically overridden by creators of DOM adapters.</summary>
protected override void OnNodeSet()
{
base.OnNodeSet();
// get trans, scale, and rot.
foreach (DomNode domNode in this.DomNode.GetChildList(Schema.node.scaleChild))
{
m_scale = Tools.GetVector3(domNode, Schema.TargetableFloat3.Attribute);
break;
}
foreach (DomNode domNode in this.DomNode.GetChildList(Schema.node.translateChild))
{
m_translation = Tools.GetVector3(domNode, Schema.TargetableFloat3.Attribute);
break;
}
const float PiOver180 = (float)(Math.PI / 180.0f);
foreach (DomNode node in DomNode.GetChildList(Schema.node.rotateChild))
{
double[] arr = (double[])node.GetAttribute(Schema.rotate.Attribute);
float angle = (float)arr[3] * PiOver180;
string sid = node.GetAttribute(Schema.rotate.sidAttribute) as string;
if (string.IsNullOrEmpty(sid))
{
continue;
}
if (sid == "rotateX")
{
m_rotation.X = angle;
}
else if (sid == "rotateY")
{
m_rotation.Y = angle;
}
else if (sid == "rotateZ")
{
m_rotation.Z = angle;
}
}
Matrix4F M = new Matrix4F();
Matrix4F temp = new Matrix4F();
temp.Scale(Scale);
M.Mul(M, temp);
if (m_rotation.X != 0)
{
temp.RotX(m_rotation.X);
M.Mul(M, temp);
}
if (m_rotation.Y != 0)
{
temp.RotY(m_rotation.Y);
M.Mul(M, temp);
}
if (m_rotation.Z != 0)
{
temp.RotZ(m_rotation.Z);
M.Mul(M, temp);
}
temp.Set(Translation);
M.Mul(M, temp);
Transform = M;
m_boundingBox = new Cached <Box>(CalculateBoundingBox);
Visible = true;
}
protected override Matrix4F GetManipulatorMatrix()
{
ITransformable node = GetManipulatorNode(TransformationTypes.Rotation);
if (node == null ) return null;
Path<DomNode> path = new Path<DomNode>(node.Cast<DomNode>().GetPath());
Matrix4F localToWorld = TransformUtils.CalcPathTransform(path, path.Count - 1);
// local transform
Matrix4F toworld = new Matrix4F(localToWorld);
// Offset by rotate pivot
Matrix4F P = new Matrix4F();
P.Translation = node.Pivot;
toworld.Mul(P, toworld);
// Normalize
toworld.Normalize(toworld);
return toworld;
}
public void Render(GUILayer.SimpleRenderingContext context, Camera cam)
{
GameEngine.SetRendererFlag(context, BasicRendererFlags.WireFrame);
IGrid grid = this.As <IGrid>();
if (grid.Visible == false)
{
return;
}
float s = grid.Size;
Matrix4F scale = new Matrix4F();
scale.Scale(new Vec3F(s, s, s));
Matrix4F gridXform = new Matrix4F();
if (cam.Frustum.IsOrtho)
{
float dist = cam.ViewMatrix.Translation.Z;
ViewTypes vt = cam.ViewType;
if (vt == ViewTypes.Top)
{
gridXform.Translation
= new Vec3F(0, dist, 0);
}
else if (vt == ViewTypes.Bottom)
{
gridXform.Translation
= new Vec3F(0, -dist, 0);
}
else if (vt == ViewTypes.Right)
{
gridXform.RotZ(MathHelper.PiOver2);
gridXform.Translation
= new Vec3F(dist, 0, 0);
}
else if (vt == ViewTypes.Left)
{
gridXform.RotZ(MathHelper.PiOver2);
gridXform.Translation
= new Vec3F(-dist, 0, 0);
}
else if (vt == ViewTypes.Front)
{
gridXform.RotX(MathHelper.PiOver2);
gridXform.Translation
= new Vec3F(0, 0, dist);
}
else if (vt == ViewTypes.Back)
{
gridXform.RotX(MathHelper.PiOver2);
gridXform.Translation
= new Vec3F(0, 0, -dist);
}
gridXform.Mul(scale, gridXform);
}
else
{
Matrix4F trans = new Matrix4F();
trans.Translation = new Vec3F(0, grid.Height, 0);
gridXform = Matrix4F.Multiply(scale, trans);
}
GameEngine.DrawPrimitive(context, PrimitiveType.LineList, m_gridVBId, 0, m_gridVertexCount, Color.LightGray,
Matrix4F.Multiply(gridXform, cam.AxisSystem));
GameEngine.DrawPrimitive(context, PrimitiveType.LineList, m_basisAxesVBId, 0, m_basisAxesVertexCount, Color.White,
gridXform);
}
/// <summary>
/// Handles mouse-move events</summary>
/// <param name="sender">Control that raised original event</param>
/// <param name="e">Event args</param>
/// <returns>true, if controller handled the event</returns>
public override bool MouseMove(object sender, MouseEventArgs e)
{
if (m_dragging &&
InputScheme.ActiveControlScheme.IsControllingCamera(Control.ModifierKeys, e))
{
float dx = (float)(e.X - m_lastMousePoint.X) / 150.0f;
float dy = (float)(e.Y - m_lastMousePoint.Y) / 150.0f;
if (InputScheme.ActiveControlScheme.IsElevating(Control.ModifierKeys, e))
{
// move camera up/down
Vec3F p = Camera.Eye;
p.Y += (dy < 0) ? m_scale : -m_scale;
Camera.Set(p);
}
else if (InputScheme.ActiveControlScheme.IsTurning(Control.ModifierKeys, e))
{
// pitch and yaw camera
Matrix4F mat = Matrix4F.RotAxisRH(Camera.Right, -dy); // pitch along camera right
Matrix4F yaw = new Matrix4F();
yaw.RotY(-dx);
mat.Mul(yaw, mat);
Vec3F lookAt = Camera.LookAt;
Vec3F up = Camera.Up;
mat.Transform(ref lookAt);
mat.Transform(ref up);
Vec3F position = Camera.Eye;
float d = Camera.DistanceFromLookAt;
Camera.Set(position, position + lookAt * d, up);
}
m_lastMousePoint = e.Location;
return true;
}
return base.MouseMove(sender, e);
}
public Manipulator()
{
NodeList = new List <ITransformable>();
HitMatrix = new Matrix4F();
DesignView = null;
}
