/// <inheritdoc/> protected internal override void OnDestroyed() { GraphicsDevice.Collect(NativeSampler); NativeSampler = Sampler.Null; base.OnDestroyed(); }
public void Init(string s) { animation = GetComponent<VillagerAnimation>(); animation.Init (s); skinMaterial = GetComponentInChildren<MeshRenderer>().material; origColor = skinMaterial.color; // music stuff musicToggle = GetComponent<ToggleSuspend>(); musicPattern = GetComponent<Pattern>(); SetMusicPattern(); musicSample = GetComponent<Sampler>(); SetMusicSample(); keyboardPosition = transform.localPosition; textMesh = GetComponentInChildren<TextMesh>(); letter = s; textMesh.text = s; currentState = State.Idle; timeSinceLastDanced = Time.time; }
public FloatMapImage RenderImage(Size imageSize) { int height = imageSize.Height; int width = imageSize.Width; FloatMapImage outputImage = new FloatMapImage((uint)width, (uint)height, PixelFormat.Greyscale); Sensor.RasterSize = imageSize; Sampler sampler = new Sampler(); int SqrtSampleCount = (int)Math.Sqrt(SampleCount); foreach (Vector2d sample in sampler.GenerateJitteredSamples(SqrtSampleCount)) { // generate a sample at the lens surface Vector3d lensPos = Lens.GetBackSurfaceSample(sample); lensPos.Z = 0; // make an incoming ray from the light source to the lens sample and // transfer the incoming ray through the lens creating the outgoing ray Ray outgoingRay = Lens.Transfer(LightSourcePosition, lensPos); if (outgoingRay == null) { continue; } // intersect the senzor with the outgoing ray Intersection intersection = Sensor.Intersect(outgoingRay); if (intersection == null) { continue; } Vector3d intersectionPoint = intersection.Position; Vector2d intersectionPixelPoint = Sensor.CameraToImage(intersectionPoint); // put a splat on the senzor at the intersection Splat(outputImage, LightIntensity, intersectionPixelPoint); } return outputImage; }
internal static unsafe SharpVulkan.DescriptorSetLayout CreateNativeDescriptorSetLayout(GraphicsDevice device, IList<DescriptorSetLayoutBuilder.Entry> entries, out uint[] typeCounts) { var bindings = new DescriptorSetLayoutBinding[entries.Count]; var immutableSamplers = new Sampler[entries.Count]; int usedBindingCount = 0; typeCounts = new uint[DescriptorTypeCount]; fixed (Sampler* immutableSamplersPointer = &immutableSamplers[0]) { for (int i = 0; i < entries.Count; i++) { var entry = entries[i]; // TODO VULKAN: Special case for unused bindings in PipelineState. Handle more nicely. if (entry.ArraySize == 0) continue; bindings[usedBindingCount] = new DescriptorSetLayoutBinding { DescriptorType = VulkanConvertExtensions.ConvertDescriptorType(entry.Class, entry.Type), StageFlags = ShaderStageFlags.All, // TODO VULKAN: Filter? Binding = (uint)i, DescriptorCount = (uint)entry.ArraySize }; if (entry.ImmutableSampler != null) { // TODO VULKAN: Handle immutable samplers for DescriptorCount > 1 if (entry.ArraySize > 1) { throw new NotImplementedException(); } // Remember this, so we can choose the right DescriptorType in DescriptorSet.SetShaderResourceView immutableSamplers[i] = entry.ImmutableSampler.NativeSampler; //bindings[i].DescriptorType = DescriptorType.CombinedImageSampler; bindings[usedBindingCount].ImmutableSamplers = new IntPtr(immutableSamplersPointer + i); } typeCounts[(int)bindings[usedBindingCount].DescriptorType] += bindings[usedBindingCount].DescriptorCount; usedBindingCount++; } var createInfo = new DescriptorSetLayoutCreateInfo { StructureType = StructureType.DescriptorSetLayoutCreateInfo, BindingCount = (uint)usedBindingCount, Bindings = usedBindingCount > 0 ? new IntPtr(Interop.Fixed(bindings)) : IntPtr.Zero }; return device.NativeDevice.CreateDescriptorSetLayout(ref createInfo); } }
public void GenerateJitteredSamples() { Stopwatch sw = Stopwatch.StartNew(); Sampler sampler = new Sampler(); //foreach (var sample in sampler.GenerateJitteredSamples(512)) ; foreach (var sample in sampler.GenerateUniformPoints(256 * 1024)) ; sw.Stop(); Console.WriteLine("Total time: {0}", sw.ElapsedMilliseconds); Console.WriteLine("Thoughput: {0} smpl/sec", 512 * 512 * (1000 / (float)sw.ElapsedMilliseconds)); }
public void TraceRays() { ComplexLens lens = ComplexLens.CreateBiconvexLens(4, 2, 0); Sampler sampler = new Sampler(); int sampleCount = 64; int sqrtSampleCount = (int)Math.Sqrt(sampleCount); Vector3d objectPos = new Vector3d(10, 0, 100); foreach (Vector2d sample in sampler.GenerateJitteredSamples(sqrtSampleCount)) { Vector3d lensPos = lens.GetBackSurfaceSample(sample); Ray result = lens.Transfer(objectPos, lensPos); } }
public void TraceParallelRays() { BiconvexLens lens = new BiconvexLens(); lens.ApertureRadius = 2; lens.CurvatureRadius = 4; Sampler sampler = new Sampler(); int sampleCount = 64; int sqrtSampleCount = (int)Math.Sqrt(sampleCount); Vector3d objectPos = new Vector3d(10, 0, 100); foreach (Vector2d sample in sampler.GenerateJitteredSamples(sqrtSampleCount)) { Vector3d lensPos = lens.GetBackSurfaceSample(sample); //Vector3d objectPos = lensPos + 10 * Vector3d.UnitZ + 2 * Vector3d.UnitX; Ray result = lens.Transfer(objectPos, lensPos); } }
public void TraceSingleRay() { ComplexLens lens = ComplexLens.CreateBiconvexLens(4, 2, 0); Sampler sampler = new Sampler(); int sampleCount = 64; int sqrtSampleCount = (int)Math.Sqrt(sampleCount); Vector3d objectPos = new Vector3d(10, 0, 100); Vector3d direction = new Vector3d(0, 0, 0); Ray ray = new Ray(objectPos, direction); Intersection isec = lens.Intersect(ray); if (isec == null) { return; } Ray result = lens.Transfer(objectPos, isec.Position); }
private unsafe void CreateNativeSampler() { var createInfo = new SamplerCreateInfo { StructureType = StructureType.SamplerCreateInfo, AddressModeU = ConvertAddressMode(Description.AddressU), AddressModeV = ConvertAddressMode(Description.AddressV), AddressModeW = ConvertAddressMode(Description.AddressW), MipLodBias = Description.MipMapLevelOfDetailBias, MaxAnisotropy = Description.MaxAnisotropy, CompareOperation = VulkanConvertExtensions.ConvertComparisonFunction(Description.CompareFunction), MinLod = Description.MinMipLevel, MaxLod = Description.MaxMipLevel, BorderColor = BorderColor.FloatOpaqueBlack // TODO VULKAN: How to handle BorderColor }; ConvertMinFilter(Description.Filter, out createInfo.MinFilter, out createInfo.MagFilter, out createInfo.MipmapMode, out createInfo.CompareEnable, out createInfo.AnisotropyEnable); NativeSampler = GraphicsDevice.NativeDevice.CreateSampler(ref createInfo); }
public void IntersectSphere() { Sphere sphere = new Sphere() { Radius = 2 }; double biggerSphereFactor = 3; Sampler sampler = new Sampler(); int sampleCount = 64; int sqrtSampleCount = (int)Math.Sqrt(sampleCount); foreach (Vector2d sample in sampler.GenerateJitteredSamples(sqrtSampleCount)) { // shoot rays at the sphere center from a bigger concontric sphere Vector3d unitSphereSample = Sampler.UniformSampleSphereWithEqualArea(sample, -1, 1); Vector3d sourcePos = biggerSphereFactor * sphere.Radius * unitSphereSample; Ray ray = new Ray(sourcePos, sphere.Center - sourcePos); Intersection intersection = sphere.Intersect(ray); Assert.NotNull(intersection); Vector3d intPos = intersection.Position; Console.WriteLine("Black, {0},", ray.ToLine()); Console.WriteLine(String.Format("Red, {0},", intPos.ToPoint())); } }
List <StateGroupAsset> loadStateGroups() { var stateGroups = new List <StateGroupAsset>(); if (!Directory.Exists(metadataPath + "StateGroups")) { Directory.CreateDirectory(metadataPath + "StateGroups"); } foreach (var filename in Directory.EnumerateFiles(metadataPath + "StateGroups")) { var metadata = File.ReadAllLines(filename); var stateGroup = new StateGroupAsset(); stateGroup.Name = System.IO.Path.GetFileNameWithoutExtension(filename); stateGroup.Description = metadata[0].Split('=')[1].Trim(); stateGroup.LastUpdated = parseLastUpdatedDate(metadata[1].Split('=')[1].Trim(), "stateGroup", stateGroup.Name); stateGroup.VertexShaderId = metadata[2].Split('=')[1].Trim(); stateGroup.GeometryShaderId = metadata[3].Split('=')[1].Trim(); stateGroup.PixelShaderId = metadata[4].Split('=')[1].Trim(); stateGroup.ShaderCombination = (ShaderCombination)Enum.Parse(typeof(ShaderCombination), metadata[5].Split('=')[1].Trim()); stateGroup.ImportedFilename = metadata[6].Split('=')[1].Trim(); stateGroup.ImporterVersion = int.Parse(metadata[7].Split('=')[1].Trim()); var samplerLine = metadata[8].Split('=')[1].Trim(); var samplerConfigs = samplerLine.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries); foreach (var config in samplerConfigs) { var data = config.Split(','); var sampler = new Sampler() { Name = data[0].Trim(), Filter = (Filter)Enum.Parse(typeof(Filter), data[1].Trim()), AddressU = (TextureAddressMode)Enum.Parse(typeof(TextureAddressMode), data[2].Trim()), AddressV = (TextureAddressMode)Enum.Parse(typeof(TextureAddressMode), data[3].Trim()), AddressW = (TextureAddressMode)Enum.Parse(typeof(TextureAddressMode), data[4].Trim()) }; stateGroup.Samplers.Add(sampler); } var textureLine = metadata[9].Split('=')[1].Trim(); var textureConfigs = textureLine.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries); foreach (var config in textureConfigs) { var data = config.Split(','); var texture = new TextureBinding() { Slot = Int32.Parse(data[0].Trim()), Binding = data[1].Trim() }; stateGroup.TextureBindings.Add(texture); } var blendStateLine = metadata[10].Split('=')[1].Trim(); var blendConfigs = blendStateLine.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries); foreach (var config in blendConfigs) { var data = config.Split(','); var renderTarget = new RenderTarget() { Index = int.Parse(data[0].Trim()), BlendEnabled = bool.Parse(data[1].Trim()), BlendOperation = (BlendOperation)Enum.Parse(typeof(BlendOperation), data[2].Trim()), BlendOperationAlpha = (BlendOperation)Enum.Parse(typeof(BlendOperation), data[3].Trim()), SourceBlend = (BlendOption)Enum.Parse(typeof(BlendOption), data[4].Trim()), DestinationBlend = (BlendOption)Enum.Parse(typeof(BlendOption), data[5].Trim()), SourceBlendAlpha = (BlendOption)Enum.Parse(typeof(BlendOption), data[6].Trim()), DestinationBlendAlpha = (BlendOption)Enum.Parse(typeof(BlendOption), data[7].Trim()), RenderTargetWriteMask = (WriteMask)Enum.Parse(typeof(WriteMask), data[8].Trim()) }; stateGroup.BlendState.RenderTargets.Add(renderTarget); } stateGroups.Add(stateGroup); } return(stateGroups); }
public ZipkinSpanWriter(Sampler sampler) { this.sampler = sampler; }
public ImportResult Import(GLTFAccessor.ImportResult[] accessors, GLTFNode.ImportResult[] nodes, ImportSettings importSettings) { bool multiRoots = nodes.Where(x => x.IsRoot).Count() > 1; ImportResult result = new ImportResult(); result.clip = new AnimationClip(); result.clip.name = name; result.clip.frameRate = importSettings.animationSettings.frameRate; result.clip.legacy = importSettings.animationSettings.useLegacyClips; if (result.clip.legacy && importSettings.animationSettings.looping) { result.clip.wrapMode = WrapMode.Loop; } for (int i = 0; i < channels.Length; i++) { Channel channel = channels[i]; if (samplers.Length <= channel.sampler) { Debug.LogWarning($"GLTFUtility: Animation channel points to sampler at index {channel.sampler} which doesn't exist. Skipping animation clip."); continue; } Sampler sampler = samplers[channel.sampler]; // Get interpolation mode InterpolationMode interpolationMode = importSettings.animationSettings.interpolationMode; if (interpolationMode == InterpolationMode.ImportFromFile) { interpolationMode = sampler.interpolation; } if (interpolationMode == InterpolationMode.CUBICSPLINE) { Debug.LogWarning("Animation interpolation mode CUBICSPLINE not fully supported, result might look different."); } string relativePath = ""; GLTFNode.ImportResult node = nodes[channel.target.node.Value]; while (node != null && !node.IsRoot) { if (string.IsNullOrEmpty(relativePath)) { relativePath = node.transform.name; } else { relativePath = node.transform.name + "/" + relativePath; } if (node.parent.HasValue) { node = nodes[node.parent.Value]; } else { node = null; } } // If file has multiple root nodes, a new parent will be created for them as a final step of the import process. This parent f***s up the curve relative paths. // Add node.transform.name to path if there are multiple roots. This is not the most elegant fix but it works. // See GLTFNodeExtensions.GetRoot if (multiRoots) { relativePath = node.transform.name + "/" + relativePath; } System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture; float[] keyframeInput = accessors[sampler.input].ReadFloat().ToArray(); switch (channel.target.path) { case "translation": Vector3[] pos = accessors[sampler.output].ReadVec3().ToArray(); AnimationCurve posX = new AnimationCurve(); AnimationCurve posY = new AnimationCurve(); AnimationCurve posZ = new AnimationCurve(); for (int k = 0; k < keyframeInput.Length; k++) { posX.AddKey(CreateKeyframe(k, keyframeInput, pos, x => - x.x, interpolationMode)); posY.AddKey(CreateKeyframe(k, keyframeInput, pos, x => x.y, interpolationMode)); posZ.AddKey(CreateKeyframe(k, keyframeInput, pos, x => x.z, interpolationMode)); } result.clip.SetCurve(relativePath, typeof(Transform), "localPosition.x", posX); result.clip.SetCurve(relativePath, typeof(Transform), "localPosition.y", posY); result.clip.SetCurve(relativePath, typeof(Transform), "localPosition.z", posZ); break; case "rotation": Vector4[] rot = accessors[sampler.output].ReadVec4().ToArray(); AnimationCurve rotX = new AnimationCurve(); AnimationCurve rotY = new AnimationCurve(); AnimationCurve rotZ = new AnimationCurve(); AnimationCurve rotW = new AnimationCurve(); for (int k = 0; k < keyframeInput.Length; k++) { // The Animation window in Unity shows keyframes incorrectly converted to euler. This is only to deceive you. The quaternions underneath work correctly rotX.AddKey(CreateKeyframe(k, keyframeInput, rot, x => x.x, interpolationMode)); rotY.AddKey(CreateKeyframe(k, keyframeInput, rot, x => - x.y, interpolationMode)); rotZ.AddKey(CreateKeyframe(k, keyframeInput, rot, x => - x.z, interpolationMode)); rotW.AddKey(CreateKeyframe(k, keyframeInput, rot, x => x.w, interpolationMode)); } result.clip.SetCurve(relativePath, typeof(Transform), "localRotation.x", rotX); result.clip.SetCurve(relativePath, typeof(Transform), "localRotation.y", rotY); result.clip.SetCurve(relativePath, typeof(Transform), "localRotation.z", rotZ); result.clip.SetCurve(relativePath, typeof(Transform), "localRotation.w", rotW); break; case "scale": Vector3[] scale = accessors[sampler.output].ReadVec3().ToArray(); AnimationCurve scaleX = new AnimationCurve(); AnimationCurve scaleY = new AnimationCurve(); AnimationCurve scaleZ = new AnimationCurve(); for (int k = 0; k < keyframeInput.Length; k++) { scaleX.AddKey(CreateKeyframe(k, keyframeInput, scale, x => x.x, interpolationMode)); scaleY.AddKey(CreateKeyframe(k, keyframeInput, scale, x => x.y, interpolationMode)); scaleZ.AddKey(CreateKeyframe(k, keyframeInput, scale, x => x.z, interpolationMode)); } result.clip.SetCurve(relativePath, typeof(Transform), "localScale.x", scaleX); result.clip.SetCurve(relativePath, typeof(Transform), "localScale.y", scaleY); result.clip.SetCurve(relativePath, typeof(Transform), "localScale.z", scaleZ); break; case "weights": GLTFNode.ImportResult skinnedMeshNode = nodes[channel.target.node.Value]; SkinnedMeshRenderer skinnedMeshRenderer = skinnedMeshNode.transform.GetComponent <SkinnedMeshRenderer>(); int numberOfBlendShapes = skinnedMeshRenderer.sharedMesh.blendShapeCount; AnimationCurve[] blendShapeCurves = new AnimationCurve[numberOfBlendShapes]; for (int j = 0; j < numberOfBlendShapes; ++j) { blendShapeCurves[j] = new AnimationCurve(); } float[] weights = accessors[sampler.output].ReadFloat().ToArray(); float[] weightValues = new float[keyframeInput.Length]; float[] previouslyKeyedValues = new float[numberOfBlendShapes]; // Reference for my future self: // keyframeInput.Length = number of keyframes // keyframeInput[ k ] = timestamp of keyframe // weights.Length = number of keyframes * number of blendshapes // weights[ j ] = actual animated weight of a specific blend shape // (index into weights[] array accounts for keyframe index and blend shape index) for (int k = 0; k < keyframeInput.Length; ++k) { for (int j = 0; j < numberOfBlendShapes; ++j) { int weightIndex = (k * numberOfBlendShapes) + j; weightValues[k] = weights[weightIndex]; bool addKey = true; if (importSettings.animationSettings.compressBlendShapeKeyFrames) { if (k == 0 || !Mathf.Approximately(weightValues[k], previouslyKeyedValues[j])) { if (k > 0) { weightValues[k - 1] = previouslyKeyedValues[j]; blendShapeCurves[j].AddKey(CreateKeyframe(k - 1, keyframeInput, weightValues, x => x, interpolationMode)); } addKey = true; previouslyKeyedValues[j] = weightValues[k]; } else { addKey = false; } } if (addKey) { blendShapeCurves[j].AddKey(CreateKeyframe(k, keyframeInput, weightValues, x => x, interpolationMode)); } } } for (int j = 0; j < numberOfBlendShapes; ++j) { string propertyName = "blendShape." + skinnedMeshRenderer.sharedMesh.GetBlendShapeName(j); result.clip.SetCurve(relativePath, typeof(SkinnedMeshRenderer), propertyName, blendShapeCurves[j]); } break; } } return(result); }
/// <summary> /// Computes 1) a boolean specifying whether the intersection was on the right side 2) the lightmap UVs 3) the texture sample color 4) the new ray direction. /// </summary> /// <param name="direction">The direction the photon was traveling when it struck the surface.</param> /// <param name="a">Triangle vertex.</param> /// <param name="b">Triangle vertex.</param> /// <param name="c">Triangle vertex.</param> /// <param name="intersection">Intersection data returned by EnhancedMesh.Intersect</param> /// <param name="textureSampler">A sampler to sample the BSPs basemap texture.</param> /// <returns></returns> public static RadiosityIntersection ProcessIntersection(Vector3 direction, Vertex a, Vertex b, Vertex c, Intersection intersection, Sampler textureSampler, bool specular) { if (intersection == Intersection.None) { return(RadiosityIntersection.None); } RadiosityIntersection radIntersect = new RadiosityIntersection(intersection); Vector3 normal = ComputeTriangleNormal(a, b, c); radIntersect.WrongSide = CheckCollisionSide(direction, normal); if (Random.NextDouble() > RadiosityDiffuseConstant) { radIntersect.Absorbed = true; } if (specular) { radIntersect.NewDirection = SpecularReflect(direction, normal); } else { radIntersect.NewDirection = DiffuseReflect(normal); } radIntersect.Scale = 1f; // TODO: Is this even necessary? Vector2 lightmapUV = ConvertBaryToTextureCoords(a, b, c, intersection); Vector2 textureUV = ConvertBaryToTextureCoords(a, b, c, intersection); radIntersect.U = lightmapUV.X; radIntersect.V = lightmapUV.Y; if (textureSampler != null) { radIntersect.TextureSampleColor = textureSampler.Sample(textureUV); } return(radIntersect); }
public SamplerKey(Sampler sampler) { m_FilterMode = sampler.filterMode; m_WrapModeU = sampler.wrapU; m_WrapModeV = sampler.wrapV; }
private void GenerateLensSamplesTextures(int textureId, int totalSampleCount, int tileSize) { // size of a group of samples for a single pixel int bands = 2; int textureSize = bands * totalSampleCount * tileSize * tileSize; //IEnumerable<Vector2d> samples = GenerateLensSamples(tileSize, (int)Math.Sqrt(MaxTotalSampleCount)).GetEnumerator(); int sqrtTotalSampleCount = (int)Math.Sqrt(totalSampleCount); Vector2[, ,] samples = new Vector2[tileSize, tileSize, totalSampleCount]; Sampler sampler = new Sampler(); for (int y = 0; y < tileSize; y++) { for (int x = 0; x < tileSize; x++) { IEnumerable<Vector2> pixelSamples = sampler.CreateLensSamplesFloat(sqrtTotalSampleCount, ShuffleLensSamples); int z = 0; foreach (Vector2 sample in pixelSamples) { samples[x, y, z] = sample; z++; } } } GL.BindTexture(TextureTarget.Texture3D, textureId); IntPtr texturePtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Half)) * textureSize); unsafe { int zStride = bands * tileSize * tileSize; for (int y = 0; y < tileSize; y++) { for (int x = 0; x < tileSize; x++) { Half* row = (Half*)texturePtr + bands * (y * tileSize + x); int index = 0; // Z dimension for (int sample = 0; sample < totalSampleCount; sample++) { Vector2 lensPos = samples[x, y, sample]; row[index] = (Half)lensPos.X; row[index + 1] = (Half)lensPos.Y; index += zStride; } } } } // TODO: could be an half float or unsigned byte instead of a float // TODO: two sample pair could be stored in one 4-channel value GL.TexImage3D(TextureTarget.Texture3D, 0, PixelInternalFormat.Rg16f, tileSize, tileSize, totalSampleCount, 0, PixelFormat.Rg, PixelType.HalfFloat, texturePtr); Marshal.FreeHGlobal(texturePtr); GL.TexParameter(TextureTarget.Texture3D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Nearest); GL.TexParameter(TextureTarget.Texture3D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Nearest); GL.TexParameter(TextureTarget.Texture3D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat); GL.TexParameter(TextureTarget.Texture3D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat); GL.TexParameter(TextureTarget.Texture3D, TextureParameterName.TextureWrapR, (int)TextureWrapMode.Clamp); }
internal static unsafe extern void vkDestroySampler(Device device, Sampler sampler, AllocationCallbacks* allocator);
public DisposableSampler(Vk api, Device device, Sampler sampler) { _api = api; _device = device; Value = sampler; }
public void Dispose() { Sampler?.Dispose(); Reporter?.Dispose(); }
private void setReplicasButton_Click(object sender, EventArgs e) { ReplicaConfiguration config = DemoLib.GetCurrentConfiguration(); config.PrimaryServers.Clear(); config.SecondaryServers.Clear(); config.NonReplicaServers.Clear(); string server = DemoLib.ServerName("West US"); if (radioButtonWestUSPrimary.Checked) { config.PrimaryServers.Add(server); } else if (radioButtonWestUSSecondary.Checked) { config.SecondaryServers.Add(server); } else { config.NonReplicaServers.Add(server); } server = DemoLib.ServerName("East US"); if (radioButtonEastUSPrimary.Checked) { config.PrimaryServers.Add(server); } else if (radioButtonEastUSSecondary.Checked) { config.SecondaryServers.Add(server); } else { config.NonReplicaServers.Add(server); } server = DemoLib.ServerName("South US"); if (radioButtonSouthUSPrimary.Checked) { config.PrimaryServers.Add(server); } else if (radioButtonSouthUSSecondary.Checked) { config.SecondaryServers.Add(server); } else { config.NonReplicaServers.Add(server); } server = DemoLib.ServerName("North US"); if (radioButtonNorthUSPrimary.Checked) { config.PrimaryServers.Add(server); } else if (radioButtonNorthUSSecondary.Checked) { config.SecondaryServers.Add(server); } else { config.NonReplicaServers.Add(server); } server = DemoLib.ServerName("West Europe"); if (radioButtonWestEuropePrimary.Checked) { config.PrimaryServers.Add(server); } else if (radioButtonWestEuropeSecondary.Checked) { config.SecondaryServers.Add(server); } else { config.NonReplicaServers.Add(server); } server = DemoLib.ServerName("North Europe"); if (radioButtonNorthEuropePrimary.Checked) { config.PrimaryServers.Add(server); } else if (radioButtonNorthEuropeSecondary.Checked) { config.SecondaryServers.Add(server); } else { config.NonReplicaServers.Add(server); } server = DemoLib.ServerName("East Asia"); if (radioButtonAsiaPrimary.Checked) { config.PrimaryServers.Add(server); } else if (radioButtonAsiaSecondary.Checked) { config.SecondaryServers.Add(server); } else { config.NonReplicaServers.Add(server); } server = DemoLib.ServerName("Brazil"); if (radioButtonBrazilPrimary.Checked) { config.PrimaryServers.Add(server); } else if (radioButtonBrazilSecondary.Checked) { config.SecondaryServers.Add(server); } else { config.NonReplicaServers.Add(server); } initialConfig = false; reconfigSampler = DemoLib.NewSampler(); DemoLib.SetCurrentConfiguration(config); }
//static LinearInterpolation linearInterpolation = new LinearInterpolation(); //static CubicInterpolation cubicInterpolation = new CubicInterpolation(); //TODO: legyen allapotmentes a maradek is? public static VerifierBenchmark Build(BenchmarkConfig config, string databasePath = null) { if (databasePath == null) { databasePath = Environment.GetEnvironmentVariable("SigStatDB"); } svcLoader = new Svc2004Loader(Path.Combine(databasePath, "SVC2004.zip"), true); mcytLoader = new MCYTLoader(Path.Combine(databasePath, "MCYT100.zip"), true); dutchLoader = new SigComp11DutchLoader(Path.Combine(databasePath, "SigComp11_Dutch.zip"), true); chineseLoader = new SigComp11ChineseLoader(Path.Combine(databasePath, "SigComp11Chinese.zip"), true); germanLoader = new SigComp15GermanLoader(Path.Combine(databasePath, "SigWiComp2015_German.zip"), true); japaneseLoader = new SigComp13JapaneseLoader(Path.Combine(databasePath, "SigWiComp2013_Japanese.zip"), true); //labor: //svcLoader = new Svc2004Loader(@"Task2.zip", true); //mcytLoader = new MCYTLoader(@"MCYT_Signature_100.zip", true); //dutchLoader = new SigComp11DutchLoader(@"dutch_renamed.zip", true); Sampler sampler1 = null; Sampler sampler2 = null; Sampler sampler3 = null; Sampler sampler4 = null; VerifierBenchmark b = new VerifierBenchmark(); switch (config.Database) { case "SVC2004": b.Loader = svcLoader; sampler1 = first10Sampler; sampler2 = last10Sampler; sampler3 = even10Sampler; sampler4 = odd10Sampler; break; case "MCYT100": b.Loader = mcytLoader; sampler1 = first10Sampler; sampler2 = last10Sampler; sampler3 = even10Sampler; sampler4 = odd10Sampler; break; case "DUTCH": b.Loader = dutchLoader; sampler1 = first10Sampler; sampler2 = last10Sampler; sampler3 = even10Sampler; sampler4 = odd10Sampler; break; case "GERMAN": b.Loader = germanLoader; sampler1 = first10Sampler; sampler2 = last10Sampler; sampler3 = even10Sampler; sampler4 = odd10Sampler; break; case "CHINESE": b.Loader = chineseLoader; sampler1 = first10Sampler; sampler2 = last10Sampler; sampler3 = even10Sampler; sampler4 = odd10Sampler; break; case "JAPANESE": b.Loader = japaneseLoader; sampler1 = first10Sampler; sampler2 = last10Sampler; sampler3 = even10Sampler; sampler4 = odd10Sampler; break; default: throw new NotSupportedException(); } switch (config.Sampling) { case "S1": b.Sampler = sampler1; break; case "S2": b.Sampler = sampler2; break; case "S3": b.Sampler = sampler3; break; case "S4": b.Sampler = sampler4; break; default: break; } var pipeline = new SequentialTransformPipeline(); //Filter first switch (config.ResamplingType_Filter) { case "P": case "P_FillPenUp": pipeline.Add(filterPoints); break; case "None": default: break; } if (config.Rotation) { pipeline.Add(normalizeRotation); } switch (config.Translation_Scaling.Translation) { case "CogToOriginX": pipeline.Add(cxTranslate); break; case "CogToOriginY": pipeline.Add(cyTranslate); break; case "CogToOriginXY": pipeline.Add(cxTranslate); pipeline.Add(cyTranslate); break; case "BottomLeftToOrigin": pipeline.Add(blxTranslate); pipeline.Add(blyTranslate); break; case "None": default: break; } switch (config.Translation_Scaling.Scaling) { case "X01": pipeline.Add(xScale); if (config.Features.Contains("P")) { pipeline.Add(pScale); } break; case "Y01": pipeline.Add(yScale); if (config.Features.Contains("P")) { pipeline.Add(pScale); } break; case "P01": pipeline.Add(pScale); break; case "X01Y01": pipeline.Add(xScale); pipeline.Add(yScale); pipeline.Add(pScale); break; case "X01Y0prop": pipeline.Add(xyUniformScale); if (config.Features.Contains("P")) { pipeline.Add(pScale); } break; case "Y01X0prop": pipeline.Add(yxUniformScale); if (config.Features.Contains("P")) { pipeline.Add(pScale); } break; case "None": if (config.Features.Contains("P")) { pipeline.Add(pRelativeScale); } break; default: break; } Type ip; switch (config.Interpolation) { case "Cubic": ip = typeof(CubicInterpolation); break; case "Linear": default: ip = typeof(LinearInterpolation); break; } var featurelist = new List <FeatureDescriptor <List <double> > >() { Features.X, Features.Y, Features.Pressure, Features.Azimuth, Features.Altitude }; //resample after transformations switch (config.ResamplingType_Filter) { case "SampleCount": pipeline.Add(new ResampleSamplesCountBased() { InputFeatures = featurelist, OutputFeatures = featurelist, OriginalTFeature = Features.T, ResampledTFeature = Features.T, NumOfSamples = (int)config.ResamplingParam, InterpolationType = ip }); break; case "P_FillPenUp": case "FillPenUp": pipeline.Add(new FillPenUpDurations() { InputFeatures = featurelist, OutputFeatures = featurelist, TimeInputFeature = Features.T, TimeOutputFeature = Features.T, InterpolationType = ip }); break; case "None": default: break; } var ClassifierFeatures = new List <FeatureDescriptor>(); switch (config.Features) { case "X": ClassifierFeatures.Add(Features.X); break; case "XP": ClassifierFeatures.Add(Features.X); ClassifierFeatures.Add(Features.Pressure); break; case "Y": ClassifierFeatures.Add(Features.Y); break; case "YP": ClassifierFeatures.Add(Features.Y); ClassifierFeatures.Add(Features.Pressure); break; case "P": ClassifierFeatures.Add(Features.Pressure); break; case "Azimuth": ClassifierFeatures.Add(Features.Azimuth); break; case "Altitude": ClassifierFeatures.Add(Features.Altitude); break; case "XY": ClassifierFeatures.Add(Features.X); ClassifierFeatures.Add(Features.Y); break; case "XYP": ClassifierFeatures.Add(Features.X); ClassifierFeatures.Add(Features.Y); ClassifierFeatures.Add(Features.Pressure); break; case "XYPAzimuthAltitude": ClassifierFeatures.Add(Features.X); ClassifierFeatures.Add(Features.Y); ClassifierFeatures.Add(Features.Pressure); ClassifierFeatures.Add(Features.Azimuth); ClassifierFeatures.Add(Features.Altitude); break; default: break; } Func <double[], double[], double> distance = null; switch (config.Distance) { case "Euclidean": distance = Accord.Math.Distance.Euclidean; break; case "Manhattan": distance = Accord.Math.Distance.Manhattan; break; default: break; } IClassifier classifier; if (config.Classifier == "Dtw") { classifier = new DtwClassifier(distance); (classifier as DtwClassifier).Features = ClassifierFeatures; } else if (config.Classifier == "OptimalDtw") { classifier = new OptimalDtwClassifier(distance) { Features = ClassifierFeatures, Sampler = b.Sampler }; } else { throw new NotSupportedException(); } b.Verifier = new Model.Verifier() { Pipeline = pipeline, Classifier = classifier }; b.Parameters = config.ToKeyValuePairs().ToList(); return(b); }
// Load Chart button private void button1_Click(object sender, EventArgs e) { Sampler sampler = initialConfig ? initialSampler : reconfigSampler; /* * sampler = DemoLib.PerformReadsWritesSyncs(sampler); * if (initialConfig) * initialSampler = sampler; * else * reconfigSampler = sampler; */ this.chart1.Series["Latency"].Points.Clear(); this.chart1.Series["Primary hit rate"].Points.Clear(); this.chart1.Legends["Latency"].Enabled = true; if (enableHitRate) { this.chart1.Series["Primary hit rate"].IsVisibleInLegend = true; } else { this.chart1.Series["Primary hit rate"].IsVisibleInLegend = false; } this.chart1.Series["Latency"].Points.AddXY("Strong", sampler.GetSampleValue("strongLatency")); if (enableHitRate) { float primaryHitRate = (sampler.GetSampleValue("strongPrimaryAccesses") * 100) / sampler.GetSampleValue("strongTotalAccesses"); this.chart1.Series["Primary hit rate"].Points.AddXY("Strong", primaryHitRate); } this.chart1.Series["Latency"].Points.AddXY("Causal", sampler.GetSampleValue("causalLatency")); if (enableHitRate) { float primaryHitRate = (sampler.GetSampleValue("causalPrimaryAccesses") * 100) / sampler.GetSampleValue("causalTotalAccesses"); this.chart1.Series["Primary hit rate"].Points.AddXY("Causal", primaryHitRate); } this.chart1.Series["Latency"].Points.AddXY("Bounded", sampler.GetSampleValue("boundedLatency")); if (enableHitRate) { float primaryHitRate = (sampler.GetSampleValue("boundedPrimaryAccesses") * 100) / sampler.GetSampleValue("boundedTotalAccesses"); this.chart1.Series["Primary hit rate"].Points.AddXY("Bounded", primaryHitRate); } this.chart1.Series["Latency"].Points.AddXY("Read my writes", sampler.GetSampleValue("readmywritesLatency")); if (enableHitRate) { float primaryHitRate = (sampler.GetSampleValue("readmywritesPrimaryAccesses") * 100) / sampler.GetSampleValue("readmywritesTotalAccesses"); this.chart1.Series["Primary hit rate"].Points.AddXY("Read my writes", primaryHitRate); } this.chart1.Series["Latency"].Points.AddXY("Monotonic", sampler.GetSampleValue("monotonicLatency")); if (enableHitRate) { float primaryHitRate = (sampler.GetSampleValue("monotonicPrimaryAccesses") * 100) / sampler.GetSampleValue("monotonicTotalAccesses"); this.chart1.Series["Primary hit rate"].Points.AddXY("Monotonic", primaryHitRate); } this.chart1.Series["Latency"].Points.AddXY("Eventual", sampler.GetSampleValue("eventualLatency")); if (enableHitRate) { float primaryHitRate = (sampler.GetSampleValue("eventualPrimaryAccesses") * 100) / sampler.GetSampleValue("eventualTotalAccesses"); this.chart1.Series["Primary hit rate"].Points.AddXY("Eventual", primaryHitRate); } }
public void Set_Sampler(int numSamples, float exp) { sampler_ptr = new Jittered(numSamples); this.exp = exp; sampler_ptr.map_samples_to_hemisphere(exp); }
/// <summary> /// Initialize the device objects /// </summary> /// <param name="dev">The grpahics device used to initialize</param> public void InitializeDeviceObjects(Device dev) { if (dev != null) { // Set up our events dev.DeviceReset += new System.EventHandler(this.RestoreDeviceObjects); } // Keep a local copy of the device device = dev; textureState0 = device.TextureState[0]; textureState1 = device.TextureState[1]; samplerState0 = device.SamplerState[0]; renderState = device.RenderState; // Establish the font and texture size textureScale = 1.0f; // Draw fonts into texture without scaling // Large fonts need larger textures if (ourFontHeight > 60) { textureWidth = textureHeight = 2048; } else if (ourFontHeight > 30) { textureWidth = textureHeight = 1024; } else if (ourFontHeight > 15) { textureWidth = textureHeight = 512; } else { textureWidth = textureHeight = 256; } // If requested texture is too big, use a smaller texture and smaller font, // and scale up when rendering. Direct3D.Caps d3dCaps = device.DeviceCaps; if (textureWidth > d3dCaps.MaxTextureWidth) { textureScale = (float)d3dCaps.MaxTextureWidth / (float)textureWidth; textureWidth = textureHeight = d3dCaps.MaxTextureWidth; } Bitmap bmp = new Bitmap(textureWidth, textureHeight, System.Drawing.Imaging.PixelFormat.Format32bppArgb); Graphics g = Graphics.FromImage(bmp); g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias; g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias; g.TextContrast = 0; string str; float x = 0; float y = 0; Point p = new Point(0, 0); Size size = new Size(0, 0); // Calculate the spacing between characters based on line height size = g.MeasureString(" ", systemFont).ToSize(); x = spacingPerChar = (int)Math.Ceiling(size.Height * 0.3); for (char c = (char)32; c < (char)127; c++) { str = c.ToString(); // We need to do some things here to get the right sizes. The default implemententation of MeasureString // will return a resolution independant size. For our height, this is what we want. However, for our width, we // want a resolution dependant size. Size resSize = g.MeasureString(str, systemFont).ToSize(); size.Height = resSize.Height + 1; // Now the Resolution independent width if (c != ' ') // We need the special case here because a space has a 0 width in GenericTypoGraphic stringformats { resSize = g.MeasureString(str, systemFont, p, StringFormat.GenericTypographic).ToSize(); size.Width = resSize.Width; } else { size.Width = resSize.Width; } if ((x + size.Width + spacingPerChar) > textureWidth) { x = spacingPerChar; y += size.Height; } if (c != ' ') // We need the special case here because a space has a 0 width in GenericTypoGraphic stringformats { g.DrawString(str, systemFont, Brushes.White, new Point((int)x, (int)y), StringFormat.GenericTypographic); } else { g.DrawString(str, systemFont, Brushes.White, new Point((int)x, (int)y)); } textureCoords[c - 32, 0] = ((float)(x + 0 - spacingPerChar)) / textureWidth; textureCoords[c - 32, 1] = ((float)(y + 0 + 0)) / textureHeight; textureCoords[c - 32, 2] = ((float)(x + size.Width + spacingPerChar)) / textureWidth; textureCoords[c - 32, 3] = ((float)(y + size.Height + 0)) / textureHeight; x += size.Width + (2 * spacingPerChar); } // Create a new texture for the font from the bitmap we just created fontTexture = Texture.FromBitmap(device, bmp, 0, Pool.Managed); RestoreDeviceObjects(null, null); }
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Sampler obj) { return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr); }
public ImportResult Import(GLTFAccessor.ImportResult[] accessors, GLTFNode.ImportResult[] nodes) { ImportResult result = new ImportResult(); result.clip = new AnimationClip(); result.clip.name = name; for (int i = 0; i < channels.Length; i++) { Channel channel = channels[i]; if (samplers.Length <= channel.sampler) { Debug.LogWarning("Animation channel points to sampler at index " + channel.sampler + " which doesn't exist. Skipping animation clip."); continue; } Sampler sampler = samplers[channel.sampler]; string relativePath = ""; GLTFNode.ImportResult node = nodes[channel.target.node.Value]; while (node != null && !node.IsRoot) { if (string.IsNullOrEmpty(relativePath)) { relativePath = node.transform.name; } else { relativePath = node.transform.name + "/" + relativePath; } if (node.parent.HasValue) { node = nodes[node.parent.Value]; } else { node = null; } } float[] keyframeInput = accessors[sampler.input].ReadFloat().ToArray(); switch (channel.target.path) { case "translation": Vector3[] pos = accessors[sampler.output].ReadVec3().ToArray(); AnimationCurve posX = new AnimationCurve(); AnimationCurve posY = new AnimationCurve(); AnimationCurve posZ = new AnimationCurve(); for (int k = 0; k < keyframeInput.Length; k++) { posX.AddKey(keyframeInput[k], pos[k].x); posY.AddKey(keyframeInput[k], pos[k].y); posZ.AddKey(keyframeInput[k], -pos[k].z); } result.clip.SetCurve(relativePath, typeof(Transform), "localPosition.x", posX); result.clip.SetCurve(relativePath, typeof(Transform), "localPosition.y", posY); result.clip.SetCurve(relativePath, typeof(Transform), "localPosition.z", posZ); break; case "rotation": Vector4[] rot = accessors[sampler.output].ReadVec4().ToArray(); AnimationCurve rotX = new AnimationCurve(); AnimationCurve rotY = new AnimationCurve(); AnimationCurve rotZ = new AnimationCurve(); AnimationCurve rotW = new AnimationCurve(); for (int k = 0; k < keyframeInput.Length; k++) { rotX.AddKey(keyframeInput[k], rot[k].x); rotY.AddKey(keyframeInput[k], rot[k].y); rotZ.AddKey(keyframeInput[k], -rot[k].z); rotW.AddKey(keyframeInput[k], -rot[k].w); } result.clip.SetCurve(relativePath, typeof(Transform), "localRotation.x", rotX); result.clip.SetCurve(relativePath, typeof(Transform), "localRotation.y", rotY); result.clip.SetCurve(relativePath, typeof(Transform), "localRotation.z", rotZ); result.clip.SetCurve(relativePath, typeof(Transform), "localRotation.w", rotW); break; case "scale": Vector3[] scale = accessors[sampler.output].ReadVec3().ToArray(); AnimationCurve scaleX = new AnimationCurve(); AnimationCurve scaleY = new AnimationCurve(); AnimationCurve scaleZ = new AnimationCurve(); for (int k = 0; k < keyframeInput.Length; k++) { scaleX.AddKey(keyframeInput[k], scale[k].x); scaleY.AddKey(keyframeInput[k], scale[k].y); scaleZ.AddKey(keyframeInput[k], scale[k].z); } result.clip.SetCurve(relativePath, typeof(Transform), "localScale.x", scaleX); result.clip.SetCurve(relativePath, typeof(Transform), "localScale.y", scaleY); result.clip.SetCurve(relativePath, typeof(Transform), "localScale.z", scaleZ); break; case "weights": Debug.LogWarning("morph weights not supported"); break; } } return(result); }
public void InitializeDeviceObjects(Device dev) { if (dev != null) { // Set up our events dev.DeviceReset += new System.EventHandler(this.RestoreDeviceObjects); } // Keep a local copy of the device device = dev; textureState0 = device.TextureState[0]; textureState1 = device.TextureState[1]; samplerState0 = device.SamplerState[0]; renderState = device.RenderState; // Create a bitmap on which to measure the alphabet Bitmap bmp = new Bitmap(1, 1, System.Drawing.Imaging.PixelFormat.Format32bppArgb); Graphics g = Graphics.FromImage(bmp); g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.Default; g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.SystemDefault; g.TextContrast = 0; // Establish the font and texture size textureScale = 1.0f; // Draw fonts into texture without scaling // Calculate the dimensions for the smallest power-of-two texture which // can hold all the printable characters textureWidth = textureHeight = 128; for (;;) { try { // Measure the alphabet PaintAlphabet(g, true); } catch (System.InvalidOperationException) { // Scale up the texture size and try again textureWidth *= 2; textureHeight *= 2; continue; } break; } // If requested texture is too big, use a smaller texture and smaller font, // and scale up when rendering. Caps d3dCaps = device.DeviceCaps; // If the needed texture is too large for the video card... if (textureWidth > d3dCaps.MaxTextureWidth) { // Scale the font size down to fit on the largest possible texture textureScale = (float)d3dCaps.MaxTextureWidth / (float)textureWidth; textureWidth = textureHeight = d3dCaps.MaxTextureWidth; for(;;) { // Create a new, smaller font fontSize = (int) Math.Floor(fontSize * textureScale); font = new System.Drawing.Font(font.Name, fontSize, font.Style); try { // Measure the alphabet PaintAlphabet(g, true); } catch (System.InvalidOperationException) { // If that still doesn't fit, scale down again and continue textureScale *= 0.9F; continue; } break; } } // Release the bitmap used for measuring and create one for drawing bmp.Dispose(); bmp = new Bitmap(textureWidth, textureHeight, System.Drawing.Imaging.PixelFormat.Format32bppArgb); g = Graphics.FromImage(bmp); g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias; g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias; g.TextContrast = 0; // Draw the alphabet PaintAlphabet(g, false); // Create a new texture for the font from the bitmap we just created fontTexture = Texture.FromBitmap(device, bmp, 0, Pool.Managed); RestoreDeviceObjects(null, null); }
public BloomCombinePS() { Name = "BloomCombinePS"; Type = ShaderType.Pixel; KeyPart = new TechniqueKey(ps: PixelShaderFlags.Diffuse | PixelShaderFlags.DiffuseMap); FeatureLevel = FeatureLevel.PS_4_0_Level_9_1; EnableSeparators = true; var inputStruct = SpriteVS.VSOut; inputStruct.Name = "input"; InputStruct = inputStruct; OutputStruct = Struct.PixelShaderOutput; Texture tDiffuse = Texture.Diffuse; Texture tBloom = new Texture() { Name = "tBloom", Type = Shaders.Type.Texture2D }; Sampler sLinearWrap = Sampler.MinMagMipLinearWrap; var cbFrame = CBFrame; var blurParams = (Struct)cbFrame[0]; Add(sLinearWrap); Add(tDiffuse); Add(tBloom); Add(cbFrame); TextureSampleNode nTexSample = new TextureSampleNode { Coordinates = new ReferenceNode { Value = InputStruct[Param.SemanticVariables.Texture] }, Texture = tDiffuse, Sampler = sLinearWrap, IsVerbose = true, Output = new Vector { Name = "cDiffuse", Type = Shaders.Type.Float4 }, }; TextureSampleNode nBloomSample = new TextureSampleNode { Coordinates = new ReferenceNode { Value = InputStruct[Param.SemanticVariables.Texture] }, Texture = tBloom, Sampler = sLinearWrap, IsVerbose = true, Output = new Vector { Name = "cBloom", Type = Shaders.Type.Float4 } }; var mAdjustSaturation = new AdjustSaturation(); FunctionNode nAdjustBloomSaturation = new FunctionNode() { Inputs = new List <INode>() { nBloomSample, new ReferenceNode() { Value = blurParams[Param.Floats.BloomSaturation] } }, Method = mAdjustSaturation, ReturnType = Shaders.Type.Float4 }; FunctionNode nAdjustBaseSaturation = new FunctionNode() { Inputs = new List <INode>() { nTexSample, new ReferenceNode() { Value = blurParams[Param.Floats.BloomBaseSaturation] } }, Method = mAdjustSaturation, ReturnType = Shaders.Type.Float4 }; MultiplyNode nMulBloom = new MultiplyNode() { Input1 = nAdjustBloomSaturation, Input2 = new ReferenceNode() { Value = blurParams[Param.Floats.BloomIntensity] }, Output = nBloomSample.Output, IsVerbose = true, Declare = false }; MultiplyNode nMulBase = new MultiplyNode() { Input1 = nAdjustBaseSaturation, Input2 = new ReferenceNode() { Value = blurParams[Param.Floats.BloomBaseIntensity] }, Output = nTexSample.Output, IsVerbose = true, Declare = false }; MultiplyNode nDarken = new MultiplyNode() { Input1 = nMulBase, Input2 = new SubtractionNode() { Input1 = new ScalarNode() { Value = 1 }, Input2 = new UnaryFunctionNode() { Input1 = nMulBloom, Function = HlslIntrinsics.Saturate }, Parenthesize = true }, Output = nTexSample.Output, IsVerbose = true, Declare = false, AssignToInput1 = true }; Result = new PSOutputNode { FinalColor = new AdditionNode() { Input1 = nDarken, Input2 = nMulBloom }, Output = OutputStruct }; }
private void OnDestroy() { this.movement = null; }
public override Spectrum Li(RayDifferential ray, Scene scene, Camera camera, Sampler sampler, int depth = 0) { var r = Random.Shared.NextSingle(); return(new Spectrum(r)); }
internal Transaction( IApmLogger logger, string name, string type, Sampler sampler, DistributedTracingData distributedTracingData, IPayloadSender sender, IConfigSnapshot configSnapshot, ICurrentExecutionSegmentsContainer currentExecutionSegmentsContainer ) { ConfigSnapshot = configSnapshot; Timestamp = TimeUtils.TimestampNow(); var idBytes = new byte[8]; Id = RandomGenerator.GenerateRandomBytesAsString(idBytes); _logger = logger?.Scoped($"{nameof(Transaction)}.{Id}"); _sender = sender; _currentExecutionSegmentsContainer = currentExecutionSegmentsContainer; Name = name; HasCustomName = false; Type = type; var isSamplingFromDistributedTracingData = false; if (distributedTracingData == null) { var traceIdBytes = new byte[16]; TraceId = RandomGenerator.GenerateRandomBytesAsString(traceIdBytes); IsSampled = sampler.DecideIfToSample(idBytes); } else { TraceId = distributedTracingData.TraceId; ParentId = distributedTracingData.ParentId; IsSampled = distributedTracingData.FlagRecorded; isSamplingFromDistributedTracingData = true; _traceState = distributedTracingData.TraceState; } SpanCount = new SpanCount(); _currentExecutionSegmentsContainer.CurrentTransaction = this; if (isSamplingFromDistributedTracingData) { _logger.Trace() ?.Log("New Transaction instance created: {Transaction}. " + "IsSampled ({IsSampled}) is based on incoming distributed tracing data ({DistributedTracingData})." + " Start time: {Time} (as timestamp: {Timestamp})", this, IsSampled, distributedTracingData, TimeUtils.FormatTimestampForLog(Timestamp), Timestamp); } else { _logger.Trace() ?.Log("New Transaction instance created: {Transaction}. " + "IsSampled ({IsSampled}) is based on the given sampler ({Sampler})." + " Start time: {Time} (as timestamp: {Timestamp})", this, IsSampled, sampler, TimeUtils.FormatTimestampForLog(Timestamp), Timestamp); } }
public DummyIntegrator(Sampler sampler) : base(sampler) { }
public static ShaderData CreateGLSL(byte[] byteCode, bool isVertexShader, List <ConstantBufferData> cbuffers, int sharedIndex, Dictionary <string, SamplerStateInfo> samplerStates, bool debug) { var dxshader = new ShaderData(isVertexShader, sharedIndex, byteCode); // Use MojoShader to convert the HLSL bytecode to GLSL. var parseDataPtr = MojoShader.NativeMethods.MOJOSHADER_parse( "glsl", byteCode, byteCode.Length, IntPtr.Zero, 0, IntPtr.Zero, 0, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero); var parseData = MarshalHelper.Unmarshal <MojoShader.MOJOSHADER_parseData> (parseDataPtr); if (parseData.error_count > 0) { var errors = MarshalHelper.UnmarshalArray <MojoShader.MOJOSHADER_error> ( parseData.errors, parseData.error_count ); throw new Exception(errors [0].error); } // Conver the attributes. // // TODO: Could this be done using DX shader reflection? // { var attributes = MarshalHelper.UnmarshalArray <MojoShader.MOJOSHADER_attribute> ( parseData.attributes, parseData.attribute_count); dxshader._attributes = new Attribute[attributes.Length]; for (var i = 0; i < attributes.Length; i++) { dxshader._attributes [i].name = attributes [i].name; dxshader._attributes [i].index = attributes [i].index; dxshader._attributes [i].usage = EffectObject.ToXNAVertexElementUsage(attributes [i].usage); } } var symbols = MarshalHelper.UnmarshalArray <MojoShader.MOJOSHADER_symbol> ( parseData.symbols, parseData.symbol_count); //try to put the symbols in the order they are eventually packed into the uniform arrays //this /should/ be done by pulling the info from mojoshader Array.Sort(symbols, delegate(MojoShader.MOJOSHADER_symbol a, MojoShader.MOJOSHADER_symbol b) { uint va = a.register_index; if (a.info.elements == 1) { va += 1024; //hax. mojoshader puts array objects first } uint vb = b.register_index; if (b.info.elements == 1) { vb += 1024; } return(va.CompareTo(vb)); } ); //(a, b) => ((int)(a.info.elements > 1))a.register_index.CompareTo(b.register_index)); // NOTE: It seems the latest versions of MojoShader only // output vec4 register sets. We leave the code below, but // the runtime has been optimized for this case. // For whatever reason the register indexing is // incorrect from MojoShader. { uint bool_index = 0; uint float4_index = 0; uint int4_index = 0; for (var i = 0; i < symbols.Length; i++) { switch (symbols [i].register_set) { case MojoShader.MOJOSHADER_symbolRegisterSet.MOJOSHADER_SYMREGSET_BOOL: symbols [i].register_index = bool_index; bool_index += symbols [i].register_count; break; case MojoShader.MOJOSHADER_symbolRegisterSet.MOJOSHADER_SYMREGSET_FLOAT4: symbols [i].register_index = float4_index; float4_index += symbols[i].register_count; break; case MojoShader.MOJOSHADER_symbolRegisterSet.MOJOSHADER_SYMREGSET_INT4: symbols [i].register_index = int4_index; int4_index += symbols [i].register_count; break; } } } // Get the samplers. var samplers = MarshalHelper.UnmarshalArray <MojoShader.MOJOSHADER_sampler> ( parseData.samplers, parseData.sampler_count); dxshader._samplers = new Sampler[samplers.Length]; for (var i = 0; i < samplers.Length; i++) { // We need the original sampler name... look for that in the symbols. var originalSamplerName = symbols.First(e => e.register_set == MojoShader.MOJOSHADER_symbolRegisterSet.MOJOSHADER_SYMREGSET_SAMPLER && e.register_index == samplers[i].index ).name; var sampler = new Sampler { //sampler mapping to parameter is unknown atm parameter = -1, // GLSL needs the MojoShader mangled sampler name. samplerName = samplers[i].name, // By default use the original sampler name for the parameter name. parameterName = originalSamplerName, textureSlot = samplers[i].index, samplerSlot = samplers[i].index, type = samplers[i].type, }; SamplerStateInfo state; if (samplerStates.TryGetValue(originalSamplerName, out state)) { sampler.state = state.State; sampler.parameterName = state.TextureName ?? originalSamplerName; } // Store the sampler. dxshader._samplers[i] = sampler; } // Gather all the parameters used by this shader. var symbol_types = new [] { new { name = dxshader.IsVertexShader ? "vs_uniforms_bool" : "ps_uniforms_bool", set = MojoShader.MOJOSHADER_symbolRegisterSet.MOJOSHADER_SYMREGSET_BOOL, }, new { name = dxshader.IsVertexShader ? "vs_uniforms_ivec4" : "ps_uniforms_ivec4", set = MojoShader.MOJOSHADER_symbolRegisterSet.MOJOSHADER_SYMREGSET_INT4, }, new { name = dxshader.IsVertexShader ? "vs_uniforms_vec4" : "ps_uniforms_vec4", set = MojoShader.MOJOSHADER_symbolRegisterSet.MOJOSHADER_SYMREGSET_FLOAT4, }, }; var cbuffer_index = new List <int> (); for (var i = 0; i < symbol_types.Length; i++) { var cbuffer = new ConstantBufferData(symbol_types [i].name, symbol_types [i].set, symbols); if (cbuffer.Size == 0) { continue; } var match = cbuffers.FindIndex(e => e.SameAs(cbuffer)); if (match == -1) { cbuffer_index.Add(cbuffers.Count); cbuffers.Add(cbuffer); } else { cbuffer_index.Add(match); } } dxshader._cbuffers = cbuffer_index.ToArray(); var glslCode = parseData.output; // TODO: This sort of sucks... why does MojoShader not produce // code valid for GLES out of the box? // GLES platforms do not like this. glslCode = glslCode.Replace("#version 110", ""); // Add the required precision specifiers for GLES. var floatPrecision = dxshader.IsVertexShader ? "precision highp float;\r\n" : "precision mediump float;\r\n"; glslCode = "#ifdef GL_ES\r\n" + floatPrecision + "precision mediump int;\r\n" + "#endif\r\n" + glslCode; // Enable standard derivatives extension as necessary if ((glslCode.IndexOf("dFdx", StringComparison.InvariantCulture) >= 0) || (glslCode.IndexOf("dFdy", StringComparison.InvariantCulture) >= 0)) { glslCode = "#extension GL_OES_standard_derivatives : enable\r\n" + glslCode; } // Store the code for serialization. dxshader.ShaderCode = Encoding.ASCII.GetBytes(glslCode); return(dxshader); }
protected override void OnLoad() { base.OnLoad(); // load texture from file using (var bitmap = new Bitmap("Data/Textures/checker.jpg")) { BitmapTexture.CreateCompatible(bitmap, out _texture); _texture.LoadBitmap(bitmap); } _texture.GenerateMipMaps(); // initialize sampler _sampler = new Sampler(); _sampler.SetWrapMode(TextureWrapMode.Repeat); // create vertex data for a big plane const int a = 10; const int b = 10; var vertices = new[] { new Vertex(-a, 0, -a, 0, 0), new Vertex(a, 0, -a, b, 0), new Vertex(-a, 0, a, 0, b), new Vertex(a, 0, a, b, b) }; // create buffer object and upload vertex data _vbo = new Buffer <Vertex>(); _vbo.Init(BufferTarget.ArrayBuffer, vertices); // initialize shader _program = ProgramFactory.Create <SimpleTextureProgram>(); // activate shader program _program.Use(); // bind sampler _sampler.Bind(TextureUnit.Texture0); // bind texture _program.Texture.BindTexture(TextureUnit.Texture0, _texture); // which is equivalent to //_program.Texture.Set(TextureUnit.Texture0); //_texture.Bind(TextureUnit.Texture0); // set up vertex array and attributes _vao = new VertexArray(); _vao.Bind(); // memory layout of our data is XYZUVXYZUV... // the buffer abstraction knows the total size of one "pack" of vertex data // and if a vertex attribute is bound without further arguments the first N elements are taken from each pack // where N is provided via the VertexAttribAttribute on the program property: _vao.BindAttribute(_program.InPosition, _vbo); // if data should not be taken from the start of each pack, the offset must be given in bytes // to reach the texture coordinates UV the XYZ coordinates must be skipped, that is 3 floats, i.e. an offset of 12 bytes is needed _vao.BindAttribute(_program.InTexCoord, _vbo, 12); // if needed all the available arguments can be specified manually, e.g. //_vao.BindAttribute(_program.InTexCoord, _vbo, 2, VertexAttribPointerType.Float, Marshal.SizeOf(typeof(Vertex)), 12, false); // set default camera ActiveCamera.Position = new Vector3(0, 0.5f, 3); // set a nice clear color GL.ClearColor(Color.MidnightBlue); }
protected override void Serialize(UnityEngine.Object sourceAsset) { this.texture = sourceAsset as UnityEngine.Cubemap; //先把原始图片导出来 this.ExportTexture(); var path = PathHelper.GetTexturePath(this.texture); var mipmap = this.texture.mipmapCount > 1; // { this._root.Images.Add(new Image() { Uri = ExportSetting.instance.GetExportPath(path) }); } // { var filterMode = this.texture.filterMode; var wrapMode = this.texture.wrapMode; var sampler = new Sampler(); this._root.Samplers.Add(sampler); if (wrapMode == TextureWrapMode.Repeat) { sampler.WrapS = GLTF.Schema.WrapMode.Repeat; sampler.WrapT = GLTF.Schema.WrapMode.Repeat; } else { sampler.WrapS = GLTF.Schema.WrapMode.ClampToEdge; sampler.WrapT = GLTF.Schema.WrapMode.ClampToEdge; } sampler.MagFilter = filterMode == FilterMode.Point ? MagFilterMode.Nearest : MagFilterMode.Linear; if (!mipmap) { sampler.MagFilter = filterMode == FilterMode.Point ? MagFilterMode.Nearest : MagFilterMode.Linear; } else if (filterMode == FilterMode.Point) { sampler.MinFilter = MinFilterMode.NearestMipmapNearest; } else if (filterMode == FilterMode.Bilinear) { sampler.MinFilter = MinFilterMode.LinearMipmapNearest; } else if (filterMode == FilterMode.Trilinear) { sampler.MinFilter = MinFilterMode.LinearMipmapLinear; } } // { var gltfTexture = new GLTF.Schema.Texture(); this._root.Textures.Add(gltfTexture); gltfTexture.Sampler = new SamplerId(); gltfTexture.Source = new ImageId(); gltfTexture.Extensions = new Dictionary <string, IExtension>() { { TextureExtension.EXTENSION_NAME, new TextureExtension() { anisotropy = this.texture.anisoLevel, format = GetTextureFormat(), levels = mipmap ? 0 : 1 } } }; } }
public static IList<Star> GenerateStars(int count, float intensity, bool colorize, int seed) { Sampler sampler = new Sampler(seed); Random random = new Random(seed); var starPositions = sampler.GenerateJitteredSamples((int)Math.Sqrt(count)).ToList(); List<Star> stars = new List<Star>(starPositions.Count()); foreach (var starPosition in starPositions) { Vector3 color = new Vector3(intensity, intensity, intensity); if (colorize) { color = Vector3.Multiply(color, new Vector3( (float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble())); } else { color = Vector3.Multiply(color, (float)random.NextDouble()); } Vector2 position = new Vector2((float)starPosition.X, (float)starPosition.Y); stars.Add(new Star() { Position = position, Color = color }); } return stars; }
public BRDF(Sampler sampler) { this.Sampler = sampler; }
public void ReadSampler( XmlNode node, ColladaMeshInfo meshInfo ) { // the spec shows the id attribute as optional, // but a sampler without an id is pointless // (cannot be referenced by a channel) string samplerId = node.Attributes[ "id" ].Value; Sampler sampler = new Sampler( samplerId ); foreach( XmlNode childNode in node.ChildNodes ) { switch( childNode.Name ) { case "input": ReadSamplerInput( sampler, childNode, meshInfo ); break; default: DebugMessage( childNode ); break; } } // TODO: Put the sampler in a dictionary if( sampler.Input == null || sampler.Output == null ) { log.InfoFormat( "Ignoring incomplete sampler: {0}", samplerId ); return; } meshInfo.Samplers[ sampler.SamplerId ] = sampler; }
public static ShaderData CreateHLSL(byte[] byteCode, bool isVertexShader, List <ConstantBufferData> cbuffers, int sharedIndex, Dictionary <string, SamplerStateInfo> samplerStates, bool debug) { var dxshader = new ShaderData(isVertexShader, sharedIndex, byteCode); dxshader._attributes = new Attribute[0]; // Strip the bytecode we're gonna save! var stripFlags = SharpDX.D3DCompiler.StripFlags.CompilerStripReflectionData | SharpDX.D3DCompiler.StripFlags.CompilerStripTestBlobs; if (!debug) { stripFlags |= SharpDX.D3DCompiler.StripFlags.CompilerStripDebugInformation; } using (var original = new SharpDX.D3DCompiler.ShaderBytecode(byteCode)) { // Strip the bytecode for saving to disk. var stripped = original.Strip(stripFlags); { // Only SM4 and above works with strip... so this can return null! if (stripped != null) { dxshader.ShaderCode = stripped; } else { // TODO: There is a way to strip SM3 and below // but we have to write the method ourselves. // // If we need to support it then consider porting // this code over... // // http://entland.homelinux.com/blog/2009/01/15/stripping-comments-from-shader-bytecodes/ // dxshader.ShaderCode = (byte[])dxshader.Bytecode.Clone(); } } // Use reflection to get details of the shader. using (var refelect = new SharpDX.D3DCompiler.ShaderReflection(byteCode)) { // Get the samplers. var samplers = new List <Sampler>(); for (var i = 0; i < refelect.Description.BoundResources; i++) { var rdesc = refelect.GetResourceBindingDescription(i); if (rdesc.Type == SharpDX.D3DCompiler.ShaderInputType.Texture) { var samplerName = rdesc.Name; var sampler = new Sampler { samplerName = string.Empty, textureSlot = rdesc.BindPoint, samplerSlot = rdesc.BindPoint, parameterName = samplerName }; SamplerStateInfo state; if (samplerStates.TryGetValue(samplerName, out state)) { sampler.parameterName = state.TextureName ?? samplerName; sampler.state = state.State; } else { foreach (var s in samplerStates.Values) { if (samplerName == s.TextureName) { sampler.state = s.State; samplerName = s.Name; break; } } } // Find sampler slot, which can be different from the texture slot. for (int j = 0; j < refelect.Description.BoundResources; j++) { var samplerrdesc = refelect.GetResourceBindingDescription(j); if (samplerrdesc.Type == SharpDX.D3DCompiler.ShaderInputType.Sampler && samplerrdesc.Name == samplerName) { sampler.samplerSlot = samplerrdesc.BindPoint; break; } } switch (rdesc.Dimension) { case ShaderResourceViewDimension.Texture1D: case ShaderResourceViewDimension.Texture1DArray: sampler.type = MojoShader.MOJOSHADER_samplerType.MOJOSHADER_SAMPLER_1D; break; case ShaderResourceViewDimension.Texture2D: case ShaderResourceViewDimension.Texture2DArray: case ShaderResourceViewDimension.Texture2DMultisampled: case ShaderResourceViewDimension.Texture2DMultisampledArray: sampler.type = MojoShader.MOJOSHADER_samplerType.MOJOSHADER_SAMPLER_2D; break; case ShaderResourceViewDimension.Texture3D: sampler.type = MojoShader.MOJOSHADER_samplerType.MOJOSHADER_SAMPLER_VOLUME; break; case ShaderResourceViewDimension.TextureCube: case ShaderResourceViewDimension.TextureCubeArray: sampler.type = MojoShader.MOJOSHADER_samplerType.MOJOSHADER_SAMPLER_CUBE; break; } samplers.Add(sampler); } } dxshader._samplers = samplers.ToArray(); // Gather all the constant buffers used by this shader. dxshader._cbuffers = new int[refelect.Description.ConstantBuffers]; for (var i = 0; i < refelect.Description.ConstantBuffers; i++) { var cb = new ConstantBufferData(refelect.GetConstantBuffer(i)); // Look for a duplicate cbuffer in the list. for (var c = 0; c < cbuffers.Count; c++) { if (cb.SameAs(cbuffers[c])) { cb = null; dxshader._cbuffers[i] = c; break; } } // Add a new cbuffer. if (cb != null) { dxshader._cbuffers[i] = cbuffers.Count; cbuffers.Add(cb); } } } } return(dxshader); }
public override void Setup(IRayDenLibraryFrame newFrame) { base.Setup(newFrame); samples = new Sample[SamplesPerIteration]; sampler = new Sampler(Width, Height, SamplesPerPixel, (MaxRecursionLevel) * (ValuesPerVertex)); }
public void SetDiffSampler(Sampler sampler) { diffuse.Sampler = sampler; }
public void SetSampler(Sampler s) { sampler = s; sampler.MapSamplesToHemisphere(1); }
public unsafe void DestroySampler(Sampler sampler, AllocationCallbacks* allocator = null) { vkDestroySampler(this, sampler, allocator); }
private static Func<int, IEnumerable<Vector2d>> GetUniformSampler() { Sampler sampler = new Sampler(); return (sampleCount) => sampler.GenerateUniformPoints(sampleCount); }
public void ReadSamplerInput( Sampler sampler, XmlNode node, ColladaMeshInfo meshInfo ) { InputSourceCollection tmp = ReadInput( node, meshInfo ); Debug.Assert( tmp.GetSources().Count == 1 ); InputSource entry = tmp.GetSources()[ 0 ]; switch( entry.Semantic ) { case "INPUT": sampler.Input = entry; break; case "OUTPUT": sampler.Output = entry; break; case "INTERPOLATION": sampler.Interpolation = entry; break; default: log.WarnFormat( "Unhandled sampler semantic: {0}", entry.Semantic ); break; } }
public static ShaderData CreateHLSL(byte[] byteCode, bool isVertexShader, List<ConstantBufferData> cbuffers, int sharedIndex, Dictionary<string, SamplerStateInfo> samplerStates, bool debug) { var dxshader = new ShaderData(); dxshader.IsVertexShader = isVertexShader; dxshader.SharedIndex = sharedIndex; dxshader.Bytecode = (byte[])byteCode.Clone(); // Strip the bytecode we're gonna save! var stripFlags = SharpDX.D3DCompiler.StripFlags.CompilerStripReflectionData | SharpDX.D3DCompiler.StripFlags.CompilerStripTestBlobs; if (!debug) stripFlags |= SharpDX.D3DCompiler.StripFlags.CompilerStripDebugInformation; using (var original = new SharpDX.D3DCompiler.ShaderBytecode(byteCode)) { // Strip the bytecode for saving to disk. var stripped = original.Strip(stripFlags); { // Only SM4 and above works with strip... so this can return null! if (stripped != null) { dxshader.ShaderCode = stripped; } else { // TODO: There is a way to strip SM3 and below // but we have to write the method ourselves. // // If we need to support it then consider porting // this code over... // // http://entland.homelinux.com/blog/2009/01/15/stripping-comments-from-shader-bytecodes/ // dxshader.ShaderCode = (byte[])dxshader.Bytecode.Clone(); } } // Use reflection to get details of the shader. using (var refelect = new SharpDX.D3DCompiler.ShaderReflection(byteCode)) { // Get the samplers. var samplers = new List<Sampler>(); for (var i = 0; i < refelect.Description.BoundResources; i++) { var rdesc = refelect.GetResourceBindingDescription(i); if (rdesc.Type == SharpDX.D3DCompiler.ShaderInputType.Texture) { var samplerName = rdesc.Name; var sampler = new Sampler { textureSlot = rdesc.BindPoint, samplerSlot = rdesc.BindPoint, parameterName = samplerName }; SamplerStateInfo state; if (samplerStates.TryGetValue(samplerName, out state)) { sampler.parameterName = state.TextureName ?? samplerName; sampler.state = state.State; } else { foreach (var s in samplerStates.Values) { if (samplerName == s.TextureName) { sampler.state = s.State; samplerName = s.Name; break; } } } // Find sampler slot, which can be different from the texture slot. for (int j = 0; j < refelect.Description.BoundResources; j++) { var samplerrdesc = refelect.GetResourceBindingDescription(j); if (samplerrdesc.Type == SharpDX.D3DCompiler.ShaderInputType.Sampler && samplerrdesc.Name == samplerName) { sampler.samplerSlot = samplerrdesc.BindPoint; break; } } switch (rdesc.Dimension) { case ShaderResourceViewDimension.Texture1D: case ShaderResourceViewDimension.Texture1DArray: sampler.type = MojoShader.MOJOSHADER_samplerType.MOJOSHADER_SAMPLER_1D; break; case ShaderResourceViewDimension.Texture2D: case ShaderResourceViewDimension.Texture2DArray: case ShaderResourceViewDimension.Texture2DMultisampled: case ShaderResourceViewDimension.Texture2DMultisampledArray: sampler.type = MojoShader.MOJOSHADER_samplerType.MOJOSHADER_SAMPLER_2D; break; case ShaderResourceViewDimension.Texture3D: sampler.type = MojoShader.MOJOSHADER_samplerType.MOJOSHADER_SAMPLER_VOLUME; break; case ShaderResourceViewDimension.TextureCube: case ShaderResourceViewDimension.TextureCubeArray: sampler.type = MojoShader.MOJOSHADER_samplerType.MOJOSHADER_SAMPLER_CUBE; break; } samplers.Add(sampler); } } dxshader._samplers = samplers.ToArray(); // Gather all the constant buffers used by this shader. dxshader._cbuffers = new int[refelect.Description.ConstantBuffers]; for (var i = 0; i < refelect.Description.ConstantBuffers; i++) { var cb = new ConstantBufferData(refelect.GetConstantBuffer(i)); // Look for a duplicate cbuffer in the list. for (var c = 0; c < cbuffers.Count; c++) { if (cb.SameAs(cbuffers[c])) { cb = null; dxshader._cbuffers[i] = c; break; } } // Add a new cbuffer. if (cb != null) { dxshader._cbuffers[i] = cbuffers.Count; cbuffers.Add(cb); } } } } return dxshader; }
public override void OnStart() { ComputeShader = Graphics.Content.LoadShaderModule(Path.Combine("Sprites", "BasicSprites.comp.spv")); VertexShader = Graphics.Content.LoadShaderModule(Path.Combine("Sprites", "BasicSprites.vert.spv")); FragmentShader = Graphics.Content.LoadShaderModule(Path.Combine("Sprites", "BasicSprites.frag.spv")); TextureSampler = Graphics.Device.CreateSampler(new SamplerCreateInfo { MinFilter = Filter.Linear, MagFilter = Filter.Linear }); GraphicsDescriptorPool = Graphics.Device.CreateDescriptorPool(new DescriptorPoolCreateInfo( MaxSets, new DescriptorPoolSize[] { new DescriptorPoolSize(DescriptorType.UniformBuffer, MaxSets), new DescriptorPoolSize(DescriptorType.CombinedImageSampler, MaxSets), new DescriptorPoolSize(DescriptorType.UniformBuffer, MaxSets) }, DescriptorPoolCreateFlags.FreeDescriptorSet )); ComputeDescriptorPool = Graphics.Device.CreateDescriptorPool(new DescriptorPoolCreateInfo( MaxSets, new DescriptorPoolSize[] { new DescriptorPoolSize(DescriptorType.StorageBuffer, MaxSets), new DescriptorPoolSize(DescriptorType.UniformBuffer, MaxSets), new DescriptorPoolSize(DescriptorType.UniformBuffer, MaxSets) }, DescriptorPoolCreateFlags.FreeDescriptorSet )); GraphicsDescriptorSetLayout = Graphics.Device.CreateDescriptorSetLayout(new DescriptorSetLayoutCreateInfo( new[] { new DescriptorSetLayoutBinding( binding: 0, descriptorType: DescriptorType.UniformBuffer, descriptorCount: 1, stageFlags: ShaderStages.Vertex ), new DescriptorSetLayoutBinding( binding: 1, descriptorType: DescriptorType.CombinedImageSampler, descriptorCount: 1, stageFlags: ShaderStages.Fragment ), new DescriptorSetLayoutBinding( binding: 2, descriptorType: DescriptorType.UniformBuffer, descriptorCount: 1, stageFlags: ShaderStages.Vertex ) } )); ComputeDescriptorSetLayout = Graphics.Device.CreateDescriptorSetLayout(new DescriptorSetLayoutCreateInfo( new[] { new DescriptorSetLayoutBinding( binding: 0, descriptorType: DescriptorType.StorageBuffer, descriptorCount: 1, stageFlags: ShaderStages.Compute ), new DescriptorSetLayoutBinding( binding: 1, descriptorType: DescriptorType.StorageBuffer, descriptorCount: 1, stageFlags: ShaderStages.Compute ), new DescriptorSetLayoutBinding( binding: 2, descriptorType: DescriptorType.UniformBuffer, descriptorCount: 1, stageFlags: ShaderStages.Compute ), new DescriptorSetLayoutBinding( binding: 3, descriptorType: DescriptorType.UniformBuffer, descriptorCount: 1, stageFlags: ShaderStages.Compute ) } )); GraphicsPipelineLayout = Graphics.Device.CreatePipelineLayout(new PipelineLayoutCreateInfo( setLayouts: new[] { GraphicsDescriptorSetLayout } )); ComputePipelineLayout = Graphics.Device.CreatePipelineLayout(new PipelineLayoutCreateInfo( setLayouts: new[] { ComputeDescriptorSetLayout } )); GraphicsPipeline = Graphics.Device.CreateGraphicsPipeline(new GraphicsPipelineCreateInfo( layout: GraphicsPipelineLayout, renderPass: RenderPass.RenderPass, subpass: 0, stages: new[] { new PipelineShaderStageCreateInfo(ShaderStages.Vertex, VertexShader, "main"), new PipelineShaderStageCreateInfo(ShaderStages.Fragment, FragmentShader, "main") }, inputAssemblyState: new PipelineInputAssemblyStateCreateInfo(PrimitiveTopology.TriangleList), vertexInputState: new PipelineVertexInputStateCreateInfo( new VertexInputBindingDescription[] { new VertexInputBindingDescription( 0, Interop.SizeOf <VertexInstance>(), VertexInputRate.Instance ) }, new VertexInputAttributeDescription[] { new VertexInputAttributeDescription( // Transform matrix row 0 0, 0, Format.R32G32B32A32SFloat, 0 ), new VertexInputAttributeDescription( // Transform matrix row 1 1, 0, Format.R32G32B32A32SFloat, 16 ), new VertexInputAttributeDescription( // Transform matrix row 2 2, 0, Format.R32G32B32A32SFloat, 32 ), new VertexInputAttributeDescription( // Transform matrix row 03 3, 0, Format.R32G32B32A32SFloat, 48 ), new VertexInputAttributeDescription( // Rectangle 4, 0, Format.R32G32B32A32SFloat, 64 ) } ), rasterizationState: new PipelineRasterizationStateCreateInfo( polygonMode: PolygonMode.Fill, cullMode: CullModes.None, frontFace: FrontFace.Clockwise, lineWidth: 1f ), viewportState: new PipelineViewportStateCreateInfo( new Viewport(0f, 0f, Graphics.Window.Size.X, Graphics.Window.Size.Y), new Rect2D(0, 0, (int)Graphics.Window.Size.X, (int)Graphics.Window.Size.Y) ), multisampleState: new PipelineMultisampleStateCreateInfo( rasterizationSamples: SampleCounts.Count1, minSampleShading: 1 ), colorBlendState: new PipelineColorBlendStateCreateInfo( attachments: new[] { BlendStates.AlphaPremultiplied } ) )); ComputePipeline = Graphics.Device.CreateComputePipeline(new ComputePipelineCreateInfo( stage: new PipelineShaderStageCreateInfo(ShaderStages.Compute, ComputeShader, "main"), layout: ComputePipelineLayout, flags: PipelineCreateFlags.None )); CameraUniform = VKBuffer <CameraUniformBlock> .UniformBuffer( $"{nameof(SpriteEffect)}.{nameof(CameraUniform)}", Graphics, 1 ); TimeUniform = VKBuffer <ListTime> .UniformBuffer( $"{nameof(SpriteEffect)}.{nameof(TimeUniform)}", Graphics, MaxSets ); AnimationUniform = VKBuffer <Animation.ComputeInstruction> .UniformBuffer( $"{nameof(SpriteEffect)}.{nameof(AnimationUniform)}", Graphics, Animation.MaxInstructions *MaxSets ); ComputeSemaphore = Graphics.Device.CreateSemaphore(); SetCamera(Vector2.Zero, new Vector2(Graphics.Window.Size.X, -Graphics.Window.Size.Y)); }
//private IEnumerable<Vector2d> GenerateLensSamples(int tileSize, int sqrtSampleCount) //{ // int pixelCount = tileSize * tileSize; // IEnumerator<Vector2d>[] jitteredSamplers = new IEnumerator<Vector2d>[pixelCount]; // Sampler sampler = new Sampler(); // for (int i = 0; i < pixelCount; i++) // { // jitteredSamplers[i] = sampler.GenerateJitteredSamples(MaxTotalSampleCount).GetEnumerator(); // } // for (int sample = 0; sample < MaxTotalSampleCount; sample++) // { // for (int i = 0; i < pixelCount; i++) // { // jitteredSamplers[i].MoveNext(); // yield return jitteredSamplers[i].Current; // } // } //} private void GeneratePixelSamplesTexture(int textureId, int sqrtSampleCount, int sampleCount) { GL.BindTexture(TextureTarget.Texture1D, textureId); // size of a group of samples for a single pixel int bands = 2; int textureSize = bands * sampleCount; Sampler sampler = new Sampler(); IntPtr texturePtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Half)) * textureSize); unsafe { Half* row = (Half*)texturePtr; int index = 0; foreach (Vector2d sample in sampler.GenerateJitteredSamples(sqrtSampleCount)) { row[index] = (Half)(sample.X - 0.5f); index++; row[index] = (Half)(sample.Y - 0.5f); index++; } } // TODO: could be an half float or unsigned byte instead of a float // TODO: two sample pair could be stored in one 4-channel value GL.TexImage1D(TextureTarget.Texture1D, 0, PixelInternalFormat.Rg16f, sampleCount, 0, PixelFormat.Rg, PixelType.HalfFloat, texturePtr); Marshal.FreeHGlobal(texturePtr); GL.TexParameter(TextureTarget.Texture1D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Nearest); GL.TexParameter(TextureTarget.Texture1D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Nearest); GL.TexParameter(TextureTarget.Texture1D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat); }
private static Func<int, IEnumerable<Vector2d>> GetSemiJitteredSampler() { Sampler sampler = new Sampler(); return (sampleCount) => sampler.GenerateSemiJitteredSamples(sampleCount, 0.5); }
internal Tracer(TracerSettings settings, IAgentWriter agentWriter, ISampler sampler, IScopeManager scopeManager, IDogStatsd statsd) { // update the count of Tracer instances Interlocked.Increment(ref _liveTracerCount); Settings = settings ?? TracerSettings.FromDefaultSources(); Settings.Freeze(); // if not configured, try to determine an appropriate service name DefaultServiceName = Settings.ServiceName ?? GetApplicationName() ?? UnknownServiceName; // only set DogStatsdClient if tracer metrics are enabled if (Settings.TracerMetricsEnabled) { Statsd = statsd ?? CreateDogStatsdClient(Settings, DefaultServiceName, Settings.DogStatsdPort); } _agentWriter = agentWriter ?? new AgentWriter(new Api(Settings.AgentUri, TransportStrategy.Get(Settings), Statsd), Statsd, queueSize: Settings.TraceQueueSize); _scopeManager = scopeManager ?? new AsyncLocalScopeManager(); Sampler = sampler ?? new RuleBasedSampler(new RateLimiter(Settings.MaxTracesSubmittedPerSecond)); if (!string.IsNullOrWhiteSpace(Settings.CustomSamplingRules)) { foreach (var rule in CustomSamplingRule.BuildFromConfigurationString(Settings.CustomSamplingRules)) { Sampler.RegisterRule(rule); } } if (Settings.GlobalSamplingRate != null) { var globalRate = (float)Settings.GlobalSamplingRate; if (globalRate < 0f || globalRate > 1f) { Log.Warning("{0} configuration of {1} is out of range", ConfigurationKeys.GlobalSamplingRate, Settings.GlobalSamplingRate); } else { Sampler.RegisterRule(new GlobalSamplingRule(globalRate)); } } // Register callbacks to make sure we flush the traces before exiting AppDomain.CurrentDomain.ProcessExit += CurrentDomain_ProcessExit; AppDomain.CurrentDomain.DomainUnload += CurrentDomain_DomainUnload; try { // Registering for the AppDomain.UnhandledException event cannot be called by a security transparent method // This will only happen if the Tracer is not run full-trust AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException; } catch (Exception ex) { Log.Warning(ex, "Unable to register a callback to the AppDomain.UnhandledException event."); } try { // Registering for the cancel key press event requires the System.Security.Permissions.UIPermission Console.CancelKeyPress += Console_CancelKeyPress; } catch (Exception ex) { Log.Warning(ex, "Unable to register a callback to the Console.CancelKeyPress event."); } // start the heartbeat loop _heartbeatTimer = new Timer(HeartbeatCallback, state: null, dueTime: TimeSpan.Zero, period: TimeSpan.FromMinutes(1)); // If configured, add/remove the correlation identifiers into the // LibLog logging context when a scope is activated/closed if (Settings.LogsInjectionEnabled) { InitializeLibLogScopeEventSubscriber(_scopeManager, DefaultServiceName, Settings.ServiceVersion, Settings.Environment); } if (Interlocked.Exchange(ref _firstInitialization, 0) == 1) { if (Settings.StartupDiagnosticLogEnabled) { _ = WriteDiagnosticLog(); } if (Settings.RuntimeMetricsEnabled) { _runtimeMetricsWriter = new RuntimeMetricsWriter(Statsd ?? CreateDogStatsdClient(Settings, DefaultServiceName, Settings.DogStatsdPort), TimeSpan.FromSeconds(10)); } } }
public static InfoBuffer GetSamplerInfo(Sampler sampler, SamplerInfo paramName, out ErrorCode error) { return GetInfo(GetSamplerInfo, sampler, paramName, out error); }
private void GenerateLensSamplesTexture(int textureId, int tileSize, int sqrtSampleCount, int totalSampleCount, float lensApertureRadius) { GL.BindTexture(TextureTarget.Texture3D, textureId); // size of a group of samples for a single pixel int bands = 2; int groupSize = bands * totalSampleCount; int textureSize = groupSize * tileSize * tileSize; Sampler sampler = new Sampler(); IntPtr texturePtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(float)) * textureSize); unsafe { int zStride = bands * tileSize * tileSize; for (int y = 0; y < tileSize; y++) { for (int x = 0; x < tileSize; x++) { float* row = (float*)texturePtr + bands * (y * tileSize + x); int index = 0; // Z dimension, totalSampleCount times foreach (Vector2d sample in sampler.GenerateJitteredSamples(sqrtSampleCount)) { Vector2d lensPos = lensApertureRadius * //2 * (sample - new Vector2d(0.5, 0.5)); Sampler.ConcentricSampleDisk(sample); row[index] = (float)lensPos.X; row[index + 1] = (float)lensPos.Y; index += zStride; } } } } // TODO: could be an unsigned byte instead of a float // TODO: two sample pair could be stored in one 4-channel value GL.TexImage3D(TextureTarget.Texture3D, 0, PixelInternalFormat.Rg32f, tileSize, tileSize, totalSampleCount, 0, PixelFormat.Rg, PixelType.Float, texturePtr); GL.TexParameter(TextureTarget.Texture3D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Nearest); GL.TexParameter(TextureTarget.Texture3D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Nearest); GL.TexParameter(TextureTarget.Texture3D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat); GL.TexParameter(TextureTarget.Texture3D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat); GL.TexParameter(TextureTarget.Texture3D, TextureParameterName.TextureWrapR, (int)TextureWrapMode.Clamp); }
public Presenter(Context glContext) { this.glContext = glContext; glPipeline = glContext.Pipeline; sourceFramebuffer = new Framebuffer(glContext); destinationFramebuffer = new Framebuffer(glContext); vertices = new Buffer(glContext, BufferTarget.ArrayBuffer, 4 * 8 * sizeof(float), BufferUsageHint.StaticDraw, new Data(new[] { new Vertex(-1f, -1f), new Vertex(-1f, 1f), new Vertex(1f, 1f), new Vertex(1f, -1f) })); indices = new Buffer(glContext, BufferTarget.ElementArrayBuffer, 6 * sizeof(ushort), BufferUsageHint.StaticDraw, new Data(new ushort[] { 0, 1, 2, 0, 2, 3 })); sampler = new Sampler(); sampler.SetMagFilter(TextureMagFilter.Nearest); sampler.SetMinFilter(TextureMinFilter.Nearest); string shaderErrors; if (!VertexShader.TryCompile(VertexShaderText, out vertexShader, out shaderErrors) || !FragmentShader.TryCompile(FragmentShaderText, out fragmentShader, out shaderErrors) || !ShaderProgram.TryLink(glContext, new ShaderProgramDescription { VertexShaders = vertexShader, FragmentShaders = fragmentShader, VertexAttributeNames = new[] { "in_position" }, SamplerNames = new[] { "Image" } }, out program, out shaderErrors)) throw new ArgumentException("Program errors:\n\n" + shaderErrors); vertexArray = new VertexArray(glContext); vertexArray.SetElementArrayBuffer(glContext, indices); vertexArray.SetVertexAttributeF(glContext, 0, vertices, VertexAttributeDimension.Two, VertexAttribPointerType.Float, false, 8, 0); }
public void Begin( Sampler samplerState, in ColorRgbaF clearColor)
internal MGFXShader (GraphicsDevice device, BinaryReader reader) { var isVertexShader = reader.ReadBoolean (); #if OPENGL if (isVertexShader) ShaderType = ShaderType.VertexShader; else ShaderType = ShaderType.FragmentShader; #endif // OPENGL var shaderLength = (int)reader.ReadUInt16 (); var shaderBytecode = reader.ReadBytes (shaderLength); var samplerCount = (int)reader.ReadByte (); _samplers = new Sampler[samplerCount]; for (var s = 0; s < samplerCount; s++) { _samplers [s].type = (SamplerType)reader.ReadByte (); _samplers [s].index = reader.ReadByte (); #if OPENGL _samplers [s].name = reader.ReadString (); #endif _samplers [s].parameter = (int)reader.ReadByte (); } var cbufferCount = (int)reader.ReadByte (); _cbuffers = new int[cbufferCount]; for (var c = 0; c < cbufferCount; c++) _cbuffers [c] = (int)reader.ReadByte (); #if DIRECTX var d3dDevice = device._d3dDevice; if (isVertexShader) { _vertexShader = new VertexShader(d3dDevice, shaderBytecode, null); // We need the bytecode later for allocating the // input layout from the vertex declaration. Bytecode = shaderBytecode; HashKey = Effect.ComputeHash(Bytecode); } else _pixelShader = new PixelShader(d3dDevice, shaderBytecode); #endif // DIRECTX #if OPENGL var attributeCount = (int)reader.ReadByte (); _attributes = new Attribute[attributeCount]; for (var a = 0; a < attributeCount; a++) { _attributes [a].name = reader.ReadString (); _attributes [a].usage = (VertexElementUsage)reader.ReadByte (); _attributes [a].index = reader.ReadByte (); _attributes [a].format = reader.ReadInt16 (); } _glslCode = System.Text.Encoding.ASCII.GetString (shaderBytecode); Compile (); #endif // OPENGL }
public void Render(Texture heightmap, Sampler heightmapSampler) { gb.Render(() => { heightmapSampler.Bind(TextureUnit.Texture0); }, (sp) => { sp.SetUniform("heightmap", 0); sp.SetUniform("texsize", (float)heightmap.Width); }); }
//▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄ // Use this for initialization void Start() { oscA = new OscRamp(); flt = new RCFilter(); kickDrum = new Sampler(kickSample); vca = new Envelope(); flt.input = oscA.output; // TODO: connect method slidderCut.onValueChanged.AddListener((float v) => { flt.cut = v; }); slidderRez.onValueChanged.AddListener((float v) => { flt.rez = v; }); Tempo = 133f; freqTable = new FreqTable (); freqTable.Create (); }
/// <summary> /// Build a GroupBy Dictionary for Peek. /// </summary> /// <remarks> /// Peek identifies each distinct common value and the approximate percentage of rows with it. /// If we have many matching rows, we can sample - the sample will have any common values in it. /// However, we don't know how many matches we have in advance. /// Therefore, we build a Dictionary of all rows, 1/8 of rows, 1/64 of rows, and 1/512 of rows. /// As soon as a given sample has enough samples to be statistically valid, we stop collecting the larger subsets. /// This strategy allows us to run the overall query only once, end up with a large enough sample, and avoid building giant Dictionaries. /// </remarks> /// <param name="cancellationToken">CancellationToken to request early stop</param> private void BuildDictionary(CancellationToken cancellationToken) { // Short-circuit path if there's one key column and it's an EnumColumn if (_column.IsEnumColumn()) { BuildSingleEnumColumnDictionary(cancellationToken); return; } // Build a Random instance to sample rows Random r = new Random(); // Build a Dictionary and CountAggregator for each sample GroupByDictionary[] dictionaries = new GroupByDictionary[SampleCount]; CountAggregator[] counts = new CountAggregator[SampleCount]; int[][] remapArrays = new int[SampleCount][]; for (int i = 0; i < SampleCount; ++i) { dictionaries[i] = new GroupByDictionary(new ColumnDetails[] { _column.ColumnDetails }); counts[i] = new CountAggregator(); } // Retrieve the column getter Func <XArray> columnGetter = _column.CurrentGetter(); // Track which sample we'll currently report int currentSample = 0; XArray[] arrays = new XArray[1]; int count; while ((count = _source.Next(XTableExtensions.DefaultBatchSize, cancellationToken)) != 0) { // Get the column values arrays[0] = columnGetter(); // Build the GroupBy count for all rows and successive 1/8 samples for (int i = 0; i < SampleCount; ++i) { // Add these to the Join Dictionary if (i >= currentSample) { // Choose buckets for each row XArray indicesForRows = dictionaries[i].FindOrAdd(arrays); // Identify the bucket for each row and aggregate them counts[i].Add(indicesForRows, dictionaries[i].Count); // If this sample now has enough values, stop collecting bigger row sets if (currentSample == i - 1 && counts[i].TotalRowCount > RequiredSampleSize) { // If every row was unique, stop early and don't set outputs (zero rows) if (ShouldStopEarly(dictionaries[currentSample], counts[currentSample])) { return; } dictionaries[currentSample] = null; counts[currentSample] = null; currentSample++; } } // Each successive dictionary has ~1/8 of the rows of the previous one if (i < SampleCount - 1) { ArraySelector sample = Sampler.Eighth(arrays[0].Selector, r, ref remapArrays[i]); arrays[0] = arrays[0].Reselect(sample); } } } // Once the loop is done, get the distinct values and aggregation results PostSortAndFilter(dictionaries[currentSample].DistinctKeys()[0], counts[currentSample].Values, counts[currentSample].TotalRowCount, currentSample == 0); }
public static DXShaderData CreateGLSL (byte[] byteCode, List<DXConstantBufferData> cbuffers, int sharedIndex, Dictionary<string, SamplerStateInfo> samplerStates) { var dxshader = new DXShaderData (); dxshader.SharedIndex = sharedIndex; dxshader.Bytecode = (byte[])byteCode.Clone (); // Use MojoShader to convert the HLSL bytecode to GLSL. var parseDataPtr = MojoShader.NativeMethods.MOJOSHADER_parse ( "glsl", byteCode, byteCode.Length, IntPtr.Zero, 0, IntPtr.Zero, 0, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero); var parseData = DXHelper.Unmarshal<MojoShader.MOJOSHADER_parseData> (parseDataPtr); if (parseData.error_count > 0) { var errors = DXHelper.UnmarshalArray<MojoShader.MOJOSHADER_error> ( parseData.errors, parseData.error_count ); throw new Exception (errors [0].error); } switch (parseData.shader_type) { case MojoShader.MOJOSHADER_shaderType.MOJOSHADER_TYPE_PIXEL: dxshader.IsVertexShader = false; break; case MojoShader.MOJOSHADER_shaderType.MOJOSHADER_TYPE_VERTEX: dxshader.IsVertexShader = true; break; default: throw new NotSupportedException (); } // Conver the attributes. // // TODO: Could this be done using DX shader reflection? // { var attributes = DXHelper.UnmarshalArray<MojoShader.MOJOSHADER_attribute> ( parseData.attributes, parseData.attribute_count); dxshader._attributes = new Attribute[attributes.Length]; for (var i = 0; i < attributes.Length; i++) { dxshader._attributes [i].name = attributes [i].name; dxshader._attributes [i].index = attributes [i].index; dxshader._attributes [i].usage = DXEffectObject.ToXNAVertexElementUsage (attributes [i].usage); } } var symbols = DXHelper.UnmarshalArray<MojoShader.MOJOSHADER_symbol> ( parseData.symbols, parseData.symbol_count); //try to put the symbols in the order they are eventually packed into the uniform arrays //this /should/ be done by pulling the info from mojoshader Array.Sort (symbols, delegate(MojoShader.MOJOSHADER_symbol a, MojoShader.MOJOSHADER_symbol b) { uint va = a.register_index; if (a.info.elements == 1) va += 1024; //hax. mojoshader puts array objects first uint vb = b.register_index; if (b.info.elements == 1) vb += 1024; return va.CompareTo (vb); } );//(a, b) => ((int)(a.info.elements > 1))a.register_index.CompareTo(b.register_index)); // NOTE: It seems the latest versions of MojoShader only // output vec4 register sets. We leave the code below, but // the runtime has been optimized for this case. // For whatever reason the register indexing is // incorrect from MojoShader. { uint bool_index = 0; uint float4_index = 0; uint int4_index = 0; for (var i = 0; i < symbols.Length; i++) { switch (symbols [i].register_set) { case MojoShader.MOJOSHADER_symbolRegisterSet.MOJOSHADER_SYMREGSET_BOOL: symbols [i].register_index = bool_index; bool_index += symbols [i].register_count; break; case MojoShader.MOJOSHADER_symbolRegisterSet.MOJOSHADER_SYMREGSET_FLOAT4: symbols [i].register_index = float4_index; float4_index += symbols[i].register_count; break; case MojoShader.MOJOSHADER_symbolRegisterSet.MOJOSHADER_SYMREGSET_INT4: symbols [i].register_index = int4_index; int4_index += symbols [i].register_count; break; } } } // Get the samplers. var samplers = DXHelper.UnmarshalArray<MojoShader.MOJOSHADER_sampler> ( parseData.samplers, parseData.sampler_count); dxshader._samplers = new Sampler[samplers.Length]; for (var i = 0; i < samplers.Length; i++) { // We need the original sampler name... look for that in the symbols. var originalSamplerName = symbols.First(e => e.register_set == MojoShader.MOJOSHADER_symbolRegisterSet.MOJOSHADER_SYMREGSET_SAMPLER && e.register_index == samplers[i].index ).name; var sampler = new Sampler { //sampler mapping to parameter is unknown atm parameter = -1, // GLSL needs the MojoShader mangled sampler name. samplerName = samplers[i].name, // By default use the original sampler name for the parameter name. parameterName = originalSamplerName, textureSlot = samplers[i].index, samplerSlot = samplers[i].index, type = samplers[i].type, }; SamplerStateInfo state; if (samplerStates.TryGetValue(originalSamplerName, out state)) { sampler.state = state.State; sampler.parameterName = state.TextureName ?? originalSamplerName; } // Store the sampler. dxshader._samplers[i] = sampler; } // Gather all the parameters used by this shader. var symbol_types = new [] { new { name = dxshader.IsVertexShader ? "vs_uniforms_bool" : "ps_uniforms_bool", set = MojoShader.MOJOSHADER_symbolRegisterSet.MOJOSHADER_SYMREGSET_BOOL, }, new { name = dxshader.IsVertexShader ? "vs_uniforms_ivec4" : "ps_uniforms_ivec4", set = MojoShader.MOJOSHADER_symbolRegisterSet.MOJOSHADER_SYMREGSET_INT4, }, new { name = dxshader.IsVertexShader ? "vs_uniforms_vec4" : "ps_uniforms_vec4", set = MojoShader.MOJOSHADER_symbolRegisterSet.MOJOSHADER_SYMREGSET_FLOAT4, }, }; var cbuffer_index = new List<int> (); for (var i = 0; i < symbol_types.Length; i++) { var cbuffer = new DXConstantBufferData (symbol_types [i].name, symbol_types [i].set, symbols); if (cbuffer.Size == 0) continue; var match = cbuffers.FindIndex (e => e.SameAs (cbuffer)); if (match == -1) { cbuffer_index.Add (cbuffers.Count); cbuffers.Add (cbuffer); } else cbuffer_index.Add (match); } dxshader._cbuffers = cbuffer_index.ToArray (); var glslCode = parseData.output; #if GLSLOPTIMIZER //glslCode = GLSLOptimizer.Optimize(glslCode, ShaderType); #endif // TODO: This sort of sucks... why does MojoShader not produce // code valid for GLES out of the box? // GLES platforms do not like this. glslCode = glslCode.Replace ("#version 110", ""); // Add the required precision specifiers for GLES. var floatPrecision = dxshader.IsVertexShader ? "precision highp float;\r\n" : "precision mediump float;\r\n"; glslCode = "#ifdef GL_ES\r\n" + floatPrecision + "precision mediump int;\r\n" + "#endif\r\n" + glslCode; // Store the code for serialization. dxshader.ShaderCode = Encoding.ASCII.GetBytes (glslCode); return dxshader; }
internal Tracer(TracerSettings settings, IAgentWriter agentWriter, ISampler sampler, IScopeManager scopeManager, IStatsd statsd) { // update the count of Tracer instances Interlocked.Increment(ref _liveTracerCount); Settings = settings ?? TracerSettings.FromDefaultSources(); // if not configured, try to determine an appropriate service name DefaultServiceName = Settings.ServiceName ?? GetApplicationName() ?? UnknownServiceName; // only set DogStatsdClient if tracer metrics are enabled if (Settings.TracerMetricsEnabled) { // Run this first in case the port override is ready TracingProcessManager.SubscribeToDogStatsDPortOverride( port => { Log.Debug("Attempting to override dogstatsd port with {0}", port); Statsd = CreateDogStatsdClient(Settings, DefaultServiceName, port); }); Statsd = statsd ?? CreateDogStatsdClient(Settings, DefaultServiceName, Settings.DogStatsdPort); } IApi apiClient = null; if (agentWriter == null) { if (Settings.ApiType.ToLower().Equals("zipkin")) { apiClient = new ZipkinApi(Settings, delegatingHandler: null); } } _agentWriter = agentWriter ?? new AgentWriter(apiClient, Statsd, Settings.SynchronousSend); _scopeManager = scopeManager ?? new AsyncLocalScopeManager(); Sampler = sampler ?? new RuleBasedSampler(new RateLimiter(Settings.MaxTracesSubmittedPerSecond)); if (!string.IsNullOrWhiteSpace(Settings.CustomSamplingRules)) { // User has opted in, ensure rate limiter is used RuleBasedSampler.OptInTracingWithoutLimits(); foreach (var rule in CustomSamplingRule.BuildFromConfigurationString(Settings.CustomSamplingRules)) { Sampler.RegisterRule(rule); } } if (Settings.GlobalSamplingRate != null) { var globalRate = (float)Settings.GlobalSamplingRate; if (globalRate < 0f || globalRate > 1f) { Log.Warning("{0} configuration of {1} is out of range", ConfigurationKeys.GlobalSamplingRate, Settings.GlobalSamplingRate); } else { Sampler.RegisterRule(new GlobalSamplingRule(globalRate)); } } // Register callbacks to make sure we flush the traces before exiting AppDomain.CurrentDomain.ProcessExit += CurrentDomain_ProcessExit; AppDomain.CurrentDomain.DomainUnload += CurrentDomain_DomainUnload; AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException; Console.CancelKeyPress += Console_CancelKeyPress; // start the heartbeat loop _heartbeatTimer = new Timer(HeartbeatCallback, state: null, dueTime: TimeSpan.Zero, period: TimeSpan.FromMinutes(1)); // If configured, add/remove the correlation identifiers into the // LibLog logging context when a scope is activated/closed if (Settings.LogsInjectionEnabled) { InitializeLibLogScopeEventSubscriber(_scopeManager); } }