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