public GOWrapperSO Create(GameObject gameObj)
{
fMaterial unityMaterial = gameObj.GetMaterial();
if (unityMaterial == null)
{
AllowMaterialChanges = false;
}
else
{
SOMaterial setMaterial = new UnitySOMaterial(unityMaterial);
AssignSOMaterial(setMaterial);
}
this.parentGO = gameObj;
AppendExistingGO(gameObj);
List <GameObject> children = new List <GameObject>();
UnityUtil.CollectAllChildren(gameObj, children);
for (int i = 0; i < children.Count; ++i)
{
AppendExistingGO(children[i]);
}
return(this);
}
public virtual void Create()
{
rootGO = new GameObject(UniqueNames.GetNext("HUDSlider"));
fMaterial useMaterial = MaterialUtil.CreateFlatMaterialF(bgColor);
backgroundGO = GameObjectFactory.CreateRectangleGO("background",
SliderWidth, SliderHeight, useMaterial, true, true);
MaterialUtil.DisableShadows(backgroundGO);
backgroundGO.RotateD(Vector3f.AxisX, -90.0f); // ??
AppendNewGO(backgroundGO, rootGO, false);
handleMaterial = MaterialUtil.CreateFlatMaterialF(handleColor);
handleGO = create_handle_go(handleMaterial);
if (handleGO != null)
{
handleGO.Translate(0.001f * Vector3f.AxisY, true);
AppendNewGO(handleGO, rootGO, false);
handleStart = handleGO.GetLocalFrame();
}
create_visuals_geometry();
TickMaterial = MaterialUtil.CreateFlatMaterialF(tickColor);
update_geometry();
}
virtual public void PushOverrideMaterial(fMaterial m)
{
vMaterialStack.Add(displayMaterial);
displayMaterial = m;
set_material_internal(displayMaterial);
increment_timestamp();
}
public virtual PolyCurveSO Create(SOMaterial defaultMaterial)
{
if (curve == null)
{
LineGenerator gen = new LineGenerator()
{
Start = Vector3f.Zero, End = 10.0f * Vector3f.AxisY, StepSize = 0.1f
};
gen.Generate();
curve = new DCurve3();
gen.Make(curve);
}
// assumes type identifier is something like BlahBlahSO
root = GameObjectFactory.CreateParentGO(UniqueNames.GetNext(Type.identifier.Remove(Type.identifier.Length - 2)));
if (EnableLineRenderer)
{
LineRenderer ren = root.AddComponent <LineRenderer>();
ren.startWidth = ren.endWidth = 0.05f;
ren.useWorldSpace = false;
}
AssignSOMaterial(defaultMaterial); // need to do this to setup BaseSO material stack
fMaterial useMaterial = CurrentMaterial;
Create_internal(useMaterial);
UpdateGeometry();
increment_timestamp();
return(this);
}
public BaseSO()
{
uuid = System.Guid.NewGuid().ToString();
displayMaterial = null;
vMaterialStack = new List <fMaterial>();
inputBehaviours = new InputBehaviorSet();
}
/// <summary>
/// This is very hacky.
/// </summary>
public static void AddDropShadow(HUDStandardItem item, Colorf color, float falloffWidth, Vector2f offset, float fZShift)
{
if (item is IBoxModelElement == false)
{
throw new Exception("HUDUtil.AddDropShadow: can only add drop shadow to IBoxModelElement");
}
// [TODO] need interface that provides a HUDShape?
var shape = item as IBoxModelElement;
float w = shape.Size2D.x + falloffWidth;
float h = shape.Size2D.y + falloffWidth;
fRectangleGameObject meshGO = GameObjectFactory.CreateRectangleGO("shadow", w, h, color, false);
meshGO.RotateD(Vector3f.AxisX, -90.0f);
fMaterial dropMat = MaterialUtil.CreateDropShadowMaterial(color, w, h, falloffWidth);
meshGO.SetMaterial(dropMat);
item.AppendNewGO(meshGO, item.RootGameObject, false);
BoxModel.Translate(meshGO, offset, fZShift);
Vector3 posW = item.RootGameObject.PointToWorld(meshGO.GetLocalPosition());
((Material)dropMat).SetVector("_Center", new Vector4(posW.x, posW.y, posW.z, 0));
}
/*
* internals
*/
// selection material handling
void push_selection_material(SceneObject so)
{
if (DisableSelectionMaterial)
{
throw new Exception("FScene.push_selection_material: disabled!");
}
fMaterial objectMat;
if (PerObjectSelectionMaterial.TryGetValue(so, out objectMat))
{
so.PushOverrideMaterial(objectMat);
return;
}
fMaterial typeMat;
if (PerTypeSelectionMaterial.TryGetValue(so.Type, out typeMat))
{
so.PushOverrideMaterial(typeMat);
return;
}
Func <SceneObject, fMaterial> matMap;
if (PerTypeSelectionMaterialMap.TryGetValue(so.Type, out matMap))
{
fMaterial useMat = matMap(so);
if (useMat != null)
{
so.PushOverrideMaterial(useMat);
return;
}
}
so.PushOverrideMaterial(SelectedMaterial);
}
override public void PushOverrideMaterial(fMaterial m)
{
if (AllowMaterialChanges)
{
base.PushOverrideMaterial(m);
}
}
public static HUDToggleButton CreateToggleButton(HUDShape shape, float fHUDRadius,
float fAngleHorz, float fAngleVert,
string enabledIcon, string disabledIcon,
IGameObjectGenerator addGeometry = null)
{
fMaterial enabledMat = MaterialUtil.CreateTransparentImageMaterialF(enabledIcon);
fMaterial disabledMat = MaterialUtil.CreateTransparentImageMaterialF(disabledIcon);
HUDToggleButton button = new HUDToggleButton()
{
Shape = shape
};
button.Create(enabledMat);
if (addGeometry != null)
{
button.AddVisualElements(addGeometry.Generate(), true);
}
HUDUtil.PlaceInSphere(button, fHUDRadius, fAngleHorz, fAngleVert);
button.OnToggled += (s, bEnabled) => {
button.SetAllGOMaterials(bEnabled ? enabledMat : disabledMat);
};
return(button);
}
virtual protected fGameObject append_widget(AxisGizmoFlags widgetType, int nAxis, string name,
fMaterial material, fMaterial hoverMaterial)
{
var useMaterial = (Factory.UniqueColorPerWidget || material == null)
? Factory.MakeMaterial(widgetType) : material;
var useHoverMaterial = (Factory.UniqueColorPerWidget || hoverMaterial == null)
? Factory.MakeHoverMaterial(widgetType) : hoverMaterial;
var go = AppendMeshGO(name, Factory.MakeGeometry(widgetType), useMaterial, RootGameObject, true);
Standard3DTransformWidget widget = null;
switch (widgetType)
{
case AxisGizmoFlags.AxisTranslateX:
case AxisGizmoFlags.AxisTranslateY:
case AxisGizmoFlags.AxisTranslateZ:
widget = new AxisTranslationWidget(nAxis)
{
RootGameObject = go, StandardMaterial = useMaterial, HoverMaterial = useHoverMaterial,
TranslationScaleF = () => { return(TranslateSpeed / parentScene.GetSceneScale()); }
};
break;
case AxisGizmoFlags.AxisRotateX:
case AxisGizmoFlags.AxisRotateY:
case AxisGizmoFlags.AxisRotateZ:
widget = new AxisRotationWidget(nAxis)
{
RootGameObject = go, StandardMaterial = useMaterial, HoverMaterial = useHoverMaterial,
EnableSnapping = EnableRotationSnapping,
SnapIncrementDeg = RotationSnapStepSizeDeg
};
break;
case AxisGizmoFlags.PlaneTranslateX:
case AxisGizmoFlags.PlaneTranslateY:
case AxisGizmoFlags.PlaneTranslateZ:
widget = new PlaneTranslationWidget(nAxis)
{
RootGameObject = go, StandardMaterial = useMaterial, HoverMaterial = useHoverMaterial,
TranslationScaleF = () => { return(TranslateSpeed / parentScene.GetSceneScale()); }
};
break;
case AxisGizmoFlags.UniformScale:
widget = new UniformScaleWidget(parentScene.ActiveCamera)
{
RootGameObject = go, StandardMaterial = useMaterial, HoverMaterial = useHoverMaterial,
ScaleMultiplierF = () => { return(ScaleSpeed / parentScene.GetSceneScale()); }
};
break;
default:
throw new Exception("DefaultAxisGizmoWidgetFactory.MakeHoverMaterial: invalid widget type " + widget.ToString());
}
Widgets[go] = widget;
return(go);
}
public override void Setup()
{
sphereGO = GameObjectFactory.CreateMeshGO("sphere", UnityUtil.GetSphereMesh(), false);
sphereMaterial = MaterialF();
sphereGO.SetMaterial(sphereMaterial);
sphereMaterial.color = ColorF();
MaterialUtil.DisableShadows(sphereGO);
}
virtual public void PushOverrideMaterial(fMaterial m)
{
foreach (var so in vChildren)
{
so.PushOverrideMaterial(m);
}
increment_timestamp();
}
public virtual fMaterial MakeHoverMaterial(AxisGizmoFlags widget)
{
switch (widget)
{
case AxisGizmoFlags.AxisRotateX:
case AxisGizmoFlags.AxisTranslateX:
case AxisGizmoFlags.PlaneTranslateX:
if (XHover == null)
{
XHover = MaterialUtil.CreateTransparentMaterial(Colorf.VideoRed);
if (OverrideRenderQueue != -1)
{
XHover.renderQueue = OverrideRenderQueue;
}
}
return(XHover);
case AxisGizmoFlags.AxisRotateY:
case AxisGizmoFlags.AxisTranslateY:
case AxisGizmoFlags.PlaneTranslateY:
if (YHover == null)
{
YHover = MaterialUtil.CreateTransparentMaterial(Colorf.VideoGreen);
if (OverrideRenderQueue != -1)
{
YHover.renderQueue = OverrideRenderQueue;
}
}
return(YHover);
case AxisGizmoFlags.AxisRotateZ:
case AxisGizmoFlags.AxisTranslateZ:
case AxisGizmoFlags.PlaneTranslateZ:
if (ZHover == null)
{
ZHover = MaterialUtil.CreateTransparentMaterial(Colorf.VideoBlue);
if (OverrideRenderQueue != -1)
{
ZHover.renderQueue = OverrideRenderQueue;
}
}
return(ZHover);
case AxisGizmoFlags.UniformScale:
if (AllHover == null)
{
AllHover = MaterialUtil.CreateTransparentMaterial(Colorf.VideoWhite);
if (OverrideRenderQueue != -1)
{
AllHover.renderQueue = OverrideRenderQueue;
}
}
return(AllHover);
default:
throw new Exception("DefaultAxisGizmoWidgetFactory.MakeHoverMaterial: invalid widget type " + widget.ToString());
}
}
public static fDiscGameObject CreateDiscGO(string sName, float fRadius, fMaterial material, bool bShareMaterial, bool bCollider)
{
GameObject go = new GameObject(sName);
Mesh discMesh = PrimitiveCache.GetPrimitiveMesh(fPrimitiveType.Disc);
initialize_meshgo(go, new fMesh(discMesh), bCollider, true);
go.SetMaterial(material, bShareMaterial);
return(new fDiscGameObject(go, new fMesh(go.GetSharedMesh()), fRadius));
}
public override void Setup()
{
planeGO = GameObjectFactory.CreateMeshGO("section_plane", UnityUtil.GetTwoSidedPlaneMesh(), false);
planeMaterial = MaterialF();
planeGO.SetMaterial(planeMaterial);
planeMaterial.color = ColorF();
MaterialUtil.DisableShadows(planeGO);
//planeGO.SetLayer(FPlatform.WidgetOverlayLayer);
}
/// <summary>
/// Create GO / geometry for a single tick, centered at origin
/// </summary>
protected virtual fGameObject create_tick_go(Vector2f tickSize, fMaterial baseMaterial)
{
fRectangleGameObject go = GameObjectFactory.CreateRectangleGO("tick", tickSize.x, tickSize.y,
baseMaterial, true, false);
MaterialUtil.DisableShadows(go);
go.RotateD(Vector3f.AxisX, -90.0f);
return(go);
}
/// <summary>
/// Create the GO that acts as the "handle", ie identifies selected position on timelin
/// Default is a kind of ugly large triangle underneath midline...
/// Override to provide your own visuals. Return null for no handle.
/// </summary>
protected virtual fGameObject create_handle_go(fMaterial handleMaterial)
{
fTriangleGameObject handle = GameObjectFactory.CreateTriangleGO(
"handle", Height, Height, handleMaterial.color, true);
MaterialUtil.DisableShadows(handle);
handle.RotateD(Vector3f.AxisX, -90.0f); // ??
return(handle);
}
override protected void set_material_internal(fMaterial m)
{
base.set_material_internal(m);
if (EnableLineRenderer)
{
LineRenderer ren = root.GetComponent <LineRenderer>();
ren.material = m;
}
}
public static void SetMaterial(this GameObject go, fMaterial mat, bool bShared = false)
{
if (bShared)
{
go.GetComponent <Renderer>().sharedMaterial = mat;
}
else
{
go.GetComponent <Renderer>().material = mat;
}
}
virtual public void PopOverrideMaterial()
{
if (vMaterialStack.Count > 0)
{
fMaterial m = vMaterialStack.Last();
vMaterialStack.RemoveAt(vMaterialStack.Count - 1);
displayMaterial = m;
set_material_internal(displayMaterial);
increment_timestamp();
}
}
// creates a button that is just the mesh
public void Create(fMesh mesh, fMaterial meshMaterial, float fScale, Quaternionf transform)
{
button = GameObjectFactory.CreateParentGO(UniqueNames.GetNext("HUDButton"));
iconMesh = AppendMeshGO("shape", mesh, meshMaterial, button);
iconMesh.SetLocalScale(new Vector3f(fScale, fScale, fScale));
iconMesh.SetLocalRotation(iconMesh.GetLocalRotation() * transform);
MaterialUtil.DisableShadows(iconMesh);
standard_mat = new fMaterial(meshMaterial);
}
/// <summary>
/// Replace the material on the background GO of item.
/// Assumes that the background GO has the name "background"...
/// </summary>
public static void SetBackgroundMaterial(HUDStandardItem item, fMaterial material, bool bShared = false)
{
var go = item.FindGOByName("background");
if (go == null)
{
DebugUtil.Log(2, "HUDUtil.SetBackgroundImage: item {0} does not have go named 'background'", item.Name);
return;
}
go.SetMaterial(material, bShared);
}
virtual public void Setup()
{
brushIndicator = new BrushCursorSphere()
{
PositionF = () => { return(lastBrushPosW.Origin); },
Radius = fDimension.World(() => { return(radius.WorldValue); })
};
primaryBrushMat = MaterialUtil.CreateTransparentMaterialF(Colorf.CornflowerBlue, 0.2f);
secondaryBrushMat = MaterialUtil.CreateTransparentMaterialF(Colorf.ForestGreen, 0.2f);
Indicators.AddIndicator(brushIndicator);
brushIndicator.material = primaryBrushMat;
}
// creates a button that is just the mesh
public void Create(Mesh mesh, Material meshMaterial, float fScale, Quaternion transform)
{
button = new GameObject(UniqueNames.GetNext("HUDButton"));
GameObject meshGO = AppendMeshGO("shape", mesh, meshMaterial, button);
meshGO.transform.localScale = new Vector3(fScale, fScale, fScale);
meshGO.transform.localRotation *= transform;
MaterialUtil.DisableShadows(meshGO);
standard_mat = new fMaterial(meshMaterial);
}
public void Create(SOMaterial useMaterial, GameObject parent, float fMinDimension)
{
meshObject = GameObject.CreatePrimitive(PrimitiveType.Sphere);
fMaterial mat = MaterialUtil.ToMaterialf(useMaterial);
meshObject.SetMaterial(mat, true);
bUpdatePending = true;
meshObject.transform.SetParent(parent.transform, false);
Height = Width = Depth = fMinDimension;
}
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 void Create(fMaterial defaultMaterial)
{
button = GameObjectFactory.CreateParentGO(UniqueNames.GetNext("HUDToggleButton"));
buttonMesh = AppendMeshGO("disc", make_button_body_mesh(),
defaultMaterial, button);
buttonMesh.RotateD(Vector3f.AxisX, -90.0f); // ??
if (text.Length > 0)
{
UpdateText();
}
}
public void Create(fMaterial defaultMaterial)
{
button = GameObjectFactory.CreateParentGO(UniqueNames.GetNext("HUDToggleButton"));
buttonMesh = AppendMeshGO("shape", HUDUtil.MakeBackgroundMesh(this.Shape),
defaultMaterial, button);
buttonMesh.RotateD(Vector3f.AxisX, -90.0f); // ??
if (text.Length > 0)
{
UpdateText();
}
}
public virtual void initialize(fGameObject go, fMaterial material, bool bSharedMat)
{
r = ((GameObject)go).AddComponent <LineRenderer>();
r.useWorldSpace = false;
if (bSharedMat)
{
r.sharedMaterial = material;
}
else
{
r.material = material;
}
}
// creates a button that is just the mesh, basically same as above but without the background disc
public void Create(PrimitiveType eType, Material primMaterial, float fPrimScale = 1.0f)
{
button = new GameObject(UniqueNames.GetNext("HUDButton"));
buttonMesh = AppendUnityPrimitiveGO(UniqueNames.GetNext("HUDButton"), eType, primMaterial, button);
float primSize = Shape.EffectiveRadius() * fPrimScale;
buttonMesh.transform.localScale = new Vector3(primSize, primSize, primSize);
buttonMesh.transform.Translate(0.0f, 0.0f, -primSize);
buttonMesh.transform.Rotate(-15.0f, 45.0f, 0.0f, Space.Self);
MaterialUtil.DisableShadows(buttonMesh);
standard_mat = new fMaterial(primMaterial);
}
