Posts made by hrgdavor

@z3dev got my first email from this user group and daily digest. That is great news that you got this working.

https://discourse.threejs.org/t/three-bvh-csg-a-library-for-performing-fast-csg-operations/42713

claims even 100x performance for booleans

look at this smooth realtime boolean

https://gkjohnson.github.io/three-bvh-csg/examples/bundle/simple.html

It is dependant on threejs, but is interesting to explore nevertheless
https://github.com/gkjohnson/three-bvh-csg

@Hermann-SW this is one of many thing we would like to implement, but it is not implemented, or even specified as a possible future feature.

Current 3d engine is regl, and I am working on interchangeable support for Three.js and Babylon.js.

regl has slowed down with development but Three.js and Babylon.js are very much active
Getting info what object is clicked or mouse over is easy in Three.js and Babylon , but for regl I am not sure (it may or may not be easy to do).

You likely want to use jacad to generate geometries, give them some identifiers, interact with them and then upon interaction change the model with performance in mind by updating only things that changed.

This is something we could colaborate on, but it is not something that can be simply implemented as part of jscad script runner. Because the current workflow for jscad is:

• make a script
• expose getParameterDefinitions - jscad can generate params form
• expose main method - jscad will call it with parameters and display result
  As you can see there is no concept of partial interactions or reactive changes, it is more like a commandline program that you write, and jscad calls to display it's output in 3d (and provide export option)

there are several building blocks that make this combo getParameterDefinitions + main work, with proper separation of those building blocks users would be allow to create much more than just scripts that produce 3d geometry. But such efforts take time, and we are low on man-power.

One such reusable block I started creating is code editor https://github.com/hrgdavor/jsx6/tree/main/libs/editor-monaco although there are nice code editors, they are not too easy to use or combine with JS projects (takes too much knowledge) so I am aiming to create more friendly wrappers. Each editor is stuck with their own cool build process and tooling that was popular at the time of the project start.

I am also improving my skills with web workers, and babel transformations to provide building blocks for script execution with proper line numbers in stack traces and built-in browser's debugger integration.

so, slowly something is comming along ... slowly...

copy pasta from https://github.com/jscad/OpenJSCAD.org/discussions/1141

Sharing this idea and also calling to discuss improvements to it.
Even ideas how jscad could be improved to better facilitate use case like this are welcome.

Very often when creating thins for 3d print I have multiple parts, so in time I have created a sort of template I like to use. Even if I have single piece I tend to split design in few parts to more easily handle it.

This is the latest iteration that solves few issues for me

• parameter definition to select a part is generated automatically
• no need to declare configurable parameters in each function ( func that creates a part)
• can reuse one part in another part

const jscad = require('@jscad/modeling')
const {sphere, cube} = jscad.primitives 
const {translate} = jscad.transforms

// all of the functions that generate parts will see the parameters without declaring them explicitly
const main = ({//@jscad-params
  size=10, // {type:'slider'}
  part,
}, getParams)=>{

  // UTILITY placeholder for part generator functions
  const parts = {}

  // CTRL+R in vscode works just fine
  parts.Sample_Cube = ()=>cube({size})

  parts.Sample_Sphere = ()=>{
    return sphere({radius:size/2})
  }

  // parts can easily be combined
  parts.Assembly = ()=>([
    // jump to definition in vscode (ALT+click) works
    parts.Sample_Cube(),
    translate([size+5,0,0], parts.Sample_Sphere()),
  ])

  /*********************** UTILITY below is just utility code. do not change **************** */

  // we were called by getParameterDefinitions so we need to provide list of parts
  if(getParams === true){
    const values = Object.keys(parts)
    return {values, initial: values[0]}
  }

  // make sure we always call one of the functions
  if(!parts[part]) part = Object.keys(parts)[0]
  return parts[part]()
}

const getParameterDefinitions = ()=>[{ name: 'part', caption:'Part', type: 'choice', ...main({}, true)}]

module.exports = {main, getParameterDefinitions}

Also if you have commandline that produces a jscad script to be executed, you can use jscad to view it without placing it online

if you have a commandline like: command_produce_sth_for_jscad.sh > test.js

then you open https://openjscad.xyz/ and turn on Auto reload and drag and drop the test.js

each time you want to update the output you can run command_produce_sth_for_jscad.sh > test.js
and jscad will notice changed file and reload it.

That looks cool. What is the the use case for those planar graphs ?

@antoine-guillaume this could be done by adding support for a second function getDynamicParameters where:

• firstly getParameterDefinitions is called and a list of basic parameters is generated and remembered
• secondly getDynamicParameters is called but with the values from the form and it provides more inputs
• on any change to base parameters, getDynamicParameters is called again with changed values to regenerate dynamic list of inputs

if there are ppl interested in this feature please open an issue or a discussion where we could define a feature like this. This is something I could implement relatively easy in my new prototype, but is unlikely I would have patience to buid it ony the current jscad web from master branch.
https://github.com/jscad/OpenJSCAD.org/discussions/944

progress of the mentioned prototype with suport for different wegl libs can be found here:
https://github.com/jscad/OpenJSCAD.org/discussions/944

I have just made another step forward: mesh support (but with some quirks ATM)
I have some lighting to fix, and also babylonjs for some weird rason uses left handed system (this adds a bit of complexity to the worker to support it properly)

Also when switching viewers, if they are different orioentation currently I need to run the script again manually to get properly oriented triangles

https://user-images.githubusercontent.com/2480762/162638934-7a945625-420d-4041-98fc-5735fcc34c6b.mp4

for now best piece of code to start with using jscad standalone or creating an app is I think in packages/utils/regl-renderer/demo.html

it is the basis I used for my jscad experiments

@udif perhaps add an issue on git, with examples what you would like to do with parameters, we could discussit there a bit more, and maybe come-up with some ideas.

This is not something possible right now, so it could be a feature request.

looking at jscad sourcecode you can set color on each polygon,

const jscad = require('@jscad/modeling')
const { cube } = jscad.primitives

function main(){
  const c = cube({size:10})
  c.polygons[0].color = [1,0,0]
  c.polygons[2].color = [0,1,0]
  console.log(c)
  return c
}

module.exports = {main}

@ajw1970 if you just push the jscad geometries to console or generate json, you will see the data inside is pretty intutive to to go through and convert to points for babylon or whatever you need.

@ajw1970 I am curious, do you have a lot of experience with Babylonjs ?
Is there a specific reason you are using it instead of Threejs ?
I am not advocating Threejs or Babylon, it is just that I already have code that converts jscad models to Threejs geometries and Babylon is only in progress.

Hi,
I am currently working on compatibility layer for 3 webgl libs I know of: relg(currenttly used in jscad), threejs, babylonjs.

I have pieces needed for threejs and regl, but I have just started with Exploring creating line segments and mesh via TypedArray directly (it is important for usability with web workers and performance of postMessage)

The work is part of a prototype branch,
https://github.com/jscad/OpenJSCAD.org/discussions/944

If you use discord, I am more active there https://discord.gg/AaqGskur93

Unfortunately email notifications do not work on this forum, and sometimes days go by before I remember to check for new topics . Actually @platypii alerted me about your question.

I will check-in here also after I produce at least some working code for Babylonjs.

@gilboonet that is excellent, it may be possible later on to integrate that one with jscad or at least take your experience for ideas how to improve 2D use-cases in jscad.

@gilboonet that is great news. the performance gain will be available in new jscad prototype too....
I could add 2d output to threejscad2 ...

There is some progress in the prototype of jscad that is able to run 3 different 3D engines:

• regl
• Three.js
• Babylon.js

https://github.com/jscad/OpenJSCAD.org/discussions/944

https://user-images.githubusercontent.com/2480762/152607806-0d244616-f0b5-4212-8db5-691e5d5ec0b7.mp4

@gilboonet those can be tricky to debug. One thing I am thinking is if you really need 3000 faces. Is that practical to actually make ?

Also issue could be in the code that sends your data to WEBGL.

can you try to run it inside:
http://3d.hrg.hr/jscad/three/threejscad2.html
?

@gilboonet yes, specification for sort functions is to

• return zero if a==b
• return neg or positive number depending if u want to sort ASC or DESC

@gilboonet JS uses a garbage collector, so to release memory you need to remove references to objects.

One advanced trick when caching stuff is using WakMap https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap . This is a familiar concept to me from Java. It allows you to cache some heavy calculations but also allows garbage collector to delete them.

Initial versions of garbage collectors counted references and when counter is zero they clean the mem. Then they added a concept of weak references where, you could reference something weakly, but allow garbage collector to clear it if RAM is needed.

chrome dev tools has a nice profiler, probably firefox too, and you could use that to see where most of RAM is spent.