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);
/// <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);
}
}
