|
NCBI Home IEB Home C Toolkit docs C++ Toolkit source browser C Toolkit source browser (2) |
NCBI C Toolkit Cross ReferenceC/vibrant/prim3d4.c |
source navigation diff markup identifier search freetext search file search |
1 /* prim3d4.c
2 * ===========================================================================
3 *
4 * PUBLIC DOMAIN NOTICE
5 * National Center for Biotechnology Information (NCBI)
6 *
7 * This software/database is a "United States Government Work" under the
8 * terms of the United States Copyright Act. It was written as part of
9 * the author's official duties as a United States Government employee and
10 * thus cannot be copyrighted. This software/database is freely available
11 * to the public for use. The National Library of Medicine and the U.S.
12 * Government do not place any restriction on its use or reproduction.
13 * We would, however, appreciate having the NCBI and the author cited in
14 * any work or product based on this material
15 *
16 * Although all reasonable efforts have been taken to ensure the accuracy
17 * and reliability of the software and data, the NLM and the U.S.
18 * Government do not and cannot warrant the performance or results that
19 * may be obtained by using this software or data. The NLM and the U.S.
20 * Government disclaim all warranties, express or implied, including
21 * warranties of performance, merchantability or fitness for any particular
22 * purpose.
23 *
24 * ===========================================================================
25 *
26 * File Name: prim3d4.c
27 *
28 * Author: Alex Smirnov
29 *
30 * Version Creation Date: 04/03/95
31 *
32 * $Revision: 6.3 $
33 *
34 * File Description:
35 *
36 * Modifications:
37 * --------------------------------------------------------------------------
38 * Date Name Description of modification
39 * ------- ---------- -----------------------------------------------------
40 *
41 *
42 * ==========================================================================
43 */
44
45 #ifndef _VIBRANT_
46 #include <vibrant.h>
47 #endif
48
49 #ifndef _PPICT3D_
50 #include <ppict3d.h>
51 #endif
52
53 #ifndef _PDIAGNOS_
54 #include <pdiagnos.h>
55 #endif
56
57 /*****************************************************************************
58 *
59 * DEFINES
60 *
61 *****************************************************************************/
62 #define SETPIXEL(zptr,imageptr,z,color) \
63 if((Uint2)z>=*((Uint2Ptr)zptr)) \
64 {*((Uint2Ptr)zptr)=(Uint2)z;*((Uint1Ptr)imageptr)=(Uint1)color;}
65
66 #define SETPIXELID(zptr,imageptr,z,curID) \
67 if((Uint2)z>=*((Uint2Ptr)zptr)) \
68 {*((Uint2Ptr)zptr)=(Uint2)z;*((VoidPtr*)imageptr)=curID;}
69
70 /*****************************************************************************
71 *
72 * TYPEDEFS
73 *
74 *****************************************************************************/
75
76 /*****************************************************************************
77 *
78 * GLOBAL VARIABLE
79 *
80 *****************************************************************************/
81 extern Nlm_Context3D Nlm_stCon;
82
83 /*****************************************************************************
84 *
85 * STATIC VARIABLE
86 *
87 *****************************************************************************/
88 static CharPtr Pict3Dclass = "Picture3D";
89 static Char *vectFont[95] = {
90 /* 32 ' ' */ "",
91 /* 33 '!' */ "ChdhdicichCkdkewbwck",
92 /* 34 '"' */ "CvbvbwcwcubtFvevewfwfuet",
93 /* 35 '#' */ "AlmlAqmqDidtJijt",
94 /* 36 '$' */ "AjcihijjkljnhodobparbtduiuktFgfw",
95 /* 37 '%' */ "AgmwIhlhmimllmimhlhiihCqfqgrgufvcvbubrcq",
96 /* 38 '&' */ "Kgihbsbtcvewfwgugsfqboamakbichegfghhkk",
97 /* 39 ''' */ "Evdvdweweucs",
98 /* 40 '(' */ "Egchbiakasbucvew",
99 /* 41 ')' */ "Agchdiekesducvaw",
100 /* 42 '*' */ "AplpCkjuCujk",
101 /* 43 '+' */ "CokoGkgs",
102 /* 44 ',' */ "Dgcgchdhdgdfce",
103 /* 45 '-' */ "Coko",
104 /* 46 '.' */ "Ggfgfhghgg",
105 /* 47 '/' */ "Agmw",
106 /* 48 '0' */ "EwcvbtbjchegigkhljltkviwewChkv",
107 /* 49 '1' */ "DtgwggDgjg",
108 /* 50 '2' */ "Kgagaibkhojpkrktjvhwdwbvat",
109 /* 51 '3' */ "AtbvdwhwjvktkrjphoeoHojnklkjjhhgdgbhaj",
110 /* 52 '4' */ "Klalhwhg",
111 /* 53 '5' */ "Kwawaocphpjokmkjjhhgcgah",
112 /* 54 '6' */ "Jvhwdwbvatajbhdghgjhkjkmjohpdpboan",
113 /* 55 '7' */ "Awkwdg",
114 /* 56 '8' */ "DwbvatarbpdohojpkrktjvhwdwDobnalajbhdghgjhkjkljnho",
115 /* 57 '9' */ "Bhdghgjhkjktjvhwdwbvataqbodnhnjokq",
116 /* 58 ':' */ "GififjgjgiGpfpfqgqgp",
117 /* 59 ';' */ "DicicjdjdidhcgCpdpdqcqcp",
118 /* 60 '<' */ "Lgbolw",
119 /* 61 '=' */ "AsisAnjn",
120 /* 62 '>' */ "Bglobw",
121 /* 63 '?' */ "ArasbucvewgwivjuktkrjphognflfjFhfgggghfh",
122 /* 64 '@' */ "Knjlhkflenepfrhsjrkqkkljmjnkomosnumvkwewcvbuasakbichegkg",
123 /* 65 'A' */ "AgcmhwmmogCmmm",
124 /* 66 'B' */ "AgigkhlimklmkniokplqmslukviwawBwbgboio",
125 /* 67 'C' */ "Milhjgegchbiakasbucvewjwlvmu",
126 /* 68 'D' */ "AgigkhlimkmslukviwawBwbg",
127 /* 69 'E' */ "KwawagkgAoho",
128 /* 70 'F' */ "KwawagAoho",
129 /* 71 'G' */ "MilhjgegchbiakasbucvewjwlvmuMgmmHmom",
130 /* 72 'H' */ "AgawKgkwAoko",
131 /* 73 'I' */ "AgggAwgwDgdw",
132 /* 74 'J' */ "AmakbichegghhiikiwDwnw",
133 /* 75 'K' */ "AgawAmkwCokg",
134 /* 76 'L' */ "Kgagaw",
135 /* 77 'M' */ "Agawhmowog",
136 /* 78 'N' */ "Agawmgmw",
137 /* 79 'O' */ "Akbichegigkhlimkmslukviwewcvbuasak",
138 /* 80 'P' */ "Agawiwkvlumsmrlpkoinan",
139 /* 81 'Q' */ "AkbichegigkhlimkmslukviwewcvbuasakHlmg",
140 /* 82 'R' */ "AgawiwkvlumsmrlpkoinanInmg",
141 /* 83 'S' */ "Ajchegigkhlimklmkncpbqasbucvewiwkvmt",
142 /* 84 'T' */ "HghwAwow",
143 /* 85 'U' */ "Awakbichegigkhlimkmw",
144 /* 86 'V' */ "Awggmw",
145 /* 87 'W' */ "Aweghokgow",
146 /* 88 'X' */ "AwkgAgkw",
147 /* 89 'Y' */ "AwfokwFgfo",
148 /* 90 'Z' */ "Awkwagkg",
149 /* 91 '[' */ "Igdgdwiw",
150 /* 92 '\' */ "Awmg",
151 /* 93 ']' */ "Dgigiwdw",
152 /* 94 '^' */ "Cqgwkq",
153 /* 95 '_' */ "Bglg",
154 /* 96 '`' */ "Cvdvdwcwcues",
155 /* 97 'a' */ "BqdrirjqkokhlgKhigdgbhajbldmimkk",
156 /* 98 'b' */ "BichegggihjikkkmjoipgqeqcpboAwbwbgag",
157 /* 99 'c' */ "Jqhrercqbpanakbicheghgjh",
158 /* 100 'd' */ "KiggegchbiakanbpcqerhrjqkoLgkgkwlw",
159 /* 101 'e' */ "Kiihggegchbiakanbpcqerhrjqkokmam",
160 /* 102 'f' */ "BgdgCgcrdtfuhtirAnfn",
161 /* 103 'g' */ "KiihggegchbiakambodphpjokmLpkpkdjbhaeacbbc",
162 /* 104 'h' */ "AwbwbgagBncpeqhqjpknkg",
163 /* 105 'i' */ "AgegCgcpbpCrcsbsbrcr",
164 /* 106 'j' */ "GshshrgrgsGphphegcebdbbcae",
165 /* 107 'k' */ "AgbgbwawBjhpIgem",
166 /* 108 'l' */ "AgegCgcubu",
167 /* 109 'm' */ "AqbqbgBncpeqfqhpiniginjplqmqoppnpg",
168 /* 110 'n' */ "AqbqbgagBncpeqhqjpknkg",
169 /* 111 'o' */ "Akbichegggihjikkkmjoipgqeqcpboamak",
170 /* 112 'p' */ "BichegggihjikkkmjoipgqeqcpboAqbqbaaa",
171 /* 113 'q' */ "KiggegchbiakanbpcqerhrjqkoLpkpkdlbna",
172 /* 114 'r' */ "AqbqbgBncpeqhqjo",
173 /* 115 's' */ "Ahcgggihjjikbmanbpdqhqjp",
174 /* 116 't' */ "AqiqEuehfghgih",
175 /* 117 'u' */ "AqakbichegggihjikkKqkglg",
176 /* 118 'v' */ "Arfgkr",
177 /* 119 'w' */ "Areghmkgor",
178 /* 120 'x' */ "ArkgAgkr",
179 /* 121 'y' */ "AqakbichegggihjikkKqkdjbhaeacbbc",
180 /* 122 'z' */ "Arkragkg",
181 /* 123 '{' */ "Egchbjblcnaocpbrbtcvew",
182 /* 124 '|' */ "Gggw",
183 /* 125 '}' */ "Agchdjdlcneocpdrdtcvaw",
184 /* 126 '~' */ "Arbtcueuftfsgrirjsku"
185 };
186
187 /*****************************************************************************
188 *
189 * FUNCTIONS
190 *
191 *****************************************************************************/
192 static void Nlm_Empty3D ( Nlm_VoidPtr p )
193 {
194 }
195
196 /*****************************************************************************
197 *
198 * TEXT
199 *
200 *****************************************************************************/
201 typedef struct Nlm_text3d {
202 Nlm_Base3D base;
203 long x,y,z;
204 long height;
205 long offset;
206 Int2 flags;
207 Int2 len;
208 Char text[1];
209 } Nlm_Text3D, PNTR Nlm_Text3DPtr;
210
211 static void Nlm_Text3DDraw ( Nlm_Text3DPtr p )
212 {
213 register long reg1;
214 register long reg2;
215 register long reg3;
216 register long reg4;
217 long x1,x2 = 0;
218 long y1,y2 = 0;
219 long dx, dy;
220 long xx1,xx2;
221 long yy1,yy2;
222 long status2;
223 long orient;
224 long endPtr;
225 long colorScale;
226 long color;
227 long offset1;
228 long offset2;
229 long ystep;
230 long zystep;
231 long x,y,z;
232 long height, width, offset;
233 long needCheck;
234 CharPtr ptr;
235 CharPtr lPtr;
236
237 reg1 = (long)p;
238
239 /* Rotate and check */
240 reg2 = ((Nlm_Text3DPtr)reg1)->x;
241 reg3 = ((Nlm_Text3DPtr)reg1)->y;
242 reg4 = ((Nlm_Text3DPtr)reg1)->z;
243 x = reg2 / Nlm_stCon.a[0][0] + reg3 / Nlm_stCon.a[0][1] +
244 reg4 / Nlm_stCon.a[0][2] + Nlm_stCon.c[0];
245 y = reg2 / Nlm_stCon.a[1][0] + reg3 / Nlm_stCon.a[1][1] +
246 reg4 / Nlm_stCon.a[1][2] + Nlm_stCon.c[1];
247 reg4 = reg2 / Nlm_stCon.a[2][0] + reg3 / Nlm_stCon.a[2][1] +
248 reg4 / Nlm_stCon.a[2][2] + Nlm_stCon.c[2];
249 z = reg4;
250 reg4 = Nlm_stCon.zmaxPersp1-reg4;
251 reg2 = ((Nlm_Text3DPtr)reg1)->height / Nlm_stCon.scale;
252 reg2 = (reg2*Nlm_stCon.zmaxPersp)/reg4;
253 height = reg2;
254 width = (reg2*15)/22;
255 reg2 = ((Nlm_Text3DPtr)reg1)->offset / Nlm_stCon.scale;
256 reg2 = (reg2*Nlm_stCon.zmaxPersp)/reg4;
257 offset = reg2;
258 switch ( ((Nlm_Text3DPtr)reg1)->flags & 0x3 ){
259 case TEXT3D_LEFT:
260 x -= offset + ((Nlm_Text3DPtr)reg1)->len*width;
261 break;
262 case TEXT3D_RIGTH:
263 x += offset;
264 break;
265 default:
266 x -= ((Nlm_Text3DPtr)reg1)->len*width/2;
267 }
268 switch ( ((Nlm_Text3DPtr)reg1)->flags & 0x30 ){
269 case TEXT3D_UPPER:
270 y += offset;
271 break;
272 case TEXT3D_LOWER:
273 y -= offset + height;
274 break;
275 default:
276 y -= height/2;
277 }
278 reg2 = Nlm_stCon.width>>1;
279 reg3 = x-reg2;
280 x = reg2 + (reg3*Nlm_stCon.zmaxPersp)/reg4;
281 reg2 = Nlm_stCon.height>>1;
282 reg3 = y-reg2;
283 y = reg2 Y_PLUS (reg3*Nlm_stCon.zmaxPersp)/reg4;
284 if ( ((Nlm_Text3DPtr)reg1)->flags & TEXT3D_FRONT ){
285 z = Nlm_stCon.zmax-1;
286 } else {
287 z = (z*Nlm_stCon.zmaxPersp)/reg4;
288 }
289 needCheck = 0;
290 reg2 = x;
291 #ifdef NEGYSCREEN
292 reg3 = y;
293 #else
294 reg3 = y-height;
295 #endif
296 if ( (reg2 > Nlm_stCon.xmax) || (reg3 > Nlm_stCon.ymax) ) return;
297 if ( (reg2 < Nlm_stCon.xmin) || (reg3 < Nlm_stCon.ymin) ) needCheck=1;
298 reg2 += width*((Nlm_Text3DPtr)reg1)->len;
299 reg3 += height;
300 if ( (reg2 < Nlm_stCon.xmin) || (reg3 < Nlm_stCon.ymin) ) return;
301 if ( (reg2 > Nlm_stCon.xmax) || (reg3 > Nlm_stCon.ymax) ) needCheck=1;
302
303 ptr = ((Nlm_Text3DPtr)reg1)->text;
304 /* Set color and colorscale */
305 color = Nlm_stCon.colorOffset +
306 ((Nlm_Text3DPtr)reg1)->base.color * Nlm_stCon.colorStep +
307 (Nlm_stCon.colorStep >> 1);
308 colorScale = Nlm_stCon.colorScale << 1;
309 color += (z<<8)/colorScale;
310 ystep = Nlm_stCon.width;
311 zystep = ystep<<1;
312
313 while ( *ptr ){
314 if ( (*ptr < 32) || (*ptr > 126) ) continue;
315 lPtr = vectFont[*ptr-32];
316 while ( *lPtr ){
317 if ( *lPtr < 'a' ){
318 x2 = x + ((long)*lPtr++ - (long)'A')*height/22;
319 y2 = y Y_PLUS ((long)*lPtr++ - (long)'a')*height/22;
320 continue;
321 }
322 x1 = x2; y1=y2;
323 x2 = x + ((long)*lPtr++ - (long)'a')*height/22;
324 y2 = y Y_PLUS ((long)*lPtr++ - (long)'a')*height/22;
325 if ( needCheck ){
326 dx = x2-x1; dy = y2-y1;
327 /* Calculate status1(reg1) and status2(reg2) */
328 reg1 = 0;
329 reg2 = 0;
330 reg3 = x1;
331 reg4 = Nlm_stCon.xmin;
332 if ( reg3 < reg4 ) reg1 = 1;
333 else if ( reg3 > Nlm_stCon.xmax ) reg1 = 2;
334 reg3 = x2;
335 if ( reg3 < reg4 ) reg2 = 1;
336 else if ( reg3 > Nlm_stCon.xmax ) reg2 = 2;
337 if ( (reg1 == reg2) && (reg1 != 0) ) continue;
338 reg3 = y1;
339 reg4 = Nlm_stCon.ymin;
340 if ( reg3 < reg4 ) reg1 += 6;
341 else if ( reg3 > Nlm_stCon.ymax ) reg1 += 3;
342 reg3 = y2;
343 if ( reg3 < reg4 ) reg2 += 6;
344 else if ( reg3 > Nlm_stCon.ymax ) reg2 += 3;
345 if ( (reg1>=6) && (reg2>=6) ) continue;
346 if ( (reg1>=3) && (reg2>=3) && (reg1<6) && (reg2<6) ) continue;
347
348 /* Save status2*/
349 status2 = reg2;
350
351 /* Calculate the first point (xx1,yy1)*/
352 switch ( reg1 ) {
353 case 0:
354 xx1 = x1; yy1=y1;
355 break;
356 case 1:
357 reg1 = x1; reg2 = Nlm_stCon.xmin;
358 reg4 = x2-reg1;
359 reg3 = y1 + dy*(reg2-reg1)/reg4;
360 yy1 = reg3;
361 xx1 = reg2;
362 break;
363 case 2:
364 reg1 = x1; reg2 = Nlm_stCon.xmax;
365 reg4 = x2-reg1;
366 reg3 = y1 + dy*(reg2-reg1)/reg4;
367 yy1 = reg3;
368 xx1 = reg2;
369 break;
370 case 3:
371 reg1 = y1; reg2 = Nlm_stCon.ymax;
372 reg4 = y2-reg1;
373 reg3 = x1 + dx*(reg2-reg1)/reg4;
374 xx1 = reg3;
375 yy1 = reg2;
376 break;
377 case 4:
378 reg1 = x1; reg2 = Nlm_stCon.xmin;
379 reg4 = x2-reg1;
380 reg3 = y1 + dy*(reg2-reg1)/reg4;
381 yy1 = reg3;
382 xx1 = reg2;
383 if ( (reg3 < Nlm_stCon.ymin) || (reg3 > Nlm_stCon.ymax) ) {
384 reg1 = y1; reg2 = Nlm_stCon.ymax;
385 reg4 = y2-reg1;
386 reg3 = x1 + dx*(reg2-reg1)/reg4;
387 xx1 = reg3;
388 yy1 = reg2;
389 }
390 break;
391 case 5:
392 reg1 = x1; reg2 = Nlm_stCon.xmax;
393 reg4 = x2-reg1;
394 reg3 = y1 + dy*(reg2-reg1)/reg4;
395 yy1 = reg3;
396 xx1 = reg2;
397 if ( (reg3 < Nlm_stCon.ymin)||(reg3 > Nlm_stCon.ymax) ) {
398 reg1 = y1; reg2 = Nlm_stCon.ymax;
399 reg4 = y2-reg1;
400 reg3 = x1 + dx*(reg2-reg1)/reg4;
401 xx1 = reg3;
402 yy1 = reg2;
403 }
404 break;
405 case 6:
406 reg1 = y1; reg2 = Nlm_stCon.ymin;
407 reg4 = y2-reg1;
408 reg3 = x1 + dx*(reg2-reg1)/reg4;
409 xx1 = reg3;
410 yy1 = reg2;
411 break;
412 case 7:
413 reg1 = x1; reg2 = Nlm_stCon.xmin;
414 reg4 = x2-reg1;
415 reg3 = y1 + dy*(reg2-reg1)/reg4;
416 yy1 = reg3;
417 xx1 = reg2;
418 if ( (reg3 < Nlm_stCon.ymin) || (reg3 > Nlm_stCon.ymax) ) {
419 reg1 = y1; reg2 = Nlm_stCon.ymin;
420 reg4 = y2-reg1;
421 reg3 = x1 + dx*(reg2-reg1)/reg4;
422 xx1 = reg3;
423 yy1 = reg2;
424 }
425 break;
426 default:
427 reg1 = x1; reg2 = Nlm_stCon.xmax;
428 reg4 = x2-reg1;
429 reg3 = y1 + dy*(reg2-reg1)/reg4;
430 yy1 = reg3;
431 xx1 = reg2;
432 if ( (reg3 < Nlm_stCon.ymin)||(reg3 > Nlm_stCon.ymax) ) {
433 reg1 = y1; reg2 = Nlm_stCon.ymin;
434 reg4 = y2-reg1;
435 reg3 = x1 + dx*(reg2-reg1)/reg4;
436 xx1 = reg3;
437 yy1 = reg2;
438 }
439 }
440
441 /* Calculate the second point (xx2,yy2)*/
442 switch ( status2 ) {
443 case 0:
444 xx2 = x2; yy2=y2;
445 break;
446 case 1:
447 reg1 = x1; reg2 = Nlm_stCon.xmin;
448 reg4 = x2-reg1;
449 yy2 = y1 + dy*(reg2-reg1)/reg4;
450 xx2 = reg2;
451 break;
452 case 2:
453 reg1 = x1; reg2 = Nlm_stCon.xmax;
454 reg4 = x2-reg1;
455 yy2 = y1 + dy*(reg2-reg1)/reg4;
456 xx2 = reg2;
457 break;
458 case 3:
459 reg1 = y1; reg2 = Nlm_stCon.ymax;
460 reg4 = y2-reg1;
461 xx2 = x1 + dx*(reg2-reg1)/reg4;
462 yy2 = reg2;
463 break;
464 case 4:
465 reg1 = x1; reg2 = Nlm_stCon.xmin;
466 reg4 = x2-reg1;
467 reg3 = y1 + dy*(reg2-reg1)/reg4;
468 yy2 = reg3;
469 xx2 = reg2;
470 if ( (reg3 < Nlm_stCon.ymin) || (reg3 > Nlm_stCon.ymax) ) {
471 reg1 = y1; reg2 = Nlm_stCon.ymax;
472 reg4 = y2-reg1;
473 reg3 = x1 + dx*(reg2-reg1)/reg4;
474 xx2 = reg3;
475 yy2 = reg2;
476 }
477 break;
478 case 5:
479 reg1 = x1; reg2 = Nlm_stCon.xmax;
480 reg4 = x2-reg1;
481 reg3 = y1 + dy*(reg2-reg1)/reg4;
482 yy2 = reg3;
483 xx2 = reg2;
484 if ( (reg3 < Nlm_stCon.ymin)||(reg3 > Nlm_stCon.ymax) ) {
485 reg1 = y1; reg2 = Nlm_stCon.ymax;
486 reg4 = y2-reg1;
487 reg3 = x1 + dx*(reg2-reg1)/reg4;
488 xx2 = reg3;
489 yy2 = reg2;
490 }
491 break;
492 case 6:
493 reg1 = y1; reg2 = Nlm_stCon.ymin;
494 reg4 = y2-reg1;
495 xx2 = x1 + dx*(reg2-reg1)/reg4;
496 yy2 = reg2;
497 break;
498 case 7:
499 reg1 = x1; reg2 = Nlm_stCon.xmin;
500 reg4 = x2-reg1;
501 reg3 = y1 + dy*(reg2-reg1)/reg4;
502 yy2 = reg3;
503 xx2 = reg2;
504 if ( (reg3 < Nlm_stCon.ymin) || (reg3 > Nlm_stCon.ymax) ) {
505 reg1 = y1; reg2 = Nlm_stCon.ymin;
506 reg4 = y2-reg1;
507 reg3 = x1 + dx*(reg2-reg1)/reg4;
508 xx2 = reg3;
509 yy2 = reg2;
510 }
511 break;
512 default:
513 reg1 = x1; reg2 = Nlm_stCon.xmax;
514 reg4 = x2-reg1;
515 reg3 = y1 + dy*(reg2-reg1)/reg4;
516 yy2 = reg3;
517 xx2 = reg2;
518 if ( (reg3 < Nlm_stCon.ymin)||(reg3 > Nlm_stCon.ymax) ) {
519 reg1 = y1; reg2 = Nlm_stCon.ymin;
520 reg4 = y2-reg1;
521 reg3 = x1 + dx*(reg2-reg1)/reg4;
522 xx2 = reg3;
523 yy2 = reg2;
524 }
525 }
526 } else {
527 xx1 = x1; yy1=y1;
528 xx2 = x2; yy2=y2;
529 }
530
531 reg3 = xx1;
532 reg4 = xx2;
533 if ( reg3 < reg4 ) {
534 if ( (reg3 < Nlm_stCon.xmin)||(reg4 > Nlm_stCon.xmax) ) continue;
535 reg1 = 0;
536 } else {
537 if ( (reg4 < Nlm_stCon.xmin)||(reg3 > Nlm_stCon.xmax) ) continue;
538 reg1 = 1;
539 }
540 reg3 = yy1;
541 reg4 = yy2;
542 if ( reg3 < reg4 ) {
543 if ( (reg3 < Nlm_stCon.ymin)||(reg4 > Nlm_stCon.ymax) ) continue;
544 } else {
545 if ( (reg4 < Nlm_stCon.ymin)||(reg3 > Nlm_stCon.ymax) ) continue;
546 reg1 |= 0x2;
547 }
548 orient = reg1;
549
550 /* Calculate offsets and pointers */
551 reg1 = yy1 * Nlm_stCon.width + xx1;
552 offset1 = reg1;
553 reg3 = (long)(Nlm_stCon.image + reg1);
554 reg2 = yy2 * Nlm_stCon.width + xx2;
555 offset2 = reg2;
556 reg4 = (long)(Nlm_stCon.image + reg2);
557 if ( reg3 == reg4 ){
558 reg2 = (long)(Nlm_stCon.zBuffer + reg1);
559 SETPIXEL ( reg2, reg3, z, color );
560 continue;
561 }
562 /* reg3 - statrt reg4 - end */
563
564 /* Will be:
565 reg1 - last orientation
566 reg3 - start
567 reg4 - zPtr
568 endPtr saved in endPtr */
569 reg1 = orient;
570 switch ( reg1 ){
571 case 0:
572 dy = yy2 - yy1;
573 reg2 = xx2 - xx1;
574 dx = reg2;
575 if ( reg2<=dy ) {
576 reg1 = 2;
577 }
578 endPtr = reg4;
579 reg4 = (long)(Nlm_stCon.zBuffer + offset1);
580 break;
581 case 1:
582 dy = yy2 - yy1;
583 reg2 = xx1 - xx2;
584 if ( reg2 <= dy ) {
585 reg1 = 3;
586 }
587 dx = reg2;
588 reg2 = reg3; reg3 = reg4; reg4 = reg2;
589 endPtr = reg4;
590 reg4 = (long)(Nlm_stCon.zBuffer + offset2);
591 break;
592 case 2:
593 dy = yy1 - yy2;
594 reg2 = xx2 - xx1;
595 if ( reg2 > dy ){
596 reg1 = 1;
597 } else {
598 reg1 = 3;
599 }
600 dx = reg2;
601 endPtr = reg4;
602 reg4 = (long)(Nlm_stCon.zBuffer + offset1);
603 break;
604 default:
605 dy = yy1 - yy2;
606 reg2 = xx1 - xx2;
607 if ( reg2 > dy ){
608 reg1 = 0;
609 } else {
610 reg1 = 2;
611 }
612 dx = reg2;
613 reg2 = reg3; reg3 = reg4; reg4 = reg2;
614 endPtr = reg4;
615 reg4 = (long)(Nlm_stCon.zBuffer + offset2);
616 }
617
618 reg2 = z;
619 /* Will be: reg1 - err */
620 switch ( reg1 ){
621 case 0:
622 reg1 = -(dx>>1);
623 do {
624 reg1 += dy;
625 if ( reg1 > 0 ){
626 reg3 += ystep;
627 reg4 += zystep;
628 reg1 -= dx;
629 }
630 reg3++; reg4++; reg4++;
631 SETPIXEL(reg4,reg3,reg2,color);
632 } while ( reg3 != endPtr );
633 break;
634 case 1:
635 reg1 = -(dx>>1);
636 do {
637 reg1 += dy;
638 if ( reg1 > 0 ){
639 reg3 -= ystep;
640 reg4 -= zystep;
641 reg1 -= dx;
642 }
643 reg3++; reg4++; reg4++;
644 SETPIXEL(reg4,reg3,reg2,color);
645 } while ( reg3 != endPtr );
646 break;
647 case 2:
648 reg1 = -(dy>>1);
649 do {
650 reg1 += dx;
651 if ( reg1 > 0 ) {
652 reg3 ++;
653 reg4 ++; reg4++;
654 reg1 -= dy;
655 }
656 reg3 += ystep;
657 reg4 += zystep;
658 SETPIXEL(reg4,reg3,reg2,color);
659 } while ( reg3 != endPtr );
660 break;
661 default:
662 reg1 = -(dy>>1);
663 do {
664 reg1 += dx;
665 if ( reg1 > 0 ) {
666 reg3 ++;
667 reg4 ++; reg4++;
668 reg1 -= dy;
669 }
670 reg3 -= ystep;
671 reg4 -= zystep;
672 SETPIXEL(reg4,reg3,reg2,color);
673 } while ( reg3 != endPtr );
674 }
675 }
676 ptr++;
677 x += width;
678 }
679 }
680
681 static void Nlm_Text3DHitT ( Nlm_Text3DPtr p )
682 {
683 register long reg1;
684 register long reg2;
685 register long reg3;
686 register long reg4;
687 long x1,x2 = 0;
688 long y1,y2 = 0;
689 long z1,z2;
690 long dx, dy, dz;
691 long xx1,xx2;
692 long yy1,yy2;
693 long zz1,zz2;
694 long status2;
695 long orient;
696 long endPtr;
697 long offset1;
698 long offset2;
699 long zrate;
700 long ystep;
701 long zystep;
702 long curz;
703 long x,y,z;
704 long height, width, offset;
705 long needCheck;
706 CharPtr ptr;
707 CharPtr lPtr;
708
709 reg1 = (long)p;
710
711 /* Rotate and check */
712 reg2 = ((Nlm_Text3DPtr)reg1)->x;
713 reg3 = ((Nlm_Text3DPtr)reg1)->y;
714 reg4 = ((Nlm_Text3DPtr)reg1)->z;
715 x = reg2 / Nlm_stCon.a[0][0] + reg3 / Nlm_stCon.a[0][1] +
716 reg4 / Nlm_stCon.a[0][2] + Nlm_stCon.c[0];
717 y = reg2 / Nlm_stCon.a[1][0] + reg3 / Nlm_stCon.a[1][1] +
718 reg4 / Nlm_stCon.a[1][2] + Nlm_stCon.c[1];
719 reg4 = reg2 / Nlm_stCon.a[2][0] + reg3 / Nlm_stCon.a[2][1] +
720 reg4 / Nlm_stCon.a[2][2] + Nlm_stCon.c[2];
721 z = reg4;
722 reg4 = Nlm_stCon.zmaxPersp1-reg4;
723 reg2 = ((Nlm_Text3DPtr)reg1)->height / Nlm_stCon.scale;
724 reg2 = (reg2*Nlm_stCon.zmaxPersp)/reg4;
725 height = reg2;
726 width = (reg2*15)/22;
727 reg2 = ((Nlm_Text3DPtr)reg1)->offset / Nlm_stCon.scale;
728 reg2 = (reg2*Nlm_stCon.zmaxPersp)/reg4;
729 offset = reg2;
730 switch ( ((Nlm_Text3DPtr)reg1)->flags & 0x3 ){
731 case TEXT3D_LEFT:
732 x -= offset + ((Nlm_Text3DPtr)reg1)->len*width;
733 break;
734 case TEXT3D_RIGTH:
735 x += offset;
736 break;
737 default:
738 x -= ((Nlm_Text3DPtr)reg1)->len*width/2;
739 }
740 switch ( ((Nlm_Text3DPtr)reg1)->flags & 0x30 ){
741 case TEXT3D_UPPER:
742 y += offset;
743 break;
744 case TEXT3D_LOWER:
745 y -= offset + height;
746 break;
747 default:
748 y -= height/2;
749 }
750 reg2 = Nlm_stCon.width>>1;
751 reg3 = x-reg2;
752 x = reg2 + (reg3*Nlm_stCon.zmaxPersp)/reg4;
753 reg2 = Nlm_stCon.height>>1;
754 reg3 = y-reg2;
755 y = reg2 Y_PLUS (reg3*Nlm_stCon.zmaxPersp)/reg4;
756 if ( ((Nlm_Text3DPtr)reg1)->flags & TEXT3D_FRONT ){
757 z = Nlm_stCon.zmax-1;
758 }else{
759 z = (z*Nlm_stCon.zmaxPersp)/reg4;
760 }
761 needCheck = 0;
762 reg2 = x;
763 reg3 = y;
764 if ( (reg2 > Nlm_stCon.xmax) || (reg3 > Nlm_stCon.ymax) ) return;
765 if ( (reg2 < Nlm_stCon.xmin) || (reg3 < Nlm_stCon.ymin) ) needCheck=1;
766 reg2 += width*((Nlm_Text3DPtr)reg1)->len;
767 reg3 += height;
768 if ( (reg2 < Nlm_stCon.xmin) || (reg3 < Nlm_stCon.ymin) ) return;
769 if ( (reg2 > Nlm_stCon.xmax) || (reg3 > Nlm_stCon.ymax) ) needCheck=1;
770
771 ptr = ((Nlm_Text3DPtr)reg1)->text;
772 z1 = z2 = z;
773 ystep = Nlm_stCon.widthCur * sizeof(Nlm_stCon.idBuffer[0]);
774 zystep = Nlm_stCon.widthCur * sizeof(Nlm_stCon.zBuffer[0]);
775
776 while ( *ptr ){
777 if ( (*ptr < 32) || (*ptr > 126) ) continue;
778 lPtr = vectFont[*ptr-32];
779 while ( *lPtr ){
780 if ( *lPtr < 'a' ){
781 x2 = x + ((long)*lPtr++ - (long)'A')*height/22;
782 y2 = y Y_PLUS ((long)*lPtr++ - (long)'a')*height/22;
783 continue;
784 }
785 x1 = x2; y1=y2;
786 x2 = x + ((long)*lPtr++ - (long)'a')*height/22;
787 y2 = y Y_PLUS ((long)*lPtr++ - (long)'a')*height/22;
788 if ( needCheck ){
789 dx = x2-x1; dy = y2-y1; dz = z2-z1;
790 /* Calculate status1(reg1) and status2(reg2) */
791 reg1 = 0;
792 reg2 = 0;
793 reg3 = x1;
794 reg4 = Nlm_stCon.xmin;
795 if ( reg3 < reg4 ) reg1 = 1;
796 else if ( reg3 > Nlm_stCon.xmax ) reg1 = 2;
797 reg3 = x2;
798 if ( reg3 < reg4 ) reg2 = 1;
799 else if ( reg3 > Nlm_stCon.xmax ) reg2 = 2;
800 if ( (reg1 == reg2) && (reg1 != 0) ) continue;
801 reg3 = y1;
802 reg4 = Nlm_stCon.ymin;
803 if ( reg3 < reg4 ) reg1 += 6;
804 else if ( reg3 > Nlm_stCon.ymax ) reg1 += 3;
805 reg3 = y2;
806 if ( reg3 < reg4 ) reg2 += 6;
807 else if ( reg3 > Nlm_stCon.ymax ) reg2 += 3;
808 if ( (reg1>=6) && (reg2>=6) ) continue;
809 if ( (reg1>=3) && (reg2>=3) && (reg1<6) && (reg2<6) ) continue;
810
811 /* Save status2*/
812 status2 = reg2;
813
814 /* Calculate the first point (xx1,yy1,zz1)*/
815 switch ( reg1 ) {
816 case 0:
817 xx1 = x1; yy1=y1; zz1=z1;
818 break;
819 case 1:
820 reg1 = x1; reg2 = Nlm_stCon.xmin;
821 reg4 = x2-reg1;
822 reg3 = y1 + dy*(reg2-reg1)/reg4;
823 yy1 = reg3;
824 xx1 = reg2;
825 zz1 = z1 + dz*(reg2-reg1)/reg4;
826 break;
827 case 2:
828 reg1 = x1; reg2 = Nlm_stCon.xmax;
829 reg4 = x2-reg1;
830 reg3 = y1 + dy*(reg2-reg1)/reg4;
831 yy1 = reg3;
832 xx1 = reg2;
833 zz1 = z1 + dz*(reg2-reg1)/reg4;
834 break;
835 case 3:
836 reg1 = y1; reg2 = Nlm_stCon.ymax;
837 reg4 = y2-reg1;
838 reg3 = x1 + dx*(reg2-reg1)/reg4;
839 xx1 = reg3;
840 yy1 = reg2;
841 zz1 = z1 + dz*(reg2-reg1)/reg4;
842 break;
843 case 4:
844 reg1 = x1; reg2 = Nlm_stCon.xmin;
845 reg4 = x2-reg1;
846 reg3 = y1 + dy*(reg2-reg1)/reg4;
847 yy1 = reg3;
848 xx1 = reg2;
849 if ( (reg3 < Nlm_stCon.ymin) || (reg3 > Nlm_stCon.ymax) ) {
850 reg1 = y1; reg2 = Nlm_stCon.ymax;
851 reg4 = y2-reg1;
852 reg3 = x1 + dx*(reg2-reg1)/reg4;
853 xx1 = reg3;
854 yy1 = reg2;
855 }
856 zz1 = z1 + dz*(reg2-reg1)/reg4;
857 break;
858 case 5:
859 reg1 = x1; reg2 = Nlm_stCon.xmax;
860 reg4 = x2-reg1;
861 reg3 = y1 + dy*(reg2-reg1)/reg4;
862 yy1 = reg3;
863 xx1 = reg2;
864 if ( (reg3 < Nlm_stCon.ymin)||(reg3 > Nlm_stCon.ymax) ) {
865 reg1 = y1; reg2 = Nlm_stCon.ymax;
866 reg4 = y2-reg1;
867 reg3 = x1 + dx*(reg2-reg1)/reg4;
868 xx1 = reg3;
869 yy1 = reg2;
870 }
871 zz1 = z1 + dz*(reg2-reg1)/reg4;
872 break;
873 case 6:
874 reg1 = y1; reg2 = Nlm_stCon.ymin;
875 reg4 = y2-reg1;
876 reg3 = x1 + dx*(reg2-reg1)/reg4;
877 xx1 = reg3;
878 yy1 = reg2;
879 zz1 = z1 + dz*(reg2-reg1)/reg4;
880 break;
881 case 7:
882 reg1 = x1; reg2 = Nlm_stCon.xmin;
883 reg4 = x2-reg1;
884 reg3 = y1 + dy*(reg2-reg1)/reg4;
885 yy1 = reg3;
886 xx1 = reg2;
887 if ( (reg3 < Nlm_stCon.ymin) || (reg3 > Nlm_stCon.ymax) ) {
888 reg1 = y1; reg2 = Nlm_stCon.ymin;
889 reg4 = y2-reg1;
890 reg3 = x1 + dx*(reg2-reg1)/reg4;
891 xx1 = reg3;
892 yy1 = reg2;
893 }
894 zz1 = z1 + dz*(reg2-reg1)/reg4;
895 break;
896 default:
897 reg1 = x1; reg2 = Nlm_stCon.xmax;
898 reg4 = x2-reg1;
899 reg3 = y1 + dy*(reg2-reg1)/reg4;
900 yy1 = reg3;
901 xx1 = reg2;
902 if ( (reg3 < Nlm_stCon.ymin)||(reg3 > Nlm_stCon.ymax) ) {
903 reg1 = y1; reg2 = Nlm_stCon.ymin;
904 reg4 = y2-reg1;
905 reg3 = x1 + dx*(reg2-reg1)/reg4;
906 xx1 = reg3;
907 yy1 = reg2;
908 }
909 zz1 = z1 + dz*(reg2-reg1)/reg4;
910 }
911
912 /* Calculate the second point (xx2,yy2,zz2)*/
913 switch ( status2 ) {
914 case 0:
915 xx2 = x2; yy2=y2; zz2=z2;
916 break;
917 case 1:
918 reg1 = x1; reg2 = Nlm_stCon.xmin;
919 reg4 = x2-reg1;
920 yy2 = y1 + dy*(reg2-reg1)/reg4;
921 xx2 = reg2;
922 zz2 = z1 + dz*(reg2-reg1)/reg4;
923 break;
924 case 2:
925 reg1 = x1; reg2 = Nlm_stCon.xmax;
926 reg4 = x2-reg1;
927 yy2 = y1 + dy*(reg2-reg1)/reg4;
928 xx2 = reg2;
929 zz2 = z1 + dz*(reg2-reg1)/reg4;
930 break;
931 case 3:
932 reg1 = y1; reg2 = Nlm_stCon.ymax;
933 reg4 = y2-reg1;
934 xx2 = x1 + dx*(reg2-reg1)/reg4;
935 yy2 = reg2;
936 zz2 = z1 + dz*(reg2-reg1)/reg4;
937 break;
938 case 4:
939 reg1 = x1; reg2 = Nlm_stCon.xmin;
940 reg4 = x2-reg1;
941 reg3 = y1 + dy*(reg2-reg1)/reg4;
942 yy2 = reg3;
943 xx2 = reg2;
944 if ( (reg3 < Nlm_stCon.ymin) || (reg3 > Nlm_stCon.ymax) ) {
945 reg1 = y1; reg2 = Nlm_stCon.ymax;
946 reg4 = y2-reg1;
947 reg3 = x1 + dx*(reg2-reg1)/reg4;
948 xx2 = reg3;
949 yy2 = reg2;
950 }
951 zz2 = z1 + dz*(reg2-reg1)/reg4;
952 break;
953 case 5:
954 reg1 = x1; reg2 = Nlm_stCon.xmax;
955 reg4 = x2-reg1;
956 reg3 = y1 + dy*(reg2-reg1)/reg4;
957 yy2 = reg3;
958 xx2 = reg2;
959 if ( (reg3 < Nlm_stCon.ymin)||(reg3 > Nlm_stCon.ymax) ) {
960 reg1 = y1; reg2 = Nlm_stCon.ymax;
961 reg4 = y2-reg1;
962 reg3 = x1 + dx*(reg2-reg1)/reg4;
963 xx2 = reg3;
964 yy2 = reg2;
965 }
966 zz2 = z1 + dz*(reg2-reg1)/reg4;
967 break;
968 case 6:
969 reg1 = y1; reg2 = Nlm_stCon.ymin;
970 reg4 = y2-reg1;
971 xx2 = x1 + dx*(reg2-reg1)/reg4;
972 yy2 = reg2;
973 zz2 = z1 + dz*(reg2-reg1)/reg4;
974 break;
975 case 7:
976 reg1 = x1; reg2 = Nlm_stCon.xmin;
977 reg4 = x2-reg1;
978 reg3 = y1 + dy*(reg2-reg1)/reg4;
979 yy2 = reg3;
980 xx2 = reg2;
981 if ( (reg3 < Nlm_stCon.ymin) || (reg3 > Nlm_stCon.ymax) ) {
982 reg1 = y1; reg2 = Nlm_stCon.ymin;
983 reg4 = y2-reg1;
984 reg3 = x1 + dx*(reg2-reg1)/reg4;
985 xx2 = reg3;
986 yy2 = reg2;
987 }
988 zz2 = z1 + dz*(reg2-reg1)/reg4;
989 break;
990 default:
991 reg1 = x1; reg2 = Nlm_stCon.xmax;
992 reg4 = x2-reg1;
993 reg3 = y1 + dy*(reg2-reg1)/reg4;
994 yy2 = reg3;
995 xx2 = reg2;
996 if ( (reg3 < Nlm_stCon.ymin)||(reg3 > Nlm_stCon.ymax) ) {
997 reg1 = y1; reg2 = Nlm_stCon.ymin;
998 reg4 = y2-reg1;
999 reg3 = x1 + dx*(reg2-reg1)/reg4;
1000 xx2 = reg3;
1001 yy2 = reg2;
1002 }
1003 zz2 = z1 + dz*(reg2-reg1)/reg4;
1004 }
1005 } else {
1006 xx1 = x1; yy1=y1; zz1=z1;
1007 xx2 = x2; yy2=y2; zz2=z2;
1008 }
1009
1010 reg3 = xx1;
1011 reg4 = xx2;
1012 if ( reg3 < reg4 ) {
1013 if ( (reg3 < Nlm_stCon.xmin)||(reg4 > Nlm_stCon.xmax) ) continue;
1014 reg1 = 0;
1015 } else {
1016 if ( (reg4 < Nlm_stCon.xmin)||(reg3 > Nlm_stCon.xmax) ) continue;
1017 reg1 = 1;
1018 }
1019 reg3 = yy1;
1020 reg4 = yy2;
1021 if ( reg3 < reg4 ) {
1022 if ( (reg3 < Nlm_stCon.ymin)||(reg4 > Nlm_stCon.ymax) ) continue;
1023 } else {
1024 if ( (reg4 < Nlm_stCon.ymin)||(reg3 > Nlm_stCon.ymax) ) continue;
1025 reg1 |= 0x2;
1026 }
1027 orient = reg1;
1028
1029 /* Calculate offsets */
1030 reg3 = Nlm_stCon.xmin;
1031 xx1 -= reg3; xx2 -= reg3;
1032 reg3 = Nlm_stCon.ymin;
1033 yy1 -= reg3; yy2 -=reg3;
1034 /* Calculate offsets and pointers */
1035 reg1 = yy1 * Nlm_stCon.widthCur + xx1;
1036 offset1 = reg1;
1037 reg3 = (long)(Nlm_stCon.idBuffer + reg1);
1038 reg2 = yy2 * Nlm_stCon.widthCur + xx2;
1039 offset2 = reg2;
1040 reg4 = (long)(Nlm_stCon.idBuffer + reg2);
1041 if ( reg3 == reg4 ){
1042 reg2 = (long)(Nlm_stCon.zBuffer + reg1);
1043 reg1 = zz1;
1044 if ( reg1 < zz2 ) reg1 = zz2;
1045 SETPIXELID ( reg2, reg3, reg1, p );
1046 continue;
1047 }
1048 /* reg3 - statrt reg4 - end */
1049
1050 /* Will be:
1051 reg1 - last orientation
1052 reg2 - zz1
1053 reg3 - start
1054 reg4 - zPtr
1055 endPtr saved in endPtr */
1056 reg1 = orient;
1057 switch ( reg1 ){
1058 case 0:
1059 dy = yy2 - yy1;
1060 reg2 = xx2 - xx1;
1061 dx = reg2;
1062 if ( reg2>dy ) {
1063 zrate = ((zz2 - zz1)<<10)/reg2;
1064 } else {
1065 zrate = ((zz2 - zz1)<<10)/dy;
1066 reg1 = 2;
1067 }
1068 reg2 = zz1;
1069 endPtr = reg4;
1070 reg4 = (long)(Nlm_stCon.zBuffer + offset1);
1071 break;
1072 case 1:
1073 dy = yy2 - yy1;
1074 reg2 = xx1 - xx2;
1075 if ( reg2 > dy ) {
1076 zrate = ((zz1 - zz2)<<10)/reg2;
1077 } else {
1078 zrate = ((zz1 - zz2)<<10)/dy;
1079 reg1 = 3;
1080 }
1081 dx = reg2;
1082 reg2 = reg3; reg3 = reg4; reg4 = reg2;
1083 reg2 = zz2;
1084 endPtr = reg4;
1085 reg4 = (long)(Nlm_stCon.zBuffer + offset2);
1086 break;
1087 case 2:
1088 dy = yy1 - yy2;
1089 reg2 = xx2 - xx1;
1090 if ( reg2 > dy ){
1091 zrate = ((zz2 - zz1)<<10)/reg2;
1092 reg1 = 1;
1093 } else {
1094 zrate = ((zz2 - zz1)<<10)/dy;
1095 reg1 = 3;
1096 }
1097 dx = reg2;
1098 reg2 = zz1;
1099 endPtr = reg4;
1100 reg4 = (long)(Nlm_stCon.zBuffer + offset1);
1101 break;
1102 default:
1103 dy = yy1 - yy2;
1104 reg2 = xx1 - xx2;
1105 if ( reg2 > dy ){
1106 zrate = ((zz1 - zz2)<<10)/reg2;
1107 reg1 = 0;
1108 } else {
1109 zrate = ((zz1 - zz2)<<10)/dy;
1110 reg1 = 2;
1111 }
1112 dx = reg2;
1113 reg2 = reg3; reg3 = reg4; reg4 = reg2;
1114 reg2 = zz2;
1115 endPtr = reg4;
1116 reg4 = (long)(Nlm_stCon.zBuffer + offset2);
1117 }
1118
1119 reg2 <<= 10;
1120 /* Will be: reg1 - err */
1121 switch ( reg1 ){
1122 case 0:
1123 reg1 = -(dx>>1);
1124 do {
1125 reg1 += dy;
1126 if ( reg1 > 0 ){
1127 reg3 += ystep;
1128 reg4 += zystep;
1129 reg1 -= dx;
1130 }
1131 reg3 += sizeof(Nlm_stCon.idBuffer[0]); reg4++; reg4++;
1132 reg2 += zrate;
1133 curz = reg2;
1134 reg2 >>= 10;
1135 SETPIXELID(reg4,reg3,reg2,p);
1136 reg2 = curz;
1137 } while ( reg3 != endPtr );
1138 break;
1139 case 1:
1140 reg1 = -(dx>>1);
1141 do {
1142 reg1 += dy;
1143 if ( reg1 > 0 ){
1144 reg3 -= ystep;
1145 reg4 -= zystep;
1146 reg1 -= dx;
1147 }
1148 reg3 += sizeof(Nlm_stCon.idBuffer[0]); reg4++; reg4++;
1149 reg2 += zrate;
1150 curz = reg2;
1151 reg2 >>= 10;
1152 SETPIXELID(reg4,reg3,reg2,p);
1153 reg2 = curz;
1154 } while ( reg3 != endPtr );
1155 break;
1156 case 2:
1157 reg1 = -(dy>>1);
1158 do {
1159 reg1 += dx;
1160 if ( reg1 > 0 ) {
1161 reg3 += sizeof(Nlm_stCon.idBuffer[0]);
1162 reg4++; reg4++;
1163 reg1 -= dy;
1164 }
1165 reg3 += ystep;
1166 reg4 += zystep;
1167 reg2 += zrate;
1168 curz = reg2;
1169 reg2 >>= 10;
1170 SETPIXELID(reg4,reg3,reg2,p);
1171 reg2 = curz;
1172 } while ( reg3 != endPtr );
1173 break;
1174 default:
1175 reg1 = -(dy>>1);
1176 do {
1177 reg1 += dx;
1178 if ( reg1 > 0 ) {
1179 reg3 += sizeof(Nlm_stCon.idBuffer[0]);
1180 reg4++; reg4++;
1181 reg1 -= dy;
1182 }
1183 reg3 -= ystep;
1184 reg4 -= zystep;
1185 reg2 += zrate;
1186 curz = reg2;
1187 reg2 >>= 10;
1188 SETPIXELID(reg4,reg3,reg2,p);
1189 reg2 = curz;
1190 } while ( reg3 != endPtr );
1191 }
1192 }
1193 ptr++;
1194 x += width;
1195 }
1196 }
1197
1198 static void Nlm_Text3DGetL ( Nlm_Text3DPtr p )
1199 {
1200 register Nlm_Text3DPtr ax;
1201 register Nlm_PSeg3DPtr bx;
1202 long minXY, maxXY;
1203 long rad;
1204
1205 ax = p;
1206 bx = (Nlm_PSeg3DPtr)((Nlm_PSeg3DPtr)ax)->base.parent;
1207 rad = ax->offset + ax->len * ax->height *15 / 22;
1208 minXY = ax->x - rad;
1209 maxXY = ax->x + rad;
1210 if ( bx->segBox.minX > minXY )
1211 bx->segBox.minX = minXY;
1212 if ( bx->segBox.maxX < maxXY )
1213 bx->segBox.maxX = maxXY;
1214 minXY = ax->y - rad;
1215 maxXY = ax->y + rad;
1216 if ( bx->segBox.minY > minXY )
1217 bx->segBox.minY = minXY;
1218 if ( bx->segBox.maxY < maxXY )
1219 bx->segBox.maxY = maxXY;
1220 minXY = ax->z - rad;
1221 maxXY = ax->z + rad;
1222 if ( bx->segBox.minZ > minXY )
1223 bx->segBox.minZ = minXY;
1224 if ( bx->segBox.maxZ < maxXY )
1225 bx->segBox.maxZ = maxXY;
1226 }
1227
1228 static Nlm_PrimDef3D textDef = {
1229 (Nlm_PrimDraw3D)Nlm_Text3DDraw,
1230 (Nlm_PrimHitTest3D)Nlm_Text3DHitT,
1231 (Nlm_PrimGetLimits3D)Nlm_Text3DGetL,
1232 (Nlm_PrimCleanup3D)Nlm_Empty3D,
1233 (Nlm_Int2)TEXT3D
1234 };
1235
1236 /*****************************************************************************
1237 *
1238 * TEXT
1239 *
1240 *****************************************************************************/
1241 Nlm_Prim3D Nlm_AddText3D ( Nlm_Picture3D pic, Nlm_Segment3D segment,
1242 BigScalar userData, Uint1 layer, Uint1 color,
1243 CharPtr string, Int4 x, Int4 y, Int4 z,
1244 Uint4 height, Int4 offset, Int2 flags )
1245 {
1246 Nlm_Text3DPtr l;
1247 Int2 len;
1248
1249 Nlm_stCon.pic = pic;
1250 Nlm_DiagReset();
1251 if ( (flags & 0x3 ) == 0 ) flags |= 0x2;
1252 if ( (flags & 0x30) == 0 ) flags |= 0x20;
1253 len = StringLen( string );
1254 l = (Nlm_Text3DPtr) MemNew(sizeof(Nlm_Text3D) + len);
1255 if (l == NULL) {
1256 Nlm_DiagPutRecord(DA_ERROR, Pict3Dclass, "AddText3D",
1257 "Memory allocation error" );
1258 return NULL;
1259 }
1260 l->base.userData = userData;
1261 l->base.layer = layer;
1262 l->base.color = color;
1263 l->base.fTable = &textDef;
1264 l->base.status = 0;
1265 l->x = (long)x; l->y = (long)y; l->z = (long)z;
1266 l->height = (long)height;
1267 l->offset = (long)offset;
1268 l->flags = flags;
1269 l->len = len;
1270 StringCpy(l->text, string);
1271
1272 {{
1273 Nlm_Prim3D prim = (Nlm_Prim3D)Nlm_AddPrim3D((Nlm_PSeg3DPtr)segment,
1274 (Nlm_Base3DPtr)l,
1275 sizeof(Nlm_Text3D) + len,
1276 "AddText3D");
1277 MemFree( l );
1278 return prim;
1279 }}
1280 }
1281
1282 |
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more information. |