public MaterialExpressionTextureSampleParameter2D(string name, int editorX, int editorY, string parameterName, ParsedPropertyBag coordinates, ResourceReference texture, SamplerType samplerType) : base(name, editorX, editorY, parameterName, null) { Coordinates = coordinates; Texture = texture; SamplerType = samplerType; }
/// <summary> /// Regression learner for XGBoost /// </summary> /// <param name="maximumTreeDepth">Maximum tree depth for base learners. (default is 3)</param> /// <param name="learningRate">Boosting learning rate (xgb's "eta"). 0 indicates no limit. (default is 0.1)</param> /// <param name="estimators">Number of estimators to fit. (default is 100)</param> /// <param name="silent">Whether to print messages while running boosting. (default is false)</param> /// <param name="objective">Specify the learning task and the corresponding learning objective. (default is LinearRegression)</param> /// <param name="boosterType"> which booster to use, can be gbtree, gblinear or dart. /// gbtree and dart use tree based model while gblinear uses linear function (default is gbtree)</param> /// <param name="treeMethod">The tree construction algorithm used in XGBoost. See reference paper: https://arxiv.org/abs/1603.02754. (default is auto)</param> /// <param name="samplerType">Type of sampling algorithm for DART. (default is uniform)</param> /// <param name="normalizeType">Type of normalization algorithm for DART. (default is tree)</param> /// <param name="dropoutRate">Dropout rate for DART (a fraction of previous trees to drop during the dropout). (default is 0.0)</param> /// <param name="oneDrop">When this is true, at least one tree is always dropped during the dropout. /// Allows Binomial-plus-one or epsilon-dropout from the original DART paper. (default is false)</param> /// <param name="skipDrop">Probability of skipping the dropout procedure during a boosting iteration. (default is 0.0) /// If a dropout is skipped, new trees are added in the same manner as gbtree. /// Note that non-zero skip_drop has higher priority than rate_drop or one_drop.</param> /// <param name="numberOfThreads">Number of parallel threads used to run xgboost. -1 means use all thread avialable. (default is -1)</param> /// <param name="gamma">Minimum loss reduction required to make a further partition on a leaf node of the tree. (default is 0) </param> /// <param name="minChildWeight">Minimum sum of instance weight(hessian) needed in a child. (default is 1)</param> /// <param name="maxDeltaStep">Maximum delta step we allow each tree's weight estimation to be. (default is 0)</param> /// <param name="subSample">Subsample ratio of the training instance. (default is 1)</param> /// <param name="colSampleByTree">Subsample ratio of columns when constructing each tree. (defualt is 1)</param> /// <param name="colSampleByLevel">Subsample ratio of columns for each split, in each level. (defualt is 1)</param> /// <param name="l1Regularization">L1 regularization term on weights. Also known as RegAlpha. (default is 0)</param> /// <param name="l2Reguralization">L2 regularization term on weights. Also known as regLambda. (default is 1)</param> /// <param name="scalePosWeight">Balancing of positive and negative weights. (default is 1)</param> /// <param name="baseScore">The initial prediction score of all instances, global bias. (default is 0.5)</param> /// <param name="seed">Random number seed. (defaukt is 0)</param> /// <param name="missing">Value in the data which needs to be present as a missing value. (default is NaN)</param> public RegressionXGBoostLearner(int maximumTreeDepth = 3, double learningRate = 0.1, int estimators = 100, bool silent = true, RegressionObjective objective = RegressionObjective.LinearRegression, BoosterType boosterType = BoosterType.GBTree, TreeMethod treeMethod = TreeMethod.Auto, SamplerType samplerType = SamplerType.Uniform, NormalizeType normalizeType = NormalizeType.Tree, double dropoutRate = 0.0, bool oneDrop = false, double skipDrop = 0.0, int numberOfThreads = -1, double gamma = 0, int minChildWeight = 1, int maxDeltaStep = 0, double subSample = 1, double colSampleByTree = 1, double colSampleByLevel = 1, double l1Regularization = 0, double l2Reguralization = 1, double scalePosWeight = 1, double baseScore = 0.5, int seed = 0, double missing = double.NaN) { ArgumentChecks.ThrowOnArgumentLessThan(nameof(maximumTreeDepth), maximumTreeDepth, 0); ArgumentChecks.ThrowOnArgumentLessThanOrHigherThan(nameof(learningRate), learningRate, 0, 1.0); ArgumentChecks.ThrowOnArgumentLessThan(nameof(estimators), estimators, 1); ArgumentChecks.ThrowOnArgumentLessThan(nameof(numberOfThreads), numberOfThreads, -1); ArgumentChecks.ThrowOnArgumentLessThan(nameof(gamma), gamma, 0); ArgumentChecks.ThrowOnArgumentLessThan(nameof(minChildWeight), minChildWeight, 0); ArgumentChecks.ThrowOnArgumentLessThan(nameof(maxDeltaStep), maxDeltaStep, 0); ArgumentChecks.ThrowOnArgumentLessThanOrHigherThan(nameof(subSample), subSample, 0, 1.0); ArgumentChecks.ThrowOnArgumentLessThanOrHigherThan(nameof(colSampleByTree), colSampleByTree, 0, 1.0); ArgumentChecks.ThrowOnArgumentLessThanOrHigherThan(nameof(colSampleByLevel), colSampleByLevel, 0, 1.0); ArgumentChecks.ThrowOnArgumentLessThan(nameof(l1Regularization), l1Regularization, 0); ArgumentChecks.ThrowOnArgumentLessThan(nameof(l2Reguralization), l2Reguralization, 0); ArgumentChecks.ThrowOnArgumentLessThan(nameof(scalePosWeight), scalePosWeight, 0); m_parameters[ParameterNames.MaxDepth] = maximumTreeDepth; m_parameters[ParameterNames.LearningRate] = (float)learningRate; m_parameters[ParameterNames.Estimators] = estimators; m_parameters[ParameterNames.Silent] = silent; m_parameters[ParameterNames.objective] = objective.ToXGBoostString(); m_parameters[ParameterNames.Threads] = numberOfThreads; m_parameters[ParameterNames.Gamma] = (float)gamma; m_parameters[ParameterNames.MinChildWeight] = minChildWeight; m_parameters[ParameterNames.MaxDeltaStep] = maxDeltaStep; m_parameters[ParameterNames.SubSample] = (float)subSample; m_parameters[ParameterNames.ColSampleByTree] = (float)colSampleByTree; m_parameters[ParameterNames.ColSampleByLevel] = (float)colSampleByLevel; m_parameters[ParameterNames.RegAlpha] = (float)l1Regularization; m_parameters[ParameterNames.RegLambda] = (float)l2Reguralization; m_parameters[ParameterNames.ScalePosWeight] = (float)scalePosWeight; m_parameters[ParameterNames.BaseScore] = (float)baseScore; m_parameters[ParameterNames.Seed] = seed; m_parameters[ParameterNames.Missing] = (float)missing; m_parameters[ParameterNames.ExistingBooster] = null; m_parameters[ParameterNames.Booster] = boosterType.ToXGBoostString(); m_parameters[ParameterNames.TreeMethod] = treeMethod.ToXGBoostString(); m_parameters[ParameterNames.SampleType] = samplerType.ToXGBoostString(); m_parameters[ParameterNames.NormalizeType] = normalizeType.ToXGBoostString(); m_parameters[ParameterNames.RateDrop] = (float)dropoutRate; m_parameters[ParameterNames.OneDrop] = oneDrop ? 1 : 0; m_parameters[ParameterNames.SkipDrop] = (float)skipDrop; }
public IRenderTarget CreateRenderTarget(uint width, uint height, bool autoClearColourAndDepthEachFrame = true, SamplerType samplerType = SamplerType.Anisotropic, uint numberOfMipMapLevels = 1) { if (width == 0 || height == 0) { throw new Yak2DException("Surfaces -> CreateRenderTarget(), dimensions cannot be zero"); } if (numberOfMipMapLevels == 0) { numberOfMipMapLevels = 1; } return(_surfaceManager.CreateRenderSurface( false, width, height, TexturePixelFormatConverter.ConvertYakToVeldrid(_systemComponents.SwapChainFramebufferPixelFormat), true, autoClearColourAndDepthEachFrame, autoClearColourAndDepthEachFrame, samplerType, numberOfMipMapLevels )); }
public void SetUsedTexture( Instruction inst, SamplerType type, TextureFormat format, TextureFlags flags, int cbufSlot, int handle) { inst &= Instruction.Mask; bool isImage = inst == Instruction.ImageLoad || inst == Instruction.ImageStore || inst == Instruction.ImageAtomic; bool isWrite = inst == Instruction.ImageStore || inst == Instruction.ImageAtomic; bool accurateType = inst != Instruction.Lod && inst != Instruction.TextureSize; bool coherent = flags.HasFlag(TextureFlags.Coherent); if (isImage) { SetUsedTextureOrImage(_usedImages, cbufSlot, handle, type, format, true, isWrite, false, coherent); } else { bool intCoords = flags.HasFlag(TextureFlags.IntCoords) || inst == Instruction.TextureSize; SetUsedTextureOrImage(_usedTextures, cbufSlot, handle, type, TextureFormat.Unknown, intCoords, false, accurateType, coherent); } GpuAccessor.RegisterTexture(handle, cbufSlot); }
private ITexture LoadTextureFromEmbeddedPngResource(bool isFrameworkInternal, bool isFontTexture, IAssembly assembly, string assetPathWithoutExtension, ImageFormat imageFormat, SamplerType samplerType, bool generateMipMaps) { var extension = GetFileExtensionFromImageFormat(imageFormat); var fullAssemblyName = string.Concat(assembly.Name, ".", assetPathWithoutExtension, extension); var stream = assembly.GetManifestResourceStream(fullAssemblyName); if (stream == null) { var names = assembly.GetManifestResourceNames(); if (names.Contains(fullAssemblyName)) { _frameworkMessenger.Report("Unable to load texture. Unknown Error. Asset stream was found by name in manifest: " + fullAssemblyName); } else { _frameworkMessenger.Report("Unable to load texture. The provided texture name was not found in assembly: " + fullAssemblyName + " | Expect location format as ASSEMBLYNAME.PATHTOTEXTURES.NAMEPROVIDED.PNG"); } return(null); } return(GenerateTextureFromStream(stream, isFrameworkInternal, isFontTexture, samplerType, generateMipMaps)); }
public TextureMeta(int cbufSlot, int handle, TextureFormat format, SamplerType type) { CbufSlot = cbufSlot; Handle = handle; Format = format; Type = type; }
private static string GetImageTypeName(SamplerType type) { string typeName; switch (type & SamplerType.Mask) { case SamplerType.Texture1D: typeName = "image1D"; break; case SamplerType.TextureBuffer: typeName = "imageBuffer"; break; case SamplerType.Texture2D: typeName = "image2D"; break; case SamplerType.Texture3D: typeName = "image3D"; break; case SamplerType.TextureCube: typeName = "imageCube"; break; default: throw new ArgumentException($"Invalid sampler type \"{type}\"."); } if ((type & SamplerType.Multisample) != 0) { typeName += "MS"; } if ((type & SamplerType.Array) != 0) { typeName += "Array"; } return(typeName); }
public static Filter Convert(SamplerType type, TextureFilter min, TextureFilter mag, TextureFilter mip) { int offset; switch (type) { case SamplerType.Normal: offset = 0; break; case SamplerType.Comparison: offset = 0x80; break; case SamplerType.Minimum: offset = 0x100; break; case SamplerType.Maximum: offset = 0x180; break; default: throw new NotSupportedException("SamplerType is not supported."); } Filter f; if (!filters.TryGetValue(new Tuple <TextureFilter, TextureFilter, TextureFilter>(min, mag, mip), out f)) { throw new NotSupportedException("TextureFilter variant not supported."); } return((Filter)(f + offset)); }
private static SamplerBase CreateSampler(SamplerType samplerType, int numSamples, int numSets = 83) { SamplerBase sampler = null; switch (samplerType) { case SamplerType.Hammersley: sampler = new HammersleySampler(numSamples, numSets); break; case SamplerType.Jittered: sampler = new JitteredSampler(numSamples, numSets); break; case SamplerType.Random: sampler = new RandomSampler(numSamples, numSets); break; case SamplerType.Regular: sampler = new RegularSampler(numSamples, numSets); break; default: sampler = new RegularSampler(numSamples, numSets); break; } return(sampler); }
public MaterialExpressionTextureSample(string name, int editorX, int editorY, ParsedPropertyBag coordinates, ResourceReference texture, ParsedPropertyBag textureObject, SamplerType samplerType) : base(name, editorX, editorY) { Coordinates = coordinates; Texture = texture; TextureObject = textureObject; SamplerType = samplerType; }
public static SamplerState GetSamplerState(SamplerType type) { if (!m_Initialized) { throw new Exception("Uninitialized sampler states!"); } return m_SamplerStates[(int)type]; }
public static SamplerState GetSamplerState(SamplerType type) { if (!m_Initialized) { throw new Exception("Uninitialized sampler states!"); } return(m_SamplerStates[(int)type]); }
public TextureDescriptor(int binding, SamplerType type, TextureFormat format, int cbufSlot, int handleIndex) { Binding = binding; Type = type; Format = format; CbufSlot = cbufSlot; HandleIndex = handleIndex; Flags = TextureUsageFlags.None; }
protected void SetSamplerState(int slot, SamplerType sampler) { if (CurrentSamplerState[slot] == (int)sampler) { return; } GetContext.PixelShader.SetSampler(slot, GetSharedItems.GetSamplerState(sampler)); CurrentSamplerState[slot] = (int)sampler; }
public void SetSampler(SamplerType samplerType, int numSamples, int numSets = 83) { m_Samplers = new SamplerBase[Environment.ProcessorCount]; for (int i = 0; i < m_Samplers.Length; i++) { m_Samplers[i] = SamplerFactory.Create(samplerType, numSamples, numSets); } //m_Sampler = sampler; }
public GpuSurface CreateGpuSurfaceFromTexture(Texture texture, bool isFrameworkInternal, bool isFontTexture, SamplerType samplerType) { if (texture == null) { throw new Yak2DException("Internal Framework Exception: GpuSurfaceFactory passed a null Veldrid Texture", new ArgumentNullException("texture")); } var view = _components.Factory.CreateTextureView(texture); Sampler wrap = null; Sampler mirror = null; switch (samplerType) { case SamplerType.Anisotropic: wrap = _anisotropicSamplerWrap; mirror = _anisotropicSamplerMirror; break; case SamplerType.Linear: wrap = _linearSamplerWrap; mirror = _linearSamplerMirror; break; case SamplerType.Point: wrap = _pointSamplerWrap; mirror = _pointSamplerMirror; break; } var resourceSet_Wrap = _components.Factory.CreateResourceSet(new ResourceSetDescription( _cachedTextureResourceLayout, view, wrap )); var resourceSet_Mirror = _components.Factory.CreateResourceSet(new ResourceSetDescription( _cachedTextureResourceLayout, view, mirror )); return(new GpuSurface { //Note Surfaces related to USER FONTS are also tagged as internal. This is so their destruction is related to //The FONT item and not caught up in any DestroyAllUserSurfaces type calls (that being reserved for TEXTURES and RENDERTARGETS Type = GpuSurfaceType.Texture | (isFrameworkInternal ? GpuSurfaceType.Internal : isFontTexture ? GpuSurfaceType.Internal : GpuSurfaceType.User), Texture = texture, TextureView = view, Framebuffer = null, ResourceSet_TexWrap = resourceSet_Wrap, ResourceSet_TexMirror = resourceSet_Mirror }); }
private void SetUsedTextureOrImage( Dictionary <TextureInfo, TextureMeta> dict, int cbufSlot, int handle, SamplerType type, TextureFormat format, bool intCoords, bool write, bool accurateType) { var dimensions = type.GetDimensions(); var isIndexed = type.HasFlag(SamplerType.Indexed); var usageFlags = TextureUsageFlags.None; if (intCoords) { usageFlags |= TextureUsageFlags.NeedsScaleValue; var canScale = (Stage == ShaderStage.Fragment || Stage == ShaderStage.Compute) && !isIndexed && !write && dimensions == 2; if (!canScale) { // Resolution scaling cannot be applied to this texture right now. // Flag so that we know to blacklist scaling on related textures when binding them. usageFlags |= TextureUsageFlags.ResScaleUnsupported; } } if (write) { usageFlags |= TextureUsageFlags.ImageStore; } int arraySize = isIndexed ? SamplerArraySize : 1; for (int layer = 0; layer < arraySize; layer++) { var info = new TextureInfo(cbufSlot, handle + layer * 2, isIndexed, format); var meta = new TextureMeta() { AccurateType = accurateType, Type = type, UsageFlags = usageFlags }; if (dict.TryGetValue(info, out var existingMeta)) { dict[info] = MergeTextureMeta(meta, existingMeta); } else { dict.Add(info, meta); } } }
public SamplerInfo( SamplerType type, int textureSlot, int samplerSlot, string name, SamplerState?state, int parameter) { Type = type; TextureSlot = textureSlot; SamplerSlot = samplerSlot; Name = name ?? throw new ArgumentNullException(nameof(name)); State = state; Parameter = parameter; }
public TextureOperation( Instruction inst, SamplerType type, TextureFormat format, TextureFlags flags, int handle, int compIndex, Operand dest, Operand[] sources) : this(inst, type, format, flags, DefaultCbufSlot, handle, compIndex, dest, sources) { }
public static int GetDimensions(this SamplerType type) { return((type & SamplerType.Mask) switch { SamplerType.Texture1D => 1, SamplerType.TextureBuffer => 1, SamplerType.Texture2D => 2, SamplerType.Texture3D => 3, SamplerType.TextureCube => 3, _ => throw new ArgumentException($"Invalid sampler type \"{type}\".") });
public TextureDescriptor(string name, SamplerType type, int cbufSlot, int cbufOffset) { Name = name; Type = type; HandleIndex = 0; IsBindless = true; CbufSlot = cbufSlot; CbufOffset = cbufOffset; }
private static Dim GetDim(SamplerType type) { return((type & SamplerType.Mask) switch { SamplerType.Texture1D => Dim.Dim1D, SamplerType.Texture2D => Dim.Dim2D, SamplerType.Texture3D => Dim.Dim3D, SamplerType.TextureCube => Dim.Cube, SamplerType.TextureBuffer => Dim.Buffer, _ => throw new ArgumentException($"Invalid sampler type \"{type & SamplerType.Mask}\".") });
public TextureDescriptor(string name, SamplerType type, int handleIndex) { Name = name; Type = type; HandleIndex = handleIndex; IsBindless = false; CbufSlot = 0; CbufOffset = 0; }
private ulong CreateSurface(uint width, uint height, SamplerType samplerType, PixelFormat pixelFormat) { return(_surfaceManager.CreateRenderSurface(true, width, height, pixelFormat, false, false, false, samplerType, 1).Id); }
private ulong CreateSurface(uint width, uint height, SamplerType samplerType) { return(_surfaceManager.CreateRenderSurface(true, width, height, TexturePixelFormatConverter.ConvertYakToVeldrid(_systemComponents.SwapChainFramebufferPixelFormat), false, false, false, samplerType, 1).Id); }
public TextureOperation( Instruction inst, SamplerType type, TextureFlags flags, int handle, int compIndex, Operand dest, params Operand[] sources) : base(inst, compIndex, dest, sources) { Type = type; Flags = flags; Handle = handle; }
public static ISampler GetSampler(SamplerType type) { var defaultSampler = new ConstSampler(sample: true); switch (type) { case SamplerType.Const: return(defaultSampler); default: return(defaultSampler); } }
public TextureDescriptor(string name, SamplerType type, TextureFormat format, int handleIndex) { Name = name; Type = type; Format = format; HandleIndex = handleIndex; IsBindless = false; CbufSlot = 0; CbufOffset = 0; Flags = TextureUsageFlags.None; }
public TextureDescriptor(string name, SamplerType type, int cbufSlot, int cbufOffset) { Name = name; Type = type; Format = TextureFormat.Unknown; HandleIndex = 0; IsBindless = true; CbufSlot = cbufSlot; CbufOffset = cbufOffset; Flags = TextureUsageFlags.None; }
public ITexture GenerateTextureFromStream(Stream stream, bool isFrameworkInternal, bool isFontTexture, SamplerType samplerType, bool generateMipMaps) { var veldridTexture = _imageSharpLoader.GenerateVeldridTextureFromStream(stream, generateMipMaps); var id = _idGenerator.New(); var surface = _gpuSurfaceFactory.CreateGpuSurfaceFromTexture(veldridTexture, isFrameworkInternal, isFontTexture, samplerType); return(_surfaceCollection.Add(id, surface) ? new TextureReference(id) : null); }
public AstTextureOperation( Instruction inst, SamplerType type, TextureFlags flags, int handle, int arraySize, int index, params IAstNode[] sources) : base(inst, index, sources) { Type = type; Flags = flags; Handle = handle; ArraySize = arraySize; }