00001 #include "splat.h"
00002 #include "vuTFunc/simpleFuncs.h"
00003 #include <fstream.h>
00004 #include <math.h>
00005
00006
00007
00008
00009
00010 static float texcoord0[2] = {0.0f, 0.0f};
00011 static float texcoord1[2] = {0.0f, 1.0f};
00012 static float texcoord2[2] = {1.0f, 1.0f};
00013 static float texcoord3[2] = {1.0f, 0.0f};
00014
00015
00016
00017
00018
00019 vu1112111::vu1112111()
00020 {
00021 m_Normals = 0;
00022
00023 m_FPSize = 256;
00024 m_Footprint = 0;
00025 m_GLSplat = 0;
00026
00027 computeSplat();
00028 }
00029
00030
00031
00032
00033
00034 vu1112111::vu1112111(const vu1112111& inst) : vu111211(inst)
00035 {
00036 dword i;
00037
00038 m_NTable = inst.m_NTable;
00039
00040 #if defined(QUANTIZE_NORMALS)
00041 m_Normals = new byte[m_DataSize];
00042 #else
00043 m_Normals = new float[m_DataSize*3];
00044 #endif
00045 for(i=0;i<m_DataSize;++i)
00046 m_Normals[i] = inst.m_Normals[i];
00047
00048 m_FPSize = inst.m_FPSize;
00049 computeSplat();
00050 }
00051
00052
00053
00054
00055
00056 vu1112111::~vu1112111()
00057 {
00058 if (m_Normals)
00059 delete [] m_Normals;
00060 if (m_Footprint)
00061 {
00062 delete [] m_Footprint;
00063 glDeleteTextures(1, &m_GLSplat);
00064 }
00065 }
00066
00067
00068
00069
00070
00071 vu1112111& vu1112111::operator=(const vu1112111& rhs)
00072 {
00073 if (this != &rhs)
00074 {
00075 vu111211::operator=(rhs);
00076
00077 dword i;
00078
00079 m_NTable = rhs.m_NTable;
00080
00081 if (m_Normals)
00082 delete [] m_Normals;
00083
00084 #if defined(QUANTIZE_NORMALS)
00085 m_Normals = new byte[m_DataSize];
00086 #else
00087 m_Normals = new float[m_DataSize*3];
00088 #endif
00089 for(i=0;i<m_DataSize;++i)
00090 m_Normals[i] = rhs.m_Normals[i];
00091
00092 m_FPSize = rhs.m_FPSize;
00093
00094 computeSplat();
00095 }
00096 return *this;
00097 }
00098
00099
00100
00101
00102
00103 void vu1112111::setViewVectors(const vuVector& view,const vuVector& up,const vuVector& right)
00104 {
00105 m_View = view;
00106 m_Shift1 = right*3.2f;
00107 m_Shift2 = up*3.2f;
00108 m_Shift0 = (m_Shift1+m_Shift2)*(-0.5f);
00109 }
00110
00111
00112
00113
00114
00115 void vu1112111::setFootprintSize(dword size)
00116 {
00117 m_FPSize = size;
00118 }
00119
00120
00121
00122
00123
00124 dword vu1112111::getFootprintSize() const
00125 {
00126 return m_FPSize;
00127 }
00128
00129
00130
00131
00132
00133 bool vu1112111::read()
00134 {
00135 bool success = vu111211::read();
00136 if (!success) return false;
00137
00138
00139 if (m_Normals != 0) delete [] m_Normals;
00140 #if defined(QUANTIZE_NORMALS)
00141
00142 m_Normals = new byte[m_DataSize];
00143 #else
00144 m_Normals = new float[m_DataSize*3];
00145 #endif
00146 preprocess();
00147 return true;
00148 }
00149
00150
00151
00152
00153
00154 bool vu1112111::readRaw(void)
00155 {
00156 dword len;
00157 ifstream in;
00158
00159 #ifdef IS_NOCREATE_NEEDED
00160 in.open(m_FileName, ios::in|ios::binary|ios::nocreate);
00161 #else
00162
00163
00164 in.open(m_FileName, ios::in|ios::binary);
00165 #endif
00166 if (!in.is_open()) return false;
00167
00168 in.seekg(0, ios::end);
00169 len = in.tellg();
00170 in.seekg(0, ios::beg);
00171
00172 in >> m_Dim1Size >> m_Dim2Size >> m_Dim3Size;
00173 if (in.fail()) return false;
00174 m_DataSize = m_Dim1Size*m_Dim2Size*m_Dim3Size;
00175
00176 m_Data = new byte[m_DataSize];
00177 in.read((char *) (m_Data), int (m_DataSize));
00178 if (in.fail()) return false;
00179
00180 in.close();
00181
00182
00183 if (m_Normals != 0) delete [] m_Normals;
00184 #if defined(QUANTIZE_NORMALS)
00185 m_Normals = new byte[m_DataSize];
00186 #else
00187 m_Normals = new float[m_DataSize*3];
00188 #endif
00189 preprocess();
00190
00191 return true;
00192 }
00193
00194
00195
00196
00197
00198 void vu1112111::preprocess(void)
00199 {
00200 float norm[3];
00201 float len;
00202 dword w, wh;
00203 dword i, j, k, index;
00204
00205 w = m_Dim1Size;
00206 wh = m_Dim1Size*m_Dim2Size;
00207
00208
00209
00210
00211
00212 index = 0;
00213 #if defined(QUANTIZE_NORMALS)
00214 m_NTable.initCollection(m_DataSize);
00215 #endif
00216 for(k=0;k<m_Dim3Size;++k)
00217 {
00218 for(j=0;j<m_Dim2Size;++j)
00219 {
00220 for(i=0;i<m_Dim1Size;++i)
00221 {
00222 if (i == 0)
00223 norm[0] = m_Data[index+1]-m_Data[index];
00224 else if (i == m_Dim1Size-1)
00225 norm[0] = m_Data[index]-m_Data[index-1];
00226 else
00227 norm[0] = (m_Data[index+1]-m_Data[index-1])*0.5;
00228
00229 if (j == 0)
00230 norm[1] = m_Data[index+w]-m_Data[index];
00231 else if (j == m_Dim2Size-1)
00232 norm[1] = m_Data[index]-m_Data[index-w];
00233 else
00234 norm[1] = (m_Data[index+w]-m_Data[index-w])*0.5;
00235
00236 if (k == 0)
00237 norm[2] = m_Data[index+wh]-m_Data[index];
00238 else if (k == m_Dim3Size-1)
00239 norm[2] = m_Data[index]-m_Data[index-wh];
00240 else
00241 norm[2] = (m_Data[index+wh]-m_Data[index-wh])*0.5;
00242
00243 len = (float)sqrt((double)((norm[0]*norm[0])+
00244 (norm[1]*norm[1])+
00245 (norm[2]*norm[2])));
00246 if (len > 0.0f)
00247 {
00248 norm[0] /= len;
00249 norm[1] /= len;
00250 norm[2] /= len;
00251 }
00252 #if defined(QUANTIZE_NORMALS)
00253 m_NTable.addToCollection(norm);
00254 #else
00255 m_Normals[index*3] = norm[0];
00256 m_Normals[index*3+1] = norm[1];
00257 m_Normals[index*3+2] = norm[2];
00258 #endif
00259 ++index;
00260 }
00261 }
00262 }
00263
00264 #if defined(QUANTIZE_NORMALS)
00265 m_NTable.computeTable();
00266
00267
00268
00269
00270
00271 index = 0;
00272 for(k=0;k<m_Dim3Size;++k)
00273 {
00274 for(j=0;j<m_Dim2Size;++j)
00275 {
00276 for(i=0;i<m_Dim1Size;++i)
00277 {
00278 if (i == 0)
00279 norm[0] = m_Data[index+1]-m_Data[index];
00280 else if (i == m_Dim1Size-1)
00281 norm[0] = m_Data[index]-m_Data[index-1];
00282 else
00283 norm[0] = (m_Data[index+1]-m_Data[index-1])*0.5;
00284
00285 if (j == 0)
00286 norm[1] = m_Data[index+w]-m_Data[index];
00287 else if (j == m_Dim2Size-1)
00288 norm[1] = m_Data[index]-m_Data[index-w];
00289 else
00290 norm[1] = (m_Data[index+w]-m_Data[index-w])*0.5;
00291
00292 if (k == 0)
00293 norm[2] = m_Data[index+wh]-m_Data[index];
00294 else if (k == m_Dim3Size-1)
00295 norm[2] = m_Data[index]-m_Data[index-wh];
00296 else
00297 norm[2] = (m_Data[index+wh]-m_Data[index-wh])*0.5;
00298
00299 len = (float)sqrt((double)((norm[0]*norm[0])+
00300 (norm[1]*norm[1])+
00301 (norm[2]*norm[2])));
00302 if (len > 0.0f)
00303 {
00304 norm[0] /= len;
00305 norm[1] /= len;
00306 norm[2] /= len;
00307 }
00308 m_Normals[index] = (byte)m_NTable.findNearest(norm);
00309
00310 ++index;
00311 }
00312 }
00313 }
00314 #endif
00315 }
00316
00317
00318
00319
00320
00321 void vu1112111::render(void)
00322
00323 {
00324 if (IsReRendering ())
00325
00326 {
00327
00328
00329 int S_index, S_step, S_size;
00330 int M_index, M_step, M_size;
00331 int F_index, F_step, F_size;
00332 float dp[3];
00333 float vals[3];
00334 float *F, *M, *S;
00335 float dF, dM, dS;
00336 float rF, rM;
00337 float *n;
00338 int index;
00339 dword density;
00340
00341 dp[0] = (m_View[0] > 0.0f)?m_View[0]:m_View[0]*-1.0f;
00342 dp[1] = (m_View[1] > 0.0f)?m_View[1]:m_View[1]*-1.0f;
00343 dp[2] = (m_View[2] > 0.0f)?m_View[2]:m_View[2]*-1.0f;
00344
00345
00346
00347
00348
00349 if (dp[0] > dp[1])
00350 {
00351 if (dp[0] > dp[2])
00352 {
00353 if (dp[1] > dp[2])
00354 {
00355
00356 S = &vals[0];
00357 M = &vals[1];
00358 F = &vals[2];
00359
00360 S_size = m_Dim1Size;
00361 if (m_View[0] >= 0.0f){
00362 S_step = 1;
00363 *S = 0.0f;
00364 dS = 1.0f;
00365 index = 0;
00366 }else{
00367 S_step = -1;
00368 *S = (float)m_Dim1Size-1.0f;
00369 dS = -1.0f;
00370 index = m_Dim1Size-1;
00371 }
00372
00373 M_size = m_Dim2Size;
00374 if (m_View[1] >= 0.0f){
00375 M_step = m_Dim1Size;
00376 *M = 0.0f;
00377 dM = 1.0f;
00378 rM = -1.0f * (float)m_Dim2Size;
00379 }else{
00380 M_step = -1*m_Dim1Size;
00381 *M = (float)m_Dim2Size-1.0f;
00382 dM = -1.0f;
00383 rM = (float)m_Dim2Size;
00384 index += (1-m_Dim2Size)*M_step;
00385 }
00386
00387 F_size = m_Dim3Size;
00388 if (m_View[2] >= 0.0f){
00389 F_step = m_Dim1Size*m_Dim2Size;
00390 *F = 0.0f;
00391 dF = 1.0f;
00392 rF = -1.0f * (float)m_Dim3Size;
00393 }else{
00394 F_step = -1*m_Dim1Size*m_Dim2Size;
00395 *F = (float)m_Dim3Size-1.0f;
00396 dF = -1.0f;
00397 rF = (float)m_Dim3Size;
00398 index += (1-m_Dim3Size)*F_step;
00399 }
00400 }
00401 else
00402 {
00403
00404 S = &vals[0];
00405 F = &vals[1];
00406 M = &vals[2];
00407
00408 S_size = m_Dim1Size;
00409 if (m_View[0] >= 0.0f){
00410 S_step = 1;
00411 *S = 0.0f;
00412 dS = 1.0f;
00413 index = 0;
00414 }else{
00415 S_step = -1;
00416 *S = (float)m_Dim1Size-1.0f;
00417 dS = -1.0f;
00418 index = m_Dim1Size-1;
00419 }
00420
00421 F_size = m_Dim2Size;
00422 if (m_View[1] >= 0.0f){
00423 F_step = m_Dim1Size;
00424 *F = 0.0f;
00425 dF = 1.0f;
00426 rF = -1.0f * (float)m_Dim2Size;
00427 }else{
00428 F_step = -1*m_Dim1Size;
00429 *F = (float)m_Dim2Size-1.0f;
00430 dF = -1.0f;
00431 rF = (float)m_Dim2Size;
00432 index += (1-m_Dim2Size)*F_step;
00433 }
00434
00435 M_size = m_Dim3Size;
00436 if (m_View[2] >= 0.0f){
00437 M_step = m_Dim1Size*m_Dim2Size;
00438 *M = 0.0f;
00439 dM = 1.0f;
00440 rM = -1.0f * (float)m_Dim3Size;
00441 }else{
00442 M_step = -1*m_Dim1Size*m_Dim2Size;
00443 *M = (float)m_Dim3Size-1.0f;
00444 dM = -1.0f;
00445 rM = (float)m_Dim3Size;
00446 index += (1-m_Dim3Size)*M_step;
00447 }
00448 }
00449 }
00450 else
00451 {
00452
00453 M = &vals[0];
00454 F = &vals[1];
00455 S = &vals[2];
00456
00457 M_size = m_Dim1Size;
00458 if (m_View[0] >= 0.0f){
00459 M_step = 1;
00460 *M = 0.0f;
00461 dM = 1.0f;
00462 rM = -1.0f* (float)m_Dim1Size;
00463 index = 0;
00464 }else{
00465 M_step = -1;
00466 *M = (float)m_Dim1Size-1.0f;
00467 dM = -1.0f;
00468 rM = (float)m_Dim1Size;
00469 index = m_Dim1Size-1;
00470 }
00471
00472 F_size = m_Dim2Size;
00473 if (m_View[1] >= 0.0f){
00474 F_step = m_Dim1Size;
00475 *F = 0.0f;
00476 dF = 1.0f;
00477 rF = -1.0f * (float)m_Dim2Size;
00478 }else{
00479 F_step = -1*m_Dim1Size;
00480 *F = (float)m_Dim2Size-1.0f;
00481 dF = -1.0f;
00482 rF = (float)m_Dim2Size;
00483 index += (1-m_Dim2Size)*F_step;
00484 }
00485
00486 S_size = m_Dim3Size;
00487 if (m_View[2] >= 0.0f){
00488 S_step = m_Dim1Size*m_Dim2Size;
00489 *S = 0.0f;
00490 dS = 1.0f;
00491 }else{
00492 S_step = -1*m_Dim1Size*m_Dim2Size;
00493 *S = (float)m_Dim3Size-1.0f;
00494 dS = -1.0f;
00495 index += (1-m_Dim3Size)*S_step;
00496 }
00497 }
00498 }
00499 else
00500 {
00501 if (dp[1] > dp[2])
00502 {
00503 if (dp[0] > dp[2])
00504 {
00505
00506 M = &vals[0];
00507 S = &vals[1];
00508 F = &vals[2];
00509
00510 M_size = m_Dim1Size;
00511 if (m_View[0] >= 0.0f){
00512 M_step = 1;
00513 *M = 0.0f;
00514 dM = 1.0f;
00515 rM = -1.0f* (float)m_Dim1Size;
00516 index = 0;
00517 }else{
00518 M_step = -1;
00519 *M = (float)m_Dim1Size-1.0f;
00520 dM = -1.0f;
00521 rM = (float)m_Dim1Size;
00522 index = m_Dim1Size-1;
00523 }
00524
00525 S_size = m_Dim2Size;
00526 if (m_View[1] >= 0.0f){
00527 S_step = m_Dim1Size;
00528 *S = 0.0f;
00529 dS = 1.0f;
00530 }else{
00531 S_step = -1*m_Dim1Size;
00532 *S = (float)m_Dim2Size-1.0f;
00533 dS = -1.0f;
00534 index += (1-m_Dim2Size)*S_step;
00535 }
00536
00537 F_size = m_Dim3Size;
00538 if (m_View[2] >= 0.0f){
00539 F_step = m_Dim1Size*m_Dim2Size;
00540 *F = 0.0f;
00541 dF = 1.0f;
00542 rF = -1.0f * (float)m_Dim3Size;
00543 }else{
00544 F_step = -1*m_Dim1Size*m_Dim2Size;
00545 *F = (float)m_Dim3Size-1.0f;
00546 dF = -1.0f;
00547 rF = (float)m_Dim3Size;
00548 index += (1-m_Dim3Size)*F_step;
00549 }
00550 }
00551 else
00552 {
00553
00554 F = &vals[0];
00555 S = &vals[1];
00556 M = &vals[2];
00557
00558 F_size = m_Dim1Size;
00559 if (m_View[0] >= 0.0f){
00560 F_step = 1;
00561 *F = 0.0f;
00562 dF = 1.0f;
00563 rF = -1.0f* (float)m_Dim1Size;
00564 index = 0;
00565 }else{
00566 F_step = -1;
00567 *F = (float)m_Dim1Size-1.0f;
00568 dF = -1.0f;
00569 rF = (float)m_Dim1Size;
00570 index = m_Dim1Size-1;
00571 }
00572
00573 S_size = m_Dim2Size;
00574 if (m_View[1] >= 0.0f){
00575 S_step = m_Dim1Size;
00576 *S = 0.0f;
00577 dS = 1.0f;
00578 }else{
00579 S_step = -1*m_Dim1Size;
00580 *S = (float)m_Dim2Size-1.0f;
00581 dS = -1.0f;
00582 index += (1-m_Dim2Size)*S_step;
00583 }
00584
00585 M_size = m_Dim3Size;
00586 if (m_View[2] >= 0.0f){
00587 M_step = m_Dim1Size*m_Dim2Size;
00588 *M = 0.0f;
00589 dM = 1.0f;
00590 rM = -1.0f * (float)m_Dim3Size;
00591 }else{
00592 M_step = -1*m_Dim1Size*m_Dim2Size;
00593 *M = (float)m_Dim3Size-1.0f;
00594 dM = -1.0f;
00595 rM = (float)m_Dim3Size;
00596 index += (1-m_Dim3Size)*M_step;
00597 }
00598 }
00599 }
00600 else
00601 {
00602
00603 F = &vals[0];
00604 M = &vals[1];
00605 S = &vals[2];
00606
00607 F_size = m_Dim1Size;
00608 if (m_View[0] >= 0.0f){
00609 F_step = 1;
00610 *F = 0.0f;
00611 dF = 1.0f;
00612 rF = -1.0f* (float)m_Dim1Size;
00613 index = 0;
00614 }else{
00615 F_step = -1;
00616 *F = (float)m_Dim1Size-1.0f;
00617 dF = -1.0f;
00618 rF = (float)m_Dim1Size;
00619 index = m_Dim1Size-1;
00620 }
00621
00622 M_size = m_Dim2Size;
00623 if (m_View[1] >= 0.0f){
00624 M_step = m_Dim1Size;
00625 *M = 0.0f;
00626 dM = 1.0f;
00627 rM = -1.0f * (float)m_Dim2Size;
00628 }else{
00629 M_step = -1*m_Dim1Size;
00630 *M = (float)m_Dim2Size-1.0f;
00631 dM = -1.0f;
00632 rM = (float)m_Dim2Size;
00633 index += (1-m_Dim2Size)*M_step;;
00634 }
00635
00636 S_size = m_Dim3Size;
00637 if (m_View[2] >= 0.0f){
00638 S_step = m_Dim1Size*m_Dim2Size;
00639 *S = 0.0f;
00640 dS = 1.0f;
00641 }else{
00642 S_step = -1*m_Dim1Size*m_Dim2Size;
00643 *S = (float)m_Dim3Size-1.0f;
00644 dS = -1.0f;
00645 index += (1-m_Dim3Size)*S_step;
00646 }
00647 }
00648 }
00649
00650 S_step -= M_step*M_size;
00651 M_step -= F_step*F_size;
00652
00653
00654
00655
00656
00657 glBegin(GL_QUADS);
00658 for(S_index=0; S_index<S_size; ++S_index)
00659 {
00660 for(M_index=0; M_index<M_size; ++M_index)
00661 {
00662 for(F_index=0; F_index<F_size; ++F_index)
00663 {
00664 density = m_Data[index];
00665 if (m_TFunc[density][3] > 0.0f)
00666 {
00667 glColor4fv(m_TFunc[density]);
00668 #if defined(QUANTIZE_NORMALS)
00669 n = m_NTable[m_Normals[index]];
00670 #else
00671 n = &m_Normals[index*3];
00672 #endif
00673
00674 #if defined(ONE_SIDED_LIGHTING)
00675 if (n[0]*m_View[0] + n[1]*m_View[1] + n[2]*m_View[2] > 0.0f)
00676 {
00677 n[0] *= -1.0f;
00678 n[1] *= -1.0f;
00679 n[2] *= -1.0f;
00680 }
00681 #endif
00682 glNormal3fv(n);
00683
00684 drawSplatOrtho(vals);
00685 }
00686
00687 index += F_step;
00688 *F += dF;
00689 }
00690 *F += rF;
00691 *M += dM;
00692 index += M_step;
00693 }
00694 *M += rM;
00695 *S += dS;
00696 index += S_step;
00697 }
00698
00699 glEnd();
00700 }
00701
00702
00703
00704
00705
00706
00707
00708
00709
00710
00711
00712
00713
00714
00715
00716
00717
00718
00719
00720
00721
00722
00723
00724 }
00725
00726 void vu1112111::drawPic ()
00727
00728 {
00729
00730 glDrawBuffer (GL_FRONT);
00731
00732
00733
00734
00735 glFinish ();
00736
00737
00738
00739 glDisable (GL_BLEND);
00740
00741 glDrawPixels (m_ImgBuffer.getWidth () - 1, m_ImgBuffer.getHeight () - 1, GL_RGB, GL_UNSIGNED_BYTE, (unsigned char *) (m_ImgBuffer.get_rgb ()));
00742 glDrawBuffer (GL_BACK);
00743 glDrawPixels (m_ImgBuffer.getWidth () - 1, m_ImgBuffer.getHeight () - 1, GL_RGB, GL_UNSIGNED_BYTE, (unsigned char *) (m_ImgBuffer.get_rgb ()));
00744
00745 glFinish ();
00746
00747 glDrawBuffer (GL_BACK);
00748
00749 glEnable (GL_BLEND);
00750
00751
00752
00753
00754 }
00755
00756 vuImage* vu1112111::getBuffer ()
00757
00758 {
00759 return &m_ImgBuffer;
00760 }
00761
00762
00763
00764
00765
00766 void vu1112111::computeSplat(void)
00767 {
00768 dword index;
00769 dword i;
00770 dword j;
00771 double x;
00772 double y;
00773 double d;
00774
00775 if (m_Footprint)
00776 {
00777 delete [] m_Footprint;
00778 glDeleteTextures(1, &m_GLSplat);
00779 }
00780 #if defined(COMBINERS)
00781 m_Footprint = new GLubyte[m_FPSize*m_FPSize];
00782 #else
00783 m_Footprint = new GLubyte[m_FPSize*m_FPSize*2];
00784 #endif
00785
00786 index = 0;
00787 for(j=0;j<m_FPSize;++j)
00788 {
00789 for(i=0;i<m_FPSize;++i)
00790 {
00791 x = 0.5 - (double)i/(double)(m_FPSize-1);
00792 y = 0.5 - (double)j/(double)(m_FPSize-1);
00793 d = sqrt(x*x+y*y);
00794 #if !defined(COMBINERS)
00795 m_Footprint[index++] = 255;
00796 #endif
00797 m_Footprint[index++] = (GLubyte)(255.0*nelsonSplat(1.6*d));
00798 }
00799 }
00800 }
00801
00802
00803
00804
00805
00806 double vu1112111::nelsonSplat(double r)
00807 {
00808 double s = 0.8893919243498159;
00809 double t = 1.556227804798694;
00810 double a = 0.5575267703530060;
00811 double b = -1.157744128784905;
00812 double c = 0.6710333014812285;
00813 double d = 0.067598983313541278;
00814 double e = 0.2824741750452964;
00815 double f = t*t*(d+e*t);
00816 double g = -t*(2*d+3*e*t);
00817 double h = d+3*e*t;
00818 double v, u, rs, y, z, p, q;
00819
00820 if(r == 0)
00821 {
00822 v = s*((a-f) + s*((-g)/2.0 + s*((b-h)/3.0 + s*(c+e)/4.0)))
00823 + t*(f + t*(g/2.0 + t*(h/3.0 + t*(-e)/4.0)));
00824 }
00825 else if(r < s)
00826 {
00827 rs = r*r;
00828 y = sqrt(s*s-rs);
00829 z = sqrt(t*t-rs);
00830 p = log(y+s);
00831 q = log(z+t);
00832 u = log(r);
00833 v = a*y + b*y*y*y/3.0 + b*y*rs + 0.5*c*rs*(y*s+rs*(p-u))
00834 + c*(y*s*s*s/4.0 - rs*0.125*(y*s+rs*(p-u)))
00835 + f*(z-y) + 0.5*(g-e*rs)*(z*t-y*s+rs*(q-p))
00836 + h*rs*(z-y) + (h/3.0)*(z*z*z-y*y*y)
00837 - e*(0.25*(z*t*t*t-y*s*s*s) - rs*0.125*(z*t-y*s+rs*(q-p)));
00838 }
00839 else if(r < t)
00840 {
00841 rs = r*r;
00842 z = sqrt(t*t-rs);
00843 q = log(z+t);
00844 u = log(r);
00845 v = f*z + 0.5*(g-e*rs)*(z*t+rs*(q-u)) + h*rs*z + (h/3.0)*z*z*z
00846 - e*(0.25*z*t*t*t-rs*0.125*(z*t+rs*(q-u)));
00847 }
00848 else
00849 {
00850 v = 0.0;
00851 }
00852
00853 return 2.0*v;
00854 }
00855
00856
00857
00858
00859
00860
00861 void vu1112111::initOpenGL(void)
00862 {
00863 GLfloat shininess = 50.0f;
00864 GLfloat specular[4] = {1.0f, 1.0f, 1.0f, 1.0f};
00865
00866 #if defined(ONE_SIDED_LIGHTING)
00867 glMaterialf(GL_FRONT, GL_SHININESS, shininess);
00868 glMaterialfv(GL_FRONT, GL_SPECULAR, specular);
00869 glEnable(GL_COLOR_MATERIAL);
00870 glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
00871
00872 glPolygonMode(GL_FRONT, GL_FILL);
00873 #else
00874 glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
00875 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular);
00876 glEnable(GL_COLOR_MATERIAL);
00877 glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
00878
00879 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
00880 #endif
00881
00882 glShadeModel(GL_SMOOTH);
00883 glDisable(GL_DEPTH_TEST);
00884 glDisable(GL_ALPHA_TEST);
00885 glDisable(GL_CULL_FACE);
00886
00887 glGenTextures(1, &m_GLSplat);
00888 glBindTexture(GL_TEXTURE_2D, m_GLSplat);
00889 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
00890 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
00891 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
00892 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
00893 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
00894
00895 #if defined(COMBINERS)
00896
00897 gluBuild2DMipmaps(GL_TEXTURE_2D, 1, m_FPSize, m_FPSize,
00898 GL_LUMINANCE, GL_UNSIGNED_BYTE,
00899 (void*)m_Footprint);
00900 glEnable(GL_TEXTURE_2D);
00901
00902 if (!glh_init_extensions("GL_NV_register_combiners "))
00903 cout << "Could not initialize extensions.\n" << flush;
00904
00905 glEnable(GL_REGISTER_COMBINERS_NV);
00906 glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, 1);
00907
00908
00909 glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_A_NV, GL_PRIMARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
00910 glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_B_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_RGB);
00911 glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_C_NV, GL_SECONDARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
00912 glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_D_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_RGB);
00913 glCombinerOutputNV(GL_COMBINER0_NV, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE);
00914
00915
00916 glCombinerInputNV(GL_COMBINER0_NV, GL_ALPHA, GL_VARIABLE_A_NV, GL_PRIMARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA);
00917 glCombinerInputNV(GL_COMBINER0_NV, GL_ALPHA, GL_VARIABLE_B_NV, GL_TEXTURE0_ARB, GL_UNSIGNED_IDENTITY_NV, GL_BLUE);
00918 glCombinerOutputNV(GL_COMBINER0_NV, GL_ALPHA, GL_SPARE0_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE);
00919
00920
00921 glFinalCombinerInputNV(GL_VARIABLE_A_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
00922 glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
00923 glFinalCombinerInputNV(GL_VARIABLE_C_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
00924 glFinalCombinerInputNV(GL_VARIABLE_D_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
00925 glFinalCombinerInputNV(GL_VARIABLE_E_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
00926 glFinalCombinerInputNV(GL_VARIABLE_F_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
00927
00928 glEnable(GL_BLEND);
00929 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
00930
00931 #else
00932
00933 gluBuild2DMipmaps(GL_TEXTURE_2D, 2, m_FPSize, m_FPSize,
00934 GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE,
00935 (void*)m_Footprint);
00936 glEnable(GL_TEXTURE_2D);
00937
00938 glEnable(GL_BLEND);
00939 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
00940 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
00941 #endif
00942 }
00943
00944
00945
00946
00947
00948 void vu1112111::drawSplatOrtho(float* v)
00949 {
00950 vuVector pos(v[0], v[1], v[2]);
00951
00952 pos += m_Shift0;
00953 glTexCoord2fv(texcoord0);
00954 glVertex3fv(pos.getData());
00955
00956 pos += m_Shift1;
00957 glTexCoord2fv(texcoord1);
00958 glVertex3fv(pos.getData());
00959
00960 pos += m_Shift2;
00961 glTexCoord2fv(texcoord2);
00962 glVertex3fv(pos.getData());
00963
00964 pos -= m_Shift1;
00965 glTexCoord2fv(texcoord3);
00966 glVertex3fv(pos.getData());
00967 }
00968
00969
00970
00971
00972
00973 void vu1112111::drawSplatPerspective(float* v)
00974 {
00975
00976 }