shroud | js module for encrypting and decrypting secrets | Identity Management library

item:find(search) requires search to be a string pattern. Yet you passed a table (itemsToDelete) to UseContainerItemByName, and therefore into search.

Instead of UseContainerItemByName(itemsToDelete), use

YOu need to keep only one of the following lines in settings.py file.

#use this

So the reason that they're undefined is that they are being set by these lines in main.js:

You should not use GeneratePreviewForURL for quicklook preview generation on Catalina.

Instead, one should implement the QuickLook Preview Extension target. Launching the target will open the debug session where everything can be debbuged in classical way.

Btw, echo-ing from GenerateThumbnailForURL.m should no longer work on Catalina because the extension doesn't have write permissions.

You can use this code.

Suggestion: It is better to use background rather than image in this case.

I'm trying to address your questions one by one

• Why are there three skins? Why is the inverseBindMatrices bound to a skin and not to a joint?

As you already found out, there is one skin per mesh. THe fact that in your specific case, you could merge all three meshes into one, doesn't really restrict this general principle. However

I think there needs to be an inverse bind matrix for each mesh in order to be able to transform the mesh to bone space (and - if need be - back).

There is an inverse bind matrix for each joint of each mesh. The name of the property is inverseBindMatrices in plural for a reason, and it references a bufferview which in turn references some data in a buffer.

Changing the order of your question here, because this way it will make more sense:

Every bone node in the file has its own rotation, translation, scale values but no matrix. Why is that? Isn't there something missing?

What else do you need? Every affine transformation can be decomposed into translation, rotation and scale, so the data is complete. glTF spec defines that the resulting matrix should be calculated in the order T*R*S.

• When I have the right rotation, scaling, translation from a key frame (per bone), how do I calculate the matrices for each bone that I need to pass to my vertex shader?

For each bone node i, you can calculate a local transformation as M_local(i) = T(i)*R(i)*S(i). You will get the joint matrices by applying the complete hierachy, so basically M_global(i) = M_global(parent(i)) * M_local(i) and can then construct the join matrices as M_joint(i) = inverse(globalTransform) * M_global(i) * inverseBindMatrix(i).

• The gltf file referse to a bone (joint) as a node id, but the weights/jointId-Arrays that get passed as attributes to the shader do not match these bone ids: jointIds-Array contains i.e. 0,1,2 for the bone ids, but the bones are in nodes 4,5,6 - how do I find the right bone for each jointId passed to the shader?

The jointIds Array contains references to the joints, not the bones (hence the name). The skinning shader does not care about bones at all, all what the bones do is define the hierachy for the joints here, so they influence the actual values of the M_global and hence also the M_joint matrices. The i-th entry just references the i-th joint in the joints array of the respective skin, hence it needs M_joint(i).

• Since every Skin has a list of three (or max. 4) Joints, these are the Joints of which the final transformations need to be passed to the vertex shader.

Why would a skin be limited to 4 joints. A skin can have as many joints a one likes.

If you have 8 Joints but the current to-be-drawn Mesh only gets affected by 4 of them, why should you pass all 8 matrices instead of only the 4 you need.

Why would you define a skin of 8 bones for a mesh which only needs four? The glTF data format does not prevent you from storing irrelevant information, or store information in an inefficient way.

The point to note here is that the hierachy between the joints is still defined by the bone node hierachy of the skeleton. So you can leave out arbitrary joints in a single skin, but these bone nodes (and a potential animation for them) can still affect the final joint matrices - for any joint defined by a bone which is below the "left out" bones in the skeleton bone hierachy.

You need to create Post API. In API Level, you need to connect to DB, validate the data model in the body and do DB insert. Finally, acknowledge the API with a response.

From frontend, you need to request via AJAX.

This basic question and you can search online to get more details.

I think the reason for the result to be this close is using a size that is so small and not allocating anything in the heap (inside your array initialization loop)to fragment object array elements.

In your benchmark code only object array elements allocates from the heap(*), this way MemoryAllocator can allocate each element sequentially(**) in the heap. When benchmark code starts to execute, data will be read from ram to cpu caches and since your object array elements written to ram in sequential(in a contiguous block) order they will be cached and thats why You don't get any cache misses.

To see this better, you can have another object array(preferably with bigger objects) that will allocate on the heap to fragment your benchmarked object array elements. This may cause cache misses to occur earlier than your current setup. In a real life scenario there will be other threads that will allocate on the same heap and further fragment the actual objects of the array. Also accessing to ram takes much more time than accessing cpu cache(or a cpu cycle). (Check this post regarding this topic).

(*) ValueType array allocates all space required for the array elements when you initialize it with new ValueType[Size]; ValueType array elements will be contiguous in the ram.

(**) objectArr[i] object element and objectArr[i+1](and so on) will be side by side in the heap, when ram block cached, probably all the object array elements will be read to cpu cache, so no ram access will be required when you iterate over the array.

You shoud attempt to use var price = object[name]; because you want to use name as a variable. object.name does not do that.

You can always troubleshoot with console.log(object); to convince yourself you fetched the right stuff.

For best results, consider doing error checking this way. (Never trust web sites, eh?)