Пример #1
0
Matrix& Matrix::SetInverse(const Matrix& mStart)
{
    const int size = 4;
    bool bSwap = false;

    Matrix m(mStart);
    SetIdentity();

    for (int row = 0; row < size; row++) {
        //
        // pick the largest row in the rowth column
        //

        float max    = abs(m.m_m[row][row]);
        int   rowMax = row;

        for (int rowIndex = row + 1; rowIndex < size; rowIndex++) {
            if (abs(m.m_m[rowIndex][row]) > max) {
                max = abs(m.m_m[rowIndex][row]);
                rowMax = rowIndex;
            }
        }

        //
        // swap this row with the largest row
        //

        if (rowMax != row) {
            //
            // swap rows
            //

            bSwap = true;
            for (int col = 0; col < size; col++) {
                Swap(m.m_m[row][col], m.m_m[rowMax][col]);
                Swap(  m_m[row][col],   m_m[rowMax][col]);
            }
        }

        //
        // scale to get a one in the diagonal
        //

        float scale = m.m_m[row][row];

        if (scale != 1.0f) {
            float rscale = 1.0f / scale;

            int col;
            m.m_m[row][row] = 1;
            for (col = row + 1; col < size; col++) {
                m.m_m[row][col] *= rscale;
            }

            if (bSwap) {
                for (col = 0; col < size; col++) {
                    m_m[row][col] *= rscale;
                }
            } else {
                m_m[row][row] = rscale;
                for (col = 0; col < row; col++) {
                    m_m[row][col] *= rscale;
                }
            }
        }

        //
        // get zeros in the rowth column of each row
        // by subtracting a multiple of row from row2
        //

        for (int row2 = 0; row2 < size; row2++) {
            if (row2 != row) {
                float scale = m.m_m[row2][row];

                if (scale != 0) {
                    int col;

                    m.m_m[row2][row] = 0;
                    for (col = row + 1; col < size; col++) {
                        m.m_m[row2][col] -= scale * m.m_m[row][col];
                    }

                    if (bSwap) {
                        for (col = 0; col < size; col++) {
                            m_m[row2][col] -= scale * m_m[row][col];
                        }
                    } else {
                        for (col = 0; col <= row; col++) {
                            m_m[row2][col] -= scale * m_m[row][col];
                        }
                    }
                }
            }
        }
    }

    m_type = TransformUnknown;

    return *this;
}
bool PraetoriansTerrainWater::loadPackedMedia(const char* path)
{
  unsigned int signature;
  unsigned short chunkid;
  unsigned int chunklength;
  unsigned int texturescount;///use one in this version
  unsigned int watercount;
  unsigned int vertexcount;
  unsigned int indexcount;
  
  Tuple3f* vertices;
  unsigned short* indices;
  Tuple4ub* colors;
  Tuple2f* txcoords;
  ArchivedFile* file;
  WaterDatabase* wdatabase;
  
  if (!(file = FileSystem::checkOut(path)))
    return Logger::writeErrorLog(String("Could not load -> ") + path);
    
  wdatabase = Gateway::getWaterDatabase();
  
  file->read(&signature, 4);
  
  file->read(&chunkid, 2);
  file->read(&chunklength, 4);
  file->read(&texturescount, 4);
  for (unsigned int i = 0; i < texturescount; i++)
    file->seek((256 * 256 * 4) + 6, SEEKD);
    
  file->read(&watercount, 4);
  for (unsigned int i = 0; i < watercount; i++)
  {
    file->read(&chunkid, 2);
    file->read(&chunklength, 4);
    file->seek(48, SEEKD);
    file->read(&vertexcount, 4);
    
    vertices = new Tuple3f[vertexcount];
    colors = new Tuple4ub[vertexcount];
    txcoords = new Tuple2f[vertexcount];
    for (unsigned int j = 0; j < vertexcount; j++)
    {
      file->read(vertices[j], 12);
      Swap(vertices[j].x, vertices[j].z);
      file->read(colors[j], 4);
      Swap(colors[j].x, colors[j].z);
      file->read(txcoords[j], 8);
    }
    
    file->read(&indexcount, 4);
    indices = new unsigned short[indexcount];
    file->read(indices, indexcount * 2);
    
    String watername = String("H2O_") + int(wdatabase->getWatersCount());
    Geometry* geometry;
    geometry = new Geometry(watername, indexcount, vertexcount);
    geometry->setIndices(indices, false);
    geometry->setVertices(vertices, false);
    geometry->setColors(colors, false);
    geometry->setTextureElements(txcoords, 2, false);
    geometry->computeBounds();
    
    Appearance* appearance = new Appearance();
    appearance->setBlendAttributes(BlendAttributes(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
    appearance->setTexture(0, wdatabase->getWaterTexture());
    
    Model* model = new Model();
    model->setAppearance(appearance);
    model->setGeometry(geometry);
    
    TransformGroup* group = new TransformGroup();
    group->addChild(model);
    group->updateBoundsDescriptor();
    wdatabase->addWaterModel(group);
    
    deleteArray(vertices);
    deleteArray(indices);
    deleteArray(colors);
    deleteArray(txcoords);
  }
  
  FileSystem::checkIn(file);
  
  return true;
}
bool PraetoriansTerrainWater::exportData(const char* projectName)
{
  WaterDatabase* wdatabase;
  TransformGroup* tgroup;
  TransformGroup* tgroupchild;
  Geometry* geo;
  const char* inp;
  unsigned char* colsbuf;
  Tuple3f* verts;
  Tuple4ub* colors;
  Tuple2f *txcoords;
  unsigned short* indices;
  
  unsigned int signature = 2;
  unsigned short texturechunkid = 22912;
  unsigned int texturechunklen = 262164;
  unsigned int texturecount = 1;
  
  unsigned short textureid = 22914;
  unsigned int texturelen = 262150;
  
  unsigned short waterid = 22913;
  unsigned int waterlen = 0;
  
  unsigned int watercount;
  unsigned char bullshit0 = 0;
  unsigned char bullshit01[4] = {0xF0, 0xAD, 0xBA, 0x0D};
  unsigned char bullshit1[4] = {0x00};
  unsigned int vertcount;
  unsigned int idxcount;
  Tuple4ub refcol;
  Tuple3f refvert;
  String path = Gateway::getExportPath();
  
  if (!(inp = MediaPathManager::lookUpMediaPath("water_2_1.col")))
    return Logger::writeErrorLog("Could not locate water_2_1.col");
  ifstream in(inp, ios_base::binary);
  if (!in.is_open())
    return false;
  colsbuf = (unsigned char*) Gateway::aquireGeometryMemory(256 * 256 * 4);
  in.read((char*)colsbuf, 256 * 256 * 4);
  in.close();
  
  ofstream out((path + "Mapas/" + projectName + ".H2O").getBytes(), ios_base::binary);
  
  if (!out.is_open())
    return false;
    
  out.write((char*)&signature, 4);
  out.write((char*)&texturechunkid, 2);
  out.write((char*)&texturechunklen, 4);
  out.write((char*)&texturecount, 4);
  
  out.write((char*)&textureid, 2);
  out.write((char*)&texturelen, 4);
  out.write((char*)colsbuf, 256 * 256 * 4);
  
  Gateway::releaseGeometryMemory(colsbuf);
  
  wdatabase = Gateway::getWaterDatabase();
  tgroup = wdatabase->getRootGroup();
  
  watercount = tgroup->getGroupsCount();
  out.write((char*)&watercount, 4);
  
  for (unsigned int i = 0; i < watercount; i++)
  {
    tgroupchild = tgroup->getGroup(i);
    geo = tgroupchild->getModel(0)->getGeometry();
    verts = geo->getVertices();
    colors = geo->getColors();
    txcoords = geo->getTextureCoords();
    indices = geo->getIndices();
    vertcount = geo->getVerticesCount();
    idxcount = geo->getIndicesCount();
    
    out.write((char*)&waterid, 2);
    waterlen = 52 + (vertcount*24) + 4 + (idxcount*2) + 6;
    out.write((char*)&waterlen, 4);
    
    out.write((char*)&bullshit0, 1);
    for (unsigned int j = 0; j < 7; j++)
      out.write((char*)bullshit01, 4);
    out.write((char*)bullshit01, 3);
    for (unsigned int j = 0; j < 4; j++)
      out.write((char*)bullshit1, 4);
      
    out.write((char*)&vertcount, 4);
    
    for (unsigned int j = 0; j < vertcount; j++)
    {
      refvert = verts[j];
      Swap(refvert.x, refvert.z);
      out.write((char*)&refvert, 12);
      
      refcol = colors[j];
      Swap(refcol.x, refcol.z);
      out.write((char*)&refcol, 4);
      
      out.write((char*)&txcoords[j], 8);
    }
    
    out.write((char*)&idxcount, 4);
    out.write((char*)indices, idxcount * 2);
  }
  
  out.close();
  
  return true;
}
Пример #4
0
void __gl_edgeIntersect( GLUvertex *o1, GLUvertex *d1,
			 GLUvertex *o2, GLUvertex *d2,
			 GLUvertex *v )
/* Given edges (o1,d1) and (o2,d2), compute their point of intersection.
 * The computed point is guaranteed to lie in the intersection of the
 * bounding rectangles defined by each edge.
 */
{
  GLdouble z1, z2;

  /* This is certainly not the most efficient way to find the intersection
   * of two line segments, but it is very numerically stable.
   *
   * Strategy: find the two middle vertices in the VertLeq ordering,
   * and interpolate the intersection s-value from these.  Then repeat
   * using the TransLeq ordering to find the intersection t-value.
   */

  if( ! VertLeq( o1, d1 )) { Swap( o1, d1 ); }
  if( ! VertLeq( o2, d2 )) { Swap( o2, d2 ); }
  if( ! VertLeq( o1, o2 )) { Swap( o1, o2 ); Swap( d1, d2 ); }

  if( ! VertLeq( o2, d1 )) {
    /* Technically, no intersection -- do our best */
    v->s = (o2->s + d1->s) / 2;
  } else if( VertLeq( d1, d2 )) {
    /* Interpolate between o2 and d1 */
    z1 = EdgeEval( o1, o2, d1 );
    z2 = EdgeEval( o2, d1, d2 );
    if( z1+z2 < 0 ) { z1 = -z1; z2 = -z2; }
    v->s = Interpolate( z1, o2->s, z2, d1->s );
  } else {
    /* Interpolate between o2 and d2 */
    z1 = EdgeSign( o1, o2, d1 );
    z2 = -EdgeSign( o1, d2, d1 );
    if( z1+z2 < 0 ) { z1 = -z1; z2 = -z2; }
    v->s = Interpolate( z1, o2->s, z2, d2->s );
  }

  /* Now repeat the process for t */

  if( ! TransLeq( o1, d1 )) { Swap( o1, d1 ); }
  if( ! TransLeq( o2, d2 )) { Swap( o2, d2 ); }
  if( ! TransLeq( o1, o2 )) { Swap( o1, o2 ); Swap( d1, d2 ); }

  if( ! TransLeq( o2, d1 )) {
    /* Technically, no intersection -- do our best */
    v->t = (o2->t + d1->t) / 2;
  } else if( TransLeq( d1, d2 )) {
    /* Interpolate between o2 and d1 */
    z1 = TransEval( o1, o2, d1 );
    z2 = TransEval( o2, d1, d2 );
    if( z1+z2 < 0 ) { z1 = -z1; z2 = -z2; }
    v->t = Interpolate( z1, o2->t, z2, d1->t );
  } else {
    /* Interpolate between o2 and d2 */
    z1 = TransSign( o1, o2, d1 );
    z2 = -TransSign( o1, d2, d1 );
    if( z1+z2 < 0 ) { z1 = -z1; z2 = -z2; }
    v->t = Interpolate( z1, o2->t, z2, d2->t );
  }
}
Пример #5
0
IOFile& IOFile::operator=(IOFile&& other)
{
	Swap(other);
	return *this;
}
Пример #6
0
IOFile::IOFile(IOFile&& other)
	: m_file(nullptr), m_good(true)
{
	Swap(other);
}