Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

specsplat.cpp

Go to the documentation of this file.
00001 #include <fstream.h>
00002 #include <math.h>
00003 #include <string>
00004 
00005 #include "vuColourRGBa.h"
00006 
00007 #include "specsplat.h"
00008 
00009 //----------------------------------------------------------------------------
00010 //------------------------- Static texture variables -------------------------
00011 //----------------------------------------------------------------------------
00012 
00013         // not used in the code.
00014 //static float texcoord0[2] = {0.0f, 0.0f};
00015 //static float texcoord1[2] = {0.0f, 1.0f};
00016 //static float texcoord2[2] = {1.0f, 1.0f};
00017 //static float texcoord3[2] = {1.0f, 0.0f};
00018 
00019 //
00020 // C0..C3 modelview matrix
00021 // C4..C7 projection matrix
00022 // C8..C11 modelview inverse transpose matrix
00023 // C12 light position
00024 // C13..c14 light colour
00025 // C15..17..20 left and right half of light transform matrix (3x8)
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 //------------------------- The default constructor --------------------------
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 //------------------------- The copy constructor -----------------------------
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 //------------------------- The destructor -----------------------------------
00123 //----------------------------------------------------------------------------
00124 
00125 vu1112115::~vu1112115()
00126 {
00127     if (m_Normals)
00128         delete [] m_Normals;
00129     if (m_Footprint)
00130     {
00131         delete [] m_Footprint;
00132 //NVCOMMENT        glDeleteTextures(1, &m_GLSplat);
00133     }
00134 }
00135 
00136 //----------------------------------------------------------------------------
00137 //------------------------- The assignment operator --------------------------
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 //------------------------- public setViewVectors() --------------------------
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 //------------------------- public setFootprintSize() ------------------------
00182 //----------------------------------------------------------------------------
00183 
00184 void vu1112115::setFootprintSize(dword size)
00185 {
00186     m_FPSize = size;
00187 }
00188 
00189 //----------------------------------------------------------------------------
00190 //------------------------- public getFootprintSize() ------------------------
00191 //----------------------------------------------------------------------------
00192 
00193 dword vu1112115::getFootprintSize() const
00194 {
00195     return m_FPSize;
00196 }
00197 
00198 //----------------------------------------------------------------------------
00199 //------------------------- public read() ------------------------------------
00200 //----------------------------------------------------------------------------
00201 
00202 bool vu1112115::read()
00203 {
00204     bool success = vu111211::read();
00205     if (!success) return false;
00206 
00207     //Allocate memory for the normals.
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 //------------------------- public readRaw() ---------------------------------
00221 //----------------------------------------------------------------------------
00222 
00223 bool vu1112115::readRaw(void)
00224 {
00225     dword len;
00226     ifstream in;
00227 
00228     in.open(m_FileName, ios::in|ios::binary);//|ios::nocreate);
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     //Allocate memory for the normals.
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 //------------------------- private preprocess() -----------------------------
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     // Compute all of the normals and create a quantization
00273     // table with 256 entries.
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     // Create a map from each voxel into the table
00332     // of quantized normals.
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 //------------------------- public render() ----------------------------------
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     // Compute indices, ranges, and values so that the rendering
00404     // loop can be as efficient as possible.
00405     //
00406     if (dp[0] > dp[1])
00407     {
00408         if (dp[0] > dp[2])
00409         {
00410             if (dp[1] > dp[2])
00411             {
00412                 // 2, 1, 0  (i.e. z=fast, y=medium, x=slow)
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                 // 1, 2, 0  (i.e. y=fast, z=medium, x=slow)
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             // 1, 0, 2  (i.e. y=fast, x=medium, z=slow)
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                 // 2, 0, 1  (i.e. z=fast, x=medium, y=slow)
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                 // 0, 2, 1  (i.e. x=fast, z=medium, y=slow)
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             // 0, 1, 2  (i.e. x=fast, y=medium, z=slow)
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     // The following loop is highly optimized for speed, given
00719     // the values and indices computed in the above conditionals.
00720     //
00721 //NVCOMMENT    glBegin(GL_QUADS);
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 //                  vuColourRGBa(col);
00732 //                  m_TFunc.getRGBa(density,col);
00733 //                    glColor4fv(col.getData()); //m_TFunc[density]);
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 //NVCOMMENT                    glNormal3fv(n);
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 //NVCOMMENT    glEnd();
00779 }
00780 
00781 //----------------------------------------------------------------------------
00782 //------------------------- private computeSplat() ---------------------------
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 //NVCOMMENT        glDeleteTextures(1, &m_GLSplat);
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 //------------------------- private nelsonSplat() ----------------------------
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 //------------------------- public initOpenGL() ------------------------------
00877 //----------------------------------------------------------------------------
00878 //#define ONE_SIDED_LIGHTING
00879     
00880 void vu1112115::initOpenGL(void)
00881 {
00882 //    GLfloat shininess = 50.0f;
00883 //    GLfloat specular[4] = {1.0f, 1.0f, 1.0f, 1.0f};
00884 /*
00885 #if defined(ONE_SIDED_LIGHTING)
00886     glMaterialf(GL_FRONT, GL_SHININESS, shininess);
00887     glMaterialfv(GL_FRONT, GL_SPECULAR, specular);
00888     glEnable(GL_COLOR_MATERIAL);
00889     glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
00890 
00891     glPolygonMode(GL_FRONT, GL_FILL);
00892 #else
00893 **
00894     glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
00895     glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular);
00896     glEnable(GL_COLOR_MATERIAL);
00897     glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
00898 **
00899     glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
00900 #endif
00901 
00902 
00903     glShadeModel(GL_SMOOTH);
00904     glDisable(GL_DEPTH_TEST);
00905     glDisable(GL_ALPHA_TEST);
00906     glDisable(GL_CULL_FACE);
00907     
00908     glGenTextures(1, &m_GLSplat);
00909     glBindTexture(GL_TEXTURE_2D, m_GLSplat);
00910     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
00911     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
00912     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
00913     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
00914     glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
00915 
00916 
00917     gluBuild2DMipmaps(GL_TEXTURE_2D, 2, m_FPSize, m_FPSize,
00918                       GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE,
00919                       (void*)m_Footprint);
00920     glEnable(GL_TEXTURE_2D);
00921 
00922     glEnable(GL_BLEND);
00923     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
00924     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
00925 
00926     
00927     initVertexProgram();
00928 */
00929 }
00930 
00931 
00932 
00933 //----------------------------------------------------------------------------
00934 //------------------------- private drawSplatOrtho() -------------------------
00935 //----------------------------------------------------------------------------
00936 
00937 void vu1112115::drawSplatOrtho(float* v)
00938 {
00939 /*
00940     vuVector pos(v[0], v[1], v[2]);
00941 
00942     pos += m_Shift0;
00943     glTexCoord2fv(texcoord0);
00944     glVertex3fv(pos.getData());
00945 
00946     pos += m_Shift1;
00947     glTexCoord2fv(texcoord1);
00948     glVertex3fv(pos.getData());
00949 
00950     pos += m_Shift2;
00951     glTexCoord2fv(texcoord2);
00952     glVertex3fv(pos.getData());
00953 
00954     pos -= m_Shift1;
00955     glTexCoord2fv(texcoord3);
00956     glVertex3fv(pos.getData());
00957 */
00958 }
00959 
00960 //----------------------------------------------------------------------------
00961 //------------------------- private drawSplatPerspective() -------------------
00962 //----------------------------------------------------------------------------
00963 
00964 void vu1112115::drawSplatPerspective(float* v)
00965 {
00966 
00967 }
00968 
00969 void vu1112115::initVertexProgram(void)
00970 {
00971 /*NVCOMMENT
00972     glEnable(GL_VERTEX_PROGRAM_NV);
00973 
00974     GLuint m_ProgramIDs[4];
00975 
00976     // Load the programs and bind to g_OneLight
00977     glGenProgramsNV(4, (GLuint*)&m_ProgramIDs);
00978     glLoadProgramNV(GL_VERTEX_PROGRAM_NV, m_ProgramIDs[0], strlen((char*)g_OneLight), g_OneLight);
00979 //    glLoadProgramNV(GL_VERTEX_PROGRAM_NV, m_ProgramIDs[1], strlen((char*)g_OneLight), g_TwoLights);
00980 //    glLoadProgramNV(GL_VERTEX_PROGRAM_NV, m_ProgramIDs[2], strlen((char*)g_OneLight), g_ThreeLights);
00981 //    glLoadProgramNV(GL_VERTEX_PROGRAM_NV, m_ProgramIDs[3], strlen((char*)g_OneLight), g_FourLights);
00982     glBindProgramNV(GL_VERTEX_PROGRAM_NV, m_ProgramIDs[0]);
00983 
00984     // Track the projection and modelview matrices
00985     // (so we know their memory locations)
00986     glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 0, GL_MODELVIEW, GL_IDENTITY_NV);
00987     glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 4, GL_PROJECTION, GL_IDENTITY_NV);
00988     glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 8, GL_MODELVIEW, GL_INVERSE_TRANSPOSE_NV);
00989 
00990     float m[3*8];
00991     for(int i=0; i<3*7; i++)
00992         m[(i/7)*8 + (i%7)] = CXF7toRGB[i/7][i%7];
00993     m[7] = m[15] = m[23] = 0;
00994     setCXFMatrix(m);
00995 */
00996 }
00997 
00998 void vu1112115::setCXFMatrix(float* m)
00999 {
01000 //NVCOMMENT    for(int i=0;i<6;i++)
01001 //NVCOMMENT     glProgramParameter4fvNV(GL_VERTEX_PROGRAM_NV, 15+i, &m[i*4]);
01002 }
01003 
01004 void vu1112115::setColour7a(const float* col)
01005 {
01006 //NVCOMMENT    glVertexAttrib4fvNV(3, col);
01007 //NVCOMMENT    glVertexAttrib4fvNV(4, col+4);
01008 }
01009 
01010 void vu1112115::setLightColour(vuColour7a& c)
01011 {
01012     float* f;
01013     f = c.getData();
01014 //NVCOMMENT    glProgramParameter4fvNV(GL_VERTEX_PROGRAM_NV, 13, f);
01015 //NVCOMMENT    glProgramParameter4fvNV(GL_VERTEX_PROGRAM_NV, 14, f+4);
01016 }
01017 
01018 void vu1112115::setLightPosition(vuVector & p)
01019 {
01020 //NVCOMMENT    glProgramParameter4fvNV(GL_VERTEX_PROGRAM_NV, 12, p.getData());
01021 }
01022 
01023 void vu1112115::drawPic ()
01024 
01025 {
01026 //      glBegin (GL_QUADS);
01027         glDrawBuffer (GL_FRONT);
01028 //      glDrawBuffer (GL_BACK);
01029 
01030 //      cout << "drawPic ()" << endl;
01031 
01032         glFinish ();
01033 
01034 //      glColor4f (0, 0, 0, 1.0);
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 //      glDrawBuffer (GL_FRONT);
01044         glDrawBuffer (GL_BACK);
01045 
01046         glEnable (GL_BLEND);
01047 //      glXSwapBuffers (
01048 
01049 //      glFlush ();
01050 //      glEnd ();
01051 }
01052 
01053 vuImage* vu1112115::getBuffer ()
01054 
01055 {
01056         return &m_ImgBuffer;
01057 }
01058 
01059 

Generated on Wed Dec 15 21:20:31 2004 for vuVolume by  doxygen 1.3.9.1