1 // texcoord.hxx -- routine(s) to handle texture coordinate generation
3 // Written by Curtis Olson, started March 1999.
5 // Copyright (C) 1999 Curtis L. Olson - http://www.flightgear.org/~curt
7 // This library is free software; you can redistribute it and/or
8 // modify it under the terms of the GNU Library General Public
9 // License as published by the Free Software Foundation; either
10 // version 2 of the License, or (at your option) any later version.
12 // This library is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 // Library General Public License for more details.
17 // You should have received a copy of the GNU General Public License
18 // along with this program; if not, write to the Free Software
19 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
24 /* The following is an explanation of our somewhat conveluted and
25 tricky texture scaling/offset scheme:
27 MAX_TEX_COORD is a value I arrived at by trial and error for my
28 voodoo2/3 video card. If you use texture coordinates that are too
29 big, you quickly start getting into round off problems and the texture
30 jumps and moves relative to the polygon.
32 The point of all of this code is that I wanted to be able to define
33 this size in meters of a texture and have it be applied seamlessly to
34 the terrain. I wanted to be able to change the defined size (in
35 meters) of textures at run time. In other words I want to be able to
36 scale the textures at run time and still have them seamlessly tile
39 The problem is that I have to pregenerate all the texture coordinates
40 when I create the scenery, and I didn't want to burn CPU doing this
41 again when I load the scenery at run time.
43 It ended up taking me a lot of thought, a lot of trial and error, and
44 a lot of fiddling around to come up with a scheme that worked.
48 Ok, so think about what needs to be done to have the texture tile
49 across a series of triangles and fans ...
51 Basically you want to use some function of lon/lat mod your max
52 texture coordinate size to calculate the texture coordinate of each
53 vertex. This should result in nice tiling across distinct triangles
56 Pretend our MAX_TEX_COORD = 4.0 and half of this is 2.0
58 Imagine the following two adjacent polygons with the "X" component of
59 the initial texture coordinate based on longitude (Note they are drawn
60 spaced apart, but in reality the two polygons are adjacent):
66 Now, this exceeds our MAX_TEX_COORD of 4.0 so we have to scale these
67 texture coordinates by some integer value. Let's say we always want
68 to minimize the tex coordinates to minimize rounding error so we will
69 offset the first polygon by 7.0 and the second by 8.0:
71 0.0 --- 1.6 and 0.6 --- 1.0
73 Our tiling is maintianed becuase the coordinates are continous (mod
74 1.0) and we still get the double repeat across both polygons.
76 We want to be able to scale these values by an arbitrary constant and
77 still have proper tiling.
79 Let's try doubling the coordinates:
81 0.0 --- 3.2 and 1.2 --- 2.0
83 Everything still tiles nicely (because the coordinates are continuous
84 mod 1.0) and the texture is now repeated 4x across the two polygons.
85 Before it was repeated 2x.
87 Let's try halving the coordinates:
89 0.0 --- 0.8 and 0.3 --- 0.5
91 Ooop! We lost continuity in texture coordinate space ... no we will
92 have a visual discontinuity in the texture tiling!
94 Ok, so we need some other scheme to keep our texture coordinates
95 smaller than MAX_TEX_COORD that preserves continuity in texture
96 space. <Deep breath> let's try the scheme that I have coded up that
97 you are asking about ... <fingers crossed> :-)
99 Going way back to the top before we shifted the texture coordinates.
100 tmin for the first polygon is 7.0, this is then adjusted to:
102 (int)(tmin.x() / HALF_MAX_TEX_COORD) ) * HALF_MAX_TEX_COORD
104 = (int)(7.0/2.0) * 2.0 = 3.0 * 2.0 = 6.0
106 The two texture coordinates are offset by 6.0 which yields 1.0 -- 2.6
108 tmin for the second polygon is 8.6 which is adjusted to:
110 (int)(tmin.x() / HALF_MAX_TEX_COORD) ) * HALF_MAX_TEX_COORD
111 = (int)( 8.6 / 2.0 ) * 2.0 = 4.0 * 2.0 = 8.0
113 The offset for the second polygon is 8.0 which yields 0.6 --- 1.0
117 1.0 --- 2.6 and 0.6 --- 1.0
119 This still tiles nicely and strethes our texture across completely, so
120 far we haven't done any damage.
122 Now let's double the coordinates:
124 2.0 --- 5.2 and 1.2 --- 2.0
126 The texture is repeated 4x as it should be and is still continuous.
128 How about halfing the coordinates. This is where the first scheme
129 broke down. Halving the coordinates yields
131 0.5 --- 1.3 and 0.3 --- 0.5
133 Woohoo, we still have texture space continuity (mod 1.0) and the
134 texture is repeated 1x.
136 Note, it took me almost as long to re-figure this out and write this
137 explanation as it did to figure out the scheme originally. I better
138 enter this in the official comments in case I forget again. :-)
143 # include <simgear_config.h>
146 #include <simgear/compiler.h>
148 // #include <iostream>
150 #include "texcoord.hxx"
156 #define FG_STANDARD_TEXTURE_DIMENSION 1000.0 // meters
157 #define MAX_TEX_COORD 8.0
158 #define HALF_MAX_TEX_COORD ( MAX_TEX_COORD * 0.5 )
161 // return the basic unshifted/unmoded texture coordinate for a lat/lon
162 static inline SGVec2f basic_tex_coord( const SGGeod& p,
164 double degree_height,
167 return SGVec2f( p.getLongitudeDeg() * ( degree_width * scale /
168 FG_STANDARD_TEXTURE_DIMENSION ),
169 p.getLatitudeDeg() * ( degree_height * scale /
170 FG_STANDARD_TEXTURE_DIMENSION )
175 // traverse the specified fan/strip/list of vertices and attempt to
176 // calculate "none stretching" texture coordinates
177 std::vector<SGVec2f> sgCalcTexCoords( const SGBucket& b, const std::vector<SGGeod>& geod_nodes,
178 const int_list& fan, double scale )
180 return sgCalcTexCoords(b.get_center_lat(), geod_nodes, fan, scale);
183 std::vector<SGVec2f> sgCalcTexCoords( double centerLat, const std::vector<SGGeod>& geod_nodes,
184 const int_list& fan, double scale )
186 // cout << "calculating texture coordinates for a specific fan of size = "
187 // << fan.size() << endl;
189 // calculate perimeter based on center of this degree (not center
191 double clat = (int)centerLat;
193 clat = (int)clat + 0.5;
195 clat = (int)clat - 0.5;
198 double clat_rad = clat * SGD_DEGREES_TO_RADIANS;
199 double cos_lat = cos( clat_rad );
200 double local_radius = cos_lat * SG_EQUATORIAL_RADIUS_M;
201 double local_perimeter = local_radius * SGD_2PI;
202 double degree_width = local_perimeter / 360.0;
204 // cout << "clat = " << clat << endl;
205 // cout << "clat (radians) = " << clat_rad << endl;
206 // cout << "cos(lat) = " << cos_lat << endl;
207 // cout << "local_radius = " << local_radius << endl;
208 // cout << "local_perimeter = " << local_perimeter << endl;
209 // cout << "degree_width = " << degree_width << endl;
211 double perimeter = SG_EQUATORIAL_RADIUS_M * SGD_2PI;
212 double degree_height = perimeter / 360.0;
213 // cout << "degree_height = " << degree_height << endl;
215 // find min/max of fan
216 SGVec2f tmin(0.0, 0.0);
217 SGVec2f tmax(0.0, 0.0);
222 for ( i = 0; i < (int)fan.size(); ++i ) {
223 SGGeod p = geod_nodes[ fan[i] ];
224 // cout << "point p = " << p << endl;
226 SGVec2f t = basic_tex_coord( p, degree_width, degree_height, scale );
227 // cout << "basic_tex_coord = " << t << endl;
233 if ( t.x() < tmin.x() ) {
236 if ( t.y() < tmin.y() ) {
239 if ( t.x() > tmax.x() ) {
242 if ( t.y() > tmax.y() ) {
248 double dx = fabs( tmax.x() - tmin.x() );
249 double dy = fabs( tmax.y() - tmin.y() );
250 // cout << "dx = " << dx << " dy = " << dy << endl;
252 // Point3D mod_shift;
253 if ( (dx > HALF_MAX_TEX_COORD) || (dy > HALF_MAX_TEX_COORD) ) {
254 // structure is too big, we'll just have to shift it so that
255 // tmin = (0,0). This messes up subsequent texture scaling,
256 // but is the best we can do.
257 // cout << "SHIFTING" << endl;
258 if ( tmin.x() < 0 ) {
259 tmin.x() = (double)( (int)tmin.x() - 1 ) ;
261 tmin.x() = (int)tmin.x();
264 if ( tmin.y() < 0 ) {
265 tmin.y() = (double)( (int)tmin.y() - 1 );
267 tmin.y() = (int)tmin.y();
269 // cout << "found tmin = " << tmin << endl;
271 if ( tmin.x() < 0 ) {
272 tmin.x() = ( (int)(tmin.x() / HALF_MAX_TEX_COORD) - 1 )
273 * HALF_MAX_TEX_COORD ;
275 tmin.x() = ( (int)(tmin.x() / HALF_MAX_TEX_COORD) )
276 * HALF_MAX_TEX_COORD ;
278 if ( tmin.y() < 0 ) {
279 tmin.y() = ( (int)(tmin.y() / HALF_MAX_TEX_COORD) - 1 )
280 * HALF_MAX_TEX_COORD ;
282 tmin.y() = ( (int)(tmin.y() / HALF_MAX_TEX_COORD) )
283 * HALF_MAX_TEX_COORD ;
286 // structure is small enough ... we can mod it so we can
287 // properly scale the texture coordinates later.
288 // cout << "MODDING" << endl;
289 double x1 = fmod(tmin.x(), MAX_TEX_COORD);
290 while ( x1 < 0 ) { x1 += MAX_TEX_COORD; }
292 double y1 = fmod(tmin.y(), MAX_TEX_COORD);
293 while ( y1 < 0 ) { y1 += MAX_TEX_COORD; }
295 double x2 = fmod(tmax.x(), MAX_TEX_COORD);
296 while ( x2 < 0 ) { x2 += MAX_TEX_COORD; }
298 double y2 = fmod(tmax.y(), MAX_TEX_COORD);
299 while ( y2 < 0 ) { y2 += MAX_TEX_COORD; }
301 // At this point we know that the object is < 16 wide in
302 // texture coordinate space. If the modulo of the tmin is >
303 // the mod of the tmax at this point, then we know that the
304 // starting tex coordinate for the tmax > 16 so we can shift
305 // everything down by 16 and get it within the 0-32 range.
308 mod_shift.setx( HALF_MAX_TEX_COORD );
310 mod_shift.setx( 0.0 );
314 mod_shift.sety( HALF_MAX_TEX_COORD );
316 mod_shift.sety( 0.0 );
319 // cout << "mod_shift = " << mod_shift << endl;
324 std::vector<SGVec2f> tex;
326 for ( i = 0; i < (int)fan.size(); ++i ) {
327 SGGeod p = geod_nodes[ fan[i] ];
328 SGVec2f t = basic_tex_coord( p, degree_width, degree_height, scale );
329 // cout << "second t = " << t << endl;
331 adjusted_t = t - tmin;
334 adjusted_t.setx( fmod(t.x() + mod_shift.x(), MAX_TEX_COORD) );
335 while ( adjusted_t.x() < 0 ) {
336 adjusted_t.setx( adjusted_t.x() + MAX_TEX_COORD );
338 adjusted_t.sety( fmod(t.y() + mod_shift.y(), MAX_TEX_COORD) );
339 while ( adjusted_t.y() < 0 ) {
340 adjusted_t.sety( adjusted_t.y() + MAX_TEX_COORD );
342 // cout << "adjusted_t " << adjusted_t << endl;
345 if ( adjusted_t.x() < SG_EPSILON ) {
346 adjusted_t.x() = 0.0;
348 if ( adjusted_t.y() < SG_EPSILON ) {
349 adjusted_t.y() = 0.0;
352 // cout << "adjusted_t = " << adjusted_t << endl;
354 tex.push_back( adjusted_t );