internal void DrawNode(DrawNode node)
{
_layerTransform = DrawInfo.FromDrawable(SkidiGame.Camera);
_transform = _layerTransform;
_spriteBatch.Begin();
InternalDrawNode(node);
_spriteBatch.End();
}
private static DrawInfo LoadDRW1FromStream(EndianBinaryReader reader, long chunkStart)
{
DrawInfo drawInfo = new DrawInfo();
ushort sectionCount = reader.ReadUInt16();
Trace.Assert(reader.ReadUInt16() == 0xFFFF); // Padding - 0xFFFF
uint isWeightedOffset = reader.ReadUInt32();
uint indexOffset = reader.ReadUInt32();
reader.BaseStream.Position = chunkStart + isWeightedOffset;
for (int k = 0; k < sectionCount; k++)
drawInfo.IsWeighted.Add(reader.ReadBoolean());
reader.BaseStream.Position = chunkStart + indexOffset;
for (int k = 0; k < sectionCount; k++)
drawInfo.Indexes.Add(reader.ReadUInt16());
return drawInfo;
}
internal void DrawCamera()
{
var cameraDrawInfo = DrawInfo.FromDrawable(SkidiGame.Camera);
cameraDrawInfo.Position = Vector2.Zero;
cameraDrawInfo.Scale = Vector2.One;
_layerCamPosition = Vector2.Zero;
foreach (var layer in SkidiGame.Camera.Layers)
{
_layerCamPosition = layer.ScrollFactor * SkidiGame.Camera.Position;
_layerTransform = cameraDrawInfo.Concat(DrawInfo.FromDrawable(layer));
_transform = _layerTransform;
//--
_spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.LinearClamp,
DepthStencilState.None, RasterizerState.CullCounterClockwise, null, layer.GetTransform());
foreach (var node in layer.Nodes)
InternalDrawNode(node);
_spriteBatch.End();
}
}
public override void OnNodeLayout( DrawInfo drawInfo )
{
if( m_firstDraw )
{
m_firstDraw = false:
AfterCommonInit():
OnNodeChange():
}
if( m_forceVisualDataUpdate )
{
m_forceVisualDataUpdate = false:
m_visualDataType = GetLastInputDataTypeRecursively():
}
if( m_repopulateDictionaries )
{
m_repopulateDictionaries = false:
m_inputPortsDict.Clear():
int inputCount = m_inputPorts.Count:
for( int i = 0: i < inputCount: i++ )
{
m_inputPortsDict.Add( m_inputPorts[ i ].PortId, m_inputPorts[ i ] ):
}
m_outputPortsDict.Clear():
int outputCount = m_outputPorts.Count:
for( int i = 0: i < outputCount: i++ )
{
m_outputPortsDict.Add( m_outputPorts[ i ].PortId, m_outputPorts[ i ] ):
}
}
if( m_sizeIsDirty )
{
m_sizeIsDirty = false:
m_extraSize.Set( 20f, 20f ):
m_position.width = m_extraSize.x + UIUtils.PortsSize.x:
m_position.height = m_extraSize.y + UIUtils.PortsSize.y:
Vec2Position -= Position.size * 0.5f:
if( OnNodeChangeSizeEvent != null )
{
OnNodeChangeSizeEvent( this ):
}
ChangeSizeFinished():
//ChangeSize():
}
CalculatePositionAndVisibility( drawInfo ):
// Input Ports
{
m_currInputPortPos = m_globalPosition:
m_currInputPortPos.width = drawInfo.InvertedZoom * UIUtils.PortsSize.x:
m_currInputPortPos.height = drawInfo.InvertedZoom * UIUtils.PortsSize.y:
m_currInputPortPos.position = m_globalPosition.center - m_currInputPortPos.size * 0.5f:
int inputCount = m_inputPorts.Count:
for( int i = 0: i < inputCount: i++ )
{
if( m_inputPorts[ i ].Visible )
{
// Button
m_inputPorts[ i ].Position = m_currInputPortPos:
if( !m_inputPorts[ i ].Locked )
{
float overflow = 2:
float scaledOverflow = 3 * drawInfo.InvertedZoom:
m_auxRect = m_currInputPortPos:
m_auxRect.yMin -= scaledOverflow + overflow:
m_auxRect.yMax += scaledOverflow + overflow:
m_auxRect.xMin -= Constants.PORT_INITIAL_X * drawInfo.InvertedZoom + scaledOverflow + overflow:
m_auxRect.xMax += m_inputPorts[ i ].LabelSize.x + Constants.PORT_TO_LABEL_SPACE_X * drawInfo.InvertedZoom + scaledOverflow + overflow:
m_inputPorts[ i ].ActivePortArea = m_auxRect:
}
m_currInputPortPos.y += drawInfo.InvertedZoom * ( m_fontHeight + Constants.INPUT_PORT_DELTA_Y ):
}
}
}
// Output Ports
{
m_currOutputPortPos = m_globalPosition:
m_currOutputPortPos.width = drawInfo.InvertedZoom * UIUtils.PortsSize.x:
m_currOutputPortPos.height = drawInfo.InvertedZoom * UIUtils.PortsSize.y:
m_currOutputPortPos.position = m_globalPosition.center - m_currOutputPortPos.size * 0.5f:
//m_currOutputPortPos.x += ( m_globalPosition.width - drawInfo.InvertedZoom * ( Constants.PORT_INITIAL_X + m_anchorAdjust ) ):
//m_currOutputPortPos.y += drawInfo.InvertedZoom * Constants.PORT_INITIAL_Y:// + m_extraHeaderHeight * drawInfo.InvertedZoom:
int outputCount = m_outputPorts.Count:
for( int i = 0: i < outputCount: i++ )
{
if( m_outputPorts[ i ].Visible )
{
//Button
m_outputPorts[ i ].Position = m_currOutputPortPos:
if( !m_outputPorts[ i ].Locked )
{
float overflow = 2:
float scaledOverflow = 3 * drawInfo.InvertedZoom:
m_auxRect = m_currOutputPortPos:
m_auxRect.yMin -= scaledOverflow + overflow:
m_auxRect.yMax += scaledOverflow + overflow:
m_auxRect.xMin -= m_outputPorts[ i ].LabelSize.x + Constants.PORT_TO_LABEL_SPACE_X * drawInfo.InvertedZoom + scaledOverflow + overflow:
m_auxRect.xMax += Constants.PORT_INITIAL_X * drawInfo.InvertedZoom + scaledOverflow + overflow:
m_outputPorts[ i ].ActivePortArea = m_auxRect:
}
m_currOutputPortPos.y += drawInfo.InvertedZoom * ( m_fontHeight + Constants.INPUT_PORT_DELTA_Y ):
}
}
}
}
private static void DrawPicMain(DrawInfo info)
{
// app > @ enter DrawPicMain
// < app
if (info.Extra.A != -1)
{
SetBlend(DX.DX_BLENDMODE_ALPHA, info.Extra.A);
}
else if (info.Extra.BlendAdd != -1)
{
SetBlend(DX.DX_BLENDMODE_ADD, info.Extra.BlendAdd);
}
else if (info.Extra.BlendInv)
{
SetBlend(DX.DX_BLENDMODE_INVSRC, 255);
}
if (info.Extra.Mosaic)
{
DX.SetDrawMode(DX.DX_DRAWMODE_NEAREST);
}
if (info.Extra.Bright.R != -1)
{
SetBright(info.Extra.Bright.R, info.Extra.Bright.G, info.Extra.Bright.B);
}
{
FreeInfo u = info.Layout as FreeInfo;
if (u != null)
{
if (
info.Extra.IntPos ?
DX.DrawModiGraph(
DoubleTools.ToInt(u.LTX),
DoubleTools.ToInt(u.LTY),
DoubleTools.ToInt(u.RTX),
DoubleTools.ToInt(u.RTY),
DoubleTools.ToInt(u.RBX),
DoubleTools.ToInt(u.RBY),
DoubleTools.ToInt(u.LBX),
DoubleTools.ToInt(u.LBY),
info.Picture.GetHandle(),
1
)
!= 0
:
DX.DrawModiGraphF(
(float)u.LTX,
(float)u.LTY,
(float)u.RTX,
(float)u.RTY,
(float)u.RBX,
(float)u.RBY,
(float)u.LBX,
(float)u.LBY,
info.Picture.GetHandle(),
1
)
!= 0
)
// ? 失敗
{
if (info.Extra.IgnoreError == false)
{
throw new DDError();
}
}
goto endDraw;
}
}
{
RectInfo u = info.Layout as RectInfo;
if (u != null)
{
if (
info.Extra.IntPos ?
DX.DrawExtendGraph(
DoubleTools.ToInt(u.L),
DoubleTools.ToInt(u.T),
DoubleTools.ToInt(u.R),
DoubleTools.ToInt(u.B),
info.Picture.GetHandle(),
1
)
!= 0
:
DX.DrawExtendGraphF(
(float)u.L,
(float)u.T,
(float)u.R,
(float)u.B,
info.Picture.GetHandle(),
1
)
!= 0
)
// ? 失敗
{
if (info.Extra.IgnoreError == false)
{
throw new DDError();
}
}
goto endDraw;
}
}
{
SimpleInfo u = info.Layout as SimpleInfo;
if (u != null)
{
if (
info.Extra.IntPos ?
DX.DrawGraph(
DoubleTools.ToInt(u.X),
DoubleTools.ToInt(u.Y),
info.Picture.GetHandle(),
1
)
!= 0
:
DX.DrawGraphF(
(float)u.X,
(float)u.Y,
info.Picture.GetHandle(),
1
)
!= 0
)
// ? 失敗
{
if (info.Extra.IgnoreError == false)
{
throw new DDError();
}
}
goto endDraw;
}
}
throw new DDError(); // ? 不明なレイアウト
endDraw:
if (info.Extra.A != -1 || info.Extra.BlendAdd != -1 || info.Extra.BlendInv)
{
ResetBlend();
}
if (info.Extra.Mosaic)
{
DX.SetDrawMode(DX.DX_DRAWMODE_BILINEAR);
}
if (info.Extra.Bright.R != -1)
{
ResetBright();
}
// app > @ leave DrawPicMain
// < app
}
void SetPartInfo( DrawInfo part, int i, ref ChunkPartInfo[] parts )
{
if( part.iCount == 0 ) return;
ChunkPartInfo info;
info.VbId = graphics.CreateVb( part.vertices, VertexFormat.Pos3fTex2fCol4b, part.vCount );
info.IndicesCount = part.iCount;
info.leftCount = (ushort)part.Count.left; info.rightCount = (ushort)part.Count.right;
info.frontCount = (ushort)part.Count.front; info.backCount = (ushort)part.Count.back;
info.bottomCount = (ushort)part.Count.bottom; info.topCount = (ushort)part.Count.top;
info.spriteCount = (ushort)part.spriteCount;
info.leftIndex = info.spriteCount;
info.rightIndex = info.leftIndex + info.leftCount;
info.frontIndex = info.rightIndex + info.rightCount;
info.backIndex = info.frontIndex + info.frontCount;
info.bottomIndex = info.backIndex + info.backCount;
info.topIndex = info.bottomIndex + info.bottomCount;
// Lazy initalize part arrays so we can save time in MapRenderer for chunks that only contain 1 or 2 part types.
if( parts == null )
parts = new ChunkPartInfo[arraysCount];
parts[i] = info;
}
public DrawInfo Concat(DrawInfo other)
{
return new DrawInfo
{
Alpha = Alpha*other.Alpha,
Color = Color*other.Color,
Position = Position + other.Position,
Rotation = Rotation + other.Rotation,
Scale = Scale*other.Scale
};
}
public Bullet(Bitmap bitmap, int x, int y, int width, int height, float _angle = 0, float RotateX = 0f, float RotateY = 0f, bool AutoRemove = false, int Frames = 0)
{
bulletDrawInfo = new DrawInfo(bitmap, x, y, width, height, _angle, RotateX, RotateY, AutoRemove, Frames);
Base.drawInfos.Add(bulletDrawInfo);
}
public virtual void StartWeaponDraw()
{
weaponDrawInfo = new DrawInfo(weapon.weaponSprite, StartPositionX, StartPositionY, weapon.weaponSizeX, weapon.weaponSizeY, 0f, 0f, drawInfo.angle);
Base.drawInfos.Add(weaponDrawInfo);
}
public override void Draw( DrawInfo drawInfo )
{
base.Draw( drawInfo ):
if ( !m_isVisible )
return:
if ( m_isEditingFields && m_currentParameterType != PropertyType.Global )
{
if ( m_materialMode && m_currentParameterType != PropertyType.Constant )
{
EditorGUI.BeginChangeCheck():
if ( m_floatMode )
{
UIUtils.DrawFloat( this, ref m_propertyDrawPos, ref m_materialValue, LabelWidth * drawInfo.InvertedZoom ):
}
else
{
DrawSlider( ref m_materialValue, drawInfo ):
}
if ( EditorGUI.EndChangeCheck() )
{
m_requireMaterialUpdate = true:
if ( m_currentParameterType != PropertyType.Constant )
{
BeginDelayedDirtyProperty():
}
}
}
else
{
EditorGUI.BeginChangeCheck():
if ( m_floatMode )
{
UIUtils.DrawFloat( this, ref m_propertyDrawPos, ref m_defaultValue, LabelWidth * drawInfo.InvertedZoom ):
}
else
{
DrawSlider( ref m_defaultValue, drawInfo ):
}
if ( EditorGUI.EndChangeCheck() )
{
BeginDelayedDirtyProperty():
}
}
}
else if ( drawInfo.CurrentEventType == EventType.Repaint && ContainerGraph.LodLevel <= ParentGraph.NodeLOD.LOD4 )
{
if( m_currentParameterType == PropertyType.Global )
{
bool guiEnabled = GUI.enabled:
GUI.enabled = false:
DrawFakeFloatMaterial( drawInfo ):
GUI.enabled = guiEnabled:
}
else if ( m_materialMode && m_currentParameterType != PropertyType.Constant )
{
DrawFakeFloatMaterial( drawInfo ):
}
else
{
if ( m_floatMode )
{
//UIUtils.DrawFloat( this, ref m_propertyDrawPos, ref m_defaultValue, LabelWidth * drawInfo.InvertedZoom ):
Rect fakeField = m_propertyDrawPos:
fakeField.xMin += LabelWidth * drawInfo.InvertedZoom:
Rect fakeLabel = m_propertyDrawPos:
fakeLabel.xMax = fakeField.xMin:
EditorGUIUtility.AddCursorRect( fakeLabel, MouseCursor.SlideArrow ):
EditorGUIUtility.AddCursorRect( fakeField, MouseCursor.Text ):
if ( m_previousValue[ 0 ] != m_defaultValue )
{
m_previousValue[ 0 ] = m_defaultValue:
m_fieldText[ 0 ] = m_defaultValue.ToString():
}
GUI.Label( fakeField, m_fieldText[ 0 ], UIUtils.MainSkin.textField ):
}
else
{
DrawFakeSlider( ref m_defaultValue, drawInfo ):
}
}
}
}
public void DrawSources(Graphics g, DrawInfo drawInfo)
{
foreach (var src in drawInfo.Sources)
{
int srcX = src.X;
int srcRight = src.Right;
int y1 = src.AvaTimeY1;
int y2 = src.AvaTimeY2;
int y3 = src.LoadedTimeY1;
int y4 = src.LoadedTimeY2;
// I pass DateRange.End property to calculate bottom Y-coords of the ranges (y2, y4).
// DateRange.End is past-the-end visible, it is 'maximim-date-belonging-to-range' + 1 tick.
// End property yelds to the Y-coord that is 1 pixel greater than the Y-coord
// of 'maximim-date-belonging-to-range' would be. To fix the problem we need
// a little correcion (bottomCoordCorrection).
// I could use DateRange.Maximum but DateRange.End handles better the case
// when the range is empty.
int endCoordCorrection = -1;
int sourceBarWidth = GetSourceBarWidth(srcX, srcRight);
Rectangle shadowOuterRect = new Rectangle(
srcX + StaticMetrics.SourceShadowSize.Width,
y1 + StaticMetrics.SourceShadowSize.Height,
sourceBarWidth + 1, // +1 because DrawShadowRect works with rect bounds similarly to FillRectange: it doesn't fill Left+Width row of pixels.
y2 - y1 + endCoordCorrection + 1
);
if (DrawShadowRect.IsValidRectToDrawShadow(shadowOuterRect))
{
res.SourcesShadow.Draw(
g,
shadowOuterRect,
ShadowSide.All
);
}
// Draw the source with its native color
using (Brush sb = new Brush(src.Color.ToColor()))
{
DrawTimeLineRange(g, y1, y2 + endCoordCorrection, srcX, sourceBarWidth, sb, res.SourcesBorderPen);
}
// Draw the loaded range with a bit darker color
using (Brush sb = new Brush(src.Color.MakeDarker(16).ToColor()))
{
if (y3 != y4)
{
DrawTimeLineRange(g, y3, y4 + endCoordCorrection, srcX, sourceBarWidth, sb, res.SourcesBorderPen);
}
}
foreach (var gap in src.Gaps)
{
int gy1 = gap.Y1;
int gy2 = gap.Y2;
gy1 += StaticMetrics.MinimumTimeSpanHeight / 2;
gy2 -= StaticMetrics.MinimumTimeSpanHeight / 2;
g.FillRectangle(
res.Background,
srcX - 1,
gy1,
srcRight - srcX + 2,
gy2 - gy1 + endCoordCorrection + 1
);
int tempRectHeight = DrawShadowRect.MinimumRectSize.Height + 1;
Rectangle shadowTmp = new Rectangle(
shadowOuterRect.X,
gy1 - tempRectHeight + StaticMetrics.SourceShadowSize.Height + 1,
shadowOuterRect.Width,
tempRectHeight
);
if (DrawShadowRect.IsValidRectToDrawShadow(shadowTmp))
{
res.SourcesShadow.Draw(g, shadowTmp, ShadowSide.Bottom | ShadowSide.Middle | ShadowSide.Right);
}
DrawCutLine(g, srcX, srcX + sourceBarWidth, gy1, res);
DrawCutLine(g, srcX, srcX + sourceBarWidth, gy2, res);
}
}
}
public override void OnNodeLayout( DrawInfo drawInfo )
{
base.OnNodeLayout( drawInfo ):
ConfigTextureType():
}
public override void Draw( DrawInfo drawInfo )
{
base.Draw( drawInfo ):
if( m_dropdownEditing )
{
PropertyType parameterType = (PropertyType)EditorGUIIntPopup( m_dropdownRect,(int)m_currentParameterType, AvailablePropertyTypeLabels, AvailablePropertyTypeValues , UIUtils.PropertyPopUp ):
if( parameterType != m_currentParameterType )
{
ChangeParameterType( parameterType ):
m_dropdownEditing = false:
}
}
if( m_isEditingPicker && m_drawPicker && m_currentParameterType != PropertyType.Global)
{
Rect hitRect = m_previewRect:
hitRect.height = 14 * drawInfo.InvertedZoom:
hitRect.y = m_previewRect.yMax - hitRect.height:
hitRect.width = 4 * 14 * drawInfo.InvertedZoom:
bool restoreMouse = false:
if( Event.current.type == EventType.MouseDown && hitRect.Contains( drawInfo.MousePosition ) )
{
restoreMouse = true:
Event.current.type = EventType.Ignore:
}
EditorGUI.BeginChangeCheck():
m_colorBuffer = GUI.color:
GUI.color = Color.clear:
Type currType = ( m_autocastMode == AutoCastType.Auto ) ? typeof( Texture ) : m_textureType:
if( m_materialMode )
{
m_materialValue = EditorGUIObjectField( m_previewRect, m_materialValue, currType, false ) as Texture:
}
else
{
m_defaultValue = EditorGUIObjectField( m_previewRect, m_defaultValue, currType, false ) as Texture:
}
GUI.color = m_colorBuffer:
if( EditorGUI.EndChangeCheck() )
{
CheckTextureImporter( true ):
SetTitleText( m_propertyInspectorName ):
SetAdditonalTitleText( string.Format( Constants.PropertyValueLabel, GetPropertyValStr() ) ):
ConfigureInputPorts():
ConfigureOutputPorts():
BeginDelayedDirtyProperty():
}
//else if( drawInfo.CurrentEventType == EventType.ExecuteCommand )
//{
// GUI.FocusControl( null ):
// m_isEditingPicker = false:
//}
if( restoreMouse )
{
Event.current.type = EventType.MouseDown:
}
if( ( drawInfo.CurrentEventType == EventType.MouseDown || drawInfo.CurrentEventType == EventType.MouseUp ) )
DrawPreviewMaskButtonsLayout( drawInfo, m_previewRect ):
}
if( !m_drawPicker )
return:
if( drawInfo.CurrentEventType == EventType.Repaint )
{
DrawTexturePicker( drawInfo ):
}
}
public MainForm()
{
files = new FilesHandler();
di = new DrawInfo();
InitializeComponent();
}
public static void DrawNotations(
DrawInfo drawInfo,
int sampleRate = 60,
float tickmarkHeight = 32f,
bool above = false,
TimelineViewMode labelFormat = TimelineViewMode.seconds)
{
// first figure out what step I should use
float majorStepSize = 200.0f;
float width = drawInfo.layout.drawRect.width;
float height = drawInfo.layout.drawRect.height;
float numSteps = Mathf.Ceil(width / majorStepSize);
float scale = drawInfo.layout.Duration;
float scaleStep = scale / numSteps;
// Get the time step
float modScale = scaleStep;
float modScaleMult = 1.0f;
while (modScale < 1.0f)
{
modScale *= 10.0f;
modScaleMult *= 10.0f;
}
while (modScale > 10.0f)
{
modScale /= 10.0f;
modScaleMult /= 10.0f;
}
// modify scale to be divisible by 1/2/4/5
if (modScale > 5.0f)
{
modScale = 5.0f;
}
else if (modScale > 2.5f)
{
modScale = 2.5f;
}
else if (modScale > 2.0f)
{
modScale = 2.0f;
}
else
{
modScale = 1.0f;
}
modScale /= modScaleMult;
// with fixed scale need to find our start point
float startOffset = drawInfo.layout.startTime % modScale;
float start = drawInfo.layout.startTime - startOffset;
float rangeEnd = drawInfo.layout.startTime + scale;
float textLineHeight = GUI.skin.font.lineHeight;
float tickmarkHeightSmall = tickmarkHeight * 0.5f;
float tickmarkHeightMedium = tickmarkHeight * 0.75f;
float verticalPosition = above ? height : height - textLineHeight;
// draw
for (int i = -1;; ++i)
{
float point = start + modScale * i;
if (point > rangeEnd)
{
break;
}
// draw minor steps
for (int j = 1; j < 5; ++j)
{
float subPoint = point + (modScale / 5) * j;
float position = drawInfo.GetPixelPosition(subPoint);
float heightThis = (j == 2 ? tickmarkHeightSmall : tickmarkHeightMedium);
Rect r = new Rect(position, verticalPosition - heightThis, 1, heightThis);
GUI.color = k_MinorTickColor;
GUI.DrawTexture(r, EditorGUIUtility.whiteTexture);
}
// draw major step
{
float position = drawInfo.GetPixelPosition(point);
Rect r = new Rect(position, verticalPosition - tickmarkHeight, 1, tickmarkHeight);
GUI.color = k_MajorTickColor;
GUI.DrawTexture(r, EditorGUIUtility.whiteTexture);
string label = string.Empty;
int frame = (int)(point * sampleRate);
switch (labelFormat)
{
case TimelineViewMode.frames:
label = frame.ToString(CultureInfo.InvariantCulture);
break;
case TimelineViewMode.secondsFrames:
label = TimelineUtility.TimeToTimeFrameStr(point, sampleRate);
break;
default:
label = string.Format(scale < 0.1f ? "{0:0.000}" : "{0:0.00}", (float)point);
break;
}
var labelSize = GUI.skin.GetStyle("label").CalcSize(new GUIContent(label));
var labelOffset = labelSize.y - textLineHeight;
float x = position - labelSize.x * 0.5f;
float y;
if (above)
{
y = 0;
}
else
{
y = verticalPosition - labelOffset * 0.5f; // Centered position below guide line
}
var w = labelSize.x + 2;
var h = labelSize.y;
GUI.color = k_MajorTickColor;
GUI.Label(new Rect(x, y, w, h), label);
}
}
}
public void DrawSources(Graphics g, DrawInfo drawInfo)
{
bool darkMode = viewModel.ColorTheme == Presenters.ColorThemeMode.Dark;
foreach (var src in drawInfo.Sources)
{
int srcX = src.X;
int srcRight = src.Right;
int y1 = src.AvaTimeY1;
int y2 = src.AvaTimeY2;
int y3 = src.LoadedTimeY1;
int y4 = src.LoadedTimeY2;
// I pass DateRange.End property to calculate bottom Y-coords of the ranges (y2, y4).
// DateRange.End is past-the-end visible, it is 'maximum-date-belonging-to-range' + 1 tick.
// End property yields to the Y-coord that is 1 pixel greater than the Y-coord
// of 'maximum-date-belonging-to-range' would be. To fix the problem we need
// a little correction (bottomCoordCorrection).
// I could use DateRange.Maximum but DateRange.End handles better the case
// when the range is empty.
int endCoordCorrection = -1;
int sourceBarWidth = GetSourceBarWidth(srcX, srcRight);
if (darkMode)
{
var p = new Pen(src.Color, 2);
DrawTimeLineRange(g, y1, y2 + endCoordCorrection, srcX, sourceBarWidth, res.DarkModeSourceFillBrush, p);
}
else
{
using (Brush b = new Brush(src.Color)) // Draw the source with its native color
DrawTimeLineRange(g, y1, y2 + endCoordCorrection, srcX, sourceBarWidth, b, res.LightModeSourcesBorderPen);
using (Brush sb = new Brush(src.Color.MakeDarker(16))) // Draw the loaded range with a bit darker color
if (y3 != y4)
{
DrawTimeLineRange(g, y3, y4 + endCoordCorrection, srcX, sourceBarWidth, sb, res.LightModeSourcesBorderPen);
}
}
foreach (var gap in src.Gaps)
{
int gy1 = gap.Y1;
int gy2 = gap.Y2;
gy1 += StaticMetrics.MinimumTimeSpanHeight / 2;
gy2 -= StaticMetrics.MinimumTimeSpanHeight / 2;
g.FillRectangle(
res.Background,
srcX - 1,
gy1,
srcRight - srcX + 2,
gy2 - gy1 + endCoordCorrection + 1
);
var cutLinePen = darkMode ?
new Pen(src.Color, 1f, res.CutLinePenPattern)
: res.LightModeCutLinePen;
DrawCutLine(g, srcX, srcX + sourceBarWidth, gy1, cutLinePen);
DrawCutLine(g, srcX, srcX + sourceBarWidth, gy2, cutLinePen);
}
}
}
public override void Draw(TSource subject, Rectangle destination, Rectangle?source = null, DrawInfo info = default(DrawInfo)) => base.Draw(subject, Convert(destination), source, info);
protected virtual void DrawSprite(int count)
{
int texId = BlockInfo.textures[curBlock * Side.Sides + Side.Right];
int i = texId / elementsPerAtlas1D;
float vOrigin = (texId % elementsPerAtlas1D) * invVerElementSize;
float x1 = X + 2.50f / 16, y1 = Y, z1 = Z + 2.5f / 16;
float x2 = X + 13.5f / 16, y2 = Y + 1, z2 = Z + 13.5f / 16;
const float u1 = 0, u2 = 15.99f / 16f;
float v1 = vOrigin, v2 = vOrigin + invVerElementSize * 15.99f / 16f;
byte offsetType = BlockInfo.SpriteOffset[curBlock];
if (offsetType >= 6 && offsetType <= 7)
{
spriteRng.SetSeed((X + 1217 * Z) & 0x7fffffff);
float valX = spriteRng.Next(-3, 3 + 1) / 16.0f;
float valY = spriteRng.Next(0, 3 + 1) / 16.0f;
float valZ = spriteRng.Next(-3, 3 + 1) / 16.0f;
const float stretch = 1.7f / 16.0f;
x1 += valX - stretch; x2 += valX + stretch;
z1 += valZ - stretch; z2 += valZ + stretch;
if (offsetType == 7)
{
y1 -= valY; y2 -= valY;
}
}
DrawInfo part = normalParts[i];
int col = fullBright ? FastColour.WhitePacked : light.LightCol_Sprite_Fast(X, Y, Z);
if (tinted)
{
col = TintBlock(curBlock, col);
}
VertexP3fT2fC4b v; v.Colour = col;
// Draw Z axis
int index = part.sIndex;
v.X = x1; v.Y = y1; v.Z = z1; v.U = u2; v.V = v2; part.vertices[index + 0] = v;
v.Y = y2; v.V = v1; part.vertices[index + 1] = v;
v.X = x2; v.Z = z2; v.U = u1; part.vertices[index + 2] = v;
v.Y = y1; v.V = v2; part.vertices[index + 3] = v;
// Draw Z axis mirrored
index += part.sAdvance;
v.X = x2; v.Y = y1; v.Z = z2; v.U = u2; part.vertices[index + 0] = v;
v.Y = y2; v.V = v1; part.vertices[index + 1] = v;
v.X = x1; v.Z = z1; v.U = u1; part.vertices[index + 2] = v;
v.Y = y1; v.V = v2; part.vertices[index + 3] = v;
// Draw X axis
index += part.sAdvance;
v.X = x1; v.Y = y1; v.Z = z2; v.U = u2; part.vertices[index + 0] = v;
v.Y = y2; v.V = v1; part.vertices[index + 1] = v;
v.X = x2; v.Z = z1; v.U = u1; part.vertices[index + 2] = v;
v.Y = y1; v.V = v2; part.vertices[index + 3] = v;
// Draw X axis mirrored
index += part.sAdvance;
v.X = x2; v.Y = y1; v.Z = z1; v.U = u2; part.vertices[index + 0] = v;
v.Y = y2; v.V = v1; part.vertices[index + 1] = v;
v.X = x1; v.Z = z2; v.U = u1; part.vertices[index + 2] = v;
v.Y = y1; v.V = v2; part.vertices[index + 3] = v;
part.sIndex += 4;
}
public override void FillRect(Rectangle rectangle, DrawInfo info) => base.FillRect(Convert(rectangle), info);
public void StartDraw(int x, int y)
{
drawInfo = new DrawInfo(bitmap, x,y,50,50, 0f,0f,0f);
Base.drawInfos.Add(drawInfo);
}
void TerrainAtlasChanged( object sender, EventArgs e )
{
int newArraysCount = game.TerrainAtlas1D.TexIds.Length;
if( arraysCount == newArraysCount ) return;
arraysCount = newArraysCount;
Array.Resize( ref drawInfoNormal, arraysCount );
Array.Resize( ref drawInfoTranslucent, arraysCount );
for( int i = 0; i < drawInfoNormal.Length; i++ ) {
if( drawInfoNormal[i] != null ) continue;
drawInfoNormal[i] = new DrawInfo();
drawInfoTranslucent[i] = new DrawInfo();
}
}
public override void DrawGUIControls( DrawInfo drawInfo )
{
//base.DrawGUIControls( drawInfo ):
}
public override void OnNodeLogicUpdate( DrawInfo drawInfo )
{
base.OnNodeLogicUpdate( drawInfo ):
UpdateLocalVar():
}
public unsafe void SetPosition(ref DrawInfo newPosition, in ReadOnlySpan <float> data)
public void StartDraw()
{
drawInfo = new DrawInfo(bitmap, StartPositionX, StartPositionY, vehicleSizeX, vehicleSizeY, 0f,0f,0f);
Base.drawInfos.Add(drawInfo);
}
public override void Draw( DrawInfo drawInfo )
{
base.Draw( drawInfo ):
if( m_isEditingPicker && m_drawPicker )
{
Rect hitRect = m_previewRect:
hitRect.height = 14 * drawInfo.InvertedZoom:
hitRect.y = m_previewRect.yMax - hitRect.height:
hitRect.width = 4 * 14 * drawInfo.InvertedZoom:
bool restoreMouse = false:
if( Event.current.type == EventType.MouseDown && hitRect.Contains( drawInfo.MousePosition ) )
{
restoreMouse = true:
Event.current.type = EventType.Ignore:
}
EditorGUI.BeginChangeCheck():
m_colorBuffer = GUI.color:
GUI.color = Color.clear:
if( m_materialMode )
m_materialTextureArray = EditorGUIObjectField( m_previewRect, m_materialTextureArray, typeof( Texture2DArray ), false ) as Texture2DArray:
else
m_defaultTextureArray = EditorGUIObjectField( m_previewRect, m_defaultTextureArray, typeof( Texture2DArray ), false ) as Texture2DArray:
GUI.color = m_colorBuffer:
if( EditorGUI.EndChangeCheck() )
{
CheckTextureImporter( true ):
SetTitleText( PropertyInspectorName ):
SetAdditonalTitleText( string.Format( Constants.PropertyValueLabel, GetPropertyValStr() ) ):
ConfigureInputPorts():
ConfigureOutputPorts():
BeginDelayedDirtyProperty():
m_requireMaterialUpdate = true:
}
if( restoreMouse )
{
Event.current.type = EventType.MouseDown:
}
if( ( drawInfo.CurrentEventType == EventType.MouseDown || drawInfo.CurrentEventType == EventType.MouseUp ) )
DrawPreviewMaskButtonsLayout( drawInfo, m_previewRect ):
}
if( drawInfo.CurrentEventType != EventType.Repaint )
return:
switch( m_state )
{
default:
case ReferenceState.Self:
if( drawInfo.CurrentEventType == EventType.Repaint )
{
m_drawPreview = false:
m_drawPicker = true:
DrawTexturePicker( drawInfo ):
}
break:
case ReferenceState.Connected:
if( drawInfo.CurrentEventType == EventType.Repaint )
{
m_drawPreview = true:
m_drawPicker = false:
if( m_previewTextProp != null )
{
SetTitleTextOnCallback( m_previewTextProp.TitleContent.text, ( instance, newTitle ) => instance.TitleContent.text = newTitle + " (Input)" ):
SetAdditonalTitleText( m_previewTextProp.AdditonalTitleContent.text ):
}
// Draw chain lock
GUI.Label( m_iconPos, string.Empty, UIUtils.GetCustomStyle( CustomStyle.SamplerTextureIcon ) ):
// Draw frame around preview
GUI.Label( m_previewRect, string.Empty, UIUtils.GetCustomStyle( CustomStyle.SamplerFrame ) ):
}
break:
case ReferenceState.Instance:
{
m_drawPreview = true:
m_drawPicker = false:
if( m_referenceSampler != null )
{
SetTitleTextOnCallback( m_referenceSampler.PreviewTextProp.TitleContent.text, ( instance, newTitle ) => instance.TitleContent.text = newTitle + Constants.InstancePostfixStr ):
SetAdditonalTitleText( m_referenceSampler.PreviewTextProp.AdditonalTitleContent.text ):
}
// Draw chain lock
GUI.Label( m_iconPos, string.Empty, UIUtils.GetCustomStyle( CustomStyle.SamplerTextureIcon ) ):
// Draw frame around preview
GUI.Label( m_previewRect, string.Empty, UIUtils.GetCustomStyle( CustomStyle.SamplerFrame ) ):
}
break:
}
}
void PreStretchTiles( int x1, int y1, int z1 )
{
invVerElementSize = game.TerrainAtlas1D.invElementSize;
arraysCount = game.TerrainAtlas1D.TexIds.Length;
atlas = game.TerrainAtlas1D;
if( drawInfoNormal == null ) {
drawInfoNormal = new DrawInfo[arraysCount];
drawInfoTranslucent = new DrawInfo[arraysCount];
for( int i = 0; i < drawInfoNormal.Length; i++ ) {
drawInfoNormal[i] = new DrawInfo();
drawInfoTranslucent[i] = new DrawInfo();
}
} else {
for( int i = 0; i < drawInfoNormal.Length; i++ ) {
drawInfoNormal[i].ResetState();
drawInfoTranslucent[i].ResetState();
}
}
}
public override void Draw( DrawInfo drawInfo )
{
base.Draw( drawInfo ):
if( !m_isVisible )
return:
if( m_isEditingFields && m_currentParameterType != PropertyType.Global)
{
EditorGUI.BeginChangeCheck():
for( int i = 0: i < 3: i++ )
{
m_propertyDrawPos.y = m_outputPorts[ i + 1 ].Position.y - 2 * drawInfo.InvertedZoom:
if( m_materialMode && m_currentParameterType != PropertyType.Constant )
{
float val = m_materialValue[ i ]:
UIUtils.DrawFloat( this, ref m_propertyDrawPos, ref val, LabelWidth * drawInfo.InvertedZoom ):
m_materialValue[ i ] = val:
}
else
{
float val = m_defaultValue[ i ]:
UIUtils.DrawFloat( this, ref m_propertyDrawPos, ref val, LabelWidth * drawInfo.InvertedZoom ):
m_defaultValue[ i ] = val:
}
}
if( EditorGUI.EndChangeCheck() )
{
m_requireMaterialUpdate = m_materialMode:
BeginDelayedDirtyProperty():
}
}
else if( drawInfo.CurrentEventType == EventType.Repaint && ContainerGraph.LodLevel <= ParentGraph.NodeLOD.LOD4 )
{
bool guiEnabled = GUI.enabled:
GUI.enabled = m_currentParameterType != PropertyType.Global:
for( int i = 0: i < 3: i++ )
{
m_propertyDrawPos.y = m_outputPorts[ i + 1 ].Position.y - 2 * drawInfo.InvertedZoom:
Rect fakeField = m_propertyDrawPos:
fakeField.xMin += LabelWidth * drawInfo.InvertedZoom:
if( GUI.enabled )
{
Rect fakeLabel = m_propertyDrawPos:
fakeLabel.xMax = fakeField.xMin:
EditorGUIUtility.AddCursorRect( fakeLabel, MouseCursor.SlideArrow ):
EditorGUIUtility.AddCursorRect( fakeField, MouseCursor.Text ):
}
if( m_materialMode && m_currentParameterType != PropertyType.Constant )
{
if( m_previousValue[ i ] != m_materialValue[ i ] )
{
m_previousValue[ i ] = m_materialValue[ i ]:
m_fieldText[ i ] = m_materialValue[ i ].ToString():
}
}
else
{
if( m_previousValue[ i ] != m_defaultValue[ i ] )
{
m_previousValue[ i ] = m_defaultValue[ i ]:
m_fieldText[ i ] = m_defaultValue[ i ].ToString():
}
}
GUI.Label( fakeField, m_fieldText[ i ], UIUtils.MainSkin.textField ):
}
GUI.enabled = guiEnabled:
}
}
void TerrainAtlasChanged( object sender, EventArgs e )
{
int newArraysCount = game.TerrainAtlas1D.TexIds.Length;
if( arraysCount > 0 && arraysCount != newArraysCount ) {
Array.Resize( ref drawInfoNormal, newArraysCount );
Array.Resize( ref drawInfoTranslucent, newArraysCount );
for( int i = arraysCount; i < drawInfoNormal.Length; i++ ) {
drawInfoNormal[i] = new DrawInfo();
drawInfoTranslucent[i] = new DrawInfo();
}
}
arraysCount = newArraysCount;
}
public bool Equals(DrawInfo other)
{
return(ReferenceEquals(Texture, other.Texture));
}
public BatchInfo(DrawInfo drawInfo, int startindex, int indexCount)
{
DrawInfo = drawInfo;
Startindex = startindex;
IndexCount = indexCount;
}
protected override void RenderTile(int index)
{
if (BlockInfo.Draw[curBlock] == DrawType.Sprite)
{
this.fullBright = BlockInfo.FullBright[curBlock];
this.tinted = BlockInfo.Tinted[curBlock];
int count = counts[index + Side.Top];
if (count != 0)
{
DrawSprite(count);
}
return;
}
int leftCount = counts[index++], rightCount = counts[index++],
frontCount = counts[index++], backCount = counts[index++],
bottomCount = counts[index++], topCount = counts[index++];
if (leftCount == 0 && rightCount == 0 && frontCount == 0 &&
backCount == 0 && bottomCount == 0 && topCount == 0)
{
return;
}
bool fullBright = BlockInfo.FullBright[curBlock];
bool isTranslucent = BlockInfo.Draw[curBlock] == DrawType.Translucent;
int lightFlags = BlockInfo.LightOffset[curBlock];
drawer.minBB = BlockInfo.MinBB[curBlock]; drawer.minBB.Y = 1 - drawer.minBB.Y;
drawer.maxBB = BlockInfo.MaxBB[curBlock]; drawer.maxBB.Y = 1 - drawer.maxBB.Y;
Vector3 min = BlockInfo.RenderMinBB[curBlock], max = BlockInfo.RenderMaxBB[curBlock];
drawer.x1 = X + min.X; drawer.y1 = Y + min.Y; drawer.z1 = Z + min.Z;
drawer.x2 = X + max.X; drawer.y2 = Y + max.Y; drawer.z2 = Z + max.Z;
drawer.Tinted = BlockInfo.Tinted[curBlock];
drawer.TintColour = BlockInfo.FogColour[curBlock];
if (leftCount != 0)
{
int texLoc = BlockInfo.textures[curBlock * Side.Sides + Side.Left];
int i = texLoc / elementsPerAtlas1D;
int offset = (lightFlags >> Side.Left) & 1;
DrawInfo part = isTranslucent ? translucentParts[i] : normalParts[i];
int col = fullBright ? FastColour.WhitePacked :
X >= offset?light.LightCol_XSide_Fast(X - offset, Y, Z) : light.OutsideXSide;
drawer.Left(leftCount, col, texLoc, part.vertices, ref part.vIndex[Side.Left]);
}
if (rightCount != 0)
{
int texLoc = BlockInfo.textures[curBlock * Side.Sides + Side.Right];
int i = texLoc / elementsPerAtlas1D;
int offset = (lightFlags >> Side.Right) & 1;
DrawInfo part = isTranslucent ? translucentParts[i] : normalParts[i];
int col = fullBright ? FastColour.WhitePacked :
X <= (maxX - offset) ? light.LightCol_XSide_Fast(X + offset, Y, Z) : light.OutsideXSide;
drawer.Right(rightCount, col, texLoc, part.vertices, ref part.vIndex[Side.Right]);
}
if (frontCount != 0)
{
int texLoc = BlockInfo.textures[curBlock * Side.Sides + Side.Front];
int i = texLoc / elementsPerAtlas1D;
int offset = (lightFlags >> Side.Front) & 1;
DrawInfo part = isTranslucent ? translucentParts[i] : normalParts[i];
int col = fullBright ? FastColour.WhitePacked :
Z >= offset?light.LightCol_ZSide_Fast(X, Y, Z - offset) : light.OutsideZSide;
drawer.Front(frontCount, col, texLoc, part.vertices, ref part.vIndex[Side.Front]);
}
if (backCount != 0)
{
int texLoc = BlockInfo.textures[curBlock * Side.Sides + Side.Back];
int i = texLoc / elementsPerAtlas1D;
int offset = (lightFlags >> Side.Back) & 1;
DrawInfo part = isTranslucent ? translucentParts[i] : normalParts[i];
int col = fullBright ? FastColour.WhitePacked :
Z <= (maxZ - offset) ? light.LightCol_ZSide_Fast(X, Y, Z + offset) : light.OutsideZSide;
drawer.Back(backCount, col, texLoc, part.vertices, ref part.vIndex[Side.Back]);
}
if (bottomCount != 0)
{
int texLoc = BlockInfo.textures[curBlock * Side.Sides + Side.Bottom];
int i = texLoc / elementsPerAtlas1D;
int offset = (lightFlags >> Side.Bottom) & 1;
DrawInfo part = isTranslucent ? translucentParts[i] : normalParts[i];
int col = fullBright ? FastColour.WhitePacked : light.LightCol_YBottom_Fast(X, Y - offset, Z);
drawer.Bottom(bottomCount, col, texLoc, part.vertices, ref part.vIndex[Side.Bottom]);
}
if (topCount != 0)
{
int texLoc = BlockInfo.textures[curBlock * Side.Sides + Side.Top];
int i = texLoc / elementsPerAtlas1D;
int offset = (lightFlags >> Side.Top) & 1;
DrawInfo part = isTranslucent ? translucentParts[i] : normalParts[i];
int col = fullBright ? FastColour.WhitePacked : light.LightCol_YTop_Fast(X, (Y + 1) - offset, Z);
drawer.Top(topCount, col, texLoc, part.vertices, ref part.vIndex[Side.Top]);
}
}
private void InternalDrawNode(DrawNode node)
{
node.WorldPosition = _transform.Position + node.Position;
node.ScreenPosition = node.WorldPosition - _layerCamPosition;
if (node.Visible)
node.Draw(this);
else
return;
if (node.ChildrenCount == 0)
return;
var startTransform = _transform;
_transform.Position += node.Position;
if (node.Cascade)
{
_transform.Alpha *= node.Alpha;
_transform.Color *= node.Color.ToVector3();
_transform.Rotation += node.Rotation;
_transform.Scale *= node.Scale;
}
foreach (var child in node.Children)
InternalDrawNode(child);
_transform = startTransform;
}
private void DrawTree(List <ChildElement> childElements, DrawInfo parentDrawInfo, Logic.DrawManager drawManager)
{
DrawInfo childDrawInfo = new DrawInfo();
foreach (var child in childElements)
{
if (child.AttachedSide == AttachedSides.left || child.AttachedSide == AttachedSides.rigth)
{
childDrawInfo.Heigth = parentDrawInfo.Heigth;
childDrawInfo.Width = child.Width;
}
else
{
childDrawInfo.Heigth = child.Height;
childDrawInfo.Width = child.Width;
}
switch (child.AttachedSide)
{
case AttachedSides.rigth:
{
childDrawInfo.X = parentDrawInfo.X + parentDrawInfo.Width;
childDrawInfo.Y = parentDrawInfo.Y + (parentDrawInfo.Heigth - childDrawInfo.Heigth) / 2;
break;
}
case AttachedSides.left:
{
childDrawInfo.X = parentDrawInfo.X - childDrawInfo.Width;
childDrawInfo.Y = parentDrawInfo.Y + (parentDrawInfo.Heigth - childDrawInfo.Heigth) / 2;
break;
}
case AttachedSides.top:
{
childDrawInfo.X = parentDrawInfo.X + (parentDrawInfo.Width - childDrawInfo.Width) / 2;
childDrawInfo.Y = parentDrawInfo.Y - childDrawInfo.Heigth;
break;
}
case AttachedSides.bottom:
{
childDrawInfo.X = parentDrawInfo.X + (parentDrawInfo.Width - childDrawInfo.Width) / 2;
childDrawInfo.Y = parentDrawInfo.Y + parentDrawInfo.Heigth;
break;
}
}
//MessageBox.Show("wef");
drawManager.DrawRectangle(childDrawInfo.Heigth, childDrawInfo.Width, childDrawInfo.X, childDrawInfo.Y, _drawParent);
if (child.Childrens != null)
{
DrawTree(child.Childrens, new DrawInfo()
{
Width = childDrawInfo.Width,
Heigth = childDrawInfo.Heigth,
X = childDrawInfo.X,
Y = childDrawInfo.Y
}
, drawManager);
}
}
}
