caiyu/solvespace
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
ad4a204edf
solvespace/src/glhelper.cpp

822 lines
25 KiB
C++
Raw Normal View History

Changes in preparation for the release of SolveSpace under the GPL, to add that license, and change all copyright notices to me, not Useful Subset, LLC. [git-p4: depot-paths = "//depot/solvespace/": change = 2211]
2013-07-29 06:08:34 +08:00
//-----------------------------------------------------------------------------
// Helper functions that ultimately draw stuff with gl.
//
// Copyright 2008-2013 Jonathan Westhues.
//-----------------------------------------------------------------------------
Add routines to draw a vector font (public domain Hershey Simplex font, not bad). Use that to label the planes now. [git-p4: depot-paths = "//depot/solvespace/": change = 1660]
2008-04-11 19:13:47 +08:00
#include "solvespace.h"
Pack everything into `namespace SolveSpace`. This is required to avoid name conflicts with the Cocoa libraries on OS X. I renamed the `class SolveSpace` to `class SolveSpaceUI`, because that's what it does, and because otherwise the namespace would have to be called something else than `namespace SolveSpace`.
2015-03-24 01:49:04 +08:00
namespace SolveSpace {
Big structural change; eliminate the Point type in SolveSpace. The points are now entities like any others; so a line segment request will generate three entities, the line segment and its endpoints. I think that's cleaner. When I do step and repeats (and imports, and other similar), I'll need a consistent way to assign those entity ids. That assignment must not change if the sketch is edited. I don't have a clean way to do that; best thought right now is to keep a record of what maps have been used previously, and not pick a new map as long as it's possible to use one that was used previously. This all means that more crap gets pushed in to the Entity structure, so that they can keep track of what solver variables define them. Still seems better, though. I'm closer to ready to start solving. [git-p4: depot-paths = "//depot/solvespace/": change = 1673]
2008-04-19 19:09:47 +08:00
static bool ColorLocked;
Add perspective, by a user-specified factor. So I have to apply that perspective in the gl matrices, and also everywhere that I check mouse pointer positions against the model, and for the zoom to fit. [git-p4: depot-paths = "//depot/solvespace/": change = 1796]
2008-06-18 03:12:25 +08:00
static bool DepthOffsetLocked;
Big structural change; eliminate the Point type in SolveSpace. The points are now entities like any others; so a line segment request will generate three entities, the line segment and its endpoints. I think that's cleaner. When I do step and repeats (and imports, and other similar), I'll need a consistent way to assign those entity ids. That assignment must not change if the sketch is edited. I don't have a clean way to do that; best thought right now is to keep a record of what maps have been used previously, and not pick a new map as long as it's possible to use one that was used previously. This all means that more crap gets pushed in to the Entity structure, so that they can keep track of what solver variables define them. Still seems better, though. I'm closer to ready to start solving. [git-p4: depot-paths = "//depot/solvespace/": change = 1673]
2008-04-19 19:09:47 +08:00
Work around poor line rendering with Intel Mesa-based drivers. However, don't use ssglLineWidth for UI drawing operations. These only draw horizontal or vertical lines that don't need to be antialiased, and thus don't require the workaround. In fact the workaround would make them thicker than needed.
2015-03-22 21:39:12 +08:00
void ssglLineWidth(GLfloat width) {
// Intel GPUs with Mesa on *nix render thin lines poorly.
static bool workaroundChecked, workaroundEnabled;
if(!workaroundChecked) {
// ssglLineWidth can be called before GL is initialized
if(glGetString(GL_VENDOR)) {
workaroundChecked = true;
if(!strcmp((char*)glGetString(GL_VENDOR), "Intel Open Source Technology Center"))
workaroundEnabled = true;
}
}
Avoid spurious double to float conversion. MSVC (mostly rightly) complains about this, even if our particular case is irrelevant.
2016-02-12 13:26:08 +08:00
if(workaroundEnabled && width < 1.6f)
width = 1.6f;
Work around poor line rendering with Intel Mesa-based drivers. However, don't use ssglLineWidth for UI drawing operations. These only draw horizontal or vertical lines that don't need to be antialiased, and thus don't require the workaround. In fact the workaround would make them thicker than needed.
2015-03-22 21:39:12 +08:00
glLineWidth(width);
}
Add a mechanism to record the lines drawn when we display a constraint, so that we can export that too. This includes the lines for the vector font. A little ugly; it needs some kind of line style (color or width) to distinguish those lines from the real geometry in the exported file. [git-p4: depot-paths = "//depot/solvespace/": change = 2007]
2009-07-04 04:55:57 +08:00
static void LineDrawCallback(void *fndata, Vector a, Vector b)
Add routines to draw a vector font (public domain Hershey Simplex font, not bad). Use that to label the planes now. [git-p4: depot-paths = "//depot/solvespace/": change = 1660]
2008-04-11 19:13:47 +08:00
{
Work around poor line rendering with Intel Mesa-based drivers. However, don't use ssglLineWidth for UI drawing operations. These only draw horizontal or vertical lines that don't need to be antialiased, and thus don't require the workaround. In fact the workaround would make them thicker than needed.
2015-03-22 21:39:12 +08:00
ssglLineWidth(1);
Add a mechanism to record the lines drawn when we display a constraint, so that we can export that too. This includes the lines for the vector font. A little ugly; it needs some kind of line style (color or width) to distinguish those lines from the real geometry in the exported file. [git-p4: depot-paths = "//depot/solvespace/": change = 2007]
2009-07-04 04:55:57 +08:00
glBegin(GL_LINES);
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
ssglVertex3v(a);
ssglVertex3v(b);
Add a mechanism to record the lines drawn when we display a constraint, so that we can export that too. This includes the lines for the vector font. A little ugly; it needs some kind of line style (color or width) to distinguish those lines from the real geometry in the exported file. [git-p4: depot-paths = "//depot/solvespace/": change = 2007]
2009-07-04 04:55:57 +08:00
glEnd();
}
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
void ssglVertex3v(Vector u)
Add routines to draw a vector font (public domain Hershey Simplex font, not bad). Use that to label the planes now. [git-p4: depot-paths = "//depot/solvespace/": change = 1660]
2008-04-11 19:13:47 +08:00
{
glVertex3f((GLfloat)u.x, (GLfloat)u.y, (GLfloat)u.z);
}
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
void ssglAxisAlignedQuad(double l, double r, double t, double b, bool lone)
Replace ugly text links to hide/show things with icons. So add code to draw those, and hit test with the mouse, and display tool tips when the user hovers with the mouse. Also, underline links only when they're hovered, and not otherwise. And add a separate menu option to align the view to the active workplane, vs. activating the active group's workplane, and remap the bottom two graphics window toolbar icons to that and "nearest iso view" instead of draw in 2d/3d, since people tended to click on those without understanding and cause trouble. And by default, we force a parallel projection; so the factory default camera tangent is now 0.3, not 0. [git-p4: depot-paths = "//depot/solvespace/": change = 2131]
2010-05-03 13:04:42 +08:00
{
OpenGL fixes glGetError() was returning GL_INVALID_OPERATION due to some minor missteps
2013-09-10 04:05:33 +08:00
if(lone) glBegin(GL_QUADS);
Replace ugly text links to hide/show things with icons. So add code to draw those, and hit test with the mouse, and display tool tips when the user hovers with the mouse. Also, underline links only when they're hovered, and not otherwise. And add a separate menu option to align the view to the active workplane, vs. activating the active group's workplane, and remap the bottom two graphics window toolbar icons to that and "nearest iso view" instead of draw in 2d/3d, since people tended to click on those without understanding and cause trouble. And by default, we force a parallel projection; so the factory default camera tangent is now 0.3, not 0. [git-p4: depot-paths = "//depot/solvespace/": change = 2131]
2010-05-03 13:04:42 +08:00
glVertex2d(l, t);
glVertex2d(l, b);
glVertex2d(r, b);
glVertex2d(r, t);
OpenGL fixes glGetError() was returning GL_INVALID_OPERATION due to some minor missteps
2013-09-10 04:05:33 +08:00
if(lone) glEnd();
Replace ugly text links to hide/show things with icons. So add code to draw those, and hit test with the mouse, and display tool tips when the user hovers with the mouse. Also, underline links only when they're hovered, and not otherwise. And add a separate menu option to align the view to the active workplane, vs. activating the active group's workplane, and remap the bottom two graphics window toolbar icons to that and "nearest iso view" instead of draw in 2d/3d, since people tended to click on those without understanding and cause trouble. And by default, we force a parallel projection; so the factory default camera tangent is now 0.3, not 0. [git-p4: depot-paths = "//depot/solvespace/": change = 2131]
2010-05-03 13:04:42 +08:00
}
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
void ssglAxisAlignedLineLoop(double l, double r, double t, double b)
Replace ugly text links to hide/show things with icons. So add code to draw those, and hit test with the mouse, and display tool tips when the user hovers with the mouse. Also, underline links only when they're hovered, and not otherwise. And add a separate menu option to align the view to the active workplane, vs. activating the active group's workplane, and remap the bottom two graphics window toolbar icons to that and "nearest iso view" instead of draw in 2d/3d, since people tended to click on those without understanding and cause trouble. And by default, we force a parallel projection; so the factory default camera tangent is now 0.3, not 0. [git-p4: depot-paths = "//depot/solvespace/": change = 2131]
2010-05-03 13:04:42 +08:00
{
glBegin(GL_LINE_LOOP);
glVertex2d(l, t);
glVertex2d(l, b);
glVertex2d(r, b);
glVertex2d(r, t);
glEnd();
}
Add ability to assign styles to cosmetic text (in the form of Constraint::COMMENTs), including line width and color, and text height and origin location. [git-p4: depot-paths = "//depot/solvespace/": change = 2033]
2009-09-24 23:52:48 +08:00
static void FatLineEndcap(Vector p, Vector u, Vector v)
{
// A table of cos and sin of (pi*i/10 + pi/2), as i goes from 0 to 10
static const double Circle[11][2] = {
{ 0.0000, 1.0000 },
{ -0.3090, 0.9511 },
{ -0.5878, 0.8090 },
{ -0.8090, 0.5878 },
{ -0.9511, 0.3090 },
{ -1.0000, 0.0000 },
{ -0.9511, -0.3090 },
{ -0.8090, -0.5878 },
{ -0.5878, -0.8090 },
{ -0.3090, -0.9511 },
{ 0.0000, -1.0000 },
};
glBegin(GL_TRIANGLE_FAN);
for(int i = 0; i <= 10; i++) {
double c = Circle[i][0], s = Circle[i][1];
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
ssglVertex3v(p.Plus(u.ScaledBy(c)).Plus(v.ScaledBy(s)));
Add ability to assign styles to cosmetic text (in the form of Constraint::COMMENTs), including line width and color, and text height and origin location. [git-p4: depot-paths = "//depot/solvespace/": change = 2033]
2009-09-24 23:52:48 +08:00
}
glEnd();
}
Accept maybeFat in ssglStippledLine.
2016-03-25 16:05:50 +08:00
void ssglLine(const Vector &a, const Vector &b, double pixelWidth, bool maybeFat) {
Allow rendering solid outlines using a distinct style. A new button is added, "Show/hide outline of solid model". When the outline is hidden, it is rendered using the "solid edge" style. When the outline is shown, it is rendered using the "outline" style. In SolveSpace's true WYSIWYG tradition, the 2d view export follows the rendered view exactly. Moreover, shell edges are not rendered anymore, since there is not much need in them anymore and not drawing them lessens the overlap between various kinds of lines, which already includes entities, solid edges and outlines.
2016-03-15 00:14:24 +08:00
if(!maybeFat || pixelWidth <= 3.0) {
Implement stippled line styles from ISO 128. Now it's possible to use a styled line to indicate e.g. a centerline.
2016-02-24 02:00:39 +08:00
glBegin(GL_LINES);
ssglVertex3v(a);
ssglVertex3v(b);
glEnd();
} else {
ssglFatLine(a, b, pixelWidth / SS.GW.scale);
}
}
void ssglPoint(Vector p, double pixelSize)
{
Allow rendering solid outlines using a distinct style. A new button is added, "Show/hide outline of solid model". When the outline is hidden, it is rendered using the "solid edge" style. When the outline is shown, it is rendered using the "outline" style. In SolveSpace's true WYSIWYG tradition, the 2d view export follows the rendered view exactly. Moreover, shell edges are not rendered anymore, since there is not much need in them anymore and not drawing them lessens the overlap between various kinds of lines, which already includes entities, solid edges and outlines.
2016-03-15 00:14:24 +08:00
if(/*!maybeFat || */pixelSize <= 3.0) {
Implement stippled line styles from ISO 128. Now it's possible to use a styled line to indicate e.g. a centerline.
2016-02-24 02:00:39 +08:00
glBegin(GL_LINES);
Vector u = SS.GW.projRight.WithMagnitude(pixelSize / SS.GW.scale / 2.0);
ssglVertex3v(p.Minus(u));
ssglVertex3v(p.Plus(u));
glEnd();
} else {
Vector u = SS.GW.projRight.WithMagnitude(pixelSize / SS.GW.scale / 2.0);
Vector v = SS.GW.projUp.WithMagnitude(pixelSize / SS.GW.scale / 2.0);
FatLineEndcap(p, u, v);
FatLineEndcap(p, u.ScaledBy(-1.0), v);
}
}
void ssglStippledLine(Vector a, Vector b, double width,
Accept maybeFat in ssglStippledLine.
2016-03-25 16:05:50 +08:00
int stippleType, double stippleScale, bool maybeFat)
Implement stippled line styles from ISO 128. Now it's possible to use a styled line to indicate e.g. a centerline.
2016-02-24 02:00:39 +08:00
{
const char *stipplePattern;
switch(stippleType) {
Accept maybeFat in ssglStippledLine.
2016-03-25 16:05:50 +08:00
case Style::STIPPLE_CONTINUOUS: ssglLine(a, b, width, maybeFat); return;
Implement stippled line styles from ISO 128. Now it's possible to use a styled line to indicate e.g. a centerline.
2016-02-24 02:00:39 +08:00
case Style::STIPPLE_DASH: stipplePattern = "- "; break;
case Style::STIPPLE_LONG_DASH: stipplePattern = "_ "; break;
case Style::STIPPLE_DASH_DOT: stipplePattern = "-."; break;
case Style::STIPPLE_DASH_DOT_DOT: stipplePattern = "-.."; break;
case Style::STIPPLE_DOT: stipplePattern = "."; break;
case Style::STIPPLE_FREEHAND: stipplePattern = "~"; break;
case Style::STIPPLE_ZIGZAG: stipplePattern = "~__"; break;
Replace all oops() checks with ssassert()s. This includes explanation and context for non-obvious cases and shortens debug cycles when just-in-time debugging is not available (like on Linux) by immediately printing description of the assert as well as symbolized backtrace.
2016-05-19 06:51:36 +08:00
default: ssassert(false, "Unexpected stipple pattern");
Implement stippled line styles from ISO 128. Now it's possible to use a styled line to indicate e.g. a centerline.
2016-02-24 02:00:39 +08:00
}
Accept maybeFat in ssglStippledLine.
2016-03-25 16:05:50 +08:00
ssglStippledLine(a, b, width, stipplePattern, stippleScale, maybeFat);
Implement stippled line styles from ISO 128. Now it's possible to use a styled line to indicate e.g. a centerline.
2016-02-24 02:00:39 +08:00
}
void ssglStippledLine(Vector a, Vector b, double width,
Accept maybeFat in ssglStippledLine.
2016-03-25 16:05:50 +08:00
const char *stipplePattern, double stippleScale, bool maybeFat)
Implement stippled line styles from ISO 128. Now it's possible to use a styled line to indicate e.g. a centerline.
2016-02-24 02:00:39 +08:00
{
Replace all oops() checks with ssassert()s. This includes explanation and context for non-obvious cases and shortens debug cycles when just-in-time debugging is not available (like on Linux) by immediately printing description of the assert as well as symbolized backtrace.
2016-05-19 06:51:36 +08:00
ssassert(stipplePattern != NULL, "Unexpected stipple pattern");
Implement stippled line styles from ISO 128. Now it's possible to use a styled line to indicate e.g. a centerline.
2016-02-24 02:00:39 +08:00
Vector dir = b.Minus(a);
double len = dir.Magnitude();
dir = dir.WithMagnitude(1.0);
const char *si = stipplePattern;
double end = len;
double ss = stippleScale / 2.0;
do {
double start = end;
switch(*si) {
case ' ':
end -= 1.0 * ss;
break;
case '-':
start = max(start - 0.5 * ss, 0.0);
end = max(start - 2.0 * ss, 0.0);
if(start == end) break;
Accept maybeFat in ssglStippledLine.
2016-03-25 16:05:50 +08:00
ssglLine(a.Plus(dir.ScaledBy(start)), a.Plus(dir.ScaledBy(end)), width, maybeFat);
Implement stippled line styles from ISO 128. Now it's possible to use a styled line to indicate e.g. a centerline.
2016-02-24 02:00:39 +08:00
end = max(end - 0.5 * ss, 0.0);
break;
case '_':
end = max(end - 4.0 * ss, 0.0);
Accept maybeFat in ssglStippledLine.
2016-03-25 16:05:50 +08:00
ssglLine(a.Plus(dir.ScaledBy(start)), a.Plus(dir.ScaledBy(end)), width, maybeFat);
Implement stippled line styles from ISO 128. Now it's possible to use a styled line to indicate e.g. a centerline.
2016-02-24 02:00:39 +08:00
break;
case '.':
end = max(end - 0.5 * ss, 0.0);
if(end == 0.0) break;
ssglPoint(a.Plus(dir.ScaledBy(end)), width);
end = max(end - 0.5 * ss, 0.0);
break;
case '~': {
Vector ab = b.Minus(a);
Vector gn = (SS.GW.projRight).Cross(SS.GW.projUp);
Vector abn = (ab.Cross(gn)).WithMagnitude(1);
abn = abn.Minus(gn.ScaledBy(gn.Dot(abn)));
double pws = 2.0 * width / SS.GW.scale;
end = max(end - 0.5 * ss, 0.0);
Vector aa = a.Plus(dir.ScaledBy(start));
Vector bb = a.Plus(dir.ScaledBy(end))
.Plus(abn.ScaledBy(pws * (start - end) / (0.5 * ss)));
Accept maybeFat in ssglStippledLine.
2016-03-25 16:05:50 +08:00
ssglLine(aa, bb, width, maybeFat);
Implement stippled line styles from ISO 128. Now it's possible to use a styled line to indicate e.g. a centerline.
2016-02-24 02:00:39 +08:00
if(end == 0.0) break;
start = end;
end = max(end - 1.0 * ss, 0.0);
aa = a.Plus(dir.ScaledBy(end))
.Plus(abn.ScaledBy(pws))
.Minus(abn.ScaledBy(2.0 * pws * (start - end) / ss));
Accept maybeFat in ssglStippledLine.
2016-03-25 16:05:50 +08:00
ssglLine(bb, aa, width, maybeFat);
Implement stippled line styles from ISO 128. Now it's possible to use a styled line to indicate e.g. a centerline.
2016-02-24 02:00:39 +08:00
if(end == 0.0) break;
start = end;
end = max(end - 0.5 * ss, 0.0);
bb = a.Plus(dir.ScaledBy(end))
.Minus(abn.ScaledBy(pws))
.Plus(abn.ScaledBy(pws * (start - end) / (0.5 * ss)));
Accept maybeFat in ssglStippledLine.
2016-03-25 16:05:50 +08:00
ssglLine(aa, bb, width, maybeFat);
Implement stippled line styles from ISO 128. Now it's possible to use a styled line to indicate e.g. a centerline.
2016-02-24 02:00:39 +08:00
break;
}
Replace all oops() checks with ssassert()s. This includes explanation and context for non-obvious cases and shortens debug cycles when just-in-time debugging is not available (like on Linux) by immediately printing description of the assert as well as symbolized backtrace.
2016-05-19 06:51:36 +08:00
default: ssassert(false, "Unexpected stipple pattern element");
Implement stippled line styles from ISO 128. Now it's possible to use a styled line to indicate e.g. a centerline.
2016-02-24 02:00:39 +08:00
}
if(*(++si) == 0) si = stipplePattern;
} while(end > 0.0);
}
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
void ssglFatLine(Vector a, Vector b, double width)
Replace ugly text links to hide/show things with icons. So add code to draw those, and hit test with the mouse, and display tool tips when the user hovers with the mouse. Also, underline links only when they're hovered, and not otherwise. And add a separate menu option to align the view to the active workplane, vs. activating the active group's workplane, and remap the bottom two graphics window toolbar icons to that and "nearest iso view" instead of draw in 2d/3d, since people tended to click on those without understanding and cause trouble. And by default, we force a parallel projection; so the factory default camera tangent is now 0.3, not 0. [git-p4: depot-paths = "//depot/solvespace/": change = 2131]
2010-05-03 13:04:42 +08:00
{
Don't draw zero-length lines. Causes "Vector::WithMagnitude(...) of zero vector!"
2016-03-29 17:54:55 +08:00
if(a.EqualsExactly(b)) return;
Add ability to assign styles to cosmetic text (in the form of Constraint::COMMENTs), including line width and color, and text height and origin location. [git-p4: depot-paths = "//depot/solvespace/": change = 2033]
2009-09-24 23:52:48 +08:00
// The half-width of the line we're drawing.
double hw = width / 2;
Vector ab = b.Minus(a);
Vector gn = (SS.GW.projRight).Cross(SS.GW.projUp);
Vector abn = (ab.Cross(gn)).WithMagnitude(1);
abn = abn.Minus(gn.ScaledBy(gn.Dot(abn)));
// So now abn is normal to the projection of ab into the screen, so the
// line will always have constant thickness as the view is rotated.
abn = abn.WithMagnitude(hw);
ab = gn.Cross(abn);
ab = ab. WithMagnitude(hw);
// The body of a line is a quad
glBegin(GL_QUADS);
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
ssglVertex3v(a.Minus(abn));
ssglVertex3v(b.Minus(abn));
ssglVertex3v(b.Plus (abn));
ssglVertex3v(a.Plus (abn));
Add ability to assign styles to cosmetic text (in the form of Constraint::COMMENTs), including line width and color, and text height and origin location. [git-p4: depot-paths = "//depot/solvespace/": change = 2033]
2009-09-24 23:52:48 +08:00
glEnd();
// And the line has two semi-circular end caps.
FatLineEndcap(a, ab, abn);
FatLineEndcap(b, ab.ScaledBy(-1), abn);
}
Rename RgbColor to RgbaColor.
2015-07-10 19:54:39 +08:00
void ssglLockColorTo(RgbaColor rgb)
Big structural change; eliminate the Point type in SolveSpace. The points are now entities like any others; so a line segment request will generate three entities, the line segment and its endpoints. I think that's cleaner. When I do step and repeats (and imports, and other similar), I'll need a consistent way to assign those entity ids. That assignment must not change if the sketch is edited. I don't have a clean way to do that; best thought right now is to keep a record of what maps have been used previously, and not pick a new map as long as it's possible to use one that was used previously. This all means that more crap gets pushed in to the Entity structure, so that they can keep track of what solver variables define them. Still seems better, though. I'm closer to ready to start solving. [git-p4: depot-paths = "//depot/solvespace/": change = 1673]
2008-04-19 19:09:47 +08:00
{
Move colors and line widths for almost everything to the styles mechanism. This gets filled in from some defaults, and stored in the registry. The default styles do not get saved in the file, but user-created styles (which aren't supported yet) do. [git-p4: depot-paths = "//depot/solvespace/": change = 2028]
2009-09-17 15:32:36 +08:00
ColorLocked = false;
Replaced RGB-color integers with dedicated data structure RGB colors were represented using a uint32_t with the red, green and blue values stuffed into the lower three octets (i.e. 0x00BBGGRR), like Microsoft's COLORREF. This approach did not lend itself to type safety, however, so this change replaces it with an RgbColor class that provides the same infomation plus a handful of useful methods to work with it. (Note that sizeof(RgbColor) == sizeof(uint32_t), so this change should not lead to memory bloat.) Some of the new methods/fields replace what were previously macro calls; e.g. RED(c) is now c.red, REDf(c) is now c.redF(). The .Equals() method is now used instead of == to compare colors. RGB colors still need to be represented as packed integers in file I/O and preferences, so the methods .FromPackedInt() and .ToPackedInt() are provided. Also implemented are Cnf{Freeze,Thaw}Color(), type-safe wrappers around Cnf{Freeze,Thaw}Int() that facilitate I/O with preferences. (Cnf{Freeze,Thaw}Color() are defined outside of the system-dependent code to minimize the footprint of the latter; because the same can be done with Cnf{Freeze,Thaw}Bool(), those are also moved out of the system code with this commit.) Color integers were being OR'ed with 0x80000000 in some places for two distinct purposes: One, to indicate use of a default color in glxFillMesh(); this has been replaced by use of the .UseDefault() method. Two, to indicate to TextWindow::Printf() that the format argument of a "%Bp"/"%Fp" specifier is an RGB color rather than a color "code" from TextWindow::bgColors[] or TextWindow::fgColors[] (as the specifier can accept either); instead, we define a new flag "z" (as in "%Bz" or "%Fz") to indicate an RGBcolor pointer, leaving "%Bp"/"%Fp" to indicate a color code exclusively. (This also allows TextWindow::meta[][].bg to be a char instead of an int, partly compensating for the new .bgRgb field added immediately after.) In array declarations, RGB colors could previously be specified as 0 (often in a terminating element). As that no longer works, we define NULL_COLOR, which serves much the same purpose for RgbColor variables as NULL serves for pointers.
2013-10-17 04:00:58 +08:00
glColor3d(rgb.redF(), rgb.greenF(), rgb.blueF());
Big structural change; eliminate the Point type in SolveSpace. The points are now entities like any others; so a line segment request will generate three entities, the line segment and its endpoints. I think that's cleaner. When I do step and repeats (and imports, and other similar), I'll need a consistent way to assign those entity ids. That assignment must not change if the sketch is edited. I don't have a clean way to do that; best thought right now is to keep a record of what maps have been used previously, and not pick a new map as long as it's possible to use one that was used previously. This all means that more crap gets pushed in to the Entity structure, so that they can keep track of what solver variables define them. Still seems better, though. I'm closer to ready to start solving. [git-p4: depot-paths = "//depot/solvespace/": change = 1673]
2008-04-19 19:09:47 +08:00
ColorLocked = true;
}
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
void ssglUnlockColor(void)
Big structural change; eliminate the Point type in SolveSpace. The points are now entities like any others; so a line segment request will generate three entities, the line segment and its endpoints. I think that's cleaner. When I do step and repeats (and imports, and other similar), I'll need a consistent way to assign those entity ids. That assignment must not change if the sketch is edited. I don't have a clean way to do that; best thought right now is to keep a record of what maps have been used previously, and not pick a new map as long as it's possible to use one that was used previously. This all means that more crap gets pushed in to the Entity structure, so that they can keep track of what solver variables define them. Still seems better, though. I'm closer to ready to start solving. [git-p4: depot-paths = "//depot/solvespace/": change = 1673]
2008-04-19 19:09:47 +08:00
{
Move colors and line widths for almost everything to the styles mechanism. This gets filled in from some defaults, and stored in the registry. The default styles do not get saved in the file, but user-created styles (which aren't supported yet) do. [git-p4: depot-paths = "//depot/solvespace/": change = 2028]
2009-09-17 15:32:36 +08:00
ColorLocked = false;
Big structural change; eliminate the Point type in SolveSpace. The points are now entities like any others; so a line segment request will generate three entities, the line segment and its endpoints. I think that's cleaner. When I do step and repeats (and imports, and other similar), I'll need a consistent way to assign those entity ids. That assignment must not change if the sketch is edited. I don't have a clean way to do that; best thought right now is to keep a record of what maps have been used previously, and not pick a new map as long as it's possible to use one that was used previously. This all means that more crap gets pushed in to the Entity structure, so that they can keep track of what solver variables define them. Still seems better, though. I'm closer to ready to start solving. [git-p4: depot-paths = "//depot/solvespace/": change = 1673]
2008-04-19 19:09:47 +08:00
}
Rename RgbColor to RgbaColor.
2015-07-10 19:54:39 +08:00
void ssglColorRGB(RgbaColor rgb)
Big structural change; eliminate the Point type in SolveSpace. The points are now entities like any others; so a line segment request will generate three entities, the line segment and its endpoints. I think that's cleaner. When I do step and repeats (and imports, and other similar), I'll need a consistent way to assign those entity ids. That assignment must not change if the sketch is edited. I don't have a clean way to do that; best thought right now is to keep a record of what maps have been used previously, and not pick a new map as long as it's possible to use one that was used previously. This all means that more crap gets pushed in to the Entity structure, so that they can keep track of what solver variables define them. Still seems better, though. I'm closer to ready to start solving. [git-p4: depot-paths = "//depot/solvespace/": change = 1673]
2008-04-19 19:09:47 +08:00
{
Move colors and line widths for almost everything to the styles mechanism. This gets filled in from some defaults, and stored in the registry. The default styles do not get saved in the file, but user-created styles (which aren't supported yet) do. [git-p4: depot-paths = "//depot/solvespace/": change = 2028]
2009-09-17 15:32:36 +08:00
// Is there a bug in some graphics drivers where this is not equivalent
// to glColor3d? There seems to be...
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
ssglColorRGBa(rgb, 1.0);
Add code to assemble the piecewise linear segments in a group into a polygon, and to fill that polygon. [git-p4: depot-paths = "//depot/solvespace/": change = 1686]
2008-04-25 15:04:09 +08:00
}
Rename RgbColor to RgbaColor.
2015-07-10 19:54:39 +08:00
void ssglColorRGBa(RgbaColor rgb, double a)
Add code to assemble the piecewise linear segments in a group into a polygon, and to fill that polygon. [git-p4: depot-paths = "//depot/solvespace/": change = 1686]
2008-04-25 15:04:09 +08:00
{
Replaced RGB-color integers with dedicated data structure RGB colors were represented using a uint32_t with the red, green and blue values stuffed into the lower three octets (i.e. 0x00BBGGRR), like Microsoft's COLORREF. This approach did not lend itself to type safety, however, so this change replaces it with an RgbColor class that provides the same infomation plus a handful of useful methods to work with it. (Note that sizeof(RgbColor) == sizeof(uint32_t), so this change should not lead to memory bloat.) Some of the new methods/fields replace what were previously macro calls; e.g. RED(c) is now c.red, REDf(c) is now c.redF(). The .Equals() method is now used instead of == to compare colors. RGB colors still need to be represented as packed integers in file I/O and preferences, so the methods .FromPackedInt() and .ToPackedInt() are provided. Also implemented are Cnf{Freeze,Thaw}Color(), type-safe wrappers around Cnf{Freeze,Thaw}Int() that facilitate I/O with preferences. (Cnf{Freeze,Thaw}Color() are defined outside of the system-dependent code to minimize the footprint of the latter; because the same can be done with Cnf{Freeze,Thaw}Bool(), those are also moved out of the system code with this commit.) Color integers were being OR'ed with 0x80000000 in some places for two distinct purposes: One, to indicate use of a default color in glxFillMesh(); this has been replaced by use of the .UseDefault() method. Two, to indicate to TextWindow::Printf() that the format argument of a "%Bp"/"%Fp" specifier is an RGB color rather than a color "code" from TextWindow::bgColors[] or TextWindow::fgColors[] (as the specifier can accept either); instead, we define a new flag "z" (as in "%Bz" or "%Fz") to indicate an RGBcolor pointer, leaving "%Bp"/"%Fp" to indicate a color code exclusively. (This also allows TextWindow::meta[][].bg to be a char instead of an int, partly compensating for the new .bgRgb field added immediately after.) In array declarations, RGB colors could previously be specified as 0 (often in a terminating element). As that no longer works, we define NULL_COLOR, which serves much the same purpose for RgbColor variables as NULL serves for pointers.
2013-10-17 04:00:58 +08:00
if(!ColorLocked) glColor4d(rgb.redF(), rgb.greenF(), rgb.blueF(), a);
Add code to assemble the piecewise linear segments in a group into a polygon, and to fill that polygon. [git-p4: depot-paths = "//depot/solvespace/": change = 1686]
2008-04-25 15:04:09 +08:00
}
Use C99 integer types and C++ boolean types/values This change comprehensively replaces the use of Microsoft-standard integer and boolean types with their C99/C++ standard equivalents, as the latter is more appropriate for a cross-platform application. With matter-of-course exceptions in the Win32-specific code, the types/values have been converted as follows: QWORD --> uint64_t SQWORD --> int64_t DWORD --> uint32_t SDWORD --> int32_t WORD --> uint16_t SWORD --> int16_t BYTE --> uint8_t BOOL --> bool TRUE --> true FALSE --> false The following related changes are also included: * Added C99 integer type definitions for Windows, as stdint.h is not available prior to Visual Studio 2010 * Changed types of some variables in the SolveSpace class from 'int' to 'bool', as they actually represent boolean settings * Implemented new Cnf{Freeze,Thaw}Bool() functions to support boolean variables in the Registry * Cnf{Freeze,Thaw}DWORD() are now Cnf{Freeze,Thaw}Int() * TtfFont::Get{WORD,DWORD}() are now TtfFont::Get{USHORT,ULONG}() (names inspired by the OpenType spec) * RGB colors are packed into an integer of type uint32_t (nee DWORD), but in a few places, these were represented by an int; these have been corrected to uint32_t
2013-10-02 13:45:13 +08:00
static void Stipple(bool forSel)
Stipple the selected/hovered faces, instead of drawing them in solid red or yellow. And add user interface to `hide' the faces (i.e., to make them unselectable), defaulting to hidden in everything except extrudes or imports. [git-p4: depot-paths = "//depot/solvespace/": change = 1768]
2008-06-02 13:38:12 +08:00
{
Use C99 integer types and C++ boolean types/values This change comprehensively replaces the use of Microsoft-standard integer and boolean types with their C99/C++ standard equivalents, as the latter is more appropriate for a cross-platform application. With matter-of-course exceptions in the Win32-specific code, the types/values have been converted as follows: QWORD --> uint64_t SQWORD --> int64_t DWORD --> uint32_t SDWORD --> int32_t WORD --> uint16_t SWORD --> int16_t BYTE --> uint8_t BOOL --> bool TRUE --> true FALSE --> false The following related changes are also included: * Added C99 integer type definitions for Windows, as stdint.h is not available prior to Visual Studio 2010 * Changed types of some variables in the SolveSpace class from 'int' to 'bool', as they actually represent boolean settings * Implemented new Cnf{Freeze,Thaw}Bool() functions to support boolean variables in the Registry * Cnf{Freeze,Thaw}DWORD() are now Cnf{Freeze,Thaw}Int() * TtfFont::Get{WORD,DWORD}() are now TtfFont::Get{USHORT,ULONG}() (names inspired by the OpenType spec) * RGB colors are packed into an integer of type uint32_t (nee DWORD), but in a few places, these were represented by an int; these have been corrected to uint32_t
2013-10-02 13:45:13 +08:00
static bool Init;
Stipple the selected/hovered faces, instead of drawing them in solid red or yellow. And add user interface to `hide' the faces (i.e., to make them unselectable), defaulting to hidden in everything except extrudes or imports. [git-p4: depot-paths = "//depot/solvespace/": change = 1768]
2008-06-02 13:38:12 +08:00
const int BYTES = (32*32)/8;
static GLubyte HoverMask[BYTES];
static GLubyte SelMask[BYTES];
if(!Init) {
int x, y;
for(x = 0; x < 32; x++) {
for(y = 0; y < 32; y++) {
int i = y*4 + x/8, b = x % 8;
int ym = y % 4, xm = x % 4;
for(int k = 0; k < 2; k++) {
if(xm >= 1 && xm <= 2 && ym >= 1 && ym <= 2) {
(k == 0 ? SelMask : HoverMask)[i] |= (0x80 >> b);
}
ym = (ym + 2) % 4; xm = (xm + 2) % 4;
}
}
}
Use C99 integer types and C++ boolean types/values This change comprehensively replaces the use of Microsoft-standard integer and boolean types with their C99/C++ standard equivalents, as the latter is more appropriate for a cross-platform application. With matter-of-course exceptions in the Win32-specific code, the types/values have been converted as follows: QWORD --> uint64_t SQWORD --> int64_t DWORD --> uint32_t SDWORD --> int32_t WORD --> uint16_t SWORD --> int16_t BYTE --> uint8_t BOOL --> bool TRUE --> true FALSE --> false The following related changes are also included: * Added C99 integer type definitions for Windows, as stdint.h is not available prior to Visual Studio 2010 * Changed types of some variables in the SolveSpace class from 'int' to 'bool', as they actually represent boolean settings * Implemented new Cnf{Freeze,Thaw}Bool() functions to support boolean variables in the Registry * Cnf{Freeze,Thaw}DWORD() are now Cnf{Freeze,Thaw}Int() * TtfFont::Get{WORD,DWORD}() are now TtfFont::Get{USHORT,ULONG}() (names inspired by the OpenType spec) * RGB colors are packed into an integer of type uint32_t (nee DWORD), but in a few places, these were represented by an int; these have been corrected to uint32_t
2013-10-02 13:45:13 +08:00
Init = true;
Stipple the selected/hovered faces, instead of drawing them in solid red or yellow. And add user interface to `hide' the faces (i.e., to make them unselectable), defaulting to hidden in everything except extrudes or imports. [git-p4: depot-paths = "//depot/solvespace/": change = 1768]
2008-06-02 13:38:12 +08:00
}
glEnable(GL_POLYGON_STIPPLE);
if(forSel) {
glPolygonStipple(SelMask);
} else {
glPolygonStipple(HoverMask);
}
}
Rename RgbColor to RgbaColor.
2015-07-10 19:54:39 +08:00
static void StippleTriangle(STriangle *tr, bool s, RgbaColor rgb)
Stipple the selected/hovered faces, instead of drawing them in solid red or yellow. And add user interface to `hide' the faces (i.e., to make them unselectable), defaulting to hidden in everything except extrudes or imports. [git-p4: depot-paths = "//depot/solvespace/": change = 1768]
2008-06-02 13:38:12 +08:00
{
glEnd();
glDisable(GL_LIGHTING);
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
ssglColorRGB(rgb);
Stipple the selected/hovered faces, instead of drawing them in solid red or yellow. And add user interface to `hide' the faces (i.e., to make them unselectable), defaulting to hidden in everything except extrudes or imports. [git-p4: depot-paths = "//depot/solvespace/": change = 1768]
2008-06-02 13:38:12 +08:00
Stipple(s);
glBegin(GL_TRIANGLES);
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
ssglVertex3v(tr->a);
ssglVertex3v(tr->b);
ssglVertex3v(tr->c);
Stipple the selected/hovered faces, instead of drawing them in solid red or yellow. And add user interface to `hide' the faces (i.e., to make them unselectable), defaulting to hidden in everything except extrudes or imports. [git-p4: depot-paths = "//depot/solvespace/": change = 1768]
2008-06-02 13:38:12 +08:00
glEnd();
glEnable(GL_LIGHTING);
glDisable(GL_POLYGON_STIPPLE);
glBegin(GL_TRIANGLES);
}
Rename RgbColor to RgbaColor.
2015-07-10 19:54:39 +08:00
void ssglFillMesh(bool useSpecColor, RgbaColor specColor,
Add support for transparent solids. Some extra code is necessary to determine that the back faces should not be drawn in red for transparent solids. It is expected that the user will first ensure that the shell is watertight and then set the opacity; back faces are still drawn if the opacity is exactly 1. The savefile format is changed backwards-compatibly by stashing the alpha value in uppermost byte of 4-byte hex color value in Surface and Triangle clauses. The existing files have 00 in the high byte, so RgbColor::FromPackedInt treats that as "opaque".
2015-03-26 18:30:12 +08:00
SMesh *m, uint32_t h, uint32_t s1, uint32_t s2)
Add code to extrude a triangle mesh, and to perform Boolean ops on a triangle mesh in a BSP. That works, although it splits too often, the initial triangulations are not good quality, and coplanar faces are not yet handled. I'll do the coplanar thing tomorrow. [git-p4: depot-paths = "//depot/solvespace/": change = 1735]
2008-05-23 18:05:07 +08:00
{
Rename RgbColor to RgbaColor.
2015-07-10 19:54:39 +08:00
RgbaColor rgbHovered = Style::Color(Style::HOVERED),
Use C99 integer types and C++ boolean types/values This change comprehensively replaces the use of Microsoft-standard integer and boolean types with their C99/C++ standard equivalents, as the latter is more appropriate for a cross-platform application. With matter-of-course exceptions in the Win32-specific code, the types/values have been converted as follows: QWORD --> uint64_t SQWORD --> int64_t DWORD --> uint32_t SDWORD --> int32_t WORD --> uint16_t SWORD --> int16_t BYTE --> uint8_t BOOL --> bool TRUE --> true FALSE --> false The following related changes are also included: * Added C99 integer type definitions for Windows, as stdint.h is not available prior to Visual Studio 2010 * Changed types of some variables in the SolveSpace class from 'int' to 'bool', as they actually represent boolean settings * Implemented new Cnf{Freeze,Thaw}Bool() functions to support boolean variables in the Registry * Cnf{Freeze,Thaw}DWORD() are now Cnf{Freeze,Thaw}Int() * TtfFont::Get{WORD,DWORD}() are now TtfFont::Get{USHORT,ULONG}() (names inspired by the OpenType spec) * RGB colors are packed into an integer of type uint32_t (nee DWORD), but in a few places, these were represented by an int; these have been corrected to uint32_t
2013-10-02 13:45:13 +08:00
rgbSelected = Style::Color(Style::SELECTED);
Move colors and line widths for almost everything to the styles mechanism. This gets filled in from some defaults, and stored in the registry. The default styles do not get saved in the file, but user-created styles (which aren't supported yet) do. [git-p4: depot-paths = "//depot/solvespace/": change = 2028]
2009-09-17 15:32:36 +08:00
Add code to extrude a triangle mesh, and to perform Boolean ops on a triangle mesh in a BSP. That works, although it splits too often, the initial triangulations are not good quality, and coplanar faces are not yet handled. I'll do the coplanar thing tomorrow. [git-p4: depot-paths = "//depot/solvespace/": change = 1735]
2008-05-23 18:05:07 +08:00
glEnable(GL_NORMALIZE);
Add support for transparent solids. Some extra code is necessary to determine that the back faces should not be drawn in red for transparent solids. It is expected that the user will first ensure that the shell is watertight and then set the opacity; back faces are still drawn if the opacity is exactly 1. The savefile format is changed backwards-compatibly by stashing the alpha value in uppermost byte of 4-byte hex color value in Surface and Triangle clauses. The existing files have 00 in the high byte, so RgbColor::FromPackedInt treats that as "opaque".
2015-03-26 18:30:12 +08:00
bool hasMaterial = false;
Rename RgbColor to RgbaColor.
2015-07-10 19:54:39 +08:00
RgbaColor prevColor;
Add code to extrude a triangle mesh, and to perform Boolean ops on a triangle mesh in a BSP. That works, although it splits too often, the initial triangulations are not good quality, and coplanar faces are not yet handled. I'll do the coplanar thing tomorrow. [git-p4: depot-paths = "//depot/solvespace/": change = 1735]
2008-05-23 18:05:07 +08:00
glBegin(GL_TRIANGLES);
for(int i = 0; i < m->l.n; i++) {
STriangle *tr = &(m->l.elem[i]);
Rename RgbColor to RgbaColor.
2015-07-10 19:54:39 +08:00
RgbaColor color;
Add support for transparent solids. Some extra code is necessary to determine that the back faces should not be drawn in red for transparent solids. It is expected that the user will first ensure that the shell is watertight and then set the opacity; back faces are still drawn if the opacity is exactly 1. The savefile format is changed backwards-compatibly by stashing the alpha value in uppermost byte of 4-byte hex color value in Surface and Triangle clauses. The existing files have 00 in the high byte, so RgbColor::FromPackedInt treats that as "opaque".
2015-03-26 18:30:12 +08:00
if(useSpecColor) {
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 11:31:37 +08:00
color = specColor;
Add support for transparent solids. Some extra code is necessary to determine that the back faces should not be drawn in red for transparent solids. It is expected that the user will first ensure that the shell is watertight and then set the opacity; back faces are still drawn if the opacity is exactly 1. The savefile format is changed backwards-compatibly by stashing the alpha value in uppermost byte of 4-byte hex color value in Surface and Triangle clauses. The existing files have 00 in the high byte, so RgbColor::FromPackedInt treats that as "opaque".
2015-03-26 18:30:12 +08:00
} else {
color = tr->meta.color;
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 11:31:37 +08:00
}
Add support for transparent solids. Some extra code is necessary to determine that the back faces should not be drawn in red for transparent solids. It is expected that the user will first ensure that the shell is watertight and then set the opacity; back faces are still drawn if the opacity is exactly 1. The savefile format is changed backwards-compatibly by stashing the alpha value in uppermost byte of 4-byte hex color value in Surface and Triangle clauses. The existing files have 00 in the high byte, so RgbColor::FromPackedInt treats that as "opaque".
2015-03-26 18:30:12 +08:00
if(!hasMaterial || !color.Equals(prevColor)) {
GLfloat mpf[] = { color.redF(), color.greenF(), color.blueF(), color.alphaF() };
Add color. Now each triangle has metadata, which are preserved in csg ops; so the union of a red part and a blue part has both red and blue faces. And some user interface to pick the color in the text window. The metadata also include a face, which will be an entity; I can use that to constrain against. But none of that is yet implemented. [git-p4: depot-paths = "//depot/solvespace/": change = 1757]
2008-05-30 14:09:41 +08:00
glEnd();
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mpf);
prevColor = color;
Add support for transparent solids. Some extra code is necessary to determine that the back faces should not be drawn in red for transparent solids. It is expected that the user will first ensure that the shell is watertight and then set the opacity; back faces are still drawn if the opacity is exactly 1. The savefile format is changed backwards-compatibly by stashing the alpha value in uppermost byte of 4-byte hex color value in Surface and Triangle clauses. The existing files have 00 in the high byte, so RgbColor::FromPackedInt treats that as "opaque".
2015-03-26 18:30:12 +08:00
hasMaterial = true;
Add color. Now each triangle has metadata, which are preserved in csg ops; so the union of a red part and a blue part has both red and blue faces. And some user interface to pick the color in the text window. The metadata also include a face, which will be an entity; I can use that to constrain against. But none of that is yet implemented. [git-p4: depot-paths = "//depot/solvespace/": change = 1757]
2008-05-30 14:09:41 +08:00
glBegin(GL_TRIANGLES);
}
Various fixes for warnings and minutia This commit consists of numerous small changes, none significant enough to merit a commit on their own: * Added extra braces to quash for-loop variable scoping issues for older compilers (or "g++ -fno-for-scope") * Appeased "unreachable code" warnings, spurious or otherwise * Added casts to fix integer-variable signedness warnings * Added a dummy virtual method to the VectorFileWriter class to silence the -Wweak-vtables warning from Clang++ * Renamed some parameters in the Expr and GraphicsWindow classes to eliminate "parameter shadows a field" warnings * Removed an inert "0 ||" from a conditional, and changed a "&& 0" into an "#if 0" * Added missing elements to array/struct/class initializers to zap further warnings * Indented some cpp conditionals where appropriate * Qualified some variables and functions as static to quiet "no previous declaration" warnings * toolbar.cpp needed to #include<icons-proto.h> to fix those same "no previous declaration" warnings from icons.h * Added some casts and const qualifiers to the Win32 code to address warnings produced by g++ when compiling under MinGW * Rewrote Cnf{Freeze,Thaw}Float() to use a union rather than pointer aliasing; this makes g++ a lot happier * Removed redundant #includes from win32/w32util.cpp * With Jonathan's blessing, shortened the last line of the About dialog text to better match the preceding lines
2013-10-19 13:36:45 +08:00
if(tr->an.EqualsExactly(Vector::From(0, 0, 0))) {
Early attempts at rational polynomial surfaces. I can create one from an extrusion, with piecewise linear trim curves for everything (that are shared, so that they appear only once for the two surfaces that each trims). No Boolean operations on them, and the triangulation is bad, because gl seems to merge collinear edges. So before going further, I seem to need my own triangulation code. I have not had great luck in the past, but I can't live without it now. [git-p4: depot-paths = "//depot/solvespace/": change = 1899]
2009-01-19 18:37:10 +08:00
// Compute the normal from the vertices
Vector n = tr->Normal();
glNormal3d(n.x, n.y, n.z);
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
ssglVertex3v(tr->a);
ssglVertex3v(tr->b);
ssglVertex3v(tr->c);
Early attempts at rational polynomial surfaces. I can create one from an extrusion, with piecewise linear trim curves for everything (that are shared, so that they appear only once for the two surfaces that each trims). No Boolean operations on them, and the triangulation is bad, because gl seems to merge collinear edges. So before going further, I seem to need my own triangulation code. I have not had great luck in the past, but I can't live without it now. [git-p4: depot-paths = "//depot/solvespace/": change = 1899]
2009-01-19 18:37:10 +08:00
} else {
// Use the exact normals that are specified
glNormal3d((tr->an).x, (tr->an).y, (tr->an).z);
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
ssglVertex3v(tr->a);
Early attempts at rational polynomial surfaces. I can create one from an extrusion, with piecewise linear trim curves for everything (that are shared, so that they appear only once for the two surfaces that each trims). No Boolean operations on them, and the triangulation is bad, because gl seems to merge collinear edges. So before going further, I seem to need my own triangulation code. I have not had great luck in the past, but I can't live without it now. [git-p4: depot-paths = "//depot/solvespace/": change = 1899]
2009-01-19 18:37:10 +08:00
glNormal3d((tr->bn).x, (tr->bn).y, (tr->bn).z);
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
ssglVertex3v(tr->b);
Early attempts at rational polynomial surfaces. I can create one from an extrusion, with piecewise linear trim curves for everything (that are shared, so that they appear only once for the two surfaces that each trims). No Boolean operations on them, and the triangulation is bad, because gl seems to merge collinear edges. So before going further, I seem to need my own triangulation code. I have not had great luck in the past, but I can't live without it now. [git-p4: depot-paths = "//depot/solvespace/": change = 1899]
2009-01-19 18:37:10 +08:00
glNormal3d((tr->cn).x, (tr->cn).y, (tr->cn).z);
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
ssglVertex3v(tr->c);
Early attempts at rational polynomial surfaces. I can create one from an extrusion, with piecewise linear trim curves for everything (that are shared, so that they appear only once for the two surfaces that each trims). No Boolean operations on them, and the triangulation is bad, because gl seems to merge collinear edges. So before going further, I seem to need my own triangulation code. I have not had great luck in the past, but I can't live without it now. [git-p4: depot-paths = "//depot/solvespace/": change = 1899]
2009-01-19 18:37:10 +08:00
}
Stipple the selected/hovered faces, instead of drawing them in solid red or yellow. And add user interface to `hide' the faces (i.e., to make them unselectable), defaulting to hidden in everything except extrudes or imports. [git-p4: depot-paths = "//depot/solvespace/": change = 1768]
2008-06-02 13:38:12 +08:00
Trim trailing whitespace.
2015-03-29 08:30:52 +08:00
if((s1 != 0 && tr->meta.face == s1) ||
Stipple the selected/hovered faces, instead of drawing them in solid red or yellow. And add user interface to `hide' the faces (i.e., to make them unselectable), defaulting to hidden in everything except extrudes or imports. [git-p4: depot-paths = "//depot/solvespace/": change = 1768]
2008-06-02 13:38:12 +08:00
(s2 != 0 && tr->meta.face == s2))
{
Use C99 integer types and C++ boolean types/values This change comprehensively replaces the use of Microsoft-standard integer and boolean types with their C99/C++ standard equivalents, as the latter is more appropriate for a cross-platform application. With matter-of-course exceptions in the Win32-specific code, the types/values have been converted as follows: QWORD --> uint64_t SQWORD --> int64_t DWORD --> uint32_t SDWORD --> int32_t WORD --> uint16_t SWORD --> int16_t BYTE --> uint8_t BOOL --> bool TRUE --> true FALSE --> false The following related changes are also included: * Added C99 integer type definitions for Windows, as stdint.h is not available prior to Visual Studio 2010 * Changed types of some variables in the SolveSpace class from 'int' to 'bool', as they actually represent boolean settings * Implemented new Cnf{Freeze,Thaw}Bool() functions to support boolean variables in the Registry * Cnf{Freeze,Thaw}DWORD() are now Cnf{Freeze,Thaw}Int() * TtfFont::Get{WORD,DWORD}() are now TtfFont::Get{USHORT,ULONG}() (names inspired by the OpenType spec) * RGB colors are packed into an integer of type uint32_t (nee DWORD), but in a few places, these were represented by an int; these have been corrected to uint32_t
2013-10-02 13:45:13 +08:00
StippleTriangle(tr, true, rgbSelected);
Stipple the selected/hovered faces, instead of drawing them in solid red or yellow. And add user interface to `hide' the faces (i.e., to make them unselectable), defaulting to hidden in everything except extrudes or imports. [git-p4: depot-paths = "//depot/solvespace/": change = 1768]
2008-06-02 13:38:12 +08:00
}
if(h != 0 && tr->meta.face == h) {
Use C99 integer types and C++ boolean types/values This change comprehensively replaces the use of Microsoft-standard integer and boolean types with their C99/C++ standard equivalents, as the latter is more appropriate for a cross-platform application. With matter-of-course exceptions in the Win32-specific code, the types/values have been converted as follows: QWORD --> uint64_t SQWORD --> int64_t DWORD --> uint32_t SDWORD --> int32_t WORD --> uint16_t SWORD --> int16_t BYTE --> uint8_t BOOL --> bool TRUE --> true FALSE --> false The following related changes are also included: * Added C99 integer type definitions for Windows, as stdint.h is not available prior to Visual Studio 2010 * Changed types of some variables in the SolveSpace class from 'int' to 'bool', as they actually represent boolean settings * Implemented new Cnf{Freeze,Thaw}Bool() functions to support boolean variables in the Registry * Cnf{Freeze,Thaw}DWORD() are now Cnf{Freeze,Thaw}Int() * TtfFont::Get{WORD,DWORD}() are now TtfFont::Get{USHORT,ULONG}() (names inspired by the OpenType spec) * RGB colors are packed into an integer of type uint32_t (nee DWORD), but in a few places, these were represented by an int; these have been corrected to uint32_t
2013-10-02 13:45:13 +08:00
StippleTriangle(tr, false, rgbHovered);
Stipple the selected/hovered faces, instead of drawing them in solid red or yellow. And add user interface to `hide' the faces (i.e., to make them unselectable), defaulting to hidden in everything except extrudes or imports. [git-p4: depot-paths = "//depot/solvespace/": change = 1768]
2008-06-02 13:38:12 +08:00
}
Add code to extrude a triangle mesh, and to perform Boolean ops on a triangle mesh in a BSP. That works, although it splits too often, the initial triangulations are not good quality, and coplanar faces are not yet handled. I'll do the coplanar thing tomorrow. [git-p4: depot-paths = "//depot/solvespace/": change = 1735]
2008-05-23 18:05:07 +08:00
}
glEnd();
}
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
static void SSGL_CALLBACK Vertex(Vector *p)
Replace ugly text links to hide/show things with icons. So add code to draw those, and hit test with the mouse, and display tool tips when the user hovers with the mouse. Also, underline links only when they're hovered, and not otherwise. And add a separate menu option to align the view to the active workplane, vs. activating the active group's workplane, and remap the bottom two graphics window toolbar icons to that and "nearest iso view" instead of draw in 2d/3d, since people tended to click on those without understanding and cause trouble. And by default, we force a parallel projection; so the factory default camera tangent is now 0.3, not 0. [git-p4: depot-paths = "//depot/solvespace/": change = 2131]
2010-05-03 13:04:42 +08:00
{
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
ssglVertex3v(*p);
Add code to assemble the piecewise linear segments in a group into a polygon, and to fill that polygon. [git-p4: depot-paths = "//depot/solvespace/": change = 1686]
2008-04-25 15:04:09 +08:00
}
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
void ssglFillPolygon(SPolygon *p)
Add polygon triangulation, by cheating. I'm using the gl tesselator for that, and storing the triangles instead of rendering them immediately. Not sure if that's smart; in theory could change from implementation to implementation, but the results look much better than I would get myself. [git-p4: depot-paths = "//depot/solvespace/": change = 1733]
2008-05-22 18:28:28 +08:00
{
GLUtesselator *gt = gluNewTess();
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
gluTessCallback(gt, GLU_TESS_BEGIN, (ssglCallbackFptr *)glBegin);
gluTessCallback(gt, GLU_TESS_END, (ssglCallbackFptr *)glEnd);
gluTessCallback(gt, GLU_TESS_VERTEX, (ssglCallbackFptr *)Vertex);
Add polygon triangulation, by cheating. I'm using the gl tesselator for that, and storing the triangles instead of rendering them immediately. Not sure if that's smart; in theory could change from implementation to implementation, but the results look much better than I would get myself. [git-p4: depot-paths = "//depot/solvespace/": change = 1733]
2008-05-22 18:28:28 +08:00
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
ssglTesselatePolygon(gt, p);
Add polygon triangulation, by cheating. I'm using the gl tesselator for that, and storing the triangles instead of rendering them immediately. Not sure if that's smart; in theory could change from implementation to implementation, but the results look much better than I would get myself. [git-p4: depot-paths = "//depot/solvespace/": change = 1733]
2008-05-22 18:28:28 +08:00
gluDeleteTess(gt);
}
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
static void SSGL_CALLBACK Combine(double coords[3], void *vertexData[4],
float weight[4], void **outData)
Add a function to combine vertices while tesselating the polygon, so that OpenGL can fill self-intersecting polygons. [git-p4: depot-paths = "//depot/solvespace/": change = 1688]
2008-04-25 18:11:29 +08:00
{
Vector *n = (Vector *)AllocTemporary(sizeof(Vector));
n->x = coords[0];
n->y = coords[1];
n->z = coords[2];
*outData = n;
}
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
void ssglTesselatePolygon(GLUtesselator *gt, SPolygon *p)
Add code to assemble the piecewise linear segments in a group into a polygon, and to fill that polygon. [git-p4: depot-paths = "//depot/solvespace/": change = 1686]
2008-04-25 15:04:09 +08:00
{
int i, j;
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
gluTessCallback(gt, GLU_TESS_COMBINE, (ssglCallbackFptr *)Combine);
Add code to assemble the piecewise linear segments in a group into a polygon, and to fill that polygon. [git-p4: depot-paths = "//depot/solvespace/": change = 1686]
2008-04-25 15:04:09 +08:00
gluTessProperty(gt, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD);
Fix some stupid bugs introduced with the new representation of workplanes. And fix up our polygon normals, so that everything gets shaded correctly (and so that later we can generate our STL files with correct normals). [git-p4: depot-paths = "//depot/solvespace/": change = 1706]
2008-05-05 17:47:23 +08:00
Vector normal = p->normal;
Make the extrude command do a bit more; now I generate all the faces of the polyhedron. And shade the faces when I draw them, and fix up our projection matrix so that the depth testing works properly. [git-p4: depot-paths = "//depot/solvespace/": change = 1703]
2008-05-02 18:54:22 +08:00
glNormal3d(normal.x, normal.y, normal.z);
Fix some stupid bugs introduced with the new representation of workplanes. And fix up our polygon normals, so that everything gets shaded correctly (and so that later we can generate our STL files with correct normals). [git-p4: depot-paths = "//depot/solvespace/": change = 1706]
2008-05-05 17:47:23 +08:00
gluTessNormal(gt, normal.x, normal.y, normal.z);
Make the extrude command do a bit more; now I generate all the faces of the polyhedron. And shade the faces when I draw them, and fix up our projection matrix so that the depth testing works properly. [git-p4: depot-paths = "//depot/solvespace/": change = 1703]
2008-05-02 18:54:22 +08:00
Add code to assemble the piecewise linear segments in a group into a polygon, and to fill that polygon. [git-p4: depot-paths = "//depot/solvespace/": change = 1686]
2008-04-25 15:04:09 +08:00
gluTessBeginPolygon(gt, NULL);
for(i = 0; i < p->l.n; i++) {
SContour *sc = &(p->l.elem[i]);
gluTessBeginContour(gt);
for(j = 0; j < (sc->l.n-1); j++) {
SPoint *sp = &(sc->l.elem[j]);
double ap[3];
ap[0] = sp->p.x;
ap[1] = sp->p.y;
ap[2] = sp->p.z;
gluTessVertex(gt, ap, &(sp->p));
}
gluTessEndContour(gt);
Big structural change; eliminate the Point type in SolveSpace. The points are now entities like any others; so a line segment request will generate three entities, the line segment and its endpoints. I think that's cleaner. When I do step and repeats (and imports, and other similar), I'll need a consistent way to assign those entity ids. That assignment must not change if the sketch is edited. I don't have a clean way to do that; best thought right now is to keep a record of what maps have been used previously, and not pick a new map as long as it's possible to use one that was used previously. This all means that more crap gets pushed in to the Entity structure, so that they can keep track of what solver variables define them. Still seems better, though. I'm closer to ready to start solving. [git-p4: depot-paths = "//depot/solvespace/": change = 1673]
2008-04-19 19:09:47 +08:00
}
Add code to assemble the piecewise linear segments in a group into a polygon, and to fill that polygon. [git-p4: depot-paths = "//depot/solvespace/": change = 1686]
2008-04-25 15:04:09 +08:00
gluTessEndPolygon(gt);
Big structural change; eliminate the Point type in SolveSpace. The points are now entities like any others; so a line segment request will generate three entities, the line segment and its endpoints. I think that's cleaner. When I do step and repeats (and imports, and other similar), I'll need a consistent way to assign those entity ids. That assignment must not change if the sketch is edited. I don't have a clean way to do that; best thought right now is to keep a record of what maps have been used previously, and not pick a new map as long as it's possible to use one that was used previously. This all means that more crap gets pushed in to the Entity structure, so that they can keep track of what solver variables define them. Still seems better, though. I'm closer to ready to start solving. [git-p4: depot-paths = "//depot/solvespace/": change = 1673]
2008-04-19 19:09:47 +08:00
}
Add code to assemble the piecewise linear segments in a group into a polygon, and to fill that polygon. [git-p4: depot-paths = "//depot/solvespace/": change = 1686]
2008-04-25 15:04:09 +08:00
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
void ssglDebugPolygon(SPolygon *p)
Add constructive solid geometry ops. These work to some extent, but not very well; I'm doing a b-rep, where the boundaries are complex polygons, and there's too many special cases. I should probably replace this with a triangle mesh solution. [git-p4: depot-paths = "//depot/solvespace/": change = 1731]
2008-05-19 17:23:49 +08:00
{
int i, j;
Work around poor line rendering with Intel Mesa-based drivers. However, don't use ssglLineWidth for UI drawing operations. These only draw horizontal or vertical lines that don't need to be antialiased, and thus don't require the workaround. In fact the workaround would make them thicker than needed.
2015-03-22 21:39:12 +08:00
ssglLineWidth(2);
Add constructive solid geometry ops. These work to some extent, but not very well; I'm doing a b-rep, where the boundaries are complex polygons, and there's too many special cases. I should probably replace this with a triangle mesh solution. [git-p4: depot-paths = "//depot/solvespace/": change = 1731]
2008-05-19 17:23:49 +08:00
glPointSize(7);
glDisable(GL_DEPTH_TEST);
for(i = 0; i < p->l.n; i++) {
SContour *sc = &(p->l.elem[i]);
for(j = 0; j < (sc->l.n-1); j++) {
Vector a = (sc->l.elem[j]).p;
Vector b = (sc->l.elem[j+1]).p;
Renamed the RGB() macro to RGBi() to avoid collisions with Microsoft Microsoft defines an RGB() macro that at one point was compatible with our version (returning a packed integer containing 8-bit red, green and blue channels), but is no longer, and the incompatibility led to an awkward situation in w32main.cpp where we had to restore Microsoft's form of the macro in order for the commctrl.h header to compile. By renaming the macro to RGBi()---analogous to the RGBf() macro we already define---we avoid the hassle entirely.
2013-12-02 14:25:09 +08:00
ssglLockColorTo(RGBi(0, 0, 255));
Add constructive solid geometry ops. These work to some extent, but not very well; I'm doing a b-rep, where the boundaries are complex polygons, and there's too many special cases. I should probably replace this with a triangle mesh solution. [git-p4: depot-paths = "//depot/solvespace/": change = 1731]
2008-05-19 17:23:49 +08:00
Vector d = (a.Minus(b)).WithMagnitude(-0);
glBegin(GL_LINES);
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
ssglVertex3v(a.Plus(d));
ssglVertex3v(b.Minus(d));
Add constructive solid geometry ops. These work to some extent, but not very well; I'm doing a b-rep, where the boundaries are complex polygons, and there's too many special cases. I should probably replace this with a triangle mesh solution. [git-p4: depot-paths = "//depot/solvespace/": change = 1731]
2008-05-19 17:23:49 +08:00
glEnd();
Renamed the RGB() macro to RGBi() to avoid collisions with Microsoft Microsoft defines an RGB() macro that at one point was compatible with our version (returning a packed integer containing 8-bit red, green and blue channels), but is no longer, and the incompatibility led to an awkward situation in w32main.cpp where we had to restore Microsoft's form of the macro in order for the commctrl.h header to compile. By renaming the macro to RGBi()---analogous to the RGBf() macro we already define---we avoid the hassle entirely.
2013-12-02 14:25:09 +08:00
ssglLockColorTo(RGBi(255, 0, 0));
Add constructive solid geometry ops. These work to some extent, but not very well; I'm doing a b-rep, where the boundaries are complex polygons, and there's too many special cases. I should probably replace this with a triangle mesh solution. [git-p4: depot-paths = "//depot/solvespace/": change = 1731]
2008-05-19 17:23:49 +08:00
glBegin(GL_POINTS);
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
ssglVertex3v(a.Plus(d));
ssglVertex3v(b.Minus(d));
Add constructive solid geometry ops. These work to some extent, but not very well; I'm doing a b-rep, where the boundaries are complex polygons, and there's too many special cases. I should probably replace this with a triangle mesh solution. [git-p4: depot-paths = "//depot/solvespace/": change = 1731]
2008-05-19 17:23:49 +08:00
glEnd();
}
}
}
Allow rendering hidden solid edges using a distinct style. Before this change, the two buttons "Show/hide shaded model" (S) and "Show/hide hidden lines" (H) resulted in drawing the following elements in the following styles: Button | Non-occluded | Non-occluded | Occluded | Occluded state | solid edges | entities | solid edges | entities --------+--------------+--------------+-------------+-------------- !S !H | | | solid-edge | entity style --------+ | +-------------+-------------- S !H | | | invisible --------+ solid-edge | entity style +-------------+-------------- !S H | | | | --------+ | | solid-edge | entity style S H | | | | --------+--------------+--------------+-------------+-------------- After this change, they are drawn as follows: Button | Non-occluded | Non-occluded | Occluded | Occluded state | solid edges | entities | solid edges | entities --------+--------------+--------------+-------------+-------------- !S !H | | | solid-edge | entity style --------+ | +-------------+-------------- S !H | | | invisible --------+ solid-edge | entity style +-------------+-------------- !S H | | | | --------+ | | hidden-edge | stippled¹ S H | | | | --------+--------------+--------------+-------------+-------------- ¹ entity style, but the stipple parameters taken from hidden-edge In SolveSpace's true WYSIWYG tradition, the 2d view export follows the rendered view exactly. Also, it is now possible to edit the stipple parameters of built-in styles, so that by changing the hidden-edge style to non-stippled it is possible to regain the old behavior.
2016-03-09 12:53:46 +08:00
void ssglDrawEdges(SEdgeList *el, bool endpointsToo, hStyle hs)
Add constructive solid geometry ops. These work to some extent, but not very well; I'm doing a b-rep, where the boundaries are complex polygons, and there's too many special cases. I should probably replace this with a triangle mesh solution. [git-p4: depot-paths = "//depot/solvespace/": change = 1731]
2008-05-19 17:23:49 +08:00
{
Allow rendering hidden solid edges using a distinct style. Before this change, the two buttons "Show/hide shaded model" (S) and "Show/hide hidden lines" (H) resulted in drawing the following elements in the following styles: Button | Non-occluded | Non-occluded | Occluded | Occluded state | solid edges | entities | solid edges | entities --------+--------------+--------------+-------------+-------------- !S !H | | | solid-edge | entity style --------+ | +-------------+-------------- S !H | | | invisible --------+ solid-edge | entity style +-------------+-------------- !S H | | | | --------+ | | solid-edge | entity style S H | | | | --------+--------------+--------------+-------------+-------------- After this change, they are drawn as follows: Button | Non-occluded | Non-occluded | Occluded | Occluded state | solid edges | entities | solid edges | entities --------+--------------+--------------+-------------+-------------- !S !H | | | solid-edge | entity style --------+ | +-------------+-------------- S !H | | | invisible --------+ solid-edge | entity style +-------------+-------------- !S H | | | | --------+ | | hidden-edge | stippled¹ S H | | | | --------+--------------+--------------+-------------+-------------- ¹ entity style, but the stipple parameters taken from hidden-edge In SolveSpace's true WYSIWYG tradition, the 2d view export follows the rendered view exactly. Also, it is now possible to edit the stipple parameters of built-in styles, so that by changing the hidden-edge style to non-stippled it is possible to regain the old behavior.
2016-03-09 12:53:46 +08:00
double lineWidth = Style::Width(hs);
int stippleType = Style::PatternType(hs);
double stippleScale = Style::StippleScaleMm(hs);
ssglLineWidth(float(lineWidth));
ssglColorRGB(Style::Color(hs));
Add sin and cos to the expression entry (for dimensions etc.), with the same precedence as sqrt. Add the code to find naked edges, and draw them highlighted on the model. And make the direction of trim curves consistent, always ccw with normal toward viewer; so there's no need to fix the directions before triangulating. [git-p4: depot-paths = "//depot/solvespace/": change = 1903]
2009-01-25 17:19:59 +08:00
SEdge *se;
for(se = el->l.First(); se; se = el->l.NextAfter(se)) {
Allow rendering hidden solid edges using a distinct style. Before this change, the two buttons "Show/hide shaded model" (S) and "Show/hide hidden lines" (H) resulted in drawing the following elements in the following styles: Button | Non-occluded | Non-occluded | Occluded | Occluded state | solid edges | entities | solid edges | entities --------+--------------+--------------+-------------+-------------- !S !H | | | solid-edge | entity style --------+ | +-------------+-------------- S !H | | | invisible --------+ solid-edge | entity style +-------------+-------------- !S H | | | | --------+ | | solid-edge | entity style S H | | | | --------+--------------+--------------+-------------+-------------- After this change, they are drawn as follows: Button | Non-occluded | Non-occluded | Occluded | Occluded state | solid edges | entities | solid edges | entities --------+--------------+--------------+-------------+-------------- !S !H | | | solid-edge | entity style --------+ | +-------------+-------------- S !H | | | invisible --------+ solid-edge | entity style +-------------+-------------- !S H | | | | --------+ | | hidden-edge | stippled¹ S H | | | | --------+--------------+--------------+-------------+-------------- ¹ entity style, but the stipple parameters taken from hidden-edge In SolveSpace's true WYSIWYG tradition, the 2d view export follows the rendered view exactly. Also, it is now possible to edit the stipple parameters of built-in styles, so that by changing the hidden-edge style to non-stippled it is possible to regain the old behavior.
2016-03-09 12:53:46 +08:00
ssglStippledLine(se->a, se->b, lineWidth, stippleType, stippleScale,
/*maybeFat=*/true);
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 13:53:16 +08:00
}
Add ability to represent our surfaces as either a shell or a mesh, according to the user's preference. I templated the housekeeping stuff for Boolean operations and step and repeat, so it's relatively clean. Still need to add the stuff to make a mesh vertex-to-vertex, and to export sections of a mesh. [git-p4: depot-paths = "//depot/solvespace/": change = 1959]
2009-05-24 19:37:07 +08:00
if(endpointsToo) {
glPointSize(12);
glBegin(GL_POINTS);
for(se = el->l.First(); se; se = el->l.NextAfter(se)) {
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
ssglVertex3v(se->a);
ssglVertex3v(se->b);
Add ability to represent our surfaces as either a shell or a mesh, according to the user's preference. I templated the housekeeping stuff for Boolean operations and step and repeat, so it's relatively clean. Still need to add the stuff to make a mesh vertex-to-vertex, and to export sections of a mesh. [git-p4: depot-paths = "//depot/solvespace/": change = 1959]
2009-05-24 19:37:07 +08:00
}
glEnd();
Add constructive solid geometry ops. These work to some extent, but not very well; I'm doing a b-rep, where the boundaries are complex polygons, and there's too many special cases. I should probably replace this with a triangle mesh solution. [git-p4: depot-paths = "//depot/solvespace/": change = 1731]
2008-05-19 17:23:49 +08:00
}
}
Allow rendering solid outlines using a distinct style. A new button is added, "Show/hide outline of solid model". When the outline is hidden, it is rendered using the "solid edge" style. When the outline is shown, it is rendered using the "outline" style. In SolveSpace's true WYSIWYG tradition, the 2d view export follows the rendered view exactly. Moreover, shell edges are not rendered anymore, since there is not much need in them anymore and not drawing them lessens the overlap between various kinds of lines, which already includes entities, solid edges and outlines.
2016-03-15 00:14:24 +08:00
void ssglDrawOutlines(SOutlineList *sol, Vector projDir, hStyle hs)
{
double lineWidth = Style::Width(hs);
int stippleType = Style::PatternType(hs);
double stippleScale = Style::StippleScaleMm(hs);
ssglLineWidth((float)lineWidth);
ssglColorRGB(Style::Color(hs));
sol->FillOutlineTags(projDir);
for(SOutline *so = sol->l.First(); so; so = sol->l.NextAfter(so)) {
if(!so->tag) continue;
ssglStippledLine(so->a, so->b, lineWidth, stippleType, stippleScale,
/*maybeFat=*/true);
}
}
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
void ssglDebugMesh(SMesh *m)
Add polygon triangulation, by cheating. I'm using the gl tesselator for that, and storing the triangles instead of rendering them immediately. Not sure if that's smart; in theory could change from implementation to implementation, but the results look much better than I would get myself. [git-p4: depot-paths = "//depot/solvespace/": change = 1733]
2008-05-22 18:28:28 +08:00
{
int i;
Work around poor line rendering with Intel Mesa-based drivers. However, don't use ssglLineWidth for UI drawing operations. These only draw horizontal or vertical lines that don't need to be antialiased, and thus don't require the workaround. In fact the workaround would make them thicker than needed.
2015-03-22 21:39:12 +08:00
ssglLineWidth(1);
Add polygon triangulation, by cheating. I'm using the gl tesselator for that, and storing the triangles instead of rendering them immediately. Not sure if that's smart; in theory could change from implementation to implementation, but the results look much better than I would get myself. [git-p4: depot-paths = "//depot/solvespace/": change = 1733]
2008-05-22 18:28:28 +08:00
glPointSize(7);
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
ssglDepthRangeOffset(1);
ssglUnlockColor();
Oops, was calling glBegin() once for each triangle when showing mesh! [git-p4: depot-paths = "//depot/solvespace/": change = 1807]
2008-06-23 16:48:19 +08:00
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
Renamed the RGB() macro to RGBi() to avoid collisions with Microsoft Microsoft defines an RGB() macro that at one point was compatible with our version (returning a packed integer containing 8-bit red, green and blue channels), but is no longer, and the incompatibility led to an awkward situation in w32main.cpp where we had to restore Microsoft's form of the macro in order for the commctrl.h header to compile. By renaming the macro to RGBi()---analogous to the RGBf() macro we already define---we avoid the hassle entirely.
2013-12-02 14:25:09 +08:00
ssglColorRGBa(RGBi(0, 255, 0), 1.0);
Oops, was calling glBegin() once for each triangle when showing mesh! [git-p4: depot-paths = "//depot/solvespace/": change = 1807]
2008-06-23 16:48:19 +08:00
glBegin(GL_TRIANGLES);
Add polygon triangulation, by cheating. I'm using the gl tesselator for that, and storing the triangles instead of rendering them immediately. Not sure if that's smart; in theory could change from implementation to implementation, but the results look much better than I would get myself. [git-p4: depot-paths = "//depot/solvespace/": change = 1733]
2008-05-22 18:28:28 +08:00
for(i = 0; i < m->l.n; i++) {
STriangle *t = &(m->l.elem[i]);
if(t->tag) continue;
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
ssglVertex3v(t->a);
ssglVertex3v(t->b);
ssglVertex3v(t->c);
Add polygon triangulation, by cheating. I'm using the gl tesselator for that, and storing the triangles instead of rendering them immediately. Not sure if that's smart; in theory could change from implementation to implementation, but the results look much better than I would get myself. [git-p4: depot-paths = "//depot/solvespace/": change = 1733]
2008-05-22 18:28:28 +08:00
}
Oops, was calling glBegin() once for each triangle when showing mesh! [git-p4: depot-paths = "//depot/solvespace/": change = 1807]
2008-06-23 16:48:19 +08:00
glEnd();
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
ssglDepthRangeOffset(0);
Oops, was calling glBegin() once for each triangle when showing mesh! [git-p4: depot-paths = "//depot/solvespace/": change = 1807]
2008-06-23 16:48:19 +08:00
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
Add polygon triangulation, by cheating. I'm using the gl tesselator for that, and storing the triangles instead of rendering them immediately. Not sure if that's smart; in theory could change from implementation to implementation, but the results look much better than I would get myself. [git-p4: depot-paths = "//depot/solvespace/": change = 1733]
2008-05-22 18:28:28 +08:00
}
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
void ssglMarkPolygonNormal(SPolygon *p)
Add constructive solid geometry ops. These work to some extent, but not very well; I'm doing a b-rep, where the boundaries are complex polygons, and there's too many special cases. I should probably replace this with a triangle mesh solution. [git-p4: depot-paths = "//depot/solvespace/": change = 1731]
2008-05-19 17:23:49 +08:00
{
Standardize naming of FromXxx (and XxxFrom) static methods to create a `new' stack-allocated instance of an object; just From, possibly different versions with different arg types. [git-p4: depot-paths = "//depot/solvespace/": change = 1763]
2008-06-01 16:45:11 +08:00
Vector tail = Vector::From(0, 0, 0);
Fix some stupid bugs introduced with the new representation of workplanes. And fix up our polygon normals, so that everything gets shaded correctly (and so that later we can generate our STL files with correct normals). [git-p4: depot-paths = "//depot/solvespace/": change = 1706]
2008-05-05 17:47:23 +08:00
int i, j, cnt = 0;
// Choose some reasonable center point.
for(i = 0; i < p->l.n; i++) {
SContour *sc = &(p->l.elem[i]);
for(j = 0; j < (sc->l.n-1); j++) {
SPoint *sp = &(sc->l.elem[j]);
tail = tail.Plus(sp->p);
cnt++;
}
}
if(cnt == 0) return;
tail = tail.ScaledBy(1.0/cnt);
Vector gn = SS.GW.projRight.Cross(SS.GW.projUp);
Vector tip = tail.Plus((p->normal).WithMagnitude(40/SS.GW.scale));
Vector arrow = (p->normal).WithMagnitude(15/SS.GW.scale);
glColor3d(1, 1, 0);
glBegin(GL_LINES);
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
ssglVertex3v(tail);
ssglVertex3v(tip);
ssglVertex3v(tip);
ssglVertex3v(tip.Minus(arrow.RotatedAbout(gn, 0.6)));
ssglVertex3v(tip);
ssglVertex3v(tip.Minus(arrow.RotatedAbout(gn, -0.6)));
Fix some stupid bugs introduced with the new representation of workplanes. And fix up our polygon normals, so that everything gets shaded correctly (and so that later we can generate our STL files with correct normals). [git-p4: depot-paths = "//depot/solvespace/": change = 1706]
2008-05-05 17:47:23 +08:00
glEnd();
glEnable(GL_LIGHTING);
}
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
void ssglDepthRangeOffset(int units)
Replace ugly text links to hide/show things with icons. So add code to draw those, and hit test with the mouse, and display tool tips when the user hovers with the mouse. Also, underline links only when they're hovered, and not otherwise. And add a separate menu option to align the view to the active workplane, vs. activating the active group's workplane, and remap the bottom two graphics window toolbar icons to that and "nearest iso view" instead of draw in 2d/3d, since people tended to click on those without understanding and cause trouble. And by default, we force a parallel projection; so the factory default camera tangent is now 0.3, not 0. [git-p4: depot-paths = "//depot/solvespace/": change = 2131]
2010-05-03 13:04:42 +08:00
{
Add perspective, by a user-specified factor. So I have to apply that perspective in the gl matrices, and also everywhere that I check mouse pointer positions against the model, and for the zoom to fit. [git-p4: depot-paths = "//depot/solvespace/": change = 1796]
2008-06-18 03:12:25 +08:00
if(!DepthOffsetLocked) {
// The size of this step depends on the resolution of the Z buffer; for
// a 16-bit buffer, this should be fine.
double d = units/60000.0;
glDepthRange(0.1-d, 1-d);
}
}
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
void ssglDepthRangeLockToFront(bool yes)
Replace ugly text links to hide/show things with icons. So add code to draw those, and hit test with the mouse, and display tool tips when the user hovers with the mouse. Also, underline links only when they're hovered, and not otherwise. And add a separate menu option to align the view to the active workplane, vs. activating the active group's workplane, and remap the bottom two graphics window toolbar icons to that and "nearest iso view" instead of draw in 2d/3d, since people tended to click on those without understanding and cause trouble. And by default, we force a parallel projection; so the factory default camera tangent is now 0.3, not 0. [git-p4: depot-paths = "//depot/solvespace/": change = 2131]
2010-05-03 13:04:42 +08:00
{
Add perspective, by a user-specified factor. So I have to apply that perspective in the gl matrices, and also everywhere that I check mouse pointer positions against the model, and for the zoom to fit. [git-p4: depot-paths = "//depot/solvespace/": change = 1796]
2008-06-18 03:12:25 +08:00
if(yes) {
DepthOffsetLocked = true;
glDepthRange(0, 0);
} else {
DepthOffsetLocked = false;
Renamed GL helper routines/identifiers to use "ssgl" prefix instead of "glx" The "glx" prefix on the names of SolveSpace's various GL helper routines was confusingly similar to those used by official OpenGL-associated libraries (e.g. "glu" used by the GL Utility library, and "glX" used by GLX), and could thus give the erroneous impression that it represented a system API rather than ordinary application logic. We thus rename these routines to have an "ssgl" prefix, clearly identifying them with SolveSpace while retaining some visual kinship to GL function names.
2013-10-22 12:45:06 +08:00
ssglDepthRangeOffset(0);
Add perspective, by a user-specified factor. So I have to apply that perspective in the gl matrices, and also everywhere that I check mouse pointer positions against the model, and for the zoom to fit. [git-p4: depot-paths = "//depot/solvespace/": change = 1796]
2008-06-18 03:12:25 +08:00
}
}
Move bitmap font to res/fonts/; remove unifont2c. This commit integrates the bitmap font in the resource system, so that cross-compilation would be easier. The font handling code was carefully written to do glyph parsing lazily; in practice this means that after this commit, startup is less than 25ms slower, most of it spent in inflate(). This should also result in faster rendering, since there is no rampant plane switching anymore; instead, all characters that are actually used are stashed into same one texture.
2016-04-23 12:37:42 +08:00
void ssglDrawPixmap(const Pixmap &pixmap, bool flip) {
glBindTexture(GL_TEXTURE_2D, TEXTURE_DRAW_PIXELS);
Initial work to move text window guts into platform-independent code. This is now drawn using gl, and the bitmap font (both there and in the graphics window) is drawn from a texture from a static table, not from the Win32 functions, since that's ~1000x faster. So this adds a tool to generate that table. With luck that will also fix my font issues under WINE, which won't have to render the TTF itself. Still needs some cleanup, and to make all the cosmetic improvements that I want. [git-p4: depot-paths = "//depot/solvespace/": change = 2130]
2010-04-26 15:52:49 +08:00
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
Rasterize non-ASCII glyphs in the UI. Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
2015-11-06 03:39:27 +08:00
Move bitmap font to res/fonts/; remove unifont2c. This commit integrates the bitmap font in the resource system, so that cross-compilation would be easier. The font handling code was carefully written to do glyph parsing lazily; in practice this means that after this commit, startup is less than 25ms slower, most of it spent in inflate(). This should also result in faster rendering, since there is no rampant plane switching anymore; instead, all characters that are actually used are stashed into same one texture.
2016-04-23 12:37:42 +08:00
int format = pixmap.hasAlpha ? GL_RGBA : GL_RGB;
glTexImage2D(GL_TEXTURE_2D, 0, format, pixmap.width, pixmap.height, 0,
In Pixmap and BitmapFont, use std::vector instead of std::unique_ptr. MSVC 2013 keeps having aggravating bugs where its unique_ptr implementation wants to use deleted functions. In this case the worst that could happen is one copy per entity once during initialization (which should in principle be elided anyway because a return value is a prvalue... no idea if MSVC does actually do that).
2016-05-18 18:40:56 +08:00
format, GL_UNSIGNED_BYTE, &pixmap.data[0]);
Initial work to move text window guts into platform-independent code. This is now drawn using gl, and the bitmap font (both there and in the graphics window) is drawn from a texture from a static table, not from the Win32 functions, since that's ~1000x faster. So this adds a tool to generate that table. With luck that will also fix my font issues under WINE, which won't have to render the TTF itself. Still needs some cleanup, and to make all the cosmetic improvements that I want. [git-p4: depot-paths = "//depot/solvespace/": change = 2130]
2010-04-26 15:52:49 +08:00
Move bitmap font to res/fonts/; remove unifont2c. This commit integrates the bitmap font in the resource system, so that cross-compilation would be easier. The font handling code was carefully written to do glyph parsing lazily; in practice this means that after this commit, startup is less than 25ms slower, most of it spent in inflate(). This should also result in faster rendering, since there is no rampant plane switching anymore; instead, all characters that are actually used are stashed into same one texture.
2016-04-23 12:37:42 +08:00
glEnable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
glTexCoord2d(0.0, flip ? 0.0 : 1.0);
glVertex2d(0.0, (double)pixmap.height);
Rasterize non-ASCII glyphs in the UI. Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
2015-11-06 03:39:27 +08:00
Move bitmap font to res/fonts/; remove unifont2c. This commit integrates the bitmap font in the resource system, so that cross-compilation would be easier. The font handling code was carefully written to do glyph parsing lazily; in practice this means that after this commit, startup is less than 25ms slower, most of it spent in inflate(). This should also result in faster rendering, since there is no rampant plane switching anymore; instead, all characters that are actually used are stashed into same one texture.
2016-04-23 12:37:42 +08:00
glTexCoord2d(1.0, flip ? 0.0 : 1.0);
glVertex2d((double)pixmap.width, (double)pixmap.height);
Rasterize non-ASCII glyphs in the UI. Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
2015-11-06 03:39:27 +08:00
Move bitmap font to res/fonts/; remove unifont2c. This commit integrates the bitmap font in the resource system, so that cross-compilation would be easier. The font handling code was carefully written to do glyph parsing lazily; in practice this means that after this commit, startup is less than 25ms slower, most of it spent in inflate(). This should also result in faster rendering, since there is no rampant plane switching anymore; instead, all characters that are actually used are stashed into same one texture.
2016-04-23 12:37:42 +08:00
glTexCoord2d(1.0, flip ? 1.0 : 0.0);
glVertex2d((double)pixmap.width, 0.0);
Rasterize non-ASCII glyphs in the UI. Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
2015-11-06 03:39:27 +08:00
Move bitmap font to res/fonts/; remove unifont2c. This commit integrates the bitmap font in the resource system, so that cross-compilation would be easier. The font handling code was carefully written to do glyph parsing lazily; in practice this means that after this commit, startup is less than 25ms slower, most of it spent in inflate(). This should also result in faster rendering, since there is no rampant plane switching anymore; instead, all characters that are actually used are stashed into same one texture.
2016-04-23 12:37:42 +08:00
glTexCoord2d(0.0, flip ? 1.0 : 0.0);
glVertex2d(0.0, 0.0);
glEnd();
glDisable(GL_TEXTURE_2D);
}
Rasterize non-ASCII glyphs in the UI. Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
2015-11-06 03:39:27 +08:00
Move bitmap font to res/fonts/; remove unifont2c. This commit integrates the bitmap font in the resource system, so that cross-compilation would be easier. The font handling code was carefully written to do glyph parsing lazily; in practice this means that after this commit, startup is less than 25ms slower, most of it spent in inflate(). This should also result in faster rendering, since there is no rampant plane switching anymore; instead, all characters that are actually used are stashed into same one texture.
2016-04-23 12:37:42 +08:00
//-----------------------------------------------------------------------------
// Bitmap font rendering
//-----------------------------------------------------------------------------
static BitmapFont BuiltinBitmapFont;
static void LoadBitmapFont() {
if(!BuiltinBitmapFont.IsEmpty()) return;
BuiltinBitmapFont = BitmapFont::From(LoadStringFromGzip("fonts/unifont.hex.gz"));
BuiltinBitmapFont.AddGlyph(0xE000, LoadPNG("fonts/private/0-check-false.png"));
BuiltinBitmapFont.AddGlyph(0xE001, LoadPNG("fonts/private/1-check-true.png"));
BuiltinBitmapFont.AddGlyph(0xE002, LoadPNG("fonts/private/2-radio-false.png"));
BuiltinBitmapFont.AddGlyph(0xE003, LoadPNG("fonts/private/3-radio-true.png"));
BuiltinBitmapFont.AddGlyph(0xE004, LoadPNG("fonts/private/4-stipple-dot.png"));
BuiltinBitmapFont.AddGlyph(0xE005, LoadPNG("fonts/private/5-stipple-dash-long.png"));
BuiltinBitmapFont.AddGlyph(0xE006, LoadPNG("fonts/private/6-stipple-dash.png"));
BuiltinBitmapFont.AddGlyph(0xE007, LoadPNG("fonts/private/7-stipple-zigzag.png"));
// Unifont doesn't have a glyph for U+0020.
In Pixmap and BitmapFont, use std::vector instead of std::unique_ptr. MSVC 2013 keeps having aggravating bugs where its unique_ptr implementation wants to use deleted functions. In this case the worst that could happen is one copy per entity once during initialization (which should in principle be elided anyway because a return value is a prvalue... no idea if MSVC does actually do that).
2016-05-18 18:40:56 +08:00
BuiltinBitmapFont.AddGlyph(0x20, Pixmap({ 8, 16, 8*3, false, std::vector<uint8_t>(8*16*3) }));
Rasterize non-ASCII glyphs in the UI. Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
2015-11-06 03:39:27 +08:00
}
void ssglInitializeBitmapFont()
{
Move bitmap font to res/fonts/; remove unifont2c. This commit integrates the bitmap font in the resource system, so that cross-compilation would be easier. The font handling code was carefully written to do glyph parsing lazily; in practice this means that after this commit, startup is less than 25ms slower, most of it spent in inflate(). This should also result in faster rendering, since there is no rampant plane switching anymore; instead, all characters that are actually used are stashed into same one texture.
2016-04-23 12:37:42 +08:00
LoadBitmapFont();
glBindTexture(GL_TEXTURE_2D, TEXTURE_BITMAP_FONT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA,
BitmapFont::TEXTURE_DIM, BitmapFont::TEXTURE_DIM,
In Pixmap and BitmapFont, use std::vector instead of std::unique_ptr. MSVC 2013 keeps having aggravating bugs where its unique_ptr implementation wants to use deleted functions. In this case the worst that could happen is one copy per entity once during initialization (which should in principle be elided anyway because a return value is a prvalue... no idea if MSVC does actually do that).
2016-05-18 18:40:56 +08:00
0, GL_ALPHA, GL_UNSIGNED_BYTE, &BuiltinBitmapFont.texture[0]);
Rasterize non-ASCII glyphs in the UI. Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
2015-11-06 03:39:27 +08:00
}
Move bitmap font to res/fonts/; remove unifont2c. This commit integrates the bitmap font in the resource system, so that cross-compilation would be easier. The font handling code was carefully written to do glyph parsing lazily; in practice this means that after this commit, startup is less than 25ms slower, most of it spent in inflate(). This should also result in faster rendering, since there is no rampant plane switching anymore; instead, all characters that are actually used are stashed into same one texture.
2016-04-23 12:37:42 +08:00
int ssglBitmapCharWidth(char32_t codepoint) {
if(codepoint >= 0xe000 && codepoint <= 0xefff) {
// These are special-cased because checkboxes predate support for 2 cell wide
// characters; and so all Printf() calls pad them with spaces.
return 1;
}
Use U+FFFD instead of crashing when encountering unknown characters. Also, use a nicer U+FFFD glyph in the builtin vector font.
2016-02-18 13:03:54 +08:00
Move bitmap font to res/fonts/; remove unifont2c. This commit integrates the bitmap font in the resource system, so that cross-compilation would be easier. The font handling code was carefully written to do glyph parsing lazily; in practice this means that after this commit, startup is less than 25ms slower, most of it spent in inflate(). This should also result in faster rendering, since there is no rampant plane switching anymore; instead, all characters that are actually used are stashed into same one texture.
2016-04-23 12:37:42 +08:00
LoadBitmapFont();
return BuiltinBitmapFont.GetGlyph(codepoint).advanceCells;
Rasterize non-ASCII glyphs in the UI. Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
2015-11-06 03:39:27 +08:00
}
Move bitmap font to res/fonts/; remove unifont2c. This commit integrates the bitmap font in the resource system, so that cross-compilation would be easier. The font handling code was carefully written to do glyph parsing lazily; in practice this means that after this commit, startup is less than 25ms slower, most of it spent in inflate(). This should also result in faster rendering, since there is no rampant plane switching anymore; instead, all characters that are actually used are stashed into same one texture.
2016-04-23 12:37:42 +08:00
double ssglBitmapCharQuad(char32_t codepoint, double x, double y)
Replace ugly text links to hide/show things with icons. So add code to draw those, and hit test with the mouse, and display tool tips when the user hovers with the mouse. Also, underline links only when they're hovered, and not otherwise. And add a separate menu option to align the view to the active workplane, vs. activating the active group's workplane, and remap the bottom two graphics window toolbar icons to that and "nearest iso view" instead of draw in 2d/3d, since people tended to click on those without understanding and cause trouble. And by default, we force a parallel projection; so the factory default camera tangent is now 0.3, not 0. [git-p4: depot-paths = "//depot/solvespace/": change = 2131]
2010-05-03 13:04:42 +08:00
{
Move bitmap font to res/fonts/; remove unifont2c. This commit integrates the bitmap font in the resource system, so that cross-compilation would be easier. The font handling code was carefully written to do glyph parsing lazily; in practice this means that after this commit, startup is less than 25ms slower, most of it spent in inflate(). This should also result in faster rendering, since there is no rampant plane switching anymore; instead, all characters that are actually used are stashed into same one texture.
2016-04-23 12:37:42 +08:00
double s0, t0, s1, t1;
size_t w, h;
if(BuiltinBitmapFont.LocateGlyph(codepoint, &s0, &t0, &s1, &t1, &w, &h)) {
// LocateGlyph modified the texture, reload it.
glEnd();
ssglInitializeBitmapFont();
glBegin(GL_QUADS);
}
Use U+FFFD instead of crashing when encountering unknown characters. Also, use a nicer U+FFFD glyph in the builtin vector font.
2016-02-18 13:03:54 +08:00
Move bitmap font to res/fonts/; remove unifont2c. This commit integrates the bitmap font in the resource system, so that cross-compilation would be easier. The font handling code was carefully written to do glyph parsing lazily; in practice this means that after this commit, startup is less than 25ms slower, most of it spent in inflate(). This should also result in faster rendering, since there is no rampant plane switching anymore; instead, all characters that are actually used are stashed into same one texture.
2016-04-23 12:37:42 +08:00
if(codepoint >= 0xe000 && codepoint <= 0xefff) {
Add special characters to font, to represent checkboxes and radio buttons. This requires some tools to convert .png images to that, and that I put the characters in a two-dimensional grid in the texture (since one-dimensional strip gets wider than the hardware supports). [git-p4: depot-paths = "//depot/solvespace/": change = 2138]
2010-05-09 09:20:02 +08:00
// Special character, like a checkbox or a radio button
Major UI changes, to use the checkboxes and radio buttons wherever possible. This replaces all of the color-coded links, that I liked but that were nonstandard. Also rip out the old sweep and helical sweep UI; that was disabled, but the code was still present. And fix dependencies in makefile, since textwin.cpp depends on the icons now. [git-p4: depot-paths = "//depot/solvespace/": change = 2139]
2010-05-10 02:25:23 +08:00
x -= 3;
Add special characters to font, to represent checkboxes and radio buttons. This requires some tools to convert .png images to that, and that I put the characters in a two-dimensional grid in the texture (since one-dimensional strip gets wider than the hardware supports). [git-p4: depot-paths = "//depot/solvespace/": change = 2138]
2010-05-09 09:20:02 +08:00
}
Move bitmap font to res/fonts/; remove unifont2c. This commit integrates the bitmap font in the resource system, so that cross-compilation would be easier. The font handling code was carefully written to do glyph parsing lazily; in practice this means that after this commit, startup is less than 25ms slower, most of it spent in inflate(). This should also result in faster rendering, since there is no rampant plane switching anymore; instead, all characters that are actually used are stashed into same one texture.
2016-04-23 12:37:42 +08:00
glTexCoord2d(s0, t0);
glVertex2d(x, y - h);
Initial work to move text window guts into platform-independent code. This is now drawn using gl, and the bitmap font (both there and in the graphics window) is drawn from a texture from a static table, not from the Win32 functions, since that's ~1000x faster. So this adds a tool to generate that table. With luck that will also fix my font issues under WINE, which won't have to render the TTF itself. Still needs some cleanup, and to make all the cosmetic improvements that I want. [git-p4: depot-paths = "//depot/solvespace/": change = 2130]
2010-04-26 15:52:49 +08:00
Move bitmap font to res/fonts/; remove unifont2c. This commit integrates the bitmap font in the resource system, so that cross-compilation would be easier. The font handling code was carefully written to do glyph parsing lazily; in practice this means that after this commit, startup is less than 25ms slower, most of it spent in inflate(). This should also result in faster rendering, since there is no rampant plane switching anymore; instead, all characters that are actually used are stashed into same one texture.
2016-04-23 12:37:42 +08:00
glTexCoord2d(s0, t1);
glVertex2d(x, y);
Rasterize non-ASCII glyphs in the UI. Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
2015-11-06 03:39:27 +08:00
Move bitmap font to res/fonts/; remove unifont2c. This commit integrates the bitmap font in the resource system, so that cross-compilation would be easier. The font handling code was carefully written to do glyph parsing lazily; in practice this means that after this commit, startup is less than 25ms slower, most of it spent in inflate(). This should also result in faster rendering, since there is no rampant plane switching anymore; instead, all characters that are actually used are stashed into same one texture.
2016-04-23 12:37:42 +08:00
glTexCoord2d(s1, t1);
glVertex2d(x + w, y);
Initial work to move text window guts into platform-independent code. This is now drawn using gl, and the bitmap font (both there and in the graphics window) is drawn from a texture from a static table, not from the Win32 functions, since that's ~1000x faster. So this adds a tool to generate that table. With luck that will also fix my font issues under WINE, which won't have to render the TTF itself. Still needs some cleanup, and to make all the cosmetic improvements that I want. [git-p4: depot-paths = "//depot/solvespace/": change = 2130]
2010-04-26 15:52:49 +08:00
Move bitmap font to res/fonts/; remove unifont2c. This commit integrates the bitmap font in the resource system, so that cross-compilation would be easier. The font handling code was carefully written to do glyph parsing lazily; in practice this means that after this commit, startup is less than 25ms slower, most of it spent in inflate(). This should also result in faster rendering, since there is no rampant plane switching anymore; instead, all characters that are actually used are stashed into same one texture.
2016-04-23 12:37:42 +08:00
glTexCoord2d(s1, t0);
glVertex2d(x + w, y - h);
Initial work to move text window guts into platform-independent code. This is now drawn using gl, and the bitmap font (both there and in the graphics window) is drawn from a texture from a static table, not from the Win32 functions, since that's ~1000x faster. So this adds a tool to generate that table. With luck that will also fix my font issues under WINE, which won't have to render the TTF itself. Still needs some cleanup, and to make all the cosmetic improvements that I want. [git-p4: depot-paths = "//depot/solvespace/": change = 2130]
2010-04-26 15:52:49 +08:00
Move bitmap font to res/fonts/; remove unifont2c. This commit integrates the bitmap font in the resource system, so that cross-compilation would be easier. The font handling code was carefully written to do glyph parsing lazily; in practice this means that after this commit, startup is less than 25ms slower, most of it spent in inflate(). This should also result in faster rendering, since there is no rampant plane switching anymore; instead, all characters that are actually used are stashed into same one texture.
2016-04-23 12:37:42 +08:00
return w;
Initial work to move text window guts into platform-independent code. This is now drawn using gl, and the bitmap font (both there and in the graphics window) is drawn from a texture from a static table, not from the Win32 functions, since that's ~1000x faster. So this adds a tool to generate that table. With luck that will also fix my font issues under WINE, which won't have to render the TTF itself. Still needs some cleanup, and to make all the cosmetic improvements that I want. [git-p4: depot-paths = "//depot/solvespace/": change = 2130]
2010-04-26 15:52:49 +08:00
}
Remove extraneous instances of .c_str(). Most of these were just converting char* into std::string back and forth; some more used ReadUTF8, which was converted to use nicer STL-style iterators over UTF-8 text. The remaining ones are: * arguments to Expr::From, which we'll change when refactoring the expression lexer; * arguments to varargs functions, which we'll change when adding localization (that requires custom printf-style functions to allow for changing argument order); * arguments where only string literals are ever passed, which are OK; * in platform-specific code, which is OK.
2016-02-15 04:13:40 +08:00
void ssglBitmapText(const std::string &str, Vector p)
Replace ugly text links to hide/show things with icons. So add code to draw those, and hit test with the mouse, and display tool tips when the user hovers with the mouse. Also, underline links only when they're hovered, and not otherwise. And add a separate menu option to align the view to the active workplane, vs. activating the active group's workplane, and remap the bottom two graphics window toolbar icons to that and "nearest iso view" instead of draw in 2d/3d, since people tended to click on those without understanding and cause trouble. And by default, we force a parallel projection; so the factory default camera tangent is now 0.3, not 0. [git-p4: depot-paths = "//depot/solvespace/": change = 2131]
2010-05-03 13:04:42 +08:00
{
Initial work to move text window guts into platform-independent code. This is now drawn using gl, and the bitmap font (both there and in the graphics window) is drawn from a texture from a static table, not from the Win32 functions, since that's ~1000x faster. So this adds a tool to generate that table. With luck that will also fix my font issues under WINE, which won't have to render the TTF itself. Still needs some cleanup, and to make all the cosmetic improvements that I want. [git-p4: depot-paths = "//depot/solvespace/": change = 2130]
2010-04-26 15:52:49 +08:00
glEnable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
Move bitmap font to res/fonts/; remove unifont2c. This commit integrates the bitmap font in the resource system, so that cross-compilation would be easier. The font handling code was carefully written to do glyph parsing lazily; in practice this means that after this commit, startup is less than 25ms slower, most of it spent in inflate(). This should also result in faster rendering, since there is no rampant plane switching anymore; instead, all characters that are actually used are stashed into same one texture.
2016-04-23 12:37:42 +08:00
for(char32_t codepoint : ReadUTF8(str)) {
p.x += ssglBitmapCharQuad(codepoint, p.x, p.y);
Initial work to move text window guts into platform-independent code. This is now drawn using gl, and the bitmap font (both there and in the graphics window) is drawn from a texture from a static table, not from the Win32 functions, since that's ~1000x faster. So this adds a tool to generate that table. With luck that will also fix my font issues under WINE, which won't have to render the TTF itself. Still needs some cleanup, and to make all the cosmetic improvements that I want. [git-p4: depot-paths = "//depot/solvespace/": change = 2130]
2010-04-26 15:52:49 +08:00
}
glEnd();
glDisable(GL_TEXTURE_2D);
}
Move vector font to res/fonts/; remove lff2c. This commit integrates the vector font in the resource system, so that cross-compilation would be easier and a custom font could be used without recompilation. The font handling code was carefully written to lazily load glyphs; as possible; in practice this means that startup is less than 15ms slower after this commit, most of it spent in inflate(). This also reduces executable size and makes compilation of glhelper.cpp much faster.
2016-04-25 06:35:23 +08:00
//-----------------------------------------------------------------------------
// Bitmap font rendering
//-----------------------------------------------------------------------------
static VectorFont BuiltinVectorFont;
static void LoadVectorFont() {
if(!BuiltinVectorFont.IsEmpty()) return;
BuiltinVectorFont = VectorFont::From(LoadStringFromGzip("fonts/unicode.lff.gz"));
}
// Internally and in the UI, the vector font is sized using cap height.
#define FONT_SCALE(h) ((h)/(double)BuiltinVectorFont.capHeight)
double ssglStrCapHeight(double h)
{
return BuiltinVectorFont.capHeight *
FONT_SCALE(h) / SS.GW.scale;
}
double ssglStrFontSize(double h)
{
return (BuiltinVectorFont.ascender - BuiltinVectorFont.descender) *
FONT_SCALE(h) / SS.GW.scale;
}
double ssglStrWidth(const std::string &str, double h)
{
LoadVectorFont();
Enable -Wfloat-conversion on Clang. This is a high-SNR warning that's enabled by default on MSVC and it has highlighted some bugs in glhelper.cpp (that are also fixed in this commit). Unfortunately GCC does not have an equivalent for that warning, and -Wconversion is very noisy.
2016-05-18 17:40:50 +08:00
double width = 0;
Move vector font to res/fonts/; remove lff2c. This commit integrates the vector font in the resource system, so that cross-compilation would be easier and a custom font could be used without recompilation. The font handling code was carefully written to lazily load glyphs; as possible; in practice this means that startup is less than 15ms slower after this commit, most of it spent in inflate(). This also reduces executable size and makes compilation of glhelper.cpp much faster.
2016-04-25 06:35:23 +08:00
for(char32_t codepoint : ReadUTF8(str)) {
width += BuiltinVectorFont.GetGlyph(codepoint).advanceWidth;
}
return width * FONT_SCALE(h) / SS.GW.scale;
}
static Vector PixelAlign(Vector v) {
v = SS.GW.ProjectPoint3(v);
v.x = floor(v.x) + 0.5;
v.y = floor(v.y) + 0.5;
v = SS.GW.UnProjectPoint3(v);
return v;
}
Enable -Wfloat-conversion on Clang. This is a high-SNR warning that's enabled by default on MSVC and it has highlighted some bugs in glhelper.cpp (that are also fixed in this commit). Unfortunately GCC does not have an equivalent for that warning, and -Wconversion is very noisy.
2016-05-18 17:40:50 +08:00
static double DrawCharacter(const VectorFont::Glyph &glyph, Vector t, Vector o, Vector u, Vector v,
double scale, ssglLineFn *fn, void *fndata, bool gridFit) {
double advanceWidth = glyph.advanceWidth;
Move vector font to res/fonts/; remove lff2c. This commit integrates the vector font in the resource system, so that cross-compilation would be easier and a custom font could be used without recompilation. The font handling code was carefully written to lazily load glyphs; as possible; in practice this means that startup is less than 15ms slower after this commit, most of it spent in inflate(). This also reduces executable size and makes compilation of glhelper.cpp much faster.
2016-04-25 06:35:23 +08:00
Enable -Wfloat-conversion on Clang. This is a high-SNR warning that's enabled by default on MSVC and it has highlighted some bugs in glhelper.cpp (that are also fixed in this commit). Unfortunately GCC does not have an equivalent for that warning, and -Wconversion is very noisy.
2016-05-18 17:40:50 +08:00
double actualWidth, offsetX;
Move vector font to res/fonts/; remove lff2c. This commit integrates the vector font in the resource system, so that cross-compilation would be easier and a custom font could be used without recompilation. The font handling code was carefully written to lazily load glyphs; as possible; in practice this means that startup is less than 15ms slower after this commit, most of it spent in inflate(). This also reduces executable size and makes compilation of glhelper.cpp much faster.
2016-04-25 06:35:23 +08:00
if(gridFit) {
o.x += glyph.leftSideBearing;
offsetX = glyph.leftSideBearing;
actualWidth = glyph.boundingWidth;
if(actualWidth == 0) {
// Dot, "i", etc.
actualWidth = 1;
}
} else {
offsetX = 0;
actualWidth = advanceWidth;
}
Vector tt = t;
tt = tt.Plus(u.ScaledBy(o.x * scale));
tt = tt.Plus(v.ScaledBy(o.y * scale));
Vector tu = tt;
tu = tu.Plus(u.ScaledBy(actualWidth * scale));
Vector tv = tt;
tv = tv.Plus(v.ScaledBy(BuiltinVectorFont.capHeight * scale));
if(gridFit) {
tt = PixelAlign(tt);
tu = PixelAlign(tu);
tv = PixelAlign(tv);
}
tu = tu.Minus(tt).ScaledBy(1.0 / actualWidth);
tv = tv.Minus(tt).ScaledBy(1.0 / BuiltinVectorFont.capHeight);
for(const VectorFont::Contour &contour : glyph.contours) {
Vector prevp;
bool penUp = true;
for(const Point2d &pt : contour.points) {
Vector p = tt;
p = p.Plus(tu.ScaledBy(pt.x - offsetX));
p = p.Plus(tv.ScaledBy(pt.y));
if(!penUp) fn(fndata, prevp, p);
prevp = p;
penUp = false;
}
}
return advanceWidth;
}
void ssglWriteText(const std::string &str, double h, Vector t, Vector u, Vector v,
ssglLineFn *fn, void *fndata)
{
LoadVectorFont();
if(!fn) fn = LineDrawCallback;
u = u.WithMagnitude(1);
v = v.WithMagnitude(1);
// Perform grid-fitting only when the text is parallel to the view plane.
bool gridFit = !SS.exportMode && u.Equals(SS.GW.projRight) && v.Equals(SS.GW.projUp);
double scale = FONT_SCALE(h) / SS.GW.scale;
Vector o = {};
for(char32_t codepoint : ReadUTF8(str)) {
o.x += DrawCharacter(BuiltinVectorFont.GetGlyph(codepoint),
t, o, u, v, scale, fn, fndata, gridFit);
}
}
void ssglWriteTextRefCenter(const std::string &str, double h, Vector t, Vector u, Vector v,
ssglLineFn *fn, void *fndata)
{
LoadVectorFont();
u = u.WithMagnitude(1);
v = v.WithMagnitude(1);
double fh = ssglStrCapHeight(h);
double fw = ssglStrWidth(str, h);
t = t.Plus(u.ScaledBy(-fw/2));
t = t.Plus(v.ScaledBy(-fh/2));
ssglWriteText(str, h, t, u, v, fn, fndata);
}
Pack everything into `namespace SolveSpace`. This is required to avoid name conflicts with the Cocoa libraries on OS X. I renamed the `class SolveSpace` to `class SolveSpaceUI`, because that's what it does, and because otherwise the namespace would have to be called something else than `namespace SolveSpace`.
2015-03-24 01:49:04 +08:00
};
Reference in New Issue Copy Permalink