public RenderPassEndingAccessResolveSubresourceParameters
        (
            uint?srcSubresource = null,
            uint?dstSubresource = null,
            uint?dstX           = null,
            uint?dstY           = null,
            Silk.NET.Maths.Rectangle <long>?srcRect = null
        ) : this()
        {
            if (srcSubresource is not null)
            {
                SrcSubresource = srcSubresource.Value;
            }

            if (dstSubresource is not null)
            {
                DstSubresource = dstSubresource.Value;
            }

            if (dstX is not null)
            {
                DstX = dstX.Value;
            }

            if (dstY is not null)
            {
                DstY = dstY.Value;
            }

            if (srcRect is not null)
            {
                SrcRect = srcRect.Value;
            }
        }
        public PresentParameters
        (
            uint?dirtyRectsCount = null,
            Silk.NET.Maths.Rectangle <int> *pDirtyRects  = null,
            Silk.NET.Maths.Rectangle <int> *pScrollRect  = null,
            Silk.NET.Maths.Vector2D <int> *pScrollOffset = null
        ) : this()
        {
            if (dirtyRectsCount is not null)
            {
                DirtyRectsCount = dirtyRectsCount.Value;
            }

            if (pDirtyRects is not null)
            {
                PDirtyRects = pDirtyRects;
            }

            if (pScrollRect is not null)
            {
                PScrollRect = pScrollRect;
            }

            if (pScrollOffset is not null)
            {
                PScrollOffset = pScrollOffset;
            }
        }
示例#3
0
        public OutputDesc
        (
            Silk.NET.Maths.Rectangle <int>?desktopCoordinates = null,
            int?attachedToDesktop = null,
            ModeRotation?rotation = null,
            nint?monitor          = null
        ) : this()
        {
            if (desktopCoordinates is not null)
            {
                DesktopCoordinates = desktopCoordinates.Value;
            }

            if (attachedToDesktop is not null)
            {
                AttachedToDesktop = attachedToDesktop.Value;
            }

            if (rotation is not null)
            {
                Rotation = rotation.Value;
            }

            if (monitor is not null)
            {
                Monitor = monitor.Value;
            }
        }
示例#4
0
        public DiscardRegion
        (
            uint?numRects = null,
            Silk.NET.Maths.Rectangle <int> *pRects = null,
            uint?firstSubresource = null,
            uint?numSubresources  = null
        ) : this()
        {
            if (numRects is not null)
            {
                NumRects = numRects.Value;
            }

            if (pRects is not null)
            {
                PRects = pRects;
            }

            if (firstSubresource is not null)
            {
                FirstSubresource = firstSubresource.Value;
            }

            if (numSubresources is not null)
            {
                NumSubresources = numSubresources.Value;
            }
        }
示例#5
0
        /// <summary>To be documented.</summary>
        public readonly unsafe int GetTargetRect(Silk.NET.Maths.Rectangle <long> *pRect)
        {
            var @this = (IDXGIDecodeSwapChain *)Unsafe.AsPointer(ref Unsafe.AsRef(in this));
            int ret   = default;

            ret = ((delegate * unmanaged[Cdecl] < IDXGIDecodeSwapChain *, Silk.NET.Maths.Rectangle <long> *, int >)LpVtbl[8])(@this, pRect);
            return(ret);
        }
        /// <summary>To be documented.</summary>
        public readonly unsafe int AddDirtyRect(Silk.NET.Maths.Rectangle <long> *pDirtyRect)
        {
            var @this = (IDirect3DTexture9 *)Unsafe.AsPointer(ref Unsafe.AsRef(in this));
            int ret   = default;

            ret = ((delegate * unmanaged[Cdecl] < IDirect3DTexture9 *, Silk.NET.Maths.Rectangle <long> *, int >)LpVtbl[21])(@this, pDirtyRect);
            return(ret);
        }
        /// <summary>To be documented.</summary>
        public readonly unsafe int LockRect(uint Level, LockedRect *pLockedRect, Silk.NET.Maths.Rectangle <long> *pRect, uint Flags)
        {
            var @this = (IDirect3DTexture9 *)Unsafe.AsPointer(ref Unsafe.AsRef(in this));
            int ret   = default;

            ret = ((delegate * unmanaged[Cdecl] < IDirect3DTexture9 *, uint, LockedRect *, Silk.NET.Maths.Rectangle <long> *, uint, int >)LpVtbl[19])(@this, Level, pLockedRect, pRect, Flags);
            return(ret);
        }
        /// <summary>To be documented.</summary>
        public readonly unsafe int Present(Silk.NET.Maths.Rectangle <long> *pSourceRect, Silk.NET.Maths.Rectangle <long> *pDestRect, nint hDestWindowOverride, RGNData *pDirtyRegion, uint dwFlags)
        {
            var @this = (IDirect3DSwapChain9 *)Unsafe.AsPointer(ref Unsafe.AsRef(in this));
            int ret   = default;

            ret = ((delegate * unmanaged[Cdecl] < IDirect3DSwapChain9 *, Silk.NET.Maths.Rectangle <long> *, Silk.NET.Maths.Rectangle <long> *, nint, RGNData *, uint, int >)LpVtbl[3])(@this, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion, dwFlags);
            return(ret);
        }
示例#9
0
        public OutputDesc1
        (
            Silk.NET.Maths.Rectangle <long>?desktopCoordinates = null,
            int?attachedToDesktop       = null,
            ModeRotation?rotation       = null,
            IntPtr?monitor              = null,
            uint?bitsPerColor           = null,
            ColorSpaceType?colorSpace   = null,
            float?minLuminance          = null,
            float?maxLuminance          = null,
            float?maxFullFrameLuminance = null
        ) : this()
        {
            if (desktopCoordinates is not null)
            {
                DesktopCoordinates = desktopCoordinates.Value;
            }

            if (attachedToDesktop is not null)
            {
                AttachedToDesktop = attachedToDesktop.Value;
            }

            if (rotation is not null)
            {
                Rotation = rotation.Value;
            }

            if (monitor is not null)
            {
                Monitor = monitor.Value;
            }

            if (bitsPerColor is not null)
            {
                BitsPerColor = bitsPerColor.Value;
            }

            if (colorSpace is not null)
            {
                ColorSpace = colorSpace.Value;
            }

            if (minLuminance is not null)
            {
                MinLuminance = minLuminance.Value;
            }

            if (maxLuminance is not null)
            {
                MaxLuminance = maxLuminance.Value;
            }

            if (maxFullFrameLuminance is not null)
            {
                MaxFullFrameLuminance = maxFullFrameLuminance.Value;
            }
        }
 public VideoProcessOutputStreamArguments
 (
     Silk.NET.Maths.Rectangle <int>?targetRectangle = null
 ) : this()
 {
     if (targetRectangle is not null)
     {
         TargetRectangle = targetRectangle.Value;
     }
 }
示例#11
0
        /// <summary>To be documented.</summary>
        public readonly unsafe int LockRect(ref LockedRect pLockedRect, Silk.NET.Maths.Rectangle <long> *pRect, uint Flags)
        {
            var @this = (IDirect3DSurface9 *)Unsafe.AsPointer(ref Unsafe.AsRef(in this));
            int ret   = default;

            fixed(LockedRect *pLockedRectPtr = &pLockedRect)
            {
                ret = ((delegate * unmanaged[Cdecl] < IDirect3DSurface9 *, LockedRect *, Silk.NET.Maths.Rectangle <long> *, uint, int >)LpVtbl[13])(@this, pLockedRectPtr, pRect, Flags);
            }

            return(ret);
        }
示例#12
0
        /// <summary>To be documented.</summary>
        public readonly int GetSourceRect(ref Silk.NET.Maths.Rectangle <long> pRect)
        {
            var @this = (IDXGIDecodeSwapChain *)Unsafe.AsPointer(ref Unsafe.AsRef(in this));
            int ret   = default;

            fixed(Silk.NET.Maths.Rectangle <long> *pRectPtr = &pRect)
            {
                ret = ((delegate * unmanaged[Cdecl] < IDXGIDecodeSwapChain *, Silk.NET.Maths.Rectangle <long> *, int >)LpVtbl[7])(@this, pRectPtr);
            }

            return(ret);
        }
        /// <summary>To be documented.</summary>
        public readonly int AddDirtyRect(CubemapFaces FaceType, ref Silk.NET.Maths.Rectangle <long> pDirtyRect)
        {
            var @this = (IDirect3DCubeTexture9 *)Unsafe.AsPointer(ref Unsafe.AsRef(in this));
            int ret   = default;

            fixed(Silk.NET.Maths.Rectangle <long> *pDirtyRectPtr = &pDirtyRect)
            {
                ret = ((delegate * unmanaged[Cdecl] < IDirect3DCubeTexture9 *, CubemapFaces, Silk.NET.Maths.Rectangle <long> *, int >)LpVtbl[21])(@this, FaceType, pDirtyRectPtr);
            }

            return(ret);
        }
        public HdetwVideoprocessblthd
        (
            ulong?pObject        = null,
            ulong?pOutputSurface = null,
            Silk.NET.Maths.Rectangle <int>?targetRect = null,
            Silk.NET.Direct3D9.Format?outputFormat    = null,
            uint?colorSpace  = null,
            uint?outputFrame = null,
            uint?streamCount = null,
            int?enter        = null
        ) : this()
        {
            if (pObject is not null)
            {
                PObject = pObject.Value;
            }

            if (pOutputSurface is not null)
            {
                POutputSurface = pOutputSurface.Value;
            }

            if (targetRect is not null)
            {
                TargetRect = targetRect.Value;
            }

            if (outputFormat is not null)
            {
                OutputFormat = outputFormat.Value;
            }

            if (colorSpace is not null)
            {
                ColorSpace = colorSpace.Value;
            }

            if (outputFrame is not null)
            {
                OutputFrame = outputFrame.Value;
            }

            if (streamCount is not null)
            {
                StreamCount = streamCount.Value;
            }

            if (enter is not null)
            {
                Enter = enter.Value;
            }
        }
示例#15
0
        public DXVA2VideoSample
        (
            long?start = null,
            long?end   = null,
            DXVA2ExtendedFormat?sampleFormat = null,
            Silk.NET.Direct3D9.IDirect3DSurface9 *srcSurface = null,
            Silk.NET.Maths.Rectangle <int>?srcRect           = null,
            Silk.NET.Maths.Rectangle <int>?dstRect           = null,
            DXVA2Fixed32?planarAlpha = null,
            uint?sampleData          = null
        ) : this()
        {
            if (start is not null)
            {
                Start = start.Value;
            }

            if (end is not null)
            {
                End = end.Value;
            }

            if (sampleFormat is not null)
            {
                SampleFormat = sampleFormat.Value;
            }

            if (srcSurface is not null)
            {
                SrcSurface = srcSurface;
            }

            if (srcRect is not null)
            {
                SrcRect = srcRect.Value;
            }

            if (dstRect is not null)
            {
                DstRect = dstRect.Value;
            }

            if (planarAlpha is not null)
            {
                PlanarAlpha = planarAlpha.Value;
            }

            if (sampleData is not null)
            {
                SampleData = sampleData.Value;
            }
        }
示例#16
0
        public DeinterlaceBltEx
        (
            uint?size = null,
            AYUVsample2?backgroundColor             = null,
            Silk.NET.Maths.Rectangle <int>?rcTarget = null,
            long?rtTarget          = null,
            uint?numSourceSurfaces = null,
            float?alpha            = null,
            uint?destinationFormat = null,
            uint?destinationFlags  = null
        ) : this()
        {
            if (size is not null)
            {
                Size = size.Value;
            }

            if (backgroundColor is not null)
            {
                BackgroundColor = backgroundColor.Value;
            }

            if (rcTarget is not null)
            {
                RcTarget = rcTarget.Value;
            }

            if (rtTarget is not null)
            {
                RtTarget = rtTarget.Value;
            }

            if (numSourceSurfaces is not null)
            {
                NumSourceSurfaces = numSourceSurfaces.Value;
            }

            if (alpha is not null)
            {
                Alpha = alpha.Value;
            }

            if (destinationFormat is not null)
            {
                DestinationFormat = destinationFormat.Value;
            }

            if (destinationFlags is not null)
            {
                DestinationFlags = destinationFlags.Value;
            }
        }
示例#17
0
        public ProcAmpControlBlt
        (
            uint?size = null,
            Silk.NET.Maths.Rectangle <int>?dstRect = null,
            Silk.NET.Maths.Rectangle <int>?srcRect = null,
            float?alpha      = null,
            float?brightness = null,
            float?contrast   = null,
            float?hue        = null,
            float?saturation = null
        ) : this()
        {
            if (size is not null)
            {
                Size = size.Value;
            }

            if (dstRect is not null)
            {
                DstRect = dstRect.Value;
            }

            if (srcRect is not null)
            {
                SrcRect = srcRect.Value;
            }

            if (alpha is not null)
            {
                Alpha = alpha.Value;
            }

            if (brightness is not null)
            {
                Brightness = brightness.Value;
            }

            if (contrast is not null)
            {
                Contrast = contrast.Value;
            }

            if (hue is not null)
            {
                Hue = hue.Value;
            }

            if (saturation is not null)
            {
                Saturation = saturation.Value;
            }
        }
示例#18
0
        public HDBltStateTargetRectData
        (
            int?enable = null,
            Silk.NET.Maths.Rectangle <int>?targetRect = null
        ) : this()
        {
            if (enable is not null)
            {
                Enable = enable.Value;
            }

            if (targetRect is not null)
            {
                TargetRect = targetRect.Value;
            }
        }
        public HDStreamStateDestinationRectData
        (
            int?enable = null,
            Silk.NET.Maths.Rectangle <int>?destinationRect = null
        ) : this()
        {
            if (enable is not null)
            {
                Enable = enable.Value;
            }

            if (destinationRect is not null)
            {
                DestinationRect = destinationRect.Value;
            }
        }
        public HDStreamStateSourceRectData
        (
            int?enable = null,
            Silk.NET.Maths.Rectangle <int>?sourceRect = null
        ) : this()
        {
            if (enable is not null)
            {
                Enable = enable.Value;
            }

            if (sourceRect is not null)
            {
                SourceRect = sourceRect.Value;
            }
        }
        public OutduplMoveRect
        (
            Silk.NET.Maths.Vector2D <int>?sourcePoint      = null,
            Silk.NET.Maths.Rectangle <int>?destinationRect = null
        ) : this()
        {
            if (sourcePoint is not null)
            {
                SourcePoint = sourcePoint.Value;
            }

            if (destinationRect is not null)
            {
                DestinationRect = destinationRect.Value;
            }
        }
示例#22
0
        public DeinterlaceBlt
        (
            uint?size     = null,
            uint?reserved = null,
            long?rtTarget = null,
            Silk.NET.Maths.Rectangle <int>?dstRect = null,
            Silk.NET.Maths.Rectangle <int>?srcRect = null,
            uint?numSourceSurfaces = null,
            float?alpha            = null
        ) : this()
        {
            if (size is not null)
            {
                Size = size.Value;
            }

            if (reserved is not null)
            {
                Reserved = reserved.Value;
            }

            if (rtTarget is not null)
            {
                RtTarget = rtTarget.Value;
            }

            if (dstRect is not null)
            {
                DstRect = dstRect.Value;
            }

            if (srcRect is not null)
            {
                SrcRect = srcRect.Value;
            }

            if (numSourceSurfaces is not null)
            {
                NumSourceSurfaces = numSourceSurfaces.Value;
            }

            if (alpha is not null)
            {
                Alpha = alpha.Value;
            }
        }
示例#23
0
        public VideoSample2
        (
            long?rtStart          = null,
            long?rtEnd            = null,
            uint?sampleFormat     = null,
            uint?sampleFlags      = null,
            void *lpDDSSrcSurface = null,
            Silk.NET.Maths.Rectangle <int>?rcSrc = null,
            Silk.NET.Maths.Rectangle <int>?rcDst = null
        ) : this()
        {
            if (rtStart is not null)
            {
                RtStart = rtStart.Value;
            }

            if (rtEnd is not null)
            {
                RtEnd = rtEnd.Value;
            }

            if (sampleFormat is not null)
            {
                SampleFormat = sampleFormat.Value;
            }

            if (sampleFlags is not null)
            {
                SampleFlags = sampleFlags.Value;
            }

            if (lpDDSSrcSurface is not null)
            {
                LpDDSSrcSurface = lpDDSSrcSurface;
            }

            if (rcSrc is not null)
            {
                RcSrc = rcSrc.Value;
            }

            if (rcDst is not null)
            {
                RcDst = rcDst.Value;
            }
        }
示例#24
0
        /// <summary>To be documented.</summary>
        public readonly int Present(ref Silk.NET.Maths.Rectangle <long> pSourceRect, ref Silk.NET.Maths.Rectangle <long> pDestRect, IntPtr hDestWindowOverride, ref RGNData pDirtyRegion, uint dwFlags)
        {
            var @this = (IDirect3DSwapChain9 *)Unsafe.AsPointer(ref Unsafe.AsRef(in this));
            int ret   = default;

            fixed(Silk.NET.Maths.Rectangle <long> *pSourceRectPtr = &pSourceRect)
            {
                fixed(Silk.NET.Maths.Rectangle <long> *pDestRectPtr = &pDestRect)
                {
                    fixed(RGNData *pDirtyRegionPtr = &pDirtyRegion)
                    {
                        ret = ((delegate * unmanaged[Cdecl] < IDirect3DSwapChain9 *, Silk.NET.Maths.Rectangle <long> *, Silk.NET.Maths.Rectangle <long> *, IntPtr, RGNData *, uint, int >)LpVtbl[3])(@this, pSourceRectPtr, pDestRectPtr, hDestWindowOverride, pDirtyRegionPtr, dwFlags);
                    }
                }
            }

            return(ret);
        }
        public DXVA2TraceVideoProcessBltData
        (
            Silk.NET.Core.Win32Extras.EventTraceHeader?wmiHeader = null,
            ulong?pObject         = null,
            ulong?pRenderTarget   = null,
            ulong?targetFrameTime = null,
            Silk.NET.Maths.Rectangle <int>?targetRect = null,
            int?enter = null
        ) : this()
        {
            if (wmiHeader is not null)
            {
                WmiHeader = wmiHeader.Value;
            }

            if (pObject is not null)
            {
                PObject = pObject.Value;
            }

            if (pRenderTarget is not null)
            {
                PRenderTarget = pRenderTarget.Value;
            }

            if (targetFrameTime is not null)
            {
                TargetFrameTime = targetFrameTime.Value;
            }

            if (targetRect is not null)
            {
                TargetRect = targetRect.Value;
            }

            if (enter is not null)
            {
                Enter = enter.Value;
            }
        }
示例#26
0
        public VideoProcessTransform
        (
            Silk.NET.Maths.Rectangle <int>?sourceRectangle      = null,
            Silk.NET.Maths.Rectangle <int>?destinationRectangle = null,
            VideoProcessOrientation?orientation = null
        ) : this()
        {
            if (sourceRectangle is not null)
            {
                SourceRectangle = sourceRectangle.Value;
            }

            if (destinationRectangle is not null)
            {
                DestinationRectangle = destinationRectangle.Value;
            }

            if (orientation is not null)
            {
                Orientation = orientation.Value;
            }
        }
示例#27
0
        public Surface
        (
            uint?flags          = null,
            PixelFormat *format = null,
            int?w          = null,
            int?h          = null,
            int?pitch      = null,
            void *pixels   = null,
            void *userdata = null,
            int?locked     = null,
            void *lockData = null,
            Silk.NET.Maths.Rectangle <int>?clipRect = null,
            BlitMap *map = null,
            int?refcount = null
        ) : this()
        {
            if (flags is not null)
            {
                Flags = flags.Value;
            }

            if (format is not null)
            {
                Format = format;
            }

            if (w is not null)
            {
                W = w.Value;
            }

            if (h is not null)
            {
                H = h.Value;
            }

            if (pitch is not null)
            {
                Pitch = pitch.Value;
            }

            if (pixels is not null)
            {
                Pixels = pixels;
            }

            if (userdata is not null)
            {
                Userdata = userdata;
            }

            if (locked is not null)
            {
                Locked = locked.Value;
            }

            if (lockData is not null)
            {
                LockData = lockData;
            }

            if (clipRect is not null)
            {
                ClipRect = clipRect.Value;
            }

            if (map is not null)
            {
                Map = map;
            }

            if (refcount is not null)
            {
                Refcount = refcount.Value;
            }
        }
        /// <summary>To be documented.</summary>
        public readonly int LockRect(CubemapFaces FaceType, uint Level, ref LockedRect pLockedRect, ref Silk.NET.Maths.Rectangle <long> pRect, uint Flags)
        {
            var @this = (IDirect3DCubeTexture9 *)Unsafe.AsPointer(ref Unsafe.AsRef(in this));
            int ret   = default;

            fixed(LockedRect *pLockedRectPtr = &pLockedRect)
            {
                fixed(Silk.NET.Maths.Rectangle <long> *pRectPtr = &pRect)
                {
                    ret = ((delegate * unmanaged[Cdecl] < IDirect3DCubeTexture9 *, CubemapFaces, uint, LockedRect *, Silk.NET.Maths.Rectangle <long> *, uint, int >)LpVtbl[19])(@this, FaceType, Level, pLockedRectPtr, pRectPtr, Flags);
                }
            }

            return(ret);
        }
示例#29
0
        public DXVA2VideoProcessBltParams
        (
            long?targetFrame = null,
            Silk.NET.Maths.Rectangle <int>?targetRect      = null,
            Silk.NET.Maths.Vector2D <int>?constrictionSize = null,
            uint?streamingFlags = null,
            DXVA2AYUVSample16?backgroundColor = null,
            DXVA2ExtendedFormat?destFormat    = null,
            DXVA2ProcAmpValues?procAmpValues  = null,
            DXVA2Fixed32?alpha = null,
            DXVA2FilterValues?noiseFilterLuma    = null,
            DXVA2FilterValues?noiseFilterChroma  = null,
            DXVA2FilterValues?detailFilterLuma   = null,
            DXVA2FilterValues?detailFilterChroma = null,
            uint?destData = null
        ) : this()
        {
            if (targetFrame is not null)
            {
                TargetFrame = targetFrame.Value;
            }

            if (targetRect is not null)
            {
                TargetRect = targetRect.Value;
            }

            if (constrictionSize is not null)
            {
                ConstrictionSize = constrictionSize.Value;
            }

            if (streamingFlags is not null)
            {
                StreamingFlags = streamingFlags.Value;
            }

            if (backgroundColor is not null)
            {
                BackgroundColor = backgroundColor.Value;
            }

            if (destFormat is not null)
            {
                DestFormat = destFormat.Value;
            }

            if (procAmpValues is not null)
            {
                ProcAmpValues = procAmpValues.Value;
            }

            if (alpha is not null)
            {
                Alpha = alpha.Value;
            }

            if (noiseFilterLuma is not null)
            {
                NoiseFilterLuma = noiseFilterLuma.Value;
            }

            if (noiseFilterChroma is not null)
            {
                NoiseFilterChroma = noiseFilterChroma.Value;
            }

            if (detailFilterLuma is not null)
            {
                DetailFilterLuma = detailFilterLuma.Value;
            }

            if (detailFilterChroma is not null)
            {
                DetailFilterChroma = detailFilterChroma.Value;
            }

            if (destData is not null)
            {
                DestData = destData.Value;
            }
        }
示例#30
0
        public HdetwVideoprocessblthdStream
        (
            ulong?pObject       = null,
            ulong?pInputSurface = null,
            Silk.NET.Maths.Rectangle <int>?sourceRect      = null,
            Silk.NET.Maths.Rectangle <int>?destinationRect = null,
            Silk.NET.Direct3D9.Format?inputFormat          = null,
            HDFrameFormat?frameFormat = null,
            uint?colorSpace           = null,
            uint?streamNumber         = null,
            uint?outputIndex          = null,
            uint?inputFrameOrField    = null,
            uint?pastFrames           = null,
            uint?futureFrames         = null
        ) : this()
        {
            if (pObject is not null)
            {
                PObject = pObject.Value;
            }

            if (pInputSurface is not null)
            {
                PInputSurface = pInputSurface.Value;
            }

            if (sourceRect is not null)
            {
                SourceRect = sourceRect.Value;
            }

            if (destinationRect is not null)
            {
                DestinationRect = destinationRect.Value;
            }

            if (inputFormat is not null)
            {
                InputFormat = inputFormat.Value;
            }

            if (frameFormat is not null)
            {
                FrameFormat = frameFormat.Value;
            }

            if (colorSpace is not null)
            {
                ColorSpace = colorSpace.Value;
            }

            if (streamNumber is not null)
            {
                StreamNumber = streamNumber.Value;
            }

            if (outputIndex is not null)
            {
                OutputIndex = outputIndex.Value;
            }

            if (inputFrameOrField is not null)
            {
                InputFrameOrField = inputFrameOrField.Value;
            }

            if (pastFrames is not null)
            {
                PastFrames = pastFrames.Value;
            }

            if (futureFrames is not null)
            {
                FutureFrames = futureFrames.Value;
            }
        }