public static double GetFieldOfView(this ViewportInfo vpi)
{
//vpi.GetCameraAngles(out var halfDiagonal, out _, out _);
//return halfDiagonal.ToDegrees();
return(60);
}
/// <summary>
/// Initializes the camera on load...
/// </summary>
public void SetupCamera()
{
if (Camera == null)
{
LoadCamera();
}
// Fix up viewport values
var cameraDir = Camera.CameraDirection;
cameraDir.Unitize();
Camera.SetCameraDirection(cameraDir);
var cameraUp = Camera.CameraUp;
cameraUp.Unitize();
Camera.SetCameraUp(cameraUp);
Renderer.Viewport = Camera;
// save initial viewport settings for restoreView
InitialPosition = new ViewportInfo(Camera);
LastPosition = new ViewportInfo(Camera);
CameraIsAtInitialPosition = true;
GL.Viewport(0, 0, (int)View.Bounds.Size.Width, (int)View.Bounds.Size.Height);
}
public static void BringCellToVisible(Excel excel, int viewCellRow, int viewCellColumn)
{
if ((excel != null) && (excel.ActiveSheet != null))
{
ViewportInfo viewportInfo = excel.GetViewportInfo();
int activeRowViewportIndex = excel.GetActiveRowViewportIndex();
int activeColumnViewportIndex = excel.GetActiveColumnViewportIndex();
int rowViewportIndex = activeRowViewportIndex;
int columnViewportIndex = activeColumnViewportIndex;
if (activeRowViewportIndex == -1)
{
if (viewCellRow >= excel.ActiveSheet.FrozenRowCount)
{
rowViewportIndex = 0;
}
}
else if ((activeRowViewportIndex == viewportInfo.RowViewportCount) && (viewCellRow < (excel.ActiveSheet.RowCount - excel.ActiveSheet.FrozenTrailingRowCount)))
{
rowViewportIndex = viewportInfo.RowViewportCount - 1;
}
if (activeColumnViewportIndex == -1)
{
if (viewCellColumn >= excel.ActiveSheet.FrozenColumnCount)
{
columnViewportIndex = 0;
}
}
else if ((activeColumnViewportIndex == viewportInfo.ColumnViewportCount) && (viewCellColumn < (excel.ActiveSheet.ColumnCount - excel.ActiveSheet.FrozenTrailingColumnCount)))
{
columnViewportIndex = viewportInfo.ColumnViewportCount - 1;
}
BringCellToVisible(excel, rowViewportIndex, columnViewportIndex, viewCellRow, viewCellColumn);
}
}
public UserOperation_SetWaterbagInfo(long userId, ViewportInfo vi, Guid guid, float width, Microsoft.Xna.Framework.Vector2[] vecs)
: base(userId, vi)
{
Guid = guid;
Width = width;
Vecs = vecs;
}
public UserOperation_SetProperty(long userId, ViewportInfo vi, Guid guid, string propertyName, object value)
: base(userId, vi)
{
Guid = guid;
PropertyName = propertyName;
Value = value;
}
/// <summary>
/// Rotate the camera about world z axis
/// </summary>
public static void RotateLeftRight(this ViewportInfo viewport, double angle)
{
var axis = Rhino.Geometry.Vector3d.ZAxis;
Rhino.Geometry.Point3d center = viewport.TargetPoint;
RotateView(viewport, axis, center, angle);
}
public UserOperation_Trans(long userId, ViewportInfo vi, Guid guid, ElementTransitionInfo info, SizeF scale)
: base(userId, vi)
{
Guid = guid;
Info = info;
Scale = scale;
}
public void ResetOperations(ViewportInfo vi)
{
if (Operations.ContainsKey(vi))
{
Operations[vi].Clear();
}
}
private static bool CalcClippingPlanesInternal(ViewportInfo vp, ClippingInfo clipping)
{
bool isPerspective = vp.IsPerspectiveProjection;
// iCalcBoundingBox() has set clipping.bbox and it cannot
// be changed or ignored.
GetBoundingBoxNearFarHelper(
clipping.bbox,
isPerspective,
vp.CameraLocation,
vp.CameraZ,
clipping.bbox_near,
clipping.bbox_far
);
// Do sanity checks and update ON_Viewport frustum if it uses
// parallel projection and near <= 0.0
CalcClippingPlanesHelper(clipping.bbox_near, clipping.bbox_far, vp);
// Set target_dist
clipping.target_dist = (vp.CameraLocation - vp.TargetPoint) * vp.CameraZ;
if (double.IsNaN(clipping.target_dist))
{
clipping.target_dist = 0.5 * (clipping.bbox_near + clipping.bbox_far);
}
return(true);
}
public ElementInfo_Audio(ResourceInfo res, ViewportInfo vi, bool isPreview, System.Drawing.PointF pos)
: base(res, vi, isPreview, pos)
{
Channel = ProjectDoc.Instance.FModPlayer.CreateChannel(res.SubPathFileName);
m_bPlaying = isPreview;
IsSoundLooping = isPreview;
}
public static bool SetupFrustum(ViewportInfo vp, ClippingInfo clipping)
{
double n0 = vp.FrustumNear;
double f0 = vp.FrustumFar;
// Because picking relies heavily on the projection, we first set the
// viewport frustum here, capture and save it, then let the conduits
// do what ever they want with it...eventually the viewport will be put
// back to the captured state before leaving the pipeline...
ClippingInfo m_SavedClipping = clipping;
vp.SetFrustumNearFar(clipping.bbox_near, clipping.bbox_far,
clipping.min_near_dist, clipping.min_near_over_far,
clipping.target_dist
);
vp.GetFrustum(out m_SavedClipping.left,
out m_SavedClipping.right,
out m_SavedClipping.bottom,
out m_SavedClipping.top,
out m_SavedClipping.bbox_near,
out m_SavedClipping.bbox_far);
// Next, set the values that the pipeline will actually use...
if (!(AdjustFrustum(vp, clipping)))
{
return(false);
}
return(true);
}
private void ZoomExtentsWithGesture(UIGestureRecognizer gesture)
{
if (Camera == null)
{
return;
}
if (gesture.State == UIGestureRecognizerState.Ended)
{
ShouldStartRestoreToInitialPosition = CameraIsAtInitialPosition;
ViewportInfo targetPosition = new ViewportInfo();
if (ShouldStartRestoreToInitialPosition)
{
// animate from current position (which is initial position) back to last position
targetPosition = LastPosition;
}
else
{
// animate from current position to initial position
targetPosition = InitialPosition;
LastPosition = new ViewportInfo(Camera);
}
StartRestoreViewTo(targetPosition);
}
}
/// <summary>
/// 打印设置
/// </summary>
/// <param name="p_memento"></param>
void Init(Memento p_memento)
{
Grid grid = VisualTreeHelper.GetParent(_excel) as Grid;
p_memento.Height = grid.Height;
p_memento.Width = grid.Width;
p_memento.VerticalScrollBarVisibility = _excel.VerticalScrollBarVisibility;
p_memento.HorizontalScrollBarVisibility = _excel.HorizontalScrollBarVisibility;
p_memento.TabStripVisibility = _excel.TabStripVisibility;
p_memento.ShowRowRangeGroup = _excel.ShowRowRangeGroup;
p_memento.ShowColumnRangeGroup = _excel.ShowColumnRangeGroup;
p_memento.ShowFreezeLine = _excel.ShowFreezeLine;
p_memento.ShowSelection = _excel.ShowSelection;
_excel.VerticalScrollBarVisibility = ScrollBarVisibility.Hidden;
_excel.HorizontalScrollBarVisibility = ScrollBarVisibility.Hidden;
_excel.TabStripVisibility = Visibility.Collapsed;
_excel.ShowRowRangeGroup = false;
_excel.ShowColumnRangeGroup = false;
_excel.ShowSelection = false;
_excel.HideDecorationWhenPrinting = true;
_excel.ShowFreezeLine = false;
Worksheet sheet = _excel.Sheets[_sheetIndex];
sheet.ZoomFactor = 1f;
ViewportInfo info = new ViewportInfo(sheet, 1, 1);
sheet.SetViewportInfo(info);
}
/// <summary>
/// Rotates camera around the x axis
/// </summary>
public static void RotateUpDown(this ViewportInfo viewport, double angle)
{
Rhino.Geometry.Vector3d cameraX;
Rhino.Geometry.Point3d center;
center = viewport.TargetPoint;
cameraX = viewport.CameraX;
RotateView(viewport, cameraX, center, angle);
}
public ElementInfo_Video(ResourceInfo res, ViewportInfo vi, bool isPreview, System.Drawing.PointF pos)
: base(res, vi, isPreview, pos)
{
for (int i = 0; i < 4; ++i)
{
m_Vectors[i] = new VertexPositionColorTexture();
}
}
public Point3D To3DPoint(Vector point)
{
LineRange r = new LineRange();
ViewportInfo.Point2DtoPoint3D(viewPort, point.ToPoint(), out r);
return(r.PointFromZ(-100));
}
public CubicCurveRibbon(ViewportInfo vi)
{
ParentViewport = vi;
ResetLifeTime = 0;
Width = ProjectDoc.Instance.DefaultCubicCurveRibbonWidth;
FillColor = ProjectDoc.Instance.DefaultCubicCurveRibbonColor;
DetailPrecision = 0.02F;
}
/// <summary>
/// Compute silhouettes of a shape for a specified projection.
/// </summary>
/// <param name="geometry">Geometry whose silhouettes need to be computed. Can be Brep, BrepFace, Mesh, or Extrusion.</param>
/// <param name="silhouetteType">Types of silhouette to compute.</param>
/// <param name="viewport">Projection.</param>
/// <param name="tolerance">Tolerance to use for determining projecting relationships.
/// Surfaces and curves that are closer than tolerance, may be treated as projecting.
/// When in doubt use RhinoDoc.ModelAbsoluteTolerance.</param>
/// <param name="angleToleranceRadians">Angular tolerance to use for determining projecting relationships.
/// A surface normal N that satisfies N o cameraDirection < Sin(angleToleranceRadians) may be considered projecting.
/// When in doubt use RhinoDoc.ModelAngleToleranceRadians.</param>
/// <returns>Array of silhouette curves.</returns>
public static Silhouette[] Compute(
GeometryBase geometry,
SilhouetteType silhouetteType,
ViewportInfo viewport,
double tolerance,
double angleToleranceRadians)
{
return(Compute(geometry, silhouetteType, viewport, tolerance, angleToleranceRadians, null, System.Threading.CancellationToken.None));
}
private void ConvertViewportToFlexSpace(Rect viewport, ref ViewportInfo info)
{
switch (flexDirection)
{
case AxisDirection.LeftToRight:
info.startInMainAxis = viewport.xMin;
info.endInMainAxis = viewport.xMax;
break;
case AxisDirection.RightToLeft:
info.startInMainAxis = viewport.xMax;
info.endInMainAxis = viewport.xMin;
break;
case AxisDirection.UpToDown:
info.startInMainAxis = viewport.yMax;
info.endInMainAxis = viewport.yMin;
break;
case AxisDirection.DownToUp:
info.startInMainAxis = viewport.yMin;
info.endInMainAxis = viewport.yMax;
break;
}
if (isFlexHorizontal)
{
switch (crossAxisDirection)
{
case CrossAxisDirection.Default:
info.startInCrossAxis = viewport.yMin;
info.endInCrossAxis = viewport.yMax;
break;
case CrossAxisDirection.Reverse:
info.startInCrossAxis = viewport.yMax;
info.endInCrossAxis = viewport.yMin;
break;
}
}
else
{
switch (crossAxisDirection)
{
case CrossAxisDirection.Default:
info.startInCrossAxis = viewport.xMin;
info.endInCrossAxis = viewport.xMax;
break;
case CrossAxisDirection.Reverse:
info.startInCrossAxis = viewport.xMax;
info.endInCrossAxis = viewport.xMin;
break;
}
}
}
/// <summary>
/// Dynamically set the frustum based on the clipping
/// </summary>
protected void SetFrustum(ViewportInfo viewport, Rhino.Geometry.BoundingBox bBox)
{
ClippingInfo clipping = new ClippingInfo();
clipping.bbox = bBox;
if (ClippingPlanes.CalcClippingPlanes(viewport, clipping))
{
ClippingPlanes.SetupFrustum(viewport, clipping);
}
}
/// <summary>
/// GestoreOrbit performs a gesture-based orbit about an anchorLocation to a location.
/// </summary>
public static void GestureOrbit(this ViewportInfo viewport, Size viewSize, System.Drawing.PointF anchorLocation, System.Drawing.PointF location)
{
int screenWidth = viewSize.Width;
float f = (float)(Math.PI / screenWidth);
float horizontalDiff = anchorLocation.X - location.X;
RotateLeftRight(viewport, (horizontalDiff * f));
float verticalDiff = anchorLocation.Y - location.Y;
RotateUpDown(viewport, (verticalDiff * f));
}
/// <summary>
/// GestoreOrbit performs a gesture-based orbit about an anchorLocation to a location.
/// </summary>
public static void GestureOrbit(this ViewportInfo viewport, CGSize viewSize, CoreGraphics.CGPoint anchorLocation, CoreGraphics.CGPoint location)
{
var screenWidth = viewSize.Width;
nfloat f = (float)(Math.PI / screenWidth);
nfloat horizontalDiff = anchorLocation.X - location.X;
RotateLeftRight(viewport, (horizontalDiff * f));
nfloat verticalDiff = anchorLocation.Y - location.Y;
RotateUpDown(viewport, (verticalDiff * f));
}
/// <summary>
/// Find the Perspective viewport in the 3dm file and sets up the default view.
/// </summary>
public void LoadCamera()
{
if (App.Manager.CurrentModel == null)
{
return;
}
Camera = new ViewportInfo();
bool cameraIsInitialized = false;
int viewCount = App.Manager.CurrentModel.ModelFile.Views.Count;
// find first perspective viewport projection in file
if (viewCount > 0)
{
foreach (var view in App.Manager.CurrentModel.ModelFile.Views)
{
if (view.Viewport.IsPerspectiveProjection)
{
cameraIsInitialized = true;
Camera = view.Viewport;
Camera.TargetPoint = view.Viewport.TargetPoint;
Camera.SetScreenPort(0, (int)View.Bounds.Size.Width, 0, (int)View.Bounds.Size.Height, 1, 1000);
Camera.FrustumAspect = Camera.ScreenPortAspect;
Camera.SetFrustumNearFar(App.Manager.CurrentModel.BBox);
break;
}
}
}
// If there isn't one, then cook up a viewport from scratch...
if (!cameraIsInitialized)
{
Camera.SetScreenPort(0, (int)View.Bounds.Size.Width, 0, (int)View.Bounds.Size.Height, 1, 1000);
Camera.TargetPoint = new Rhino.Geometry.Point3d(0, 0, 0);
var plane = new Rhino.Geometry.Plane(Rhino.Geometry.Point3d.Origin, new Rhino.Geometry.Vector3d(-1, -1, -1));
Camera.SetCameraLocation(new Rhino.Geometry.Point3d(10, 10, 10));
var dir = new Rhino.Geometry.Vector3d(-1, -1, -1);
dir.Unitize();
Camera.SetCameraDirection(dir);
Camera.SetCameraUp(plane.YAxis);
Camera.SetFrustum(-1, 1, -1, 1, 0.1, 1000);
Camera.FrustumAspect = Camera.ScreenPortAspect;
Camera.IsPerspectiveProjection = true;
Camera.Camera35mmLensLength = 50;
if (App.Manager.CurrentModel != null)
{
if (App.Manager.CurrentModel.AllMeshes != null)
{
Camera.DollyExtents(App.Manager.CurrentModel.AllMeshes, 1.0);
}
}
}
}
/// <summary>
/// Returns a bounding box for the custom render meshes for the given object.
/// </summary>
/// <param name="vp">The viewport being rendered.</param>
/// <param name="obj">The Rhino object of interest.</param>
/// <param name="requestingPlugIn">UUID of the RDK plug-in requesting the meshes.</param>
/// <param name="preview">Type of mesh to build.</param>
/// <returns>A bounding box value.</returns>
public virtual BoundingBox BoundingBox(ViewportInfo vp, RhinoObject obj, Guid requestingPlugIn, bool preview)
{
var min = new Point3d();
var max = new Point3d();
if (UnsafeNativeMethods.Rdk_RMPBoundingBoxImpl(m_runtime_serial_number, vp.ConstPointer(), obj.ConstPointer(), requestingPlugIn, preview ? 1 : 0, ref min, ref max))
{
return(new BoundingBox(min, max));
}
return(new BoundingBox());
}
/// <summary>
/// Rotates a viewport about an axis relative to a center point
/// </summary>
public static void RotateView(this ViewportInfo viewport, Rhino.Geometry.Vector3d axis, Rhino.Geometry.Point3d center, double angle)
{
Rhino.Geometry.Point3d cameraLocation = viewport.CameraLocation;
Rhino.Geometry.Vector3d cameraY = viewport.CameraY;
Rhino.Geometry.Vector3d cameraZ = viewport.CameraZ;
Rhino.Geometry.Transform rotation = Rhino.Geometry.Transform.Rotation(angle, axis, center);
cameraLocation = rotation * cameraLocation;
cameraY = rotation * cameraY;
cameraZ = -(rotation * cameraZ);
viewport.SetCameraLocation(cameraLocation);
viewport.SetCameraDirection(cameraZ);
viewport.SetCameraUp(cameraY);
}
/// <summary>
/// Sets the viewport's camera location, target and up vector
/// </summary>
public static void SetTarget(this ViewportInfo viewport, Rhino.Geometry.Point3d targetLocation, Rhino.Geometry.Point3d cameraLocation, Rhino.Geometry.Vector3d cameraUp)
{
Rhino.Geometry.Vector3d cameraDirection = targetLocation - cameraLocation;
cameraDirection.Unitize();
if (!viewport.CameraDirection.IsTiny())
{
Rhino.Geometry.Vector3d cameraDirection0 = -viewport.CameraZ;
Rhino.Geometry.Vector3d cameraY = viewport.CameraY;
const double tiltAngle = 0;
viewport.SetCameraLocation(cameraLocation);
viewport.SetCameraDirection(cameraDirection);
bool didSetTarget = false;
didSetTarget = viewport.SetCameraUp(cameraUp);
if (!didSetTarget)
{
didSetTarget = viewport.SetCameraUp(cameraY);
cameraUp = cameraY;
}
if (!didSetTarget)
{
Rhino.Geometry.Vector3d rotationAxis = Rhino.Geometry.Vector3d.CrossProduct(cameraDirection0, cameraDirection);
double sinAngle = rotationAxis.Length;
double cosAngle = cameraDirection0 * cameraDirection;
Rhino.Geometry.Transform rot = Rhino.Geometry.Transform.Rotation(sinAngle, cosAngle, rotationAxis, Rhino.Geometry.Point3d.Origin);
cameraUp = rot * cameraY;
didSetTarget = viewport.SetCameraUp(cameraUp);
}
if (didSetTarget)
{
// Apply tilt angle to new camera and target location
if (Math.Abs(tiltAngle) > 1.0e-6)
{
Rhino.Geometry.Transform rot = Rhino.Geometry.Transform.Rotation(tiltAngle, -cameraDirection0, cameraLocation);
cameraUp = rot * cameraUp;
didSetTarget = viewport.SetCameraUp(cameraUp);
}
if (didSetTarget)
{
viewport.TargetPoint = targetLocation;
}
}
}
}
public ElementInfo_StaticImage(ResourceInfo res, ViewportInfo vi, bool isPreview, System.Drawing.PointF pos)
: base(res, vi, isPreview, pos)
{
if (vi != null && vi.BackImage != null)
{
m_ManualScale.Width = vi.BackImage.CurImageScale;
m_ManualScale.Height = vi.BackImage.CurImageScale;
}
for (int i = 0; i < 4; ++i)
{
m_Vectors[i] = new VertexPositionColorTexture();
}
}
void CachFloatingObjectsMovingResizingLayoutModels()
{
ViewportInfo viewportInfo = GetViewportInfo();
int columnViewportCount = viewportInfo.ColumnViewportCount;
int rowViewportCount = viewportInfo.RowViewportCount;
_cachedFloatingObjectMovingResizingLayoutModel = new FloatingObjectLayoutModel[rowViewportCount + 2, columnViewportCount + 2];
for (int i = -1; i <= rowViewportCount; i++)
{
for (int j = -1; j <= columnViewportCount; j++)
{
_cachedFloatingObjectMovingResizingLayoutModel[i + 1, j + 1] = new FloatingObjectLayoutModel(GetViewportFloatingObjectLayoutModel(i, j));
}
}
}
/// <summary>
/// Compute silhouettes of a shape for a specified projection.
/// </summary>
/// <param name="geometry">Geometry whose silhouettes need to be computed. Can be Brep, BrepFace, Mesh, or Extrusion.</param>
/// <param name="silhouetteType">Types of silhouette to compute.</param>
/// <param name="viewport">Projection.</param>
/// <param name="tolerance">Tolerance to use for determining projecting relationships.
/// Surfaces and curves that are closer than tolerance, may be treated as projecting.
/// When in doubt use RhinoDoc.ModelAbsoluteTolerance.</param>
/// <param name="angleToleranceRadians">Angular tolerance to use for determining projecting relationships.
/// A surface normal N that satisfies N o cameraDirection < Sin(angleToleranceRadians) may be considered projecting.
/// When in doubt use RhinoDoc.ModelAngleToleranceRadians.</param>
/// <param name="clippingPlanes">Optional collection of clipping planes.</param>
/// <param name="cancelToken">Computation cancellation token.</param>
/// <returns>Array of silhouette curves.</returns>
public static Silhouette[] Compute(
GeometryBase geometry,
SilhouetteType silhouetteType,
ViewportInfo viewport,
double tolerance,
double angleToleranceRadians,
IEnumerable <Plane> clippingPlanes,
System.Threading.CancellationToken cancelToken)
{
if (viewport.IsParallelProjection)
{
return(Compute(geometry, silhouetteType, viewport.CameraDirection, tolerance, angleToleranceRadians, clippingPlanes, cancelToken));
}
return(Compute(geometry, silhouetteType, viewport.CameraLocation, tolerance, angleToleranceRadians, clippingPlanes, cancelToken));
}
public ElementInfo_Waterbag(ResourceInfo res, ViewportInfo vi, bool isPreview, System.Drawing.PointF pos)
: base(res, vi, isPreview, pos)
{
Name = "水带";
if (CommonTexture == null)
{
try
{
CommonTexture = Texture2D.FromFile(ProjectDoc.Instance.HostGame.GraphicsDevice, Options.SystemResourceRootPath + "waterbag.tga");
}
catch { }
}
AddJoint(new System.Drawing.Point((int)pos.X, (int)pos.Y));
AddJoint(new System.Drawing.Point((int)pos.X + 50, (int)pos.Y));
}
