private void ReadOrdinals(IDataReader reader, int cmd_bit)
{
string key;
IDynaField field;
ReadList.Clear();
foreach (var p in FieldDict.Values)
{
p.Ordinal = -1;
}
int i_ord, i_count = reader.FieldCount;
for (i_ord = 0; i_ord < i_count; i_ord++)
{
key = reader.GetName(i_ord);
if (FieldDict.Keys.Contains <string>(key))
{
field = FieldDict[key];
//read 1 - for select
//read 2 - for detail
if ((field.GetOutMask() & cmd_bit) > 0)
{
field.Ordinal = i_ord;
ReadList.Add(field);
}
}
}
}
/*--------------------------------------------------------------------------------------------*/
public void UpdateAfterInput() {
var isMenuOnLeft = vInteractSettings.IsMenuOnLeftSide;
IInputMenu inputMenu = vInput.GetMenu(isMenuOnLeft);
HovercastCursorType[] cursorTypes = vInteractSettings.Cursors;
ReadOnlyCollection<BaseItemState> items = FullMenu.GetItems();
Dictionary<HovercastCursorType, CursorType> convertMap =
(vInteractSettings.IsMenuOnLeftSide ? vRightCursorConvertMap : vLeftCursorConvertMap);
vActiveCursorTypes.Clear();
vActiveCursorInteractions.Clear();
FullMenu.ClearCursors();
foreach ( HovercastCursorType unsidedCursorType in cursorTypes ) {
CursorType cursorType = convertMap[unsidedCursorType];
ICursorState cursor = vHovercursorSetup.State.GetCursorState(cursorType);
vActiveCursorTypes.Add(cursorType);
FullMenu.AddCursor(cursor);
}
for ( int i = 0 ; i < items.Count ; i++ ) {
vActiveCursorInteractions.Add(items[i]);
}
FullMenu.UpdateAfterInput(inputMenu);
if ( isMenuOnLeft != vCurrIsMenuOnLeftSide ) {
vCurrIsMenuOnLeftSide = isMenuOnLeft;
FullMenu.ResetAllItemCursorInteractions();
OnSideChange();
}
}
/*--------------------------------------------------------------------------------------------*/
public ReadOnlyCollection <IBaseItemState> GetLevelItems()
{
vLevelItems.Clear();
for (int i = 0; i < vItems.ReadOnly.Count; i++)
{
vLevelItems.Add(vItems.ReadOnly[i]);
}
return(vLevelItems.ReadOnly);
}
/*--------------------------------------------------------------------------------------------*/
public void Update()
{
vActiveCursorTypes.Clear();
foreach (Bundle bundle in vBundles)
{
if (bundle.ShowFunc())
{
vActiveCursorTypes.Add(bundle.State.Type);
}
vFakeItem.MaxHighlightProgress = HighlightProgress;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public ReadOnlyCollection <Vector3> GetWorldPoints()
{
if (RelativeToTransform == null)
{
throw new Exception("Transform must be set.");
}
vWorldPoints.Clear();
for (int i = 0; i < Points.Count; i++)
{
vWorldPoints.Add(RelativeToTransform.TransformPoint(Points[i]));
}
return(vWorldPoints.ReadOnly);
}
/*--------------------------------------------------------------------------------------------*/
private void HandleLevelChange(int pDirection)
{
vAllItems.Clear();
vItems.Clear();
IBaseItem[] items = vItemHierarchy.CurrentLevel.Items;
foreach (IBaseItem item in items)
{
var seg = new BaseItemState(item, vInteractSettings);
vAllItems.Add(seg);
vItems.Add(seg);
}
vAllItems.Add(vPalmItem);
OnLevelChange(pDirection);
}
/*--------------------------------------------------------------------------------------------*/
public static void CalcHoverPoints(float pWidth, float pHeight, ReadList <Vector3> pResult)
{
int stepsX = (int)Math.Round(pWidth / UiItem.Size) * 6;
int stepsY = (int)Math.Round(pHeight / UiItem.Size) * 6;
float x0 = -pWidth / 2f;
float y0 = -pHeight / 2f;
float xInc = pWidth / stepsX;
float yInc = pHeight / stepsY;
pResult.Clear();
for (int xi = 1; xi < stepsX; xi += 2)
{
for (int yi = 1; yi < stepsY; yi += 2)
{
pResult.Add(new Vector3(x0 + xInc * xi, 0, y0 + yInc * yi)); //relative to parent
}
}
}
/*--------------------------------------------------------------------------------------------*/
public void UpdateAfterInput()
{
IsCursorInteractionEnabled = false;
vActiveItems.Clear();
vActiveCursorInteractions.Clear();
vActiveCursorPlanes.Clear();
foreach (PanelState panel in FullPanels)
{
if (!IsPanelActive(panel))
{
continue;
}
IsCursorInteractionEnabled = true;
vActiveCursorPlanes.Add(panel.InteractionPlane);
}
foreach (ItemTree itemTree in vAllItems)
{
if (IsItemTreeActive(itemTree))
{
vActiveItems.Add(itemTree);
vActiveCursorInteractions.Add(itemTree.Item);
}
itemTree.Item.UpdateBeforeCursors();
}
for (int i = 0; i < vProjectionMap.ValuesReadOnly.Count; i++)
{
UpdateProjection(vProjectionMap.ValuesReadOnly[i]);
}
foreach (ItemTree itemTree in vActiveItems)
{
itemTree.Item.UpdateSelectionProcess();
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
protected virtual void UpdateMeshes(float pValue, float pHoverValue, float pHoverArc)
{
vTrackSegments.Clear();
vTrackCuts.Clear();
const float radInn = UiItemSelectRenderer.InnerRadius;
const float radOut = UiItemSelectRenderer.OuterRadius;
const float radInset = 0.04f;
float fullAngle = vAngle1 - vAngle0;
float slideAngle = fullAngle - vGrabArc;
float grabArcHalf = vGrabArc / 2;
float valCenter = pValue * slideAngle + grabArcHalf;
float hovCenter = pHoverValue * slideAngle + grabArcHalf;
float zeroCenter = vZeroValue * slideAngle + grabArcHalf;
bool isHoverTooClose = (Math.Abs(valCenter - hovCenter) < vGrabArc * (0.5f + HoverBarRelW));
if (vSliderItem.FillStartingPoint == SliderItem.FillType.Zero)
{
float break0 = Math.Min(zeroCenter, valCenter);
float break1 = Math.Max(zeroCenter, valCenter);
vTrackSegments.Add(new DisplayUtil.TrackSegment {
StartValue = 0,
EndValue = break0
});
vTrackSegments.Add(new DisplayUtil.TrackSegment {
StartValue = break0,
EndValue = break1,
IsFill = true,
IsZeroAtStart = (break0 == zeroCenter)
});
vTrackSegments.Add(new DisplayUtil.TrackSegment {
StartValue = break1,
EndValue = fullAngle
});
}
else
{
bool isMinStart = (vSliderItem.FillStartingPoint == SliderItem.FillType.MinimumValue);
vTrackSegments.Add(new DisplayUtil.TrackSegment {
StartValue = 0,
EndValue = valCenter,
IsFill = isMinStart
});
vTrackSegments.Add(new DisplayUtil.TrackSegment {
StartValue = valCenter,
EndValue = fullAngle,
IsFill = !isMinStart
});
}
vTrackCuts.Add(new DisplayUtil.TrackSegment {
StartValue = valCenter - grabArcHalf,
EndValue = valCenter + grabArcHalf,
});
if (pHoverArc > 0 && !isHoverTooClose)
{
vTrackCuts.Add(new DisplayUtil.TrackSegment {
StartValue = hovCenter - pHoverArc / 2,
EndValue = hovCenter + pHoverArc / 2,
});
vHover.UpdateSize(radInn, radOut, pHoverArc);
}
else
{
vHover.UpdateSize(0, 0, 0);
}
vTrack.UpdateSegments(vTrackSegments.ReadOnly, vTrackCuts.ReadOnly,
radInn + radInset, radOut - radInset);
}
/*--------------------------------------------------------------------------------------------*/
public static void CalcHoverPoints(float pWidth, float pHeight, ReadList<Vector3> pResult) {
int stepsX = (int)Math.Round(pWidth/UiItem.Size)*6;
int stepsY = (int)Math.Round(pHeight/UiItem.Size)*6;
float x0 = -pWidth/2f;
float y0 = -pHeight/2f;
float xInc = pWidth/stepsX;
float yInc = pHeight/stepsY;
pResult.Clear();
for ( int xi = 1 ; xi < stepsX ; xi += 2 ) {
for ( int yi = 1 ; yi < stepsY ; yi += 2 ) {
pResult.Add(new Vector3(x0+xInc*xi, 0, y0+yInc*yi)); //relative to parent
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void SetReferences(Transform pMenuTx) {
MenuTransform = pMenuTx;
vMenuPlanes.Clear();
vMenuPlanes.Add(new PlaneData("Hovercast.Menu", MenuTransform, Vector3.up));
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
protected virtual void UpdateMeshes(float pValue, float pHoverValue, float pHoverW)
{
vTrackSegments.Clear();
vTrackCuts.Clear();
float halfGrabW = vGrabW / 2;
float valCenter = pValue * vSlideW + halfGrabW;
float hovCenter = pHoverValue * vSlideW + halfGrabW;
float zeroCenter = vZeroValue * vSlideW + halfGrabW;
bool isHoverTooClose = (Math.Abs(valCenter - hovCenter) < vGrabW * (0.5f + HoverBarRelW));
if (vSliderItem.FillStartingPoint == SliderItem.FillType.Zero)
{
float break0 = Math.Min(zeroCenter, valCenter);
float break1 = Math.Max(zeroCenter, valCenter);
vTrackSegments.Add(new DisplayUtil.TrackSegment {
StartValue = 0,
EndValue = break0
});
vTrackSegments.Add(new DisplayUtil.TrackSegment {
StartValue = break0,
EndValue = break1,
IsFill = true,
IsZeroAtStart = (break0 == zeroCenter)
});
vTrackSegments.Add(new DisplayUtil.TrackSegment {
StartValue = break1,
EndValue = vWidth
});
}
else
{
bool isMinStart = (vSliderItem.FillStartingPoint == SliderItem.FillType.MinimumValue);
vTrackSegments.Add(new DisplayUtil.TrackSegment {
StartValue = 0,
EndValue = valCenter,
IsFill = isMinStart
});
vTrackSegments.Add(new DisplayUtil.TrackSegment {
StartValue = valCenter,
EndValue = vWidth,
IsFill = !isMinStart
});
}
vTrackCuts.Add(new DisplayUtil.TrackSegment {
StartValue = valCenter - halfGrabW,
EndValue = valCenter + halfGrabW,
});
if (pHoverW > 0 && !isHoverTooClose)
{
vTrackCuts.Add(new DisplayUtil.TrackSegment {
StartValue = hovCenter - pHoverW / 2,
EndValue = hovCenter + pHoverW / 2,
});
vHover.UpdateSize(pHoverW, vHeight);
}
else
{
vHover.UpdateSize(0, 0);
}
vTrack.UpdateSegments(vTrackSegments.ReadOnly, vTrackCuts.ReadOnly, vHeight * 0.92f);
}
