Panda3D

Loading...
Searching...
No Matches
freetypeFont.I
Go to the documentation of this file.
1/**
2 * PANDA 3D SOFTWARE
3 * Copyright (c) Carnegie Mellon University. All rights reserved.
4 *
5 * All use of this software is subject to the terms of the revised BSD
6 * license. You should have received a copy of this license along
7 * with this source code in a file named "LICENSE."
8 *
9 * @file freetypeFont.I
10 * @author drose
11 * @date 2003-09-07
12 */
13
14/**
15 *
16 */
17INLINE FreetypeFont::
18~FreetypeFont() {
19 unload_font();
20}
21
22/**
23 * Sets the point size of the font. This controls the apparent size of the
24 * font onscreen. By convention, a 10 point font is about 1 screen unit high.
25 *
26 * This should only be called before any characters have been requested out of
27 * the font, or immediately after calling clear().
28 */
29INLINE bool FreetypeFont::
30set_point_size(PN_stdfloat point_size) {
31 _point_size = point_size;
32 return reset_scale();
33}
34
35/**
36 * Returns the point size of the font.
37 */
38INLINE PN_stdfloat FreetypeFont::
39get_point_size() const {
40 return _point_size;
41}
42
43/**
44 * Set the resolution of the texture map, and hence the clarity of the
45 * resulting font. This sets the number of pixels in the texture map that are
46 * used for each onscreen unit.
47 *
48 * Setting this number larger results in an easier to read font, but at the
49 * cost of more texture memory.
50 *
51 * This should only be called before any characters have been requested out of
52 * the font, or immediately after calling clear().
53 */
54INLINE bool FreetypeFont::
55set_pixels_per_unit(PN_stdfloat pixels_per_unit) {
56 _requested_pixels_per_unit = pixels_per_unit;
57 return reset_scale();
58}
59
60/**
61 * Returns the resolution of the texture map. See set_pixels_per_unit().
62 */
63INLINE PN_stdfloat FreetypeFont::
64get_pixels_per_unit() const {
65 return _tex_pixels_per_unit;
66}
67
68/**
69 * Computes the appropriate pixels_per_unit value to set the size of the font
70 * in the texture to the indicated number of pixels. This is just another way
71 * to specify pixels_per_unit().
72 */
73INLINE bool FreetypeFont::
74set_pixel_size(PN_stdfloat pixel_size) {
75 return set_pixels_per_unit(pixel_size * _points_per_unit / _point_size);
76}
77
78/**
79 * Returns the size of the font in pixels, as it appears in the texture.
80 */
81INLINE PN_stdfloat FreetypeFont::
82get_pixel_size() const {
83 return _tex_pixels_per_unit * _point_size / _points_per_unit;
84}
85
86/**
87 * Sets the factor by which the font is rendered larger by the FreeType
88 * library before being filtered down to its actual size in the texture as
89 * specified by set_pixels_per_unit(). This may be set to a number larger
90 * than 1.0 to improve the font's antialiasing (since FreeType doesn't really
91 * do a swell job of antialiasing by itself). There is some performance
92 * implication for setting this different than 1.0.
93 *
94 * This should only be called before any characters have been requested out of
95 * the font, or immediately after calling clear().
96 */
97INLINE bool FreetypeFont::
98set_scale_factor(PN_stdfloat scale_factor) {
99 _requested_scale_factor = scale_factor;
100 return reset_scale();
101}
102
103/**
104 * Returns the antialiasing scale factor. See set_scale_factor().
105 */
106INLINE PN_stdfloat FreetypeFont::
107get_scale_factor() const {
108 return _scale_factor;
109}
110
111/**
112 * Sets whether the Freetype library's built-in antialias mode is enabled.
113 * There are two unrelated ways to achieve antialiasing: with Freetype's
114 * native antialias mode, and with the use of a scale_factor greater than one.
115 * By default, both modes are enabled.
116 *
117 * At low resolutions, some fonts may do better with one mode or the other.
118 * In general, Freetype's native antialiasing will produce less blurry
119 * results, but may introduce more artifacts.
120 */
121INLINE void FreetypeFont::
122set_native_antialias(bool native_antialias) {
123 _native_antialias = native_antialias;
124}
125
126/**
127 * Returns whether Freetype's built-in antialias mode is enabled. See
128 * set_native_antialias().
129 */
130INLINE bool FreetypeFont::
131get_native_antialias() const {
132 return _native_antialias;
133}
134
135/**
136 * This is used to report whether the requested pixel size is being only
137 * approximated by a fixed-pixel-size font. This returns 0 in the normal
138 * case, in which a scalable font is used, or the fixed-pixel-size font has
139 * exactly the requested pixel size.
140 *
141 * If this returns non-zero, it is the pixel size of the font that we are
142 * using to approximate our desired size.
143 */
144INLINE int FreetypeFont::
145get_font_pixel_size() const {
146 return _pixel_height;
147}
148
149/**
150 * Returns the number of units high each line of text is.
151 */
152INLINE PN_stdfloat FreetypeFont::
153get_line_height() const {
154 return _line_height;
155}
156
157/**
158 * Returns the number of units wide a space is.
159 */
160INLINE PN_stdfloat FreetypeFont::
161get_space_advance() const {
162 return _space_advance;
163}
164
165/**
166 * Returns the point size of the font that is one Panda unit high. This is an
167 * arbitrary Panda convention for text, and is set to 10.0.
168 */
169INLINE PN_stdfloat FreetypeFont::
170get_points_per_unit() {
171 return _points_per_unit;
172}
173
174/**
175 * Returns the number of points in one inch. This is a universal typographic
176 * convention.
177 */
178INLINE PN_stdfloat FreetypeFont::
179get_points_per_inch() {
180 return _points_per_inch;
181}
182
183/**
184 * Specifies an explicitly winding order on this particular font. This is
185 * only necessary if the render_mode is RM_polygon or RM_solid, and only if
186 * FreeType appears to guess wrong on this font. Normally, you should leave
187 * this at WO_default.
188 */
189INLINE void FreetypeFont::
190set_winding_order(WindingOrder winding_order) {
191 _winding_order = winding_order;
192}
193
194/**
195 * Returns the winding order set via set_winding_order().
196 */
197INLINE FreetypeFont::WindingOrder FreetypeFont::
198get_winding_order() const {
199 return _winding_order;
200}
201
202/**
203 * Retrieves the internal freetype face, and also acquires the lock.
204 *
205 * You must call release_face() when you are done using it, to release the
206 * lock.
207 */
208INLINE FT_Face FreetypeFont::
209acquire_face() const {
210 nassertr(_face != nullptr, nullptr);
211 return _face->acquire_face(_char_size, _dpi, _pixel_width, _pixel_height);
212}
213
214/**
215 * Releases the lock acquired by a previous call to acquire_face(), and allows
216 * another thread to use the face.
217 */
218INLINE void FreetypeFont::
219release_face(FT_Face face) const {
220 nassertv(_face != nullptr);
221 _face->release_face(face);
222}
223
224/**
225 *
226 */
227INLINE FreetypeFont::ContourPoint::
228ContourPoint(const LPoint2 &p, const LVector2 &in, const LVector2 &out) :
229 _p(p), _in(in), _out(out), _radius(0)
230{
231}
232
233/**
234 *
235 */
236INLINE FreetypeFont::ContourPoint::
237ContourPoint(PN_stdfloat px, PN_stdfloat py, PN_stdfloat tx, PN_stdfloat ty) :
238 _p(px, py), _in(tx, ty), _out(tx, ty), _radius(0)
239{
240}
241
242/**
243 * Connects the indicated point to the next point, whose tangent is given.
244 * The given tangent becomes the out tangent at this point. If the in tangent
245 * and out tangent are sufficiently close, they will be smoothed together.
246 */
247INLINE void FreetypeFont::ContourPoint::
248connect_to(const LVector2 &out) {
249 _out = out;
250 if (_in.dot(_out) > 0.7071) {
251 // Less than 45 degrees of difference: smooth them.
252 LVector2 av = (_in + _out) * 0.5f;
253 av.normalize();
254 _in = av;
255 _out = av;
256 }
257}