Vega Strike Forums

Code: Select all

GamePlanet::GamePlanet( QVector x,
                        QVector y,
                        float vely,
                        const Vector &rotvel,
                        float pos,
                        float gravity,
                        float radius,
                        const string &textname,
                        const string &technique,
                        const string &unitname,
                        BLENDFUNC blendSrc,
                        BLENDFUNC blendDst,
                        const vector< string > &dest,
                        const QVector &orbitcent,
                        Unit *parent,
                        const GFXMaterial &ourmat,
                        const std::vector< GFXLightLocal > &ligh,
                        int faction,
                        string fgid,
                        bool inside_out ) :
{
...
//my code
//FIXME:an error with loading textures.. the texture wont be loaded in correctly
        std::vector< std::string > textures;
        textures.push_back( "planets/forest.texture" );
   //     textures.push_back( textname.c_str() );


 
        vector< Mesh* > m = Mesh::LoadMeshes( f, Vector(radius,radius,radius), faction, NULL, surface_unit.c_str(), textures );
        Unit *surface = UnitFactory::createUnit( m, true, faction );
...

Code: Select all

...
    if (!wormhole) {
        static int stacks = XMLSupport::parse_int( vs_config->getVariable( "graphics", "planet_detail", "24" ) );
        atmospheric = !(blendSrc == ONE && blendDst == ZERO);
//changed from here on
        //FIXED BUG: the radius of the sphere (the surface) must be a little bit smaller than the athmosphere in order to see the athmosphere
        SphereMesh* m = new SphereMesh( radius * 0.95, 1000, 1000, textname.c_str(), technique, NULL, inside_out, blendSrc, blendDst, false, 0.0, M_PI, 0.0, 2*M_PI, MIPMAP, false, true); //<--there is the last var is added and remarks that a planet surfsce sphere //shall be generated, it is the surface var below, add it to the class constructor and //InitSphere; set stacks and slices to 1000
        meshdata.push_back( m );
...

Code: Select all

...
//not changed code
        float rhol[2];
        float thetal[2];
#define g_rho( i ) ((rhol[((i))&1]))
#define g_theta( i ) ((thetal[((i))&1]))

//new code - this creates a basic height map - the only function implemented right now is
//to set a mountain top with all border pieces to zero level
        int   thir  = 2;
        int   four  = 3;
        int pos[stacks+2][slices+4];
        if(surface) {
            for(int i=0; i<stacks; i+=2) {
                //this row must be zero cause of alignment - maybe there is only one
                //stack needed
                pos[i][fir] = 0;
                pos[i][sec] = 0;
                pos[i+sec][fir] = 0;
                pos[i+sec][sec] = 0;
                for(int j=1; j<slices; j+=4)
                        //there are 
                        //the middle part that marks the mountain top
                        pos[i+fir][j+fir] = 0; //top border
                        pos[i+fir][j+sec] = 1; //mountain top first row
                        pos[i+sec][j+fir] = 1; //mountain top second row - must be at same
                                                     // level with first else the stacks are not linked
                        pos[i+sec][j+sec] = 0; //bottom border
                        
                        //the right border
                        pos[i+fir][j+thir] = 0;
                        pos[i+fir][j+four] = 0;
                        pos[i+sec][j+thir] = 0;
                        pos[i+sec][j+four] = 0;
                 }
            }
        }

....
//not changed
                //texcoords
                vertexlist[j*2+fir].s = GetS( g_theta( j ), theta_min, theta_max );                 //1-s;
                vertexlist[j*2+fir].t = GetT( g_rho( i ), rho_min, rho_max );                 //t;
//changed from here on
                //position
                if(!surface) {
                    vertexlist[j*2+fir].x = x*radius;
                    vertexlist[j*2+fir].z = -y*radius;
                    vertexlist[j*2+fir].y = z*radius;
                } else {
                    if(pos[i][j] == 0) {
                        vertexlist[j*2+fir].x = x*radius;
                        vertexlist[j*2+fir].z = -y*radius;
                        vertexlist[j*2+fir].y = z*radius;
                    } else {
                        vertexlist[j*2+fir].x = x*radius*1.005; //here is the terrain raised top
                                                                            //vertex of the stack
                        vertexlist[j*2+fir].z = -y*radius*1.005;
                        vertexlist[j*2+fir].y = z*radius*1.005;
                    }
                }
...




//not changed
                //texcoords
                vertexlist[j*2+sec].s  = GetS( g_theta( j ), theta_min, theta_max );                 //1-s;
                vertexlist[j*2+sec].t  = GetT( g_rho( i+1 ), rho_min, rho_max );                 //t - dt;
//changed from here on
                //position
                if(!surface) {
                    vertexlist[j*2+sec].x = x*radius;
                    vertexlist[j*2+sec].z = -y*radius;
                    vertexlist[j*2+sec].y = z*radius;
                } else {
                    if(pos[i+1][j] == 0) {
                        vertexlist[j*2+sec].x = x*radius;
                        vertexlist[j*2+sec].z = -y*radius;
                        vertexlist[j*2+sec].y = z*radius;
                    } else {
                        vertexlist[j*2+sec].x = x*radius*1.005; //here too - bottom vertex
                        vertexlist[j*2+sec].z = -y*radius*1.005;
                        vertexlist[j*2+sec].y = z*radius*1.005;
                    }
                }
//not changed
                s       += ds;
...

Code: Select all

...
//not modified
        case JpegImage:
            ret = this->ReadJPEG();
            break;
        case BmpImage:
            ret = this->ReadBMP();
            break;
        default:
            vs_dprintf( 1, "%s\n", img_file->GetFilename().c_str() );
            ret = NULL;
        }
//modified from here on
        if (t) {
           unsigned char* r[sizeY];
           for( int i=0; i < sizeY; i++)
               r[i] = &ret[ sizeX * img_depth/8 * i ];
           unsigned char* tmp_ret = (*t)(img_depth, img_color_type, sizeX, sizeY, r);
           free( ret );
           ret = tmp_ret;
        }
//not modified
        return ret;
...

Code: Select all

        if (t) {
           unsigned char** rp = new unsigned char*[sizeY];
           for (unsigned int i = 0; i < sizeY; i++) {
               rp[i] = new unsigned char[sizeX * img_depth/8];
               memcpy( rp[i], ret+(sizeX * img_depth/8 * i), sizeX * img_depth/8 );
           }
           free( ret );
           ret = (*t)(img_depth, img_color_type, sizeX, sizeY, rp);
           for (int i = 0; i < sizeY; i++)
               free(rp[i]);
           free(rp); 
        }

Code: Select all

...
//old code
        if ( header.dcaps2&(DDS_CUBEMAP|DDS_CUBEMAP_ALLFACES) ) {
            vs_dprintf(3, "Reading Cubemap %s\n", img_file->GetFilename().c_str() );
            inputSize = inputSize*6;
            this->img_sides =
                SIDE_POS_X|SIDE_NEG_X
                |SIDE_POS_Y|SIDE_NEG_Y
                |SIDE_POS_Z|SIDE_NEG_Z;                  //all sides, we don't support partial DDS files
            this->img_color_type = 998;             //Cubemap'd dds
        } else {
            this->img_color_type = 999;              //Regular DDS
        }
//new code
        if(tt) {
            vs_dprintf(3, "Doing a transformation \n");

            JSAMPARRAY     row_pointers = NULL; //Output row buffer
            row_pointers    = (unsigned char**) malloc( sizeof (unsigned char*)*this->sizeY );
            s = (unsigned char*) malloc( inputSize+3 );
            unsigned char* s2 = s+2;

            sprintf( (char*) s, "%i", header.nmips );         //if cubemap, mips per face

            if(img_color_type = 998) {
                for(int side = 0; side < 6; side++) { //side is a side of the cubemap
                    int side_offset = inputSize/6*side;
                    int row_offset = side_offset/this->sizeY;

                    for (unsigned int i = 0; i < this->sizeY; i++)
                        row_pointers[i] = &s2[i*row_offset];

                    vs_dprintf(3, "transforming %i \n", side);

                    img_file->Read( s2+side_offset, inputSize/6 );

                    unsigned char *result = s2+side_offset;
                    result = (*tt)(this->img_depth, this->img_color_type, this->sizeX, this->sizeY, row_pointers);
                    memcpy( s2+side_offset, result, inputSize/6 );
                    free(result);
                    result = NULL;
                }
            } else {
                for (unsigned int i = 0; i < this->sizeY; i++)
                    row_pointers[i] = &s2[i*inputSize/this->sizeY];

                img_file->Read( s+2, inputSize );

                unsigned char *result = s;
                result = (*tt)(this->img_depth, this->img_color_type, this->sizeX, this->sizeY, row_pointers);
                free( s );
                s = result;
            }
        } else {
            s = (unsigned char*) malloc( inputSize+3 );
            sprintf( (char*) s, "%i", header.nmips );         //if cubemap, mips per face
            img_file->Read( s+2, inputSize );
        }
//old code
        //At the end of execution what we have is the following:
        //s contains the number of mipmaps then the main texture and all it's mipmaps
        //sizeY is the height of the initial texture, sizeX is the width.
        //mode is the compressed format of the texture. It is assumed to be rgba
        //depth is the depth of the uncompressed image. not sure where this is used
        //nmaps is the number of mipmaps
        return s;
...

Code: Select all

...
//old code
            for (int palcount = 0; palcount < 256; palcount++) {
                img_file->Read( paltemp, SIZEOF_RGBQUAD );
                ctemp      = paltemp[0];
                paltemp[0] = paltemp[2];
                paltemp[2] = ctemp;
                paltemp   += 4;                 //pal size
            }
            if (!data)
                return NULL;
//new code
            if(tt) {
                vs_dprintf(3, "Doing a transformation \n");

                JSAMPARRAY     row_pointers = NULL; //Output row buffer
                row_pointers    = (unsigned char**) malloc( sizeof (unsigned char*)*this->sizeY );

                unsigned long stride = sizeof (unsigned char)*this->img_depth/8;
                for (unsigned int i = 0; i < this->sizeY; i++)
                    row_pointers[i] = &data[i*stride*this->sizeX];
                unsigned int count = 0;

                for (int i = sizeY-1; i >= 0; i--)
                    for (unsigned int j = 0; j < sizeX; j++)
                        img_file->Read( (void*)&row_pointers[i][j], sizeof (unsigned char) );

                unsigned char *result = data;
                result = (*tt)(this->img_depth, this->img_color_type, this->sizeX, this->sizeY, row_pointers);
                free( data );
                data = result;
            } else {
                for (int i = sizeY-1; i >= 0; i--)
                    for (unsigned int j = 0; j < sizeX; j++)
                        img_file->Read( data+j+i*sizeX, sizeof (unsigned char) );
            }
        }
//old code
        return data;