<spaceSub>
Heyho. I have a circle centered at the xy origin. I have smaler circles in each quadrant. Can I somehow use the angel constraint to angel them 45 degrees from the the x or y axis?
<wpwrak>
spaceSub: you could add construction lines (draw line, select, G) and set the angle of that
<wpwrak>
45 deg means that there are also other equalities, but that may be the easiest one
<spaceSub>
wpwrak: Works, thanks!
<spaceSub>
Okay, another one: When I extrude a plane, solvespace leaves out the before mentioned circles in the bigger circle. Can I supress this behavior?
<spaceSub>
I only want to negatively extrude those inner circles partially and not have a hole through the whole part.
<wpwrak>
then you need to arrange the construction differently. e.g., make a group with the big circle, extrude, then make a new group with the smaller circles, and extrude them separately
<wpwrak>
if you want everything in one sketch (group) for some reason, you can aleo make the small circles "construction" (G), and just retrace them in the group from which they'll be extruded
<spaceSub>
Ah I see. So extrusion and other options under "New Group" generally apply to the whole group?
<wpwrak>
yes
<wpwrak>
but only non-construction things become part of the solid. you can still reuse construction items for later groups/sketches, though.
<wpwrak>
important: information always flows "down", from earlier groups to later groups, never "up". so if your big circle is the basis, then you can reuse its geometry in a later group with the smaller circles. but you can't use the smaller circles to define the geometry of the big circles.
<wpwrak>
unless you place them into the same group, as construction. then you can constrain as you like.
<wpwrak>
so it's sometimes desirable to make a complete "floor plan", and then use parts of it as you build things up, instead of adding incremental sketches as you go.
<whitequark>
I wonder if something like a non-parametric command to duplicate entities in the current group would be useful
<wpwrak>
but it all depends on what you build and how you organize it. alas, while rearranging things within a group is usually very easy, it's hard to rearrange things across groups. so some experimenting may be needed before you find a good workflow.
<wpwrak>
whitequark: like copy & paste ?
<wpwrak>
ah, you mean "into"
<wpwrak>
like "make copy this construction line from group A into group B", right ? yes, i'd find that very useful
<whitequark>
mm
<whitequark>
something like "Paste Linked"
<whitequark>
could work
<travis-ci>
solvespace/solvespace#390 (staging - 6cdd8a9 : whitequark): The build was broken.
<wpwrak>
hmm, it may be necessary to modify what's been copied. so the "link" would be more informative
<wpwrak>
well, another option would be to draw everything you need as "construction", and just "link" it. that would then avoid the need to modify. may get a little crowded, but that's a separate issue.
<whitequark>
wpwrak: no, I mean, you get a new entity but constrained to be in the same relative position as the old
<whitequark>
and size
<spaceSub>
wpwrak: Hm, that is but much to grasp right now. I'll get there ;)
<wpwrak>
whitequark: in different groups, right ?
<travis-ci>
solvespace/solvespace#389 (master - 7e2b1b1 : whitequark): The build passed.
<whitequark>
you can modify it because it's just a bunch of entities
<wpwrak>
spaceSub: yeah, solvespace has a somewhat steep and stepped learning curve. first it can be confusing, but every one in a while you can celebrate a little triumph :)
<wpwrak>
whitequark: hmm, a tightly linked copy may work better with the "draft it all once, then reuse" approach
<wpwrak>
so you'd change geometries in the base group, and the copies in the others would just follow
<travis-ci>
solvespace/solvespace#391 (staging - f5afe00 : whitequark): The build is still failing.
<wpwrak>
where copy = original minus "construction" (or the same, if the original was a construction, too)
<wpwrak>
one issue you'll get is that this approach produces more overlaying items. it can already be fiendishly hard to disentangle such stuff, so you'll also have to solve the selection problem
<whitequark>
mhm
<wpwrak>
btw, relatd to this is the point selection problem. when selecting a point, it often doesn't have the properties (constraints, etc.) you expect. that's because the point you're looking for is p2p-constrained to it, but not the one the selection picked
<wpwrak>
one way to disentangle the p2p mess would be show the transitive hull of the "equivalent" points, along with their role (i.e., what item they belong to), in the text window
<wpwrak>
but maybe there's a less "technical" way
<wpwrak>
(in the TW) with the usual hover-to-highlight. so that one can visually explore the critters.
<wpwrak>
back to the "reuse" aka linked copy: a different way to solve this problem cluster would be to make it easier to change things across groups, and even the group structure. that would include reordering, but also "soft" deletion, and a way to relax the "data diode" the group order currently implies
<wpwrak>
but i think a workflow based on central sketches could be quite nice. i sometimes even get the feeling that solvespace tries to pull me in that direction
<travis-ci>
solvespace/solvespace#392 (staging - 2570bd2 : whitequark): The build is still failing.
<wpwrak>
ah, for easier finding of needles in the haystack, how about this: 1) get user create named/color-coded/whatever tags, 2) show tags as buttons, e.g., on the right-hand side of the canvas, 3) let user freely assign tags to items, 4) hovering over tag button would highlight all items with tag, clicking button would show/hidethe items
<whitequark>
that seems overly complicated
<wpwrak>
with this, you could implement "sub-groups" in that master sketch. e.g., geometry of a part that gets insertes, geometry of the structure(s) holding it, and geometry of the casing around it
<wpwrak>
maybe there's a simpler way. but you'd probably need some means to structure the master sketch, since it could get pretty complicated
<wpwrak>
e.g., consider anelok's battery area. there we have, looking along the long axis: 1) the battery (circle), 2) the battery contacts, 3) the wall behind each contact, with space for the cable, 4) the wall around the contact, 5) the wall in front of the contact, with openings for the spring/nipple, 6) the wall along the battery, 7) the cover that closes the battery compartment
<wpwrak>
and i currently even have a few more silly things in there that are related, but that, in hindsight, i should have done differently
<wpwrak>
so you rapidly get half a dozen coincident or partially overlapping lines and arcs, making selection quite a challenge.
<wpwrak>
all this is made worse by each extrusion copying the whole point set. so if at some point you have to select the right point in 3D, that can get rather entertaining
<wpwrak>
e.g., on occasions, i spent up to about half an hour trying to pick the right points. having some means of hiding what i don't need or annotating/tagging would really have been great. (the tags i proposed would provide both, visibility control and annotation)
<wpwrak>
(half an hour) that's 1) search for the point, often twisting and turning to aim across some more easily identified reference point, 2) select and use it (if i'm lucky), 3) if i'm unlucky, i need a second point, so repeat 1) but trying not to lose the point from 2) in the process
<whitequark>
hm, that sounds rather troublesome indeed
<whitequark>
I think what will help you here is ummm
<wpwrak>
4) proceed, and find that i didn't pick quite the correct point, 5) undo/delete/delete-by-reloading what i had built on the wrong point, 6) try again. etc.
<wpwrak>
that could help to make things a little easier, yes. but the main problem is getting lost amidst all the points.
<travis-ci>
solvespace/solvespace#393 (staging - 866a850 : whitequark): The build is still failing.
<wpwrak>
whitequark: btw, such tags could also be useful for "soft delete". with that, i mean that, when a deletion implies deleting a point that is referenced by something else, then instead of recursively deleting this something else, slvs could just clone the point.
<whitequark>
I don't see how that relates to "tags"
<wpwrak>
now, the problem with this is that you probably have to do some cleanup, e.g., re-introduce constraints. such recovered points could be automatically tagged, so one could use the highlighting to find them
<wpwrak>
i.e., you wouldn't need to have to come up with an additional mechanism
<whitequark>
that also sounds way too complicated
<wpwrak>
ah, and if TW is showing the group list, highlighting tags could also highlight the groups in which the tag occurs
<wpwrak>
which part of it, the reuse of tags, or cloning of points ?
<whitequark>
it's an elaborate kludge that's a nightmare to teach
<wpwrak>
how else would you do it ?
<whitequark>
dunno
<wpwrak>
;-)
<whitequark>
"how else" implies there's no viable alternative.
<whitequark>
not implementing a kludge is better than implementing one
<wpwrak>
i'm no saying there's no viable alternative. i just don't see any easy way to do better.
<wpwrak>
and i don't mind kludges so much, as long as they solve a much bigger problem. if, instead of walking 1000 km, i have to move 10 m by hopping backwards, that's a win for me
<whitequark>
that's because you don't have to support them forever
<wpwrak>
meh. have some courage. once you find a better way, you can just drop the kludge. people will complain, then adapt.
<whitequark>
that means allocating my already limited time to something that's known to be a waste
<wpwrak>
and i don't really see what would be so horrible about tags. think of them as a form of annotation.
<whitequark>
pretty sure that any system that involves elaborately annotating specific entities is doomed to be used by select few
<whitequark>
and the rest will just continue to complain about the same problem
<wpwrak>
well, the way deletions currently work is a major stumbling block when using solvespace. it bascially means that, when you notice that you have to make an even relatively small change to some early group in your design, youessentially have to throw it away and start over
<whitequark>
sure, that's a fairly serious issue
<whitequark>
which are the scenarios you commonly observe?
<whitequark>
changing origin of a group is one, I would think
<wpwrak>
if you don't like "annotation", call it "layers". lots of graphical programs use them.
<whitequark>
I don't like the fact that it doesn't go with the usual workflow
<wpwrak>
yes, loss of the origin is a common source. part of the problem is that i'm not even quite sure what specifically causes a deletion, since all i get is a body count, which i have no choice but to accept.
<whitequark>
the deletion preview dialog is fairly high on my priority list
<wpwrak>
so i can't even go through the things that would be deleted. we discussed this a while ago.
<wpwrak>
perfect. that'll help to make things more transparent.
<whitequark>
mostly I haven't had any time to work on solvespace in a while
<wpwrak>
you really ought to find a sugar daddy (with deep pockets) for it :)
<whitequark>
how would that help exactly?
<whitequark>
we have a fairly decent stream of licensing fees
<wpwrak>
well, if your priorities are constrained by income, then having a bigger budget would allow you to put more time on slvs. or if you're simply overloaded, you could add manpower
<whitequark>
that would make it more late :p
<whitequark>
try finding a decent C++ programmer someday
<whitequark>
much less one who can actually write portable code
<wpwrak>
as i see it, slvs is currently in a very peculiar state. you can do great things with it already, but it also has major holes that can easily trap the user. and it works mainly for constructing, not so much for modifying
<whitequark>
that's by and large true
<whitequark>
however, *my* view of slvs is that I can't do any sort of major work on it until the technical debt is paid off
<whitequark>
and there's a *lot* of technical debt
<wpwrak>
well, portability could be an issue. but then, that's something you can do in stages: have the feature developed on the platform(s) the developer is familiar with, then address the portability issues. after a few round, the developer will probably get it right most of the time even without help.
<whitequark>
haha no
<whitequark>
you'd think windows devs can write decent winapi code but no
<whitequark>
much less linux apis
<wpwrak>
you mean things like a more efficient solver, the new file format, hierarchical groups ?
<whitequark>
not even that
<whitequark>
the new file format, yes
<whitequark>
but mostly I'm talking about gross crap like a completely ad-hoc window system abstraction that leaks
<whitequark>
e.g. right now I can't even use solvespace myself without breaking my eyes
<wpwrak>
urgh :)
<whitequark>
I've just spent two days unbreaking path management
<whitequark>
so I can finally merge the image entity
<whitequark>
you should see the diff..
<whitequark>
well, once I push it, for some reason it doesn't work on macos yet
<wpwrak>
regarding code quality, i think you may be too picky. granted, you wouldn't want to accept a major foundation block that's all wrong, but many of the things we're talking about would have a limited scope. so having to clean them up woldn't be the end of the world.
<wpwrak>
and you could adopt a much more agile development model
<whitequark>
accepting shoddy code is how we've ended up where we are
<whitequark>
I've spent literally months cleaning it up until it could do completely basic things, like not exploding on unicode
<wpwrak>
but that shoddy code is something you inherited, no ? or was that added after you had taken over ?
<whitequark>
inherited
<wpwrak>
see, that's very different
<whitequark>
not particularly. I have no interest in making the problem worse
<wpwrak>
naw, now you can control admission. so you can accept things that meet your standard, parole things that don't, accept-and-immediately clean-up things that are almost right, or send stuff that's too bothersome back with constructuve comments
<wpwrak>
but if all people get is "no", that doesn't help anyone
<whitequark>
um, no, that's a different issue
<whitequark>
the reason I can't accept any PR is because of the lack of CLA
<wpwrak>
yes, what's the blocker there ? you said you already have a license you like, so what's stopping you from using it ?
<whitequark>
I don't have a CLA, no
<whitequark>
that's the problem exactly
<wpwrak>
right now the number of contributors would be very small anyway, so even if you change your mind after a while, the damage would probably be insignificant
<whitequark>
the damage is to a degree already done
<wpwrak>
i.e., most likely any halfway reasonable change would just be nodded off, without further ado
<whitequark>
if anyone ever wants to license the GUI, I have to ditch master and cherry-pick every single commit in the last two years
<whitequark>
(or hunt down a dozen contributors, most of whom did one or two lines, and somehow convince them to sign a CLA postfactum)
<wpwrak>
(no CLA) i know that you don't have one yet, but you mentioned that there is one that you like and though of using/adapting. forgot what it was
<whitequark>
again, I'd like to avoid making the problem worse
<whitequark>
yes, I thought of adapting it, I didn't. there are a bunch of moving parts that need satisfying
<wpwrak>
maybe an alternative plan would be to define the key points of the license you want to use, then contact the existing contributors and get them to agree on that. once your legal department has worked out the fine print, getting them to agree to that would then hopefully just a formality.
<whitequark>
it's not a license?
<whitequark>
it's a rights transfer agreement
<wpwrak>
well, there's a license in it
<wpwrak>
also, i'm not even sure you need a rights transfer. just granting the necessary rights ought to be sufficient. i'm sure there are more legal considerations, though, like under what conditions grants or transfers could be revoked, and such, possibly against the will of the author
<wpwrak>
at the end of the day, you'll never have something 100% bullet-proof anyway. but it doesn't have to be. i mean, you don't wear a meteorite-proof helmet when you go out either :)
<spaceSub>
I linked to parts and put the point from one part on the circle of another part. Now I get a unresolvable constraint error. What could case this?
<wpwrak>
screenshot ? often unexpected conflicts come from automatically placed H and V constraints
<wpwrak>
e.g., if you've drawn a rectangle and then, in another group, draw a line along one of its sides, you get a) the two coincident points, plus b) the automatic H/V constraint. this means that the new line is over-constrained
<wpwrak>
whitequark: might actually be nice if slvs would not place H/V if it can see that the line is already fully constrained
<whitequark>
wpwrak: we had a patch for that somewhere
<whitequark>
but really that feature was a mistake
<whitequark>
I should probably just rip it out
<wpwrak>
yeah, that would work, too. it's occasionally useful, but about just as often not, or fails to work,or mis-fires