virtual protected void make_materials()
{
float fAlpha = 0.5f;
srcMaterial = MaterialUtil.CreateTransparentMaterial(ColorUtil.CgRed, fAlpha);
srcHoverMaterial = MaterialUtil.CreateStandardMaterial(ColorUtil.CgRed);
}
public FScene(FContext context)
{
this.context = context;
history = new ChangeHistory();
history_stack = new List <ChangeHistory>();
TypeRegistry = new SORegistry();
initialize_scene_root();
// initialize materials
DefaultSOMaterial = new SOMaterial()
{
Name = "DefaultSO",
Type = SOMaterial.MaterialType.StandardRGBColor, RGBColor = ColorUtil.StandardBeige
};
DefaultCurveSOMaterial = new SOMaterial()
{
Name = "DefaultCurveSO",
Type = SOMaterial.MaterialType.UnlitRGBColor, RGBColor = Colorf.DarkSlateGrey
};
DefaultMeshSOMaterial = new SOMaterial()
{
Name = "DefaultMeshSO",
Type = SOMaterial.MaterialType.PerVertexColor, RGBColor = Colorf.White
};
NewSOMaterial = new SOMaterial()
{
Name = "NewSO",
Type = SOMaterial.MaterialType.StandardRGBColor, RGBColor = Colorf.CornflowerBlue
};
TransparentNewSOMaterial = new SOMaterial()
{
Name = "NewSO",
Type = SOMaterial.MaterialType.TransparentRGBColor, RGBColor = new Colorf(Colorf.CornflowerBlue, 0.5f)
};
PivotSOMaterial = new SOMaterial()
{
Name = "PivotSO",
Type = SOMaterial.MaterialType.TransparentRGBColor, RGBColor = ColorUtil.PivotYellow.SetAlpha(0.75f)
};
FrameSOMaterial = new SOMaterial()
{
Name = "PivotFrame",
Type = SOMaterial.MaterialType.StandardRGBColor, RGBColor = ColorUtil.DarkGrey
};
SelectedMaterial = MaterialUtil.CreateStandardMaterial(ColorUtil.SelectionGold);
FrameMaterial = MaterialUtil.CreateStandardMaterial(ColorUtil.DarkGrey);
PivotMaterial = MaterialUtil.ToMaterialf(PivotSOMaterial);
defaultPrimitiveType = SOTypes.Cylinder;
}
public Scene()
{
vObjects = new List <SceneObject> ();
vSelected = new List <SceneObject> ();
vUIElements = new List <SceneUIElement> ();
vBoundsObjects = new List <GameObject> ();
sceneo = new GameObject("Scene");
// initialize materials
defaultMaterial = MaterialUtil.CreateStandardMaterial(new Color(0.75f, 0.75f, 0.5f));
selectedMaterial = MaterialUtil.CreateStandardMaterial(new Color(1.0f, 0.6f, 0.05f));
}
public void Initialize(Cockpit cockpit)
{
Frame3 cockpitF = cockpit.GetLocalFrame(CoordSpace.WorldCoords);
float fHUDRadius = 0.7f;
Color bgColor = new Color(0.7f, 0.7f, 1.0f);
Material bgMaterial = MaterialUtil.CreateTransparentMaterial(bgColor, 0.7f);
Material primMaterial = MaterialUtil.CreateStandardMaterial(Color.yellow);
HUDButton addCylinderButton = new HUDButton()
{
Radius = 0.08f
};
addCylinderButton.Create(PrimitiveType.Cylinder, bgMaterial, primMaterial);
Frame3 cylFrame = addCylinderButton.GetObjectFrame();
Frame3 cylHUDFrame = make_hud_sphere_frame(fHUDRadius, -45.0f, 0.0f);
addCylinderButton.SetObjectFrame(
cylFrame.Translated(cylHUDFrame.Origin)
.Rotated(Quaternion.FromToRotation(cylFrame.Z, cylHUDFrame.Z)));
addCylinderButton.OnClicked += (s, e) => {
cockpit.Parent.Scene.AddCylinder();
};
cockpit.AddUIElement(addCylinderButton, true);
HUDButton addBoxButton = new HUDButton()
{
Radius = 0.08f
};
addBoxButton.Create(PrimitiveType.Cube, bgMaterial, primMaterial);
Frame3 boxFrame = addBoxButton.GetObjectFrame();
Frame3 boxHUDFrame = make_hud_sphere_frame(fHUDRadius, -45.0f, -15.0f);
addBoxButton.SetObjectFrame(
boxFrame.Translated(boxHUDFrame.Origin)
.Rotated(Quaternion.FromToRotation(boxFrame.Z, boxHUDFrame.Z)));
addBoxButton.OnClicked += (s, e) => {
cockpit.Parent.Scene.AddBox();
};
cockpit.AddUIElement(addBoxButton, true);
}
public static HUDButton CreateMeshClickButton(
Mesh mesh, Color color, float fMeshScale, Quaternion meshRotation,
float fHUDRadius, float fAngleHorz, float fAngleVert,
IGameObjectGenerator addGeometry = null)
{
Material mat = (color.a < 1.0f) ?
MaterialUtil.CreateTransparentMaterial(color, color.a) :
MaterialUtil.CreateStandardMaterial(color);
HUDButton button = new HUDButton();
button.Create(mesh, mat, fMeshScale, meshRotation);
if (addGeometry != null)
{
button.AddVisualElements(addGeometry.Generate(), true);
}
HUDUtil.PlaceInSphere(button, fHUDRadius, fAngleHorz, fAngleVert);
return(button);
}
public static HUDButton CreateGeometryIconClickButton(HUDShape shape,
float fHUDRadius, float fAngleHorz, float fAngleVert,
Color bgColor,
IGameObjectGenerator addGeometry = null)
{
Material mat = (bgColor.a == 1.0f) ?
MaterialUtil.CreateStandardMaterial(bgColor) : MaterialUtil.CreateTransparentMaterial(bgColor);
HUDButton button = new HUDButton()
{
Shape = shape
};
button.Create(mat);
if (addGeometry != null)
{
button.AddVisualElements(addGeometry.Generate(), true);
}
HUDUtil.PlaceInSphere(button, fHUDRadius, fAngleHorz, fAngleVert);
return(button);
}
public List <fGameObject> Generate()
{
fMesh mesh = FResources.LoadMesh(Path);
fMeshGameObject fMeshGO = GameObjectFactory.CreateMeshGO("iconMesh", mesh, false, true);
fMeshGO.SetMaterial(MaterialUtil.CreateStandardMaterial(this.Color), true);
// apply orientation
fMeshGO.SetLocalScale(new Vector3f(Scale, Scale, Scale));
fMeshGO.SetLocalPosition(fMeshGO.GetLocalPosition() + Translate);
fMeshGO.SetLocalRotation(Rotate);
// ignore material changes when we add to GameObjectSet
fMeshGO.AddComponent <IgnoreMaterialChanges>();
return(new List <fGameObject>()
{
fMeshGO
});
}
public static HUDButton CreateMeshClickButton(
Mesh mesh, Color color, float fMeshScale, Quaternion meshRotation,
HUDSurface hudSurf, float dx, float dy,
IGameObjectGenerator addGeometry = null)
{
Material mat = (color.a < 1.0f) ?
MaterialUtil.CreateTransparentMaterial(color, color.a) :
MaterialUtil.CreateStandardMaterial(color);
HUDButton button = new HUDButton();
button.Create(mesh, mat, fMeshScale, meshRotation);
if (addGeometry != null)
{
button.AddVisualElements(addGeometry.Generate(), true);
}
hudSurf.Place(button, dx, dy);
return(button);
}
public static GameObject CreateMeshGO(string name, Mesh mesh,
Material setMaterial = null, bool bCollider = true)
{
var gameObj = new GameObject(name);
gameObj.AddComponent <MeshFilter>();
gameObj.SetMesh(mesh);
if (bCollider)
{
gameObj.AddComponent(typeof(MeshCollider));
gameObj.GetComponent <MeshCollider>().enabled = false;
}
if (setMaterial)
{
(gameObj.AddComponent(typeof(MeshRenderer)) as MeshRenderer).material = setMaterial;
}
else
{
(gameObj.AddComponent(typeof(MeshRenderer)) as MeshRenderer).material =
MaterialUtil.CreateStandardMaterial(Color.red);
}
return(gameObj);
}
// creates a button with a floating primitive in front of the button shape
public void CreateMeshIconButton(float fRadius, string sMeshPath, Material bgMaterial,
float fMeshScaleFudge)
{
Shape = new HUDShape(HUDShapeType.Disc, fRadius);
fMesh iconmesh = null;
Material meshMaterial = null;
try {
iconmesh = FResources.LoadMesh(sMeshPath);
meshMaterial = MaterialUtil.CreateStandardVertexColorMaterial(Color.white);
} catch { }
if (iconmesh == null)
{
iconmesh = UnityUtil.GetPrimitiveMesh(PrimitiveType.Sphere);
meshMaterial = MaterialUtil.CreateStandardMaterial(Color.red);
}
float fMeshRadius = fRadius * fMeshScaleFudge;
base.Create(bgMaterial, iconmesh, meshMaterial, fMeshRadius,
Frame3f.Identity.Translated(-fMeshRadius * 0.25f, 2).Rotated(-15.0f, 1));
}
public List <GameObject> Generate()
{
var gameObj = new GameObject("iconMesh");
var gameObjMesh = (MeshFilter)gameObj.AddComponent(typeof(MeshFilter));
gameObj.SetMesh((Mesh)Resources.Load(Path, typeof(Mesh)));
MeshRenderer ren = gameObj.AddComponent <MeshRenderer>();
ren.material = MaterialUtil.CreateStandardMaterial(this.Color);
// apply orientation
gameObjMesh.transform.localScale = new Vector3(Scale, Scale, Scale);
gameObjMesh.transform.localPosition += Translate;
gameObjMesh.transform.localRotation = Rotate;
// ignore material changes when we add to GameObjectSet
gameObj.AddComponent <IgnoreMaterialChanges>();
return(new List <GameObject>()
{
gameObj
});
}
public static Material ToUnityMaterial(SOMaterial m)
{
if (m.Type == SOMaterial.MaterialType.TextureMap)
{
Material unityMat = new Material(Shader.Find("Standard"));
unityMat.SetName(m.Name);
unityMat.color = m.RGBColor;
//if (m.Alpha < 1.0f)
// MaterialUtil.SetupMaterialWithBlendMode(unityMat, MaterialUtil.BlendMode.Transparent);
unityMat.mainTexture = m.MainTexture;
return(unityMat);
}
else if (m.Type == SOMaterial.MaterialType.PerVertexColor)
{
return(MaterialUtil.CreateStandardVertexColorMaterial(m.RGBColor));
}
else if (m.Type == SOMaterial.MaterialType.TransparentRGBColor)
{
return(MaterialUtil.CreateTransparentMaterial(m.RGBColor));
}
else if (m.Type == SOMaterial.MaterialType.StandardRGBColor)
{
return(MaterialUtil.CreateStandardMaterial(m.RGBColor));
}
else if (m.Type == SOMaterial.MaterialType.UnlitRGBColor)
{
return(MaterialUtil.CreateFlatMaterial(m.RGBColor));
}
else if (m is UnitySOMaterial)
{
return((m as UnitySOMaterial).unityMaterial);
}
else
{
return(MaterialUtil.CreateStandardMaterial(Color.black));
}
}
// Use this for initialization
public void Start()
{
fCursorSpeedNormalization = 1.0f;
fCurPlaneX = 0;
fCurPlaneY = 0;
vPlaneCursorPos = Vector3.zero;
vSceneCursorPos = vPlaneCursorPos;
CursorDefaultMaterial = MaterialUtil.CreateTransparentMaterial(Color.grey, 0.6f);
//CursorHitMaterial = MaterialUtil.CreateTransparentMaterial (Color.yellow, 0.8f);
CursorHitMaterial = MaterialUtil.CreateStandardMaterial(Color.yellow);
CursorCapturingMaterial = MaterialUtil.CreateTransparentMaterial(Color.yellow, 0.75f);
CursorVisualAngleInDegrees = 1.5f;
standardCursorMesh = MeshGenerators.Create3DArrow(1.0f, 1.0f, 1.0f, 0.5f, 16);
UnityUtil.TranslateMesh(standardCursorMesh, 0, -2.0f, 0);
activeToolCursorMesh = MeshGenerators.Create3DArrow(1.0f, 1.0f, 1.0f, 1.0f, 16);
UnityUtil.TranslateMesh(activeToolCursorMesh, 0, -2.0f, 0);
Cursor = UnityUtil.CreateMeshGO("cursor", standardCursorMesh, CursorDefaultMaterial);
Cursor.SetSharedMesh(standardCursorMesh);
Cursor.transform.localScale = new Vector3(0.3f, 0.3f, 0.3f);
Cursor.transform.localRotation = Quaternion.AngleAxis(45.0f, new Vector3(1, 0, 1).normalized);
MaterialUtil.DisableShadows(Cursor);
xformObject = GameObject.CreatePrimitive(PrimitiveType.Plane);
xformObject.SetName("cursor_plane");
MaterialUtil.DisableShadows(xformObject);
xformObject.GetComponent <MeshRenderer>().material
= MaterialUtil.CreateTransparentMaterial(Color.cyan, 0.2f);
xformObject.GetComponent <MeshRenderer>().enabled = false;
lastMouseEventTime = FPlatform.RealTime();
mouseInactiveState = false;
}
public void Create(FScene parentScene, List <TransformableSO> targets)
{
this.parentScene = parentScene;
this.targets = targets;
gizmo = new GameObject("TransformGizmo");
float fAlpha = 0.5f;
xMaterial = MaterialUtil.CreateTransparentMaterial(Color.red, fAlpha);
yMaterial = MaterialUtil.CreateTransparentMaterial(Color.green, fAlpha);
zMaterial = MaterialUtil.CreateTransparentMaterial(Color.blue, fAlpha);
xHoverMaterial = MaterialUtil.CreateStandardMaterial(Color.red);
yHoverMaterial = MaterialUtil.CreateStandardMaterial(Color.green);
zHoverMaterial = MaterialUtil.CreateStandardMaterial(Color.blue);
allMaterial = MaterialUtil.CreateTransparentMaterial(Color.white, fAlpha);
allHoverMaterial = MaterialUtil.CreateStandardMaterial(Color.white);
x = AppendMeshGO("x_translate",
(Mesh)Resources.Load("transform_gizmo/axis_translate_x", typeof(Mesh)),
xMaterial, gizmo);
Widgets[x] = new AxisTranslationWidget(0)
{
RootGameObject = x, StandardMaterial = xMaterial, HoverMaterial = xHoverMaterial,
TranslationScaleF = () => { return(1.0f / parentScene.GetSceneScale()); }
};
y = AppendMeshGO("y_translate",
(Mesh)Resources.Load("transform_gizmo/axis_translate_y", typeof(Mesh)),
yMaterial, gizmo);
Widgets [y] = new AxisTranslationWidget(1)
{
RootGameObject = y, StandardMaterial = yMaterial, HoverMaterial = yHoverMaterial,
TranslationScaleF = () => { return(1.0f / parentScene.GetSceneScale()); }
};
z = AppendMeshGO("z_translate",
(Mesh)Resources.Load("transform_gizmo/axis_translate_z", typeof(Mesh)),
zMaterial, gizmo);
Widgets [z] = new AxisTranslationWidget(2)
{
RootGameObject = z, StandardMaterial = zMaterial, HoverMaterial = zHoverMaterial,
TranslationScaleF = () => { return(1.0f / parentScene.GetSceneScale()); }
};
rotate_x = AppendMeshGO("x_rotate",
(Mesh)Resources.Load("transform_gizmo/axisrotate_x", typeof(Mesh)),
xMaterial, gizmo);
Widgets [rotate_x] = new AxisRotationWidget(0)
{
RootGameObject = rotate_x, StandardMaterial = xMaterial, HoverMaterial = xHoverMaterial
};
rotate_y = AppendMeshGO("y_rotate",
(Mesh)Resources.Load("transform_gizmo/axisrotate_y", typeof(Mesh)),
yMaterial, gizmo);
Widgets [rotate_y] = new AxisRotationWidget(1)
{
RootGameObject = rotate_y, StandardMaterial = yMaterial, HoverMaterial = yHoverMaterial
};
rotate_z = AppendMeshGO("z_rotate",
(Mesh)Resources.Load("transform_gizmo/axisrotate_z", typeof(Mesh)),
zMaterial, gizmo);
Widgets [rotate_z] = new AxisRotationWidget(2)
{
RootGameObject = rotate_z, StandardMaterial = zMaterial, HoverMaterial = zHoverMaterial
};
// plane translation widgets
translate_xy = AppendMeshGO("xy_translate",
(Mesh)Resources.Load("transform_gizmo/plane_translate_xy", typeof(Mesh)),
zMaterial, gizmo);
Widgets [translate_xy] = new PlaneTranslationWidget(2)
{
RootGameObject = translate_xy, StandardMaterial = zMaterial, HoverMaterial = zHoverMaterial,
TranslationScaleF = () => { return(1.0f / parentScene.GetSceneScale()); }
};
translate_xz = AppendMeshGO("xz_translate",
(Mesh)Resources.Load("transform_gizmo/plane_translate_xz", typeof(Mesh)),
yMaterial, gizmo);
Widgets [translate_xz] = new PlaneTranslationWidget(1)
{
RootGameObject = translate_xz, StandardMaterial = yMaterial, HoverMaterial = yHoverMaterial,
TranslationScaleF = () => { return(1.0f / parentScene.GetSceneScale()); }
};
translate_yz = AppendMeshGO("yz_translate",
(Mesh)Resources.Load("transform_gizmo/plane_translate_yz", typeof(Mesh)),
xMaterial, gizmo);
Widgets [translate_yz] = new PlaneTranslationWidget(0)
{
RootGameObject = translate_yz, StandardMaterial = xMaterial, HoverMaterial = xHoverMaterial,
TranslationScaleF = () => { return(1.0f / parentScene.GetSceneScale()); }
};
uniform_scale = AppendMeshGO("uniform_scale",
Resources.Load <Mesh>("transform_gizmo/uniform_scale"), allMaterial, gizmo);
Widgets[uniform_scale] = new UniformScaleWidget(parentScene.ActiveCamera)
{
RootGameObject = uniform_scale, StandardMaterial = allMaterial, HoverMaterial = allHoverMaterial,
ScaleMultiplierF = () => { return(1.0f / parentScene.GetSceneScale()); }
};
gizmoGeomBounds = UnityUtil.GetGeometryBoundingBox(new List <GameObject>()
{
x, y, z, rotate_x, rotate_y, rotate_z, translate_xy, translate_xz, translate_yz, uniform_scale
});
// disable shadows on widget components
foreach (var go in GameObjects)
{
MaterialUtil.DisableShadows(go);
}
eCurrentFrameMode = FrameType.LocalFrame;
SetActiveFrame(eCurrentFrameMode);
SetLayer(FPlatform.WidgetOverlayLayer);
// seems like possibly this geometry will be shown this frame, before PreRender()
// is called, which means that on next frame the geometry will pop.
// So we hide here and show in PreRender
gizmo.Hide();
}
public FScene(FContext context)
{
this.context = context;
history = new ChangeHistory();
TypeRegistry = new SORegistry();
vObjects = new List <SceneObject>();
vSelected = new List <SceneObject>();
vUIElements = new List <SceneUIElement>();
vBoundsObjects = new List <fGameObject>();
ObjectAnimator = new GenericAnimator();
LinkManager = new SOLinkManager(this);
sceneRoot = GameObjectFactory.CreateParentGO("Scene");
// for animation playbacks
sceneRoot.AddComponent <SceneAnimator>().Scene = this;
sceneRoot.AddComponent <UnityPerFrameAnimationBehavior>().Animator = ObjectAnimator;
scene_objects = GameObjectFactory.CreateParentGO("scene_objects");
sceneRoot.AddChild(scene_objects, false);
deleted_objects = GameObjectFactory.CreateParentGO("deleted_objects");
sceneRoot.AddChild(deleted_objects, false);
vDeleted = new List <SceneObject>();
// initialize materials
DefaultSOMaterial = new SOMaterial()
{
Name = "DefaultSO",
Type = SOMaterial.MaterialType.StandardRGBColor, RGBColor = ColorUtil.StandardBeige
};
DefaultCurveSOMaterial = new SOMaterial()
{
Name = "DefaultCurveSO",
Type = SOMaterial.MaterialType.UnlitRGBColor, RGBColor = Colorf.DarkSlateGrey
};
DefaultMeshSOMaterial = new SOMaterial()
{
Name = "DefaultMeshSO",
Type = SOMaterial.MaterialType.PerVertexColor, RGBColor = Colorf.White
};
NewSOMaterial = new SOMaterial()
{
Name = "NewSO",
Type = SOMaterial.MaterialType.StandardRGBColor, RGBColor = Colorf.CornflowerBlue
};
TransparentNewSOMaterial = new SOMaterial()
{
Name = "NewSO",
Type = SOMaterial.MaterialType.TransparentRGBColor, RGBColor = new Colorf(Colorf.CornflowerBlue, 0.5f)
};
PivotSOMaterial = new SOMaterial()
{
Name = "PivotSO",
Type = SOMaterial.MaterialType.TransparentRGBColor, RGBColor = ColorUtil.PivotYellow.SetAlpha(0.75f)
};
FrameSOMaterial = new SOMaterial()
{
Name = "PivotFrame",
Type = SOMaterial.MaterialType.StandardRGBColor, RGBColor = ColorUtil.DarkGrey
};
SelectedMaterial = MaterialUtil.CreateStandardMaterial(ColorUtil.SelectionGold);
FrameMaterial = MaterialUtil.CreateStandardMaterial(ColorUtil.DarkGrey);
PivotMaterial = MaterialUtil.ToUnityMaterial(PivotSOMaterial);
defaultPrimitiveType = SOTypes.Cylinder;
}
public void Create(Cockpit cockpit)
{
base.Create();
this.cockpit = cockpit;
float fHUDRadius = 0.7f;
float fButtonRadius = 0.06f;
Colorf bgColor = new Color(0.7f, 0.7f, 1.0f, 0.7f);
Colorf activeColor = new Colorf(ColorUtil.SelectionGold, 0.7f);
defaultMaterial = (bgColor.a == 1.0f) ?
MaterialUtil.CreateStandardMaterialF(bgColor) : MaterialUtil.CreateTransparentMaterialF(bgColor);
activeMaterial = (activeColor.a == 1.0f) ?
MaterialUtil.CreateStandardMaterialF(activeColor) : MaterialUtil.CreateTransparentMaterialF(activeColor);
List <toolInfo> toolNames = new List <toolInfo>()
{
new toolInfo()
{
identifier = "cancel", sMeshPath = "tool_icons/cancel", fMeshScaleFudge = 1.2f
},
new toolInfo()
{
identifier = SnapDrawPrimitivesTool.Identifier, sMeshPath = "tool_icons/draw_primitive", fMeshScaleFudge = 1.2f
},
new toolInfo()
{
identifier = DrawTubeTool.Identifier, sMeshPath = "tool_icons/draw_tube", fMeshScaleFudge = 1.2f
},
new toolInfo()
{
identifier = DrawCurveTool.Identifier, sMeshPath = "tool_icons/draw_curve", fMeshScaleFudge = 1.2f
},
new toolInfo()
{
identifier = DrawSurfaceCurveTool.Identifier, sMeshPath = "tool_icons/draw_surface_curve", fMeshScaleFudge = 1.2f
},
new toolInfo()
{
identifier = RevolveTool.Identifier, sMeshPath = "tool_icons/revolve", fMeshScaleFudge = 1.2f
},
new toolInfo()
{
identifier = TwoPointMeasureTool.Identifier, sMeshPath = "tool_icons/measure", fMeshScaleFudge = 1.2f
},
new toolInfo()
{
identifier = SculptCurveTool.Identifier, sMeshPath = "tool_icons/sculpt_curve", fMeshScaleFudge = 1.2f
},
new toolInfo()
{
identifier = PlaneCutTool.Identifier, sMeshPath = "tool_icons/plane_cut", fMeshScaleFudge = 1.2f
}
};
float fRight = -43.0f;
float df = -11.0f;
List <float> AngleSteps = new List <float>()
{
fRight, fRight + df, fRight + 2 * df
};
float fVertStep = 11.0f;
float fTop = 0.0f;
int ri = 0, ci = 0;
toolButtons = new List <ActivateToolButton>();
toolButtonInfo = new List <toolInfo>();
foreach (toolInfo t in toolNames)
{
float fX = AngleSteps[ci++];
float fY = fTop - (float)ri * fVertStep;
if (ci == AngleSteps.Count)
{
ci = 0; ri++;
}
var button = add_tool_button(cockpit, t.identifier, fHUDRadius,
fX, fY, fButtonRadius, t);
AddChild(button);
toolButtons.Add(button);
toolInfo ti = new toolInfo();
ti = t;
ti.button = button;
toolButtonInfo.Add(ti);
}
// build indicators
string[] paths = { "tool_icons/star_green", "tool_icons/star_red" };
for (int k = 0; k < 2; ++k)
{
Mesh iconMesh = null;
Material iconMaterial = null;
try {
iconMesh = Resources.Load <Mesh>(paths[k]);
iconMaterial = MaterialUtil.CreateStandardVertexColorMaterial(Color.white);
} catch { }
if (iconMesh == null)
{
iconMesh = UnityUtil.GetPrimitiveMesh(PrimitiveType.Sphere);
iconMaterial = MaterialUtil.CreateStandardMaterial((k == 0) ? Color.green : Color.red);
}
indicator[k] = GameObject.CreatePrimitive(PrimitiveType.Sphere);
indicator[k].name = (k == 0) ? "left_tool_star" : "right_tool_star";
Component.Destroy(indicator[k].GetComponent <Collider>());
indicator[k].SetMesh(iconMesh);
indicator[k].GetComponent <Renderer>().material = iconMaterial;
// have to add to some button because we need them to be in GO tree
// when we do AddChild() on cockpit...that sets up layer, size, etc
indicatorButton[k] = toolButtons[0];
indicator[k].transform.localScale = fIndicatorSize * Vector3.one;
indicator[k].transform.localPosition +=
fIndicatorShiftXY * (Vector3.up + Vector3.right * ((k == 0) ? -1 : 1)) - fIndicatorShiftZ * Vector3.forward;
indicatorButton[k].AppendNewGO(indicator[k], indicatorButton[k].RootGameObject, false);
indicator[k].Hide();
}
// listen for changes
cockpit.Context.ToolManager.OnToolActivationChanged += on_tool_changed;
}
public void Create(Cockpit cockpit)
{
base.Create();
float fHUDRadius = 0.75f;
float fButtonRadius = 0.06f;
Color bgColor = new Color(0.7f, 0.7f, 1.0f, 0.7f);
Material bgMaterial = (bgColor.a == 1.0f) ?
MaterialUtil.CreateStandardMaterial(bgColor) : MaterialUtil.CreateTransparentMaterial(bgColor);
List <SOMaterial> materials = new List <SOMaterial>()
{
SOMaterial.CreateStandard("default", ColorUtil.StandardBeige),
SOMaterial.CreateStandard("standard_white", Colorf.VideoWhite),
SOMaterial.CreateStandard("standard_black", Colorf.VideoBlack),
SOMaterial.CreateStandard("middle_grey", new Colorf(0.5f)),
SOMaterial.CreateStandard("standard_green", Colorf.VideoGreen),
SOMaterial.CreateStandard("forest_green", Colorf.ForestGreen),
SOMaterial.CreateStandard("teal", Colorf.Teal),
SOMaterial.CreateStandard("light_green", Colorf.LightGreen),
SOMaterial.CreateStandard("standard_blue", Colorf.VideoBlue),
SOMaterial.CreateStandard("navy", Colorf.Navy),
SOMaterial.CreateStandard("cornflower_blue", Colorf.CornflowerBlue),
SOMaterial.CreateStandard("light_steel_blue", Colorf.LightSteelBlue),
SOMaterial.CreateStandard("standard_red", Colorf.VideoRed),
SOMaterial.CreateStandard("fire_red", Colorf.FireBrick),
SOMaterial.CreateStandard("hot_pink", Colorf.HotPink),
SOMaterial.CreateStandard("light_pink", Colorf.LightPink),
SOMaterial.CreateStandard("standard_yellow", Colorf.VideoYellow),
SOMaterial.CreateStandard("standard_orange", Colorf.Orange),
SOMaterial.CreateStandard("saddle_brown", Colorf.SaddleBrown),
SOMaterial.CreateStandard("wheat", Colorf.Wheat),
SOMaterial.CreateStandard("standard_cyan", Colorf.VideoCyan),
SOMaterial.CreateStandard("standard_magenta", Colorf.VideoMagenta),
SOMaterial.CreateStandard("silver", Colorf.Silver),
SOMaterial.CreateStandard("dark_slate_grey", Colorf.DarkSlateGrey)
};
float fRight = -41.0f;
float df = -7.25f;
float df_fudge = -0.2f;
List <float> AngleSteps = new List <float>()
{
fRight, fRight + df, fRight + 2 * df, fRight + 3 * df
};
float fVertStep = 6.75f;
float fTop = 2.0f;
int ri = 0, ci = 0;
foreach (SOMaterial m in materials)
{
float fXFudge = df_fudge * (float)ri * (float)ci;
float fX = AngleSteps[ci++] + fXFudge;
float fY = fTop - (float)ri * fVertStep;
if (ci == AngleSteps.Count)
{
ci = 0; ri++;
}
var button = add_material_button(cockpit, m.Name, fHUDRadius,
fX, fY, fButtonRadius, bgMaterial, m);
AddChild(button);
buttons.Add(button);
}
fMesh iconMesh = null;
Material iconMaterial = null;
try {
iconMesh = new fMesh(Resources.Load <Mesh>("tool_icons/star"));
iconMaterial = MaterialUtil.CreateStandardVertexColorMaterial(Color.white);
} catch { }
if (iconMesh == null)
{
iconMesh = new fMesh(UnityUtil.GetPrimitiveMesh(PrimitiveType.Sphere));
iconMaterial = MaterialUtil.CreateStandardMaterial(Color.yellow);
}
indicatorGO = new fMeshGameObject(iconMesh);
indicatorGO.SetName("active_star");
indicatorGO.SetMesh(iconMesh);
indicatorGO.SetMaterial(iconMaterial);
indicatorGO.SetLocalScale(fIndicatorSize * Vector3f.One);
indicatorGO.SetLocalPosition(indicatorGO.GetLocalPosition() +
fIndicatorShift * (Vector3f.AxisY - 4 * Vector3f.AxisZ + Vector3f.AxisX));
indicatorButton = buttons[0]; // this is default material
indicatorButton.AppendNewGO(indicatorGO, indicatorButton.RootGameObject, false);
}
void InitializeSpatialInput()
{
Left = new SpatialDevice();
Right = new SpatialDevice();
Left.CursorDefaultMaterial = MaterialUtil.CreateTransparentMaterial(ColorUtil.ForestGreen, 0.6f);
Left.CursorHitMaterial = MaterialUtil.CreateStandardMaterial(ColorUtil.SelectionGold);
Left.CursorCapturingMaterial = MaterialUtil.CreateTransparentMaterial(ColorUtil.SelectionGold, 0.75f);
Left.HandMaterial = MaterialUtil.CreateTransparentMaterial(ColorUtil.ForestGreen, 0.3f);
Right.CursorDefaultMaterial = MaterialUtil.CreateTransparentMaterial(Colorf.DarkRed, 0.6f);
Right.CursorHitMaterial = MaterialUtil.CreateStandardMaterial(ColorUtil.PivotYellow);
Right.CursorCapturingMaterial = MaterialUtil.CreateTransparentMaterial(ColorUtil.PivotYellow, 0.75f);
Right.HandMaterial = MaterialUtil.CreateTransparentMaterial(ColorUtil.CgRed, 0.3f);
CursorVisualAngleInDegrees = 1.5f;
standardCursorMesh = MeshGenerators.Create3DArrow(1.0f, 1.0f, 1.0f, 0.5f, 16);
UnityUtil.TranslateMesh(standardCursorMesh, 0, -2.0f, 0);
activeToolCursorMesh = MeshGenerators.Create3DArrow(1.0f, 1.0f, 1.0f, 1.0f, 16);
UnityUtil.TranslateMesh(activeToolCursorMesh, 0, -2.0f, 0);
Left.Cursor = UnityUtil.CreateMeshGO("left_cursor", standardCursorMesh, Left.CursorDefaultMaterial);
Left.Cursor.transform.localScale = 0.3f * Vector3.one;
Left.Cursor.transform.localRotation = Quaternion.AngleAxis(45.0f, new Vector3(1, 0, 1).normalized);
MaterialUtil.DisableShadows(Left.Cursor);
Left.Cursor.SetLayer(FPlatform.CursorLayer);
Left.SmoothedHandFrame = Frame3f.Identity;
var leftHandMesh = MeshGenerators.Create3DArrow(1.0f, 1.0f, 1.0f, 0.5f, 16);
Left.Hand = UnityUtil.CreateMeshGO("left_hand", leftHandMesh, Left.HandMaterial);
UnityUtil.TranslateMesh(leftHandMesh, 0, -1.0f, 0);
Left.Hand.transform.localScale = 0.1f * Vector3.one;
Left.Hand.transform.rotation = Quaternion.FromToRotation(Vector3.up, Vector3.forward);
Left.Hand.SetLayer(FPlatform.HUDLayer);
Left.Laser = new GameObject("left_laser");
Left.LaserRen = Left.Laser.AddComponent <LineRenderer>();
Left.LaserRen.SetPositions(new Vector3[2] {
Vector3.zero, 100 * Vector3.up
});
Left.LaserRen.startWidth = Left.LaserRen.endWidth = 0.01f;
Left.LaserRen.material = MaterialUtil.CreateFlatMaterial(ColorUtil.ForestGreen, 0.2f);
Left.Laser.SetLayer(FPlatform.CursorLayer);
Left.Laser.transform.parent = Left.Cursor.transform;
Right.Cursor = UnityUtil.CreateMeshGO("right_cursor", standardCursorMesh, Right.CursorDefaultMaterial);
Right.Cursor.transform.localScale = 0.3f * Vector3.one;
Right.Cursor.transform.localRotation = Quaternion.AngleAxis(45.0f, new Vector3(1, 0, 1).normalized);
MaterialUtil.DisableShadows(Right.Cursor);
Right.Cursor.SetLayer(FPlatform.CursorLayer);
Right.SmoothedHandFrame = Frame3f.Identity;
var rightHandMesh = MeshGenerators.Create3DArrow(1.0f, 1.0f, 1.0f, 0.5f, 16);
Right.Hand = UnityUtil.CreateMeshGO("right_hand", rightHandMesh, Right.HandMaterial);
UnityUtil.TranslateMesh(rightHandMesh, 0, -1.0f, 0);
Right.Hand.transform.localScale = 0.1f * Vector3.one;
Right.Hand.transform.rotation = Quaternion.FromToRotation(Vector3.up, Vector3.forward);
Right.Hand.SetLayer(FPlatform.HUDLayer);
Right.Laser = new GameObject("right_laser");
Right.LaserRen = Right.Laser.AddComponent <LineRenderer>();
Right.LaserRen.SetPositions(new Vector3[2] {
Vector3.zero, 100 * Vector3.up
});
Right.LaserRen.startWidth = Right.LaserRen.endWidth = 0.01f;
Right.LaserRen.material = MaterialUtil.CreateFlatMaterial(ColorUtil.CgRed, 0.2f);
Right.Laser.SetLayer(FPlatform.CursorLayer);
Right.Laser.transform.parent = Right.Cursor.transform;
spatialInputInitialized = true;
}
public void Create(Cockpit cockpit)
{
base.Create();
float fHUDRadius = 0.7f;
float fButtonRadius = 0.08f;
Color bgColor = new Color(0.7f, 0.7f, 1.0f, 0.7f);
Material bgMaterial = (bgColor.a == 1.0f) ?
MaterialUtil.CreateStandardMaterial(bgColor) : MaterialUtil.CreateTransparentMaterial(bgColor);
Material primMaterial = MaterialUtil.CreateStandardMaterial(Color.yellow);
var addCylinderButton = add_primitive_button(cockpit, "addCylinder", fHUDRadius, -45.0f, 0.0f,
PrimitiveType.Cylinder, 0.7f, bgMaterial, primMaterial,
() => {
return(new CylinderSO().Create(cockpit.Scene.DefaultSOMaterial));
});
AddChild(addCylinderButton);
buttons.Add(addCylinderButton);
buttonTypes[addCylinderButton] = SOTypes.Cylinder;
var addBoxButton = add_primitive_button(cockpit, "addBox", fHUDRadius, -45.0f, -15.0f,
PrimitiveType.Cube, 0.7f, bgMaterial, primMaterial,
() => {
return(new BoxSO().Create(cockpit.Scene.DefaultSOMaterial));
});
AddChild(addBoxButton);
buttons.Add(addBoxButton);
buttonTypes[addBoxButton] = SOTypes.Box;
var addSphereButton = add_primitive_button(cockpit, "addSphere", fHUDRadius, -45.0f, -30.0f,
PrimitiveType.Sphere, 0.85f, bgMaterial, primMaterial,
() => {
return(new SphereSO().Create(cockpit.Scene.DefaultSOMaterial));
});
AddChild(addSphereButton);
buttons.Add(addSphereButton);
buttonTypes[addSphereButton] = SOTypes.Sphere;
var addPivotButton = add_primitive_button(cockpit, "addPivot", fHUDRadius, -60.0f, 0.0f,
PrimitiveType.Sphere, 0.7f, bgMaterial, primMaterial,
() => {
return(new PivotSO().Create(cockpit.Scene.PivotSOMaterial, cockpit.Scene.FrameSOMaterial,
FPlatform.WidgetOverlayLayer));
},
new pivotIconGenerator()
{
SphereMaterial = cockpit.Scene.SelectedMaterial,
FrameMaterial = cockpit.Scene.FrameMaterial, PrimSize = fButtonRadius * 0.7f
});
AddChild(addPivotButton);
buttons.Add(addPivotButton);
buttonTypes[addPivotButton] = SOTypes.Pivot;
//var addCurveButton = add_curve_button(cockpit, "addCurve", fHUDRadius, -60.0f, -15.0f,
// bgMaterial, primMaterial,
// () => {
// return new PolyCurveSO().Create(cockpit.ActiveScene.DefaultSOMaterial);
// });
//AddChild(addCurveButton);
/*
* HUDButton addBunnyButton = HUDBuilder.CreateGeometryIconClickButton(
* new HUDShape(HUDShapeType.Disc, fButtonRadius ),
* fHUDRadius, -45.0f, -30.0f, bgColor,
* new meshIconGenerator() { MeshPath = "icon_meshes/bunny_1k", UseMaterial = primMaterial, UseSize = fButtonRadius * 0.7f });
* addBunnyButton.Name = "addBunnyButton";
* addBunnyButton.OnClicked += (s, e) => {
* // TODO add existing mesh to scene
* cockpit.Parent.Scene.AddBox();
* };
* cockpit.AddUIElement(addBunnyButton, true);
*/
// initialize selected-primitive indicator icon
fMesh iconMesh = null;
fMaterial iconMaterial = null;
try {
iconMesh = new fMesh(Resources.Load <Mesh>("tool_icons/star"));
iconMaterial = MaterialUtil.CreateStandardVertexColorMaterialF(Color.white);
} catch { }
if (iconMesh == null)
{
iconMesh = new fMesh(UnityUtil.GetPrimitiveMesh(PrimitiveType.Sphere));
iconMaterial = MaterialUtil.CreateStandardMaterialF(Color.yellow);
}
indicatorGO = new fMeshGameObject(iconMesh);
indicatorGO.SetName("active_star");
indicatorGO.SetMesh(iconMesh);
indicatorGO.SetMaterial(iconMaterial);
indicatorGO.SetLocalScale(fIndicatorSize * Vector3f.One);
indicatorGO.SetLocalPosition(indicatorGO.GetLocalPosition() +
fIndicatorShift * (Vector3f.AxisY - 1 * Vector3f.AxisZ + Vector3f.AxisX));
indicatorButton = buttons[0]; // this is default material
indicatorButton.AppendNewGO(indicatorGO, indicatorButton.RootGameObject, false);
}
public static fMaterial ToMaterialf(SOMaterial m)
{
fMaterial unityMat = null;
if (m.Type == SOMaterial.MaterialType.TextureMap)
{
unityMat = new Material(Shader.Find("Standard"));
unityMat.name = m.Name;
unityMat.color = m.RGBColor;
//if (m.Alpha < 1.0f)
// MaterialUtil.SetupMaterialWithBlendMode(unityMat, MaterialUtil.BlendMode.Transparent);
unityMat.mainTexture = m.MainTexture;
}
else if (m.Type == SOMaterial.MaterialType.PerVertexColor)
{
unityMat = MaterialUtil.CreateStandardVertexColorMaterial(m.RGBColor);
unityMat.renderQueue += m.RenderQueueShift;
unityMat.SetInt("_Cull", (int)m.CullingMode);
}
else if (m.Type == SOMaterial.MaterialType.FlatShadedPerVertexColor)
{
unityMat = MaterialUtil.CreateFlatShadedVertexColorMaterialF(m.RGBColor);
unityMat.renderQueue += m.RenderQueueShift;
unityMat.SetInt("_Cull", (int)m.CullingMode);
}
else if (m.Type == SOMaterial.MaterialType.TransparentRGBColor)
{
unityMat = MaterialUtil.CreateTransparentMaterial(m.RGBColor);
unityMat.renderQueue += m.RenderQueueShift;
}
else if (m.Type == SOMaterial.MaterialType.StandardRGBColor)
{
unityMat = MaterialUtil.CreateStandardMaterial(m.RGBColor);
unityMat.renderQueue += m.RenderQueueShift;
}
else if (m.Type == SOMaterial.MaterialType.UnlitRGBColor)
{
unityMat = MaterialUtil.CreateFlatMaterial(m.RGBColor);
unityMat.renderQueue += m.RenderQueueShift;
}
else if (m.Type == SOMaterial.MaterialType.DepthWriteOnly)
{
unityMat = MaterialUtil.CreateDepthWriteOnly();
unityMat.renderQueue += m.RenderQueueShift;
}
else if (m.Type == SOMaterial.MaterialType.StandardMesh)
{
fMeshMaterial meshMat = MaterialUtil.CreateStandardMeshMaterial(m.RGBColor);
meshMat.renderQueue += m.RenderQueueShift;
if (m is SOMeshMaterial)
{
meshMat.InitializeFromSOMaterial(m as SOMeshMaterial);
}
unityMat = meshMat;
}
else if (m is UnitySOMeshMaterial)
{
unityMat = (m as UnitySOMeshMaterial).meshMaterial;
}
else if (m is UnitySOMaterial)
{
unityMat = (m as UnitySOMaterial).unityMaterial;
}
else
{
unityMat = MaterialUtil.CreateStandardMaterial(Color.black);
}
if ((m.Hints & SOMaterial.HintFlags.UseTransparentPass) != 0)
{
SetupMaterialWithBlendMode(unityMat, BlendMode.Transparent);
}
if (m.MaterialCustomizerF != null)
{
m.MaterialCustomizerF(unityMat);
}
return(unityMat);
}
