protected override void OnMouseWheel(MouseEventArgs e)
{
if (!Enabled)
{
return;
}
float z = (float)e.Delta / 120.0f;
if (Control.ModifierKeys == Keys.Shift)
{
z *= 32;
}
ModelPanelViewport v = HighlightedViewport;
v.Zoom(-z * v._zoomFactor);
if (Control.ModifierKeys == Keys.Alt)
{
if (z < 0)
{
v._multiplier /= 0.9f;
}
else
{
v._multiplier *= 0.9f;
}
}
base.OnMouseWheel(e);
}
/// <summary>
/// Use this for transforming points
/// </summary>
public bool GetTransformPoint(
Vector2 mousePoint,
out Vector3 point,
ModelPanelViewport panel,
Vector3 center)
{
return(GetTransformPoint(mousePoint, out point, panel, Matrix.TranslationMatrix(center)));
}
public unsafe void RenderTransformControls(ModelPanelViewport panel)
{
if (_playing || ControlType == TransformType.None)
{
return;
}
bool hasBone = SelectedBone != null;
if (hasBone || VertexLoc.HasValue)
{
Vector3 pos;
Matrix rot = Matrix.Identity;
float radius;
if (hasBone)
{
pos = BoneLoc(SelectedBone);
radius = OrbRadius(pos, panel.Camera);
switch (_coordinateTypes[(int)ControlType])
{
case CoordinateType.Local:
rot = GetBoneWorldMtx().GetRotationMatrix();
break;
case CoordinateType.World:
//rot = Matrix.Identity; //Already set to identity above
break;
case CoordinateType.Screen:
//rot = CameraFacingRotationMatrix(panel, pos);
rot = Matrix.RotationMatrix(panel.Camera._rotation);
break;
}
RenderTransformControl(pos, rot, radius, panel, _boneSelection);
}
if (VertexLoc.HasValue)
{
pos = VertexLoc.Value;
radius = OrbRadius(pos, panel.Camera);
switch (_coordinateTypes[(int)ControlType])
{
case CoordinateType.Local:
case CoordinateType.World:
//rot = Matrix.Identity; //Already set to identity above
break;
case CoordinateType.Screen:
rot = CameraFacingRotationMatrix(panel, pos);
break;
}
RenderTransformControl(pos, rot, radius, panel, _vertexSelection);
}
}
}
public unsafe void RenderOrb(IBoneNode bone, GLDisplayList list, ModelPanelViewport v, bool doScale)
{
float radius = MDL0BoneNode._nodeRadius * (doScale ? OrbRadius(bone, v) : 1.0f);
Matrix m = Matrix.TransformMatrix(new Vector3(radius), new Vector3(), bone.Matrix.GetPoint());
GL.PushMatrix();
GL.MultMatrix((float *)&m);
list.Call();
GL.PopMatrix();
}
public unsafe virtual void modelPanel1_PreRender(ModelPanelViewport vp)
{
if (vp != null)
{
if (vp._renderFloor)
{
OnRenderFloor();
}
GL.Enable(EnableCap.DepthTest);
GL.DepthFunc(DepthFunction.Lequal);
}
}
private void MouseMoveTargetBone(
ModelPanel panel,
MouseEventArgs e,
float depth,
ModelPanelViewport v)
{
if (SelectedBone != null)
{
MouseMoveTarget(panel, e, depth, v, GetBoneWorldMtx(), GetBoneInvWorldMtx());
}
GetBone(panel, e, depth, v);
}
private void MouseMoveTargetVertex(
ModelPanel panel,
MouseEventArgs e,
float depth,
ModelPanelViewport v)
{
if (VertexLoc.HasValue /* && v._renderAttrib._renderVertices*/)
{
Vector3 center = VertexLoc.Value;
MouseMoveTarget(panel, e, depth, v, Matrix.TranslationMatrix(center), Matrix.TranslationMatrix(-center));
}
GetVertex(panel, e, depth, v);
}
protected virtual void modelPanel1_MouseDown(object sender, MouseEventArgs e)
{
_createdNewBone = false;
ModelPanel panel = sender as ModelPanel;
ModelPanelViewport viewport = panel.CurrentViewport;
if (panel._draggingViewports)
{
return;
}
if (e.Button == Forms.MouseButtons.Left)
{
if (DoNotHighlightOnMouseMove)
{
HighlightStuff(e, panel);
//Reset the cursor (HighlightStuff sets the cursor)
panel.Cursor = Cursors.Default;
}
//Reset snap flags
_boneSelection.ResetSnaps();
_vertexSelection.ResetSnaps();
MouseDownTargetBone(e, panel);
if (!MouseDownTargetVertex(e, panel))
{
if (CurrentFrame == 0 &&
TargetAnimType == NW4RAnimType.CHR &&
CHR0Editor.chkMoveBoneOnly.Checked &&
TargetModel != null &&
TargetModel is MDL0Node)
{
MDL0Node m = TargetModel as MDL0Node;
m._dontUpdateMesh = true;
}
}
//Ensure a redraw so the snapping indicators are correct
panel.Invalidate();
}
}
public unsafe void RenderTranslationControl(
Vector3 position,
float radius,
Matrix rotation,
ModelPanelViewport panel,
SelectionParams selection)
{
Matrix m = Matrix.TransformMatrix(new Vector3(radius * 0.25f), new Vector3(), position) *
CameraFacingRotationMatrix(panel, position);
GL.PushMatrix();
GL.MultMatrix((float *)&m);
GL.Color4(selection._hiCirc || selection._snapCirc ? Color.Yellow : Color.Gray);
GL.Begin(PrimitiveType.LineLoop);
GL.Vertex2(-0.5f, -0.5f);
GL.Vertex2(-0.5f, 0.5f);
GL.Vertex2(0.5f, 0.5f);
GL.Vertex2(0.5f, -0.5f);
GL.Vertex2(-0.5f, -0.5f);
GL.End();
GL.PopMatrix();
//Enter local space
m = Matrix.TransformMatrix(new Vector3(radius), new Vector3(), position) * rotation;
GL.PushMatrix();
GL.MultMatrix((float *)&m);
GetTranslationAxes(selection).Call();
GL.PopMatrix();
panel.ScreenText["X"] = panel.Camera.Project(new Vector3(_axisLDist + 0.1f, 0, 0) * m) -
new Vector3(8.0f, 8.0f, 0);
panel.ScreenText["Y"] = panel.Camera.Project(new Vector3(0, _axisLDist + 0.1f, 0) * m) -
new Vector3(8.0f, 8.0f, 0);
panel.ScreenText["Z"] = panel.Camera.Project(new Vector3(0, 0, _axisLDist + 0.1f) * m) -
new Vector3(8.0f, 8.0f, 0);
}
private void topToolStripMenuItem1_Click(object sender, EventArgs e)
{
ModelPanelViewport curViewport = modelPanel.CurrentViewport;
ModelPanelViewport newViewport = ModelPanelViewport.DefaultPerspective;
newViewport.BackgroundColor = curViewport.BackgroundColor;
ModelPanel.AddViewport(newViewport);
float xMin = curViewport.Percentages._x;
float yMin = curViewport.Percentages._y;
float xMax = curViewport.Percentages._z;
float yMax = curViewport.Percentages._w;
float averageY = (yMin + yMax) / 2.0f;
curViewport.SetPercentages(xMin, averageY, xMax, yMax);
newViewport.SetPercentages(xMin, yMin, xMax, averageY);
ModelPanel.Invalidate();
}
protected override void OnMouseDown(MouseEventArgs e)
{
if (!Enabled)
{
return;
}
ModelPanelViewport highlighted = HighlightedViewport;
if (CurrentViewport != highlighted)
{
CurrentViewport = highlighted;
CurrentViewport._lastX = e.X - CurrentViewport.Region.X;
CurrentViewport._lastY = e.Y - CurrentViewport.Region.Y;
}
switch (e.Button)
{
case Forms.MouseButtons.Left:
_mouseDown = true;
if (_dragging.Count > 0 && _viewports.Count > 1)
{
_draggingViewports = true;
}
else
{
CurrentViewport.HandleLeftMouseDown(e);
}
break;
case Forms.MouseButtons.Right:
CurrentViewport._grabbing = true;
break;
case Forms.MouseButtons.Middle:
CurrentViewport._scrolling = true;
break;
}
base.OnMouseDown(e);
}
public virtual void PostRender(IModel model, ModelPanelViewport vp)
{
if (vp._renderAttrib._renderVertices)
{
model.RenderVertices(false, SelectedBone, vp.Camera);
}
if (vp._renderAttrib._renderNormals)
{
model.RenderNormals();
}
if (vp._renderAttrib._renderBones)
{
model.RenderBones(vp);
}
model.RenderBoxes(
vp._renderAttrib._renderModelBox,
vp._renderAttrib._renderObjectBoxes,
vp._renderAttrib._renderBoneBoxes,
vp._renderAttrib._useBindStateBoxes);
}
private bool CompareBoneDistanceRecursive(IBoneNode bone, Vector3 point, ref IBoneNode match,
ModelPanelViewport v, bool doScale)
{
float dist = bone.Matrix.GetPoint().TrueDistance(point) / (doScale ? OrbRadius(bone, v) : 1.0f);
if (Math.Abs(dist - MDL0BoneNode._nodeRadius) < 0.01f)
{
match = bone;
return(true);
}
foreach (IBoneNode b in ((ResourceNode)bone).Children)
{
if (CompareBoneDistanceRecursive(b, point, ref match, v, doScale))
{
return(true);
}
}
return(false);
}
public unsafe void RenderScaleControl(
Vector3 pos,
float radius,
Matrix rotation,
ModelPanelViewport panel,
SelectionParams selection)
{
//Enter local space
Matrix m = Matrix.TransformMatrix(new Vector3(radius), new Vector3(), pos) * rotation;
GL.PushMatrix();
GL.MultMatrix((float *)&m);
GetScaleAxes(selection).Call();
GL.PopMatrix();
panel.ScreenText["X"] = panel.Camera.Project(new Vector3(_axisLDist + 0.1f, 0, 0) * m) - new Vector3(8.0f, 8.0f, 0);
panel.ScreenText["Y"] = panel.Camera.Project(new Vector3(0, _axisLDist + 0.1f, 0) * m) - new Vector3(8.0f, 8.0f, 0);
panel.ScreenText["Z"] = panel.Camera.Project(new Vector3(0, 0, _axisLDist + 0.1f) * m) - new Vector3(8.0f, 8.0f, 0);
}
public ModelPanelViewport AsViewport()
{
ModelPanelViewport v = ModelPanelViewport.DefaultPerspective;
v.Camera = new GLCamera(1, 1, (Vector3)_defaultTranslate, (Vector3)_defaultRotate, (Vector3)_defaultScale)
{
_farZ = _farZ,
_fovY = _fovY,
_nearZ = _nearZ,
_ortho = _ortho,
_restrictXRot = _restrictXRot,
_restrictYRot = _restrictYRot,
_restrictZRot = _restrictZRot,
};
v.SetPercentages(_percentages);
v.LightPosition = _lightPosition;
v.Enabled = _enabled;
v.BackgroundColor = (Color)_backColor;
v.BackgroundImageType = _bgType;
v._allowSelection = _allowSelection;
v._showCamCoords = _showCamCoords;
v._textEnabled = _textEnabled;
v._type = _type;
v._diffuse = _diffuse;
v._ambient = _ambient;
v._emission = _emission;
v._renderAttrib = _renderAttrib;
v._renderFloor = _renderFloor;
v._firstPersonCamera = _firstPersonCamera;
v._rotFactor = _rotFactor;
v._specular = _specular;
v._spotCutoff = _spotCutoff;
v._spotExponent = _spotExponent;
v._transFactor = _transFactor;
v._viewDistance = _viewDistance;
v._zoomFactor = _zoomFactor;
v._lightEnabled = _lightEnabled;
v._renderSCN0Controls = _renderSCN0Controls;
return(v);
}
public void HighlightStuff(MouseEventArgs e, ModelPanel panel)
{
panel.Capture();
_hiX = _hiY = _hiZ = _hiCirc = _hiSphere = false;
float depth = panel.GetDepth(e.X, e.Y);
ModelPanelViewport v = panel.HighlightedViewport;
foreach (var targetFunc in _mouseMoveTargetType)
{
targetFunc(panel, e, depth, v);
}
#if DEBUG
if (_renderDepth)
{
v.ScreenText["Depth: " + depth.ToString()] = new Vector3(5.0f, v.Height - 20.0f, 0.5f);
panel.Invalidate();
}
#endif
}
public void RenderTransformControl(
Vector3 pos,
Matrix rot,
float radius,
ModelPanelViewport panel,
SelectionParams selection)
{
switch (ControlType)
{
case TransformType.Translation:
RenderTranslationControl(pos, radius, rot, panel, selection);
break;
case TransformType.Rotation:
RenderRotationControl(pos, radius, rot, panel, selection);
break;
case TransformType.Scale:
RenderScaleControl(pos, radius, rot, panel, selection);
break;
}
}
public void HighlightStuff(MouseEventArgs e, ModelPanel panel)
{
panel.Capture();
_boneSelection.ResetHighlights();
_vertexSelection.ResetHighlights();
float depth = panel.GetDepth(e.X, e.Y);
ModelPanelViewport v = panel.HighlightedViewport;
foreach (MouseMoveTargetType targetFunc in _mouseMoveTargetType)
{
targetFunc(panel, e, depth, v);
}
#if DEBUG
if (_renderDepth)
{
v.ScreenText["Depth: " + depth.ToString()] = new Vector3(5.0f, v.Height - 20.0f, 0.5f);
panel.Invalidate();
}
#endif
}
public unsafe virtual void modelPanel1_PostRender(ModelPanelViewport vp)
{
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
GL.Disable(EnableCap.Lighting);
if (_targetModels != null)
{
foreach (IModel m in _targetModels)
{
PostRender(m, vp);
}
}
GL.Disable(EnableCap.DepthTest);
if (RenderLightDisplay /* && vp == ModelPanel.CurrentViewport*/)
{
OnRenderLightDisplay(vp);
}
if (TargetAnimType == NW4RAnimType.SCN && vp.RenderSCN0Controls)
{
RenderSCN0Controls(vp);
}
//For now we'll clear the depth buffer bit here.
//We're not using the model depth in any way so it doesn't matter
//The problem with not doing this at the moment is the rotation control clips with the model.
//This is because the rotation axes need to be lequal depth tested against an invisible sphere
//I don't know how to test a sub depth buffer and then always make it pass on the actual buffer
GL.Clear(ClearBufferMask.DepthBufferBit);
RenderTransformControls(vp);
RenderDepth(vp);
}
public void LinkTranslate(ModelPanelViewport control, ModelPanelViewport affected)
{
control.Translated += affected.Translate;
}
public void LinkZoom(ModelPanelViewport control, ModelPanelViewport affected)
{
control.Zoomed += affected.Zoom;
}
public void RenderBrawlStageData(ModelPanelViewport panel)
{
//If you ever make changes to GL attributes (enabled and disabled things)
//and don't want to keep track of what you changed,
//you can push all attributes and then pop them when you're done, like this.
//This will make sure the GL state is back to how it was before you changed it.
GL.PushAttrib(AttribMask.AllAttribBits);
GL.Disable(EnableCap.DepthTest);
if (RenderCollisions)
{
foreach (CollisionNode node in _collisions)
{
node.Render();
}
}
#region RenderOverlays
List <MDL0BoneNode> ItemBones = new List <MDL0BoneNode>();
MDL0Node stgPos = null;
MDL0BoneNode CamBone0 = null, CamBone1 = null,
DeathBone0 = null, DeathBone1 = null;
//Get bones and render spawns if checked
if (_targetModel != null &&
_targetModel is MDL0Node &&
((((ResourceNode)_targetModel).Name.Contains("StgPosition")) ||
((ResourceNode)_targetModel).Name.Contains("stagePosition")))
{
stgPos = _targetModel as MDL0Node;
}
else if (_targetModels != null)
{
stgPos = _targetModels.Find(x => x is MDL0Node &&
((ResourceNode)x).Name.Contains("StgPosition") ||
((ResourceNode)x).Name.Contains("stagePosition")) as MDL0Node;
}
if (stgPos != null)
{
foreach (MDL0BoneNode bone in stgPos._linker.BoneCache)
{
if (bone._name == "CamLimit0N")
{
CamBone0 = bone;
}
else if (bone.Name == "CamLimit1N")
{
CamBone1 = bone;
}
else if (bone.Name == "Dead0N")
{
DeathBone0 = bone;
}
else if (bone.Name == "Dead1N")
{
DeathBone1 = bone;
}
else if (bone._name.Contains("Player") && chkSpawns.Checked)
{
Vector3 position = bone._frameMatrix.GetPoint();
if (PointCollides(position))
{
GL.Color4(0.0f, 1.0f, 0.0f, 0.5f);
}
else
{
GL.Color4(1.0f, 0.0f, 0.0f, 0.5f);
}
TKContext.DrawSphere(position, 5.0f, 32);
}
else if (bone._name.Contains("Rebirth") && chkSpawns.Checked)
{
GL.Color4(1.0f, 1.0f, 1.0f, 0.1f);
TKContext.DrawSphere(bone._frameMatrix.GetPoint(), 5.0f, 32);
}
else if (bone._name.Contains("Item"))
{
ItemBones.Add(bone);
}
}
}
//Render item fields if checked
if (ItemBones != null && chkItems.Checked)
{
GL.Color4(0.5f, 0.0f, 1.0f, 0.4f);
for (int i = 0; i < ItemBones.Count; i += 2)
{
Vector3 pos1 = new Vector3(ItemBones[i]._frameMatrix.GetPoint()._x, ItemBones[i]._frameMatrix.GetPoint()._y + 3.0f, 1.0f);
Vector3 pos2 = new Vector3(ItemBones[i + 1]._frameMatrix.GetPoint()._x, ItemBones[i + 1]._frameMatrix.GetPoint()._y - 3.0f, 1.0f);
TKContext.DrawBox(pos1, pos2);
}
}
//Render boundaries if checked
if (CamBone0 != null && CamBone1 != null && chkBoundaries.Checked)
{
//GL.Clear(ClearBufferMask.DepthBufferBit);
GL.Disable(EnableCap.DepthTest);
GL.Disable(EnableCap.Lighting);
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
GL.Enable(EnableCap.CullFace);
GL.CullFace(CullFaceMode.Front);
GL.Color4(Color.Blue);
GL.Begin(BeginMode.LineLoop);
GL.LineWidth(15.0f);
Vector3
camBone0 = CamBone0._frameMatrix.GetPoint(),
camBone1 = CamBone1._frameMatrix.GetPoint(),
deathBone0 = DeathBone0._frameMatrix.GetPoint(),
deathBone1 = DeathBone1._frameMatrix.GetPoint();
GL.Vertex2(camBone0._x, camBone0._y);
GL.Vertex2(camBone1._x, camBone0._y);
GL.Vertex2(camBone1._x, camBone1._y);
GL.Vertex2(camBone0._x, camBone1._y);
GL.End();
GL.Begin(BeginMode.LineLoop);
GL.Color4(Color.Red);
GL.Vertex2(deathBone0._x, deathBone0._y);
GL.Vertex2(deathBone1._x, deathBone0._y);
GL.Vertex2(deathBone1._x, deathBone1._y);
GL.Vertex2(deathBone0._x, deathBone1._y);
GL.End();
GL.Color4(0.0f, 0.5f, 1.0f, 0.3f);
GL.Begin(BeginMode.TriangleFan);
GL.Vertex2(camBone0._x, camBone0._y);
GL.Vertex2(deathBone0._x, deathBone0._y);
GL.Vertex2(deathBone1._x, deathBone0._y);
GL.Vertex2(camBone1._x, camBone0._y);
GL.End();
GL.Begin(BeginMode.TriangleFan);
GL.Vertex2(camBone1._x, camBone1._y);
GL.Vertex2(deathBone1._x, deathBone1._y);
GL.Vertex2(deathBone0._x, deathBone1._y);
GL.Vertex2(camBone0._x, camBone1._y);
GL.End();
GL.Begin(BeginMode.TriangleFan);
GL.Vertex2(camBone1._x, camBone0._y);
GL.Vertex2(deathBone1._x, deathBone0._y);
GL.Vertex2(deathBone1._x, deathBone1._y);
GL.Vertex2(camBone1._x, camBone1._y);
GL.End();
GL.Begin(BeginMode.TriangleFan);
GL.Vertex2(camBone0._x, camBone1._y);
GL.Vertex2(deathBone0._x, deathBone1._y);
GL.Vertex2(deathBone0._x, deathBone0._y);
GL.Vertex2(camBone0._x, camBone0._y);
GL.End();
}
#endregion
GL.PopAttrib();
}
public unsafe override void modelPanel1_PostRender(ModelPanelViewport panel)
{
RenderBrawlStageData(panel);
base.modelPanel1_PostRender(panel);
}
public void LinkPivot(ModelPanelViewport control, ModelPanelViewport affected)
{
control.Pivoted += affected.Pivot;
}
private void MouseMoveTarget(
ModelPanel panel,
MouseEventArgs e,
float depth,
ModelPanelViewport v,
Matrix transformMatrix,
Matrix invTransformMatrix,
SelectionParams selection)
{
if (ControlType == TransformType.None)
{
return;
}
CoordinateType coord = _coordinateTypes[(int)ControlType];
//Get the location of the bone
Vector3 center = transformMatrix.GetPoint();
//Standard radius scaling snippet. This is used for orb scaling depending on camera distance.
float radius = CamDistance(center, v);
bool snapFound = false;
if (ControlType == TransformType.Rotation)
{
//Get point projected onto our orb.
Vector3 point = v.ProjectCameraSphere(new Vector2(e.X, e.Y), center, radius, false);
//Get the distance of the mouse point from the bone
float distance = point.TrueDistance(center);
if (Math.Abs(distance - radius) < (radius * _selectOrbScale)) //Point lies within orb radius
{
selection._hiSphere = true;
//Determine axis snapping
Vector3 angles = (invTransformMatrix * point).GetAngles() * Maths._rad2degf;
angles._x = (float)Math.Abs(angles._x);
angles._y = (float)Math.Abs(angles._y);
angles._z = (float)Math.Abs(angles._z);
if (Math.Abs(angles._y - 90.0f) <= _axisSnapRange)
{
selection._hiX = true;
}
else if (angles._x >= (180.0f - _axisSnapRange) || angles._x <= _axisSnapRange)
{
selection._hiY = true;
}
else if (angles._y >= (180.0f - _axisSnapRange) || angles._y <= _axisSnapRange)
{
selection._hiZ = true;
}
}
else if (Math.Abs(distance - (radius * _circOrbScale)) < (radius * _selectOrbScale)) //Point lies on circ line
{
selection._hiCirc = true;
}
if (selection._hiX || selection._hiY || selection._hiZ || selection._hiCirc)
{
snapFound = true;
}
}
else if (ControlType == TransformType.Translation || ControlType == TransformType.Scale)
{
//No more need to use depth!!! Just some nice math
if (_coordinateTypes[(int)ControlType] == CoordinateType.World)
{
transformMatrix = Matrix.TranslationMatrix(center) * Matrix.ScaleMatrix(transformMatrix.GetScale());
}
Vector3[] planePoints = new Vector3[3]; //xy, yz, xz
v.ProjectCameraPlanes(new Vector2(e.X, e.Y), transformMatrix,
out planePoints[0], out planePoints[1], out planePoints[2]);
List <Vector3> testDiffs = new List <Vector3>();
foreach (Vector3 planePoint in planePoints)
{
Vector3 d =
coord == CoordinateType.World ? (planePoint - center) / radius :
coord == CoordinateType.Local ? (invTransformMatrix * planePoint) / radius :
(panel.Camera._matrix * planePoint - panel.Camera._matrix * center) / radius;
if (d._x > -_axisSelectRange && d._x < (_axisLDist + 0.01f) &&
d._y > -_axisSelectRange && d._y < (_axisLDist + 0.01f) &&
d._z > -_axisSelectRange && d._z < (_axisLDist + 0.01f))
{
testDiffs.Add(d);
}
}
//Check if point lies on a specific axis
foreach (Vector3 diff in testDiffs)
{
float errorRange = _axisSelectRange;
if (diff._x > _axisHalfLDist &&
Math.Abs(diff._y) < errorRange &&
Math.Abs(diff._z) < errorRange)
{
selection._hiX = true;
}
if (diff._y > _axisHalfLDist &&
Math.Abs(diff._x) < errorRange &&
Math.Abs(diff._z) < errorRange)
{
selection._hiY = true;
}
if (diff._z > _axisHalfLDist &&
Math.Abs(diff._x) < errorRange &&
Math.Abs(diff._y) < errorRange)
{
selection._hiZ = true;
}
if (snapFound = selection._hiX || selection._hiY || selection._hiZ)
{
break;
}
}
if (!snapFound)
{
foreach (Vector3 diff in testDiffs)
{
if (ControlType == TransformType.Translation)
{
if (diff._x < _axisHalfLDist &&
diff._y < _axisHalfLDist &&
diff._z < _axisHalfLDist)
{
//Point lies inside the double drag areas
if (diff._x > _axisSelectRange)
{
selection._hiX = true;
}
if (diff._y > _axisSelectRange)
{
selection._hiY = true;
}
if (diff._z > _axisSelectRange)
{
selection._hiZ = true;
}
selection._hiCirc =
!selection._hiX &&
!selection._hiY &&
!selection._hiZ;
snapFound = true;
}
}
else if (ControlType == TransformType.Scale)
{
//Determine if the point is in the double or triple drag triangles
float halfDist = _scaleHalf2LDist;
float centerDist = _scaleHalf1LDist;
if (diff.IsInTriangle(new Vector3(), new Vector3(halfDist, 0, 0), new Vector3(0, halfDist, 0)))
{
if (diff.IsInTriangle(new Vector3(), new Vector3(centerDist, 0, 0), new Vector3(0, centerDist, 0)))
{
selection._hiX = selection._hiY = selection._hiZ = true;
}
else
{
selection._hiX = selection._hiY = true;
}
}
else if (diff.IsInTriangle(new Vector3(), new Vector3(halfDist, 0, 0), new Vector3(0, 0, halfDist)))
{
if (diff.IsInTriangle(new Vector3(), new Vector3(centerDist, 0, 0), new Vector3(0, 0, centerDist)))
{
selection._hiX = selection._hiY = selection._hiZ = true;
}
else
{
selection._hiX = selection._hiZ = true;
}
}
else if (diff.IsInTriangle(new Vector3(), new Vector3(0, halfDist, 0), new Vector3(0, 0, halfDist)))
{
if (diff.IsInTriangle(new Vector3(), new Vector3(0, centerDist, 0), new Vector3(0, 0, centerDist)))
{
selection._hiX = selection._hiY = selection._hiZ = true;
}
else
{
selection._hiY = selection._hiZ = true;
}
}
snapFound = selection._hiX || selection._hiY || selection._hiZ;
}
if (snapFound)
{
break;
}
}
}
}
if (snapFound)
{
panel.Cursor = Cursors.Hand;
panel.Invalidate();
}
}
public void LinkScale(ModelPanelViewport control, ModelPanelViewport affected)
{
control.Scaled += affected.Scale;
}
public void LinkRotate(ModelPanelViewport control, ModelPanelViewport affected)
{
control.Rotated += affected.Rotate;
}
private void GetBone(ModelPanel panel, MouseEventArgs e, float depth, ModelPanelViewport v)
{
if (!_boneSelection.IsMoving() && depth < 1.0f)
{
IBoneNode o = null;
Vector3 point = v.UnProject(e.X, e.Y, depth);
bool doScale = v._renderAttrib._scaleBones;
//Find orb near chosen point
if (EditingAll)
{
foreach (IModel m in _targetModels)
{
foreach (IBoneNode b in m.RootBones)
{
if (CompareBoneDistanceRecursive(b, point, ref o, v, doScale))
{
break;
}
}
}
}
else if (_targetModel != null)
{
foreach (IBoneNode b in _targetModel.RootBones)
{
if (CompareBoneDistanceRecursive(b, point, ref o, v, doScale))
{
break;
}
}
}
bool update = false;
if (_hiBone != null && _hiBone != SelectedBone && (update = _hiBone.NodeColor != Color.Transparent))
{
_hiBone.NodeColor = Color.Transparent;
}
if ((_hiBone = o) != null)
{
_hiBone.NodeColor = Color.FromArgb(255, 128, 0);
panel.Cursor = Cursors.Hand;
update = true;
}
if (update)
{
panel.Invalidate();
}
}
else if (_hiBone != null)
{
if (_hiBone != SelectedBone)
{
_hiBone.NodeColor = Color.Transparent;
panel.Invalidate();
}
_hiBone = null;
}
}
private void modelPanel_OnCurrentViewportChanged(GLViewport p)
{
ModelPanelViewport v = p as ModelPanelViewport;
stretchToolStripMenuItem1.Checked = p.BackgroundImageType == BGImageType.Stretch;
centerToolStripMenuItem1.Checked = p.BackgroundImageType == BGImageType.Center;
resizeToolStripMenuItem1.Checked = p.BackgroundImageType == BGImageType.ResizeWithBars;
bool camDefaultSet =
p.Camera._defaultRotate != p.GetDefaultRotate() ||
p.Camera._defaultScale != p.GetDefaultScale() ||
p.Camera._defaultTranslate != new Vector3();
btnSaveCam.Text = camDefaultSet ? "Clear Camera" : "Save Camera";
modelPanel_RenderBonesChanged(ModelPanel, v.RenderBones);
modelPanel_RenderFloorChanged(ModelPanel, v.RenderFloor);
modelPanel_RenderModelBoxChanged(ModelPanel, v.RenderModelBox);
modelPanel_RenderNormalsChanged(ModelPanel, v.RenderNormals);
modelPanel_RenderObjectBoxChanged(ModelPanel, v.RenderObjectBox);
modelPanel_RenderOffscreenChanged(ModelPanel, v.DontRenderOffscreen);
ModelPanel_RenderPolygonsChanged(ModelPanel, v.RenderPolygons);
ModelPanel_RenderVerticesChanged(ModelPanel, v.RenderVertices);
modelPanel_RenderVisBoneBoxChanged(ModelPanel, v.RenderVisBoneBox);
ModelPanel_RenderWireframeChanged(ModelPanel, v.RenderWireframe);
ModelPanel_ScaleBonesChanged(ModelPanel, v.ScaleBones);
ModelPanel_ApplyBillboardBonesChanged(ModelPanel, v.ApplyBillboardBones);
modelPanel_FirstPersonCameraChanged(ModelPanel, v._firstPersonCamera);
ModelPanel_RenderShadersChanged(ModelPanel, v._renderAttrib._renderShaders);
ModelPanel_UseBindStateBoxesChanged(ModelPanel, v.UseBindStateBoxes);
sCN0ToolStripMenuItem.Checked = v.RenderSCN0Controls;
_currentProjBox.Checked = false;
switch (p.ViewType)
{
case ViewportProjection.Perspective:
_currentProjBox = perspectiveToolStripMenuItem; break;
case ViewportProjection.Orthographic:
_currentProjBox = orthographicToolStripMenuItem; break;
case ViewportProjection.Top:
_currentProjBox = topToolStripMenuItem; break;
case ViewportProjection.Bottom:
_currentProjBox = bottomToolStripMenuItem; break;
case ViewportProjection.Left:
_currentProjBox = leftToolStripMenuItem; break;
case ViewportProjection.Right:
_currentProjBox = rightToolStripMenuItem; break;
case ViewportProjection.Front:
_currentProjBox = frontToolStripMenuItem; break;
case ViewportProjection.Back:
_currentProjBox = backToolStripMenuItem; break;
}
_currentProjBox.Checked = true;
showCameraCoordinatesToolStripMenuItem.Checked = v._showCamCoords;
loadImageToolStripMenuItem.Text = v.BackgroundImage == null ? "Load Image" : "Clear Image";
}
private void GetVertex(ModelPanel panel, MouseEventArgs e, float depth, ModelPanelViewport v)
{
//Try targeting a vertex
if (RenderVertices)
{
if (panel.CurrentViewport.Selecting)
{
if (NotCtrlAlt)
{
ClearSelectedVertices();
}
bool selected = false;
if (TargetModel != null)
{
if (TargetModel.SelectedObjectIndex < 0)
{
foreach (IObject o in TargetModel.Objects)
{
if (o.IsRendering)
{
SelectVertices(o, panel);
selected = true;
}
}
}
else
{
IObject w = TargetModel.Objects[TargetModel.SelectedObjectIndex];
if (w.IsRendering)
{
SelectVertices(w, panel);
selected = true;
}
else
{
foreach (IObject h in TargetModel.Objects)
{
if (h.IsRendering)
{
SelectVertices(h, panel);
selected = true;
}
}
}
}
}
else if (_targetModels != null)
{
foreach (IModel m in _targetModels)
{
if (m.SelectedObjectIndex < 0)
{
foreach (IObject o in m.Objects)
{
if (o.IsRendering)
{
SelectVertices(o, panel);
selected = true;
}
}
}
else
{
IObject w = m.Objects[m.SelectedObjectIndex];
if (w.IsRendering)
{
SelectVertices(w, panel);
selected = true;
}
else
{
foreach (IObject h in m.Objects)
{
if (h.IsRendering)
{
SelectVertices(h, panel);
selected = true;
}
}
}
}
}
}
if (selected)
{
OnSelectedVerticesChanged();
}
}
else
{
if (depth < 1.0f && _targetModel != null)
{
Vector3 point = v.UnProject(e.X, e.Y, depth);
Vertex3 vertex = CompareVertexDistance(point);
bool update = false;
if (_hiVertex != null && !_hiVertex._selected)
{
update = true;
_hiVertex._highlightColor = Color.Transparent;
ModelPanel.CurrentViewport.AllowSelection = true;
}
if ((_hiVertex = vertex) != null)
{
update = true;
_hiVertex._highlightColor = Color.Orange;
panel.Cursor = Cursors.Cross;
ModelPanel.CurrentViewport.AllowSelection = false;
}
if (update)
{
panel.Invalidate();
}
}
else if (_hiVertex != null)
{
if (!_hiVertex._selected)
{
_hiVertex._highlightColor = Color.Transparent;
ModelPanel.CurrentViewport.AllowSelection = true;
panel.Invalidate();
}
_hiVertex = null;
}
}
}
}