private glTFLoader.Schema.Image GetImageFromBitmapText(Bitmap bitmap) { byte[] imageBytes = GetImageBytes(bitmap); var textureBuffer = new glTFLoader.Schema.Buffer(); textureBuffer.Uri = Constants.TextBufferHeader + Convert.ToBase64String(imageBytes); textureBuffer.ByteLength = imageBytes.Length; int textureBufferIdx = dummy.Buffers.AddAndReturnIndex(textureBuffer); // Create bufferviews var textureBufferView = new BufferView() { Buffer = textureBufferIdx, ByteOffset = 0, ByteLength = textureBuffer.ByteLength, }; int textureBufferViewIdx = dummy.BufferViews.AddAndReturnIndex(textureBufferView); return(new glTFLoader.Schema.Image() { BufferView = textureBufferViewIdx, MimeType = glTFLoader.Schema.Image.MimeTypeEnum.image_png, }); }
private void LoadMesh(Gltf model, out BufferView indicesBufferView, out BufferView[] attributesBufferView) { var mesh = model.Meshes[0]; indicesBufferView = null; attributesBufferView = null; for (var i = 0; i < mesh.Primitives.Length; i++) { var primitive = mesh.Primitives[i]; if (primitive.Indices.HasValue) { indicesBufferView = ReadAccessor(model, primitive.Indices.Value); } var attributesCount = primitive.Attributes.Values.Count; attributesBufferView = new BufferView[attributesCount]; var insertIndex = 0; foreach (var attribute in primitive.Attributes) { attributesBufferView[insertIndex++] = ReadAccessor(model, attribute.Value); } } }
public override void OnLoad(PluginAssemblyPointer ptr) { base.OnLoad(ptr); PluginHost.OnBufferClick += (program, buffer) => { BufferView bvv = new BufferView( program.Instance, buffer, program.Dimensions.x, program.Dimensions.y ); Views.Add(bvv); bvv.Show(); }; PluginHost.OnInternalBufferClick += (program, buffer) => { BufferView bvv = new BufferView( program.Instance, buffer, program.Dimensions.x, program.Dimensions.y ); Views.Add(bvv); bvv.Show(); }; }
public static string ToReport(this BufferView bv) { var path = string.Empty; if (bv.IsVertexBuffer) { path += " VertexView"; } else if (bv.IsIndexBuffer) { path += " IndexView"; } else { path += " BufferView"; } var content = bv.Content; path += $"[{bv.LogicalIndex}ᴵᵈˣ]"; path += $"[{content.Count}ᴮʸᵗᵉˢ]"; if (bv.ByteStride > 0) { path += $" Stride:{bv.ByteStride}ᴮʸᵗᵉˢ"; } return(path); }
void ImportSkin(int skinIndex, GameObject go, Dictionary <int, GameObject> gameObjects) { var gltf = Container.Gltf; var gltfSkin = gltf.Skins[skinIndex]; var smr = go.GetComponent <SkinnedMeshRenderer>(); if (smr == null) { throw new NotImplementedException(); // TODO } if (gltfSkin.Skeleton != null) { smr.rootBone = gameObjects[gltfSkin.Skeleton.Value].transform; } smr.bones = gltfSkin.Joints.Select(i => gameObjects[i].transform).ToArray(); if (gltfSkin.InverseBindMatrices != null) { var buf = BufferView.GetOrLoadTypedBufferByAccessorIndex(gltfSkin.InverseBindMatrices.Value); var matrices = buf.GetEntity <Matrix4x4>().GetEnumerable().Select(CoordUtils.ConvertSpace).ToArray(); var mesh = smr.sharedMesh; mesh.bindposes = matrices; } }
private void AddBufferView(Model model, IList <List <byte> > buffers, IList <int> accessors, int bufferIndex, int byteOffset, int?byteStride, TargetType?target) { var byteLength = 0; var bvIndex = model.BufferViews.Count; for (var i = 0; i < buffers.Count; i++) { var accessor = model.Accessors[accessors[i]]; accessor.BufferView = bvIndex; accessor.ByteOffset = byteLength; byteLength += buffers[i].Count; } var bufferView = new BufferView { Name = "bv_" + bvIndex, Buffer = bufferIndex, ByteLength = byteLength, ByteOffset = byteOffset, ByetStride = byteStride }; if (target.HasValue) { bufferView.Target = new CheckedValue <TargetType, int>(target.Value); } model.BufferViews.Add(bufferView); }
public OrientedBox(BufferView <Vector3> positions) { unsafe { GetOrientedBox((byte *)positions.BasePter, positions.Count, positions.Stride); } }
public void RestoreView(BufferView view) { if (_index > view.Length) { throw new InvalidOperationException("Can't restore view. Already read data after end of view."); } _length = view.Length; }
public MdfBufferAdapter(MdfChannelAdapter masterChannel, MdfChannelAdapter channel, BufferView <Mdf4Channel> channelSamples, BufferView <Mdf4Channel> masterSamples) { _masterSamples = masterSamples; _channelSamples = channelSamples; Channel = channel; Master = masterChannel; }
private JoinPlanResult HandleJoin( string[] streamNames, Viewable[] streamViews, ResultSetProcessor resultSetProcessor, AgentInstanceContext agentInstanceContext, IList <StopCallback> stopCallbacks, StreamJoinAnalysisResult joinAnalysisResult, bool isRecoveringResilient) { var joinSetComposerDesc = _joinSetComposerPrototype.Create(streamViews, false, agentInstanceContext, isRecoveringResilient); stopCallbacks.Add(new ProxyStopCallback(() => joinSetComposerDesc.JoinSetComposer.Destroy())); var filter = new JoinSetFilter(joinSetComposerDesc.PostJoinFilterEvaluator); var indicatorView = _outputProcessViewFactory.MakeView(resultSetProcessor, agentInstanceContext); // Create strategy for join execution JoinExecutionStrategy execution = new JoinExecutionStrategyImpl(joinSetComposerDesc.JoinSetComposer, filter, indicatorView, agentInstanceContext); // The view needs a reference to the join execution to pull iterator values indicatorView.JoinExecutionStrategy = execution; // Hook up dispatchable with buffer and execution strategy var joinStatementDispatch = new JoinExecStrategyDispatchable(execution, _statementSpec.StreamSpecs.Length); agentInstanceContext.EpStatementAgentInstanceHandle.OptionalDispatchable = joinStatementDispatch; JoinPreloadMethod preloadMethod; if (joinAnalysisResult.UnidirectionalStreamNumber >= 0) { preloadMethod = new JoinPreloadMethodNull(); } else { if (!joinSetComposerDesc.JoinSetComposer.AllowsInit) { preloadMethod = new JoinPreloadMethodNull(); } else { preloadMethod = new JoinPreloadMethodImpl(streamNames.Length, joinSetComposerDesc.JoinSetComposer); } } // Create buffer for each view. Point buffer to dispatchable for join. for (var i = 0; i < _statementSpec.StreamSpecs.Length; i++) { var buffer = new BufferView(i); streamViews[i].AddView(buffer); buffer.Observer = joinStatementDispatch; preloadMethod.SetBuffer(buffer, i); } return(new JoinPlanResult(indicatorView, preloadMethod, joinSetComposerDesc)); }
private static MgtfBufferView ExtractBufferView(BufferView src) { return(new MgtfBufferView { BufferIndex = src.Buffer, ByteStride = src.ByteStride, BufferOffset = src.ByteOffset, ByteLength = src.ByteLength, Usage = DetrimineUsage(src), }); }
private void CreateNormalBuffer(BrgMesh mesh, GltfFormatter formatter, Stream bufferStream) { long bufferViewOffset; Vector3 max = new Vector3(float.MinValue); Vector3 min = new Vector3(float.MaxValue); using (BinaryWriter writer = new BinaryWriter(bufferStream, Encoding.UTF8, true)) { // padding writer.Write(new byte[(-bufferStream.Length) & (PaddingBytes(Accessor.ComponentTypeEnum.FLOAT) - 1)]); bufferViewOffset = bufferStream.Length; foreach (int index in Indices) { Vector3 vec = mesh.Normals[index]; vec = vec / vec.Length(); max.X = Math.Max(max.X, vec.X); max.Y = Math.Max(max.Y, vec.Y); max.Z = Math.Max(max.Z, vec.Z); min.X = Math.Min(min.X, vec.X); min.Y = Math.Min(min.Y, vec.Y); min.Z = Math.Min(min.Z, vec.Z); writer.Write(vec.X); writer.Write(vec.Y); writer.Write(vec.Z); } } BufferView posBufferView = new BufferView(); posBufferView.Buffer = 0; posBufferView.ByteLength = Indices.Count * 12; posBufferView.ByteOffset = (int)bufferViewOffset; posBufferView.ByteStride = 12; posBufferView.Name = "normalBufferView"; posBufferView.Target = BufferView.TargetEnum.ARRAY_BUFFER; Accessor posAccessor = new Accessor(); posAccessor.BufferView = formatter.bufferViews.Count; posAccessor.ByteOffset = 0; posAccessor.ComponentType = Accessor.ComponentTypeEnum.FLOAT; posAccessor.Count = Indices.Count; posAccessor.Max = new[] { max.X, max.Y, max.Z }; posAccessor.Min = new[] { min.X, min.Y, min.Z }; posAccessor.Name = "normalBufferViewAccessor"; posAccessor.Type = Accessor.TypeEnum.VEC3; formatter.bufferViews.Add(posBufferView); formatter.accessors.Add(posAccessor); }
public unsafe void AddNormal(byte *vertexData, int index) { var buffer = _vertexBufferData.GetBuffer(); using ArrayPtr arrayPtr = new ArrayPtr(buffer); var source = new BufferView <Vector3>(vertexData, _vd, VertexSemantic.Normal, 0, 1); var dest = new BufferView <Vector3>(arrayPtr.Pointer, _vd, VertexSemantic.Normal, 0, _count); dest[index] += source[0]; dest[index] = Vector3.Normalize(dest[index]); }
public void SetUp() { _bufferViewOne = new BufferView(0); _bufferViewTwo = new BufferView(1); _joinExecutionStrategy = new SupportJoinExecutionStrategy(); _dispatchable = new JoinExecStrategyDispatchable( _joinExecutionStrategy, 2); _bufferViewOne.Observer = _dispatchable; _bufferViewTwo.Observer = _dispatchable; }
private void CreateIndexBuffer(BrgMesh mesh, GltfFormatter formatter, Stream bufferStream) { long bufferViewOffset; short faceMin = short.MaxValue; short faceMax = short.MinValue; using (BinaryWriter writer = new BinaryWriter(bufferStream, Encoding.UTF8, true)) { // padding writer.Write(new byte[(-bufferStream.Length) & (PaddingBytes(Accessor.ComponentTypeEnum.UNSIGNED_SHORT) - 1)]); bufferViewOffset = bufferStream.Length; foreach (var face in Faces) { faceMin = Math.Min(faceMin, face.Indices[0]); faceMin = Math.Min(faceMin, face.Indices[1]); faceMin = Math.Min(faceMin, face.Indices[2]); faceMax = Math.Max(faceMax, face.Indices[0]); faceMax = Math.Max(faceMax, face.Indices[1]); faceMax = Math.Max(faceMax, face.Indices[2]); writer.Write(face.Indices[0]); writer.Write(face.Indices[1]); writer.Write(face.Indices[2]); } } BufferView indexBufferView = new BufferView(); indexBufferView.Buffer = 0; indexBufferView.ByteLength = Faces.Count * 6; indexBufferView.ByteOffset = (int)bufferViewOffset; indexBufferView.Name = "indexBufferView"; indexBufferView.Target = BufferView.TargetEnum.ELEMENT_ARRAY_BUFFER; Accessor indexAccessor = new Accessor(); indexAccessor.BufferView = formatter.bufferViews.Count; indexAccessor.ByteOffset = 0; indexAccessor.ComponentType = Accessor.ComponentTypeEnum.UNSIGNED_SHORT; indexAccessor.Count = Faces.Count * 3; indexAccessor.Max = new[] { (float)faceMax }; indexAccessor.Min = new[] { (float)faceMin }; indexAccessor.Name = "indexBufferViewAccessor"; indexAccessor.Type = Accessor.TypeEnum.SCALAR; formatter.bufferViews.Add(indexBufferView); formatter.accessors.Add(indexAccessor); }
/// <summary> /// Initializes the views. /// </summary> private void InitializeViews() { var viewFormat = ViewFormat; if ((ViewFlags & BufferFlags.RawBuffer) != 0) { viewFormat = PixelFormat.R32_Typeless; } if ((ViewFlags & (BufferFlags.ShaderResource | BufferFlags.UnorderedAccess)) != 0) { NativeBufferView = GetShaderResourceView(viewFormat); } }
private static MgBufferUsageFlagBits DetrimineUsage(BufferView src) { switch (src.Target) { case glTFLoader.Schema.BufferView.TargetEnum.ARRAY_BUFFER: return(MgBufferUsageFlagBits.VERTEX_BUFFER_BIT); case glTFLoader.Schema.BufferView.TargetEnum.ELEMENT_ARRAY_BUFFER: return(MgBufferUsageFlagBits.INDEX_BUFFER_BIT); default: throw new NotSupportedException($"specified target:({src.Target}) not supported"); } }
public BufferView SetView(int length) { // can't set more than we have now var end = _index + length; if (end > _length) { throw OutOfInputException(); } var view = new BufferView(_length); _length = end; return(view); }
private static int AddBufferView(List <BufferView> bufferViews, int buffer, int byteOffset, int byteLength, BufferView.TargetEnum?target, int?byteStride) { var b = new BufferView(); b.Buffer = buffer; b.ByteLength = byteLength; b.ByteOffset = byteOffset; b.Target = target; b.ByteStride = byteStride; bufferViews.Add(b); return(bufferViews.Count - 1); }
private DescriptorSetCollection CreateBufferImage(CommandBufferScoped cbs, ref HandleSet key, int setIndex, DescriptorType type) { var dsc = _gd.DescriptorSetManager.AllocateDescriptorSet(_gd.Api, _descriptorSetLayouts[setIndex]).Get(cbs); Span <BufferView> texelBufferView = stackalloc BufferView[key.Count]; for (int i = 0; i < key.Count; i++) { texelBufferView[i] = new BufferView(key.Handles[i]); } dsc.UpdateBufferImages(0, 0, texelBufferView, type); return(dsc); }
public BufferView CreateBufferview(Buffer buffer, Format format, DeviceSize size) { BufferView bufferView = VContext.Instance.device.CreateBufferView ( new BufferViewCreateInfo() { Buffer = buffer, Format = format, Offset = 0, Range = size } ); return(bufferView); }
Vector4[] ImportTangents(int index) { // VEC4 | FLOAT var buf = BufferView.GetOrLoadTypedBufferByAccessorIndex(index); var acc = buf.Accessor; if (acc.Type == Types.Accessor.TypeEnum.Vec4) { if (acc.ComponentType == Types.Accessor.ComponentTypeEnum.FLOAT) { return(buf.GetEntity <Vector4>().GetEnumerable().Select(CoordUtils.ConvertSpace).ToArray()); } } throw new NotImplementedException(); // TODO }
public unsafe static byte[] CreateBufferViewCopy(BufferView bufferView, GlbBinChunk chunk, byte[] bytes) { var result = new byte[bufferView.byteLength]; fixed(void *p = &(result[0]), src = &(bytes[bufferView.byteOffset + chunk.start])) { System.Buffer.MemoryCopy( src, p, bufferView.byteLength, bufferView.byteLength ); } return(result); }
void AddBufferView(string name, byte[] buffer) { int offset = internalBuffer.Count; int length = buffer.Length; foreach (var b in buffer) { internalBuffer.Add(b); } var bufferView = new BufferView(); bufferView.byteOffset = offset; bufferView.byteLength = length; bufferViews.Add(name, bufferView); }
public async Task <Texture> GetTextureAsync(int textureIndex, bool isSRgb = false) { int imageIndex = gltf.Textures[textureIndex].Source ?? throw new Exception(); GltfLoader.Schema.Image image = gltf.Images[imageIndex]; int bufferViewIndex = image.BufferView ?? throw new Exception(); BufferView bufferView = gltf.BufferViews[bufferViewIndex]; byte[] currentBuffer = buffers[bufferView.Buffer]; MemoryStream stream = new MemoryStream(currentBuffer, bufferView.ByteOffset, bufferView.ByteLength); Texture texture = await Texture.LoadAsync(GraphicsDevice, stream, isSRgb); return(texture); }
private BufferViewId ExportBufferView(int byteOffset, int byteLength) { var bufferView = new BufferView { Buffer = _bufferId, ByteOffset = byteOffset, ByteLength = byteLength, }; var id = new BufferViewId { Id = _root.BufferViews.Count, Root = _root }; _root.BufferViews.Add(bufferView); return(id); }
public unsafe void UpdateBufferImage(int setIndex, int bindingIndex, BufferView texelBufferView, DescriptorType type) { if (texelBufferView.Handle != 0UL) { var writeDescriptorSet = new WriteDescriptorSet { SType = StructureType.WriteDescriptorSet, DstSet = _descriptorSets[setIndex], DstBinding = (uint)bindingIndex, DescriptorType = type, DescriptorCount = 1, PTexelBufferView = &texelBufferView }; _holder.Api.UpdateDescriptorSets(_holder.Device, 1, writeDescriptorSet, 0, null); } }
private Span <byte> GetVertexBuffer(int accessorIndex, out int stride) { Accessor accessor = gltf.Accessors[accessorIndex]; int bufferViewIndex = accessor.BufferView ?? throw new Exception(); BufferView bufferView = gltf.BufferViews[bufferViewIndex]; int offset = bufferView.ByteOffset + accessor.ByteOffset; stride = accessor.ComponentType switch { Accessor.GltfComponentType.Float => GetCountOfAccessorType(accessor.Type) * sizeof(float), _ => throw new NotSupportedException("This component type is not supported.") }; return(buffers[bufferView.Buffer].AsSpan(offset, stride * accessor.Count)); }
private void CreateWeightsBuffer(AoMEngineLibrary.Graphics.Model.Animation animation, int weightCount, Stream bufferStream) { long bufferViewOffset; using (BinaryWriter writer = new BinaryWriter(bufferStream, Encoding.UTF8, true)) { // padding writer.Write(new byte[(-bufferStream.Length) & (PaddingBytes(Accessor.ComponentTypeEnum.FLOAT) - 1)]); bufferViewOffset = bufferStream.Length; for (int i = 0; i < weightCount; ++i) { writer.Write(0.0f); } for (int i = 1; i < animation.MeshKeys.Count; ++i) { for (int j = 0; j < weightCount; ++j) { writer.Write(i == j + 1 ? 1.0f : 0.0f); } } } BufferView posBufferView = new BufferView(); posBufferView.Buffer = 0; posBufferView.ByteLength = animation.MeshKeys.Count * weightCount * 4; posBufferView.ByteOffset = (int)bufferViewOffset; posBufferView.Name = "weightsBufferView"; Accessor posAccessor = new Accessor(); posAccessor.BufferView = bufferViews.Count; posAccessor.ByteOffset = 0; posAccessor.ComponentType = Accessor.ComponentTypeEnum.FLOAT; posAccessor.Count = animation.MeshKeys.Count * weightCount; posAccessor.Max = new[] { 1.0f }; posAccessor.Min = new[] { 0.0f }; posAccessor.Name = "weightsBufferViewAccessor"; posAccessor.Type = Accessor.TypeEnum.SCALAR; bufferViews.Add(posBufferView); accessors.Add(posAccessor); }
Vector4[] ImportWeights(int index) { // VEC4 | FLOAT // | UNSIGNED_BYTE (normalized) // | UNSIGNED_SHORT (normalized) var buf = BufferView.GetOrLoadTypedBufferByAccessorIndex(index); var acc = buf.Accessor; if (acc.Type == Types.Accessor.TypeEnum.Vec4) { if (acc.ComponentType == Types.Accessor.ComponentTypeEnum.FLOAT) { return(buf.GetEntity <Vector4>().GetEnumerable().ToArray()); } } throw new NotImplementedException(); // TODO }
/// <inheritdoc/> protected internal override void OnDestroyed() { GraphicsDevice.BuffersMemory -= SizeInBytes / (float)0x100000; if (NativeBufferView != BufferView.Null) { GraphicsDevice.Collect(NativeBufferView); NativeBufferView = BufferView.Null; } if (NativeBuffer != SharpVulkan.Buffer.Null) { GraphicsDevice.Collect(NativeBuffer); NativeBuffer = SharpVulkan.Buffer.Null; } if (NativeMemory != DeviceMemory.Null) { GraphicsDevice.Collect(NativeMemory); NativeMemory = DeviceMemory.Null; } base.OnDestroyed(); }
internal static unsafe extern void vkDestroyBufferView(Device device, BufferView bufferView, AllocationCallbacks* allocator);
public ILanguageServiceItem CreateItem(BufferView bufferView) { return new ToDoLanguageServiceItem(bufferView, SquiggleProviderFactory); }
public ToDoLanguageServiceItem(BufferView b, ISquiggleProviderFactory squiggleProviderFactory) { this.bufferView = b; this.uri = this.bufferView.Buffer.Uri; this.squiggleProviderFactory = squiggleProviderFactory; this.squiggles = new List<ISquiggleAdornment>(); this.textBuffer = this.bufferView.TextBuffer; this.reparseTimer = new Timer(Reparse, null, Timeout.Infinite, Timeout.Infinite); // Described in MGrammar in a Nutshell (http://msdn.microsoft.com/en-us/library/dd129870.aspx) // and in PDC 2008 talk "Building Textual DSLs with the "Oslo" Modeling Language" (32:00 mark). // this.parser = null; using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ToDo.mgx")) { // Load image and instantiate a corresponding dynamic parser this.parser = DynamicParser.LoadFromMgx(stream, "ToDo.Tasks4"); } this.classifier = new ParserClassifier(parser, bufferView.Buffer.TextBuffer); this.bufferView.EditorInitialized += OnBufferViewEditorInitialized; this.textBuffer.Changed += (ignore1, ignore2) => { lock (l) { bufferDirty = true; } }; }
public unsafe void DestroyBufferView(BufferView bufferView, AllocationCallbacks* allocator = null) { vkDestroyBufferView(this, bufferView, allocator); }
internal static unsafe extern Result vkCreateBufferView(Device device, BufferViewCreateInfo* createInfo, AllocationCallbacks* allocator, BufferView* view);