mirror/openmw
1
0
Fork 0
mirror of https://github.com/OpenMW/openmw.git synced 2025-01-16 21:59:55 +00:00
Code Issues Releases Wiki Activity

Deleted old code

Browse source
This commit is contained in:
scrawl 2013-08-08 03:10:25 +02:00
parent 08d1d486a4
commit a41a23c90a
13 changed files with 0 additions and 500 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
components/terrain/esm_land_factory.cpp
View file

@ -1,14 +0,0 @@
#include "esm_land_factory.hpp"
// The first one already includes the others implicitly, but it
// doesn't hurt to be explicit.
#include "../esm_store/store.hpp"
#include "../esm/esmreader.hpp"
#include "../esm/loadland.hpp"
using namespace Terrain;
bool ESMLandFactory::has(int x, int y)
{
return store.landscapes.has(x,y);
}

37
components/terrain/esm_land_factory.hpp
View file

@ -1,37 +0,0 @@
#ifndef TERRAIN_ESM_LAND_FACTORY_H
#define TERRAIN_ESM_LAND_FACTORY_H
#include "land_factory.hpp"
namespace ESMS
{
struct ESMStore;
}
namespace ESM
{
class ESMReader;
}
namespace Terrain
{
/*
Land factory that loads data from ESM files.
*/
class ESMLandFactory
{
ESMS::ESMStore &store;
ESM::ESMReader &reader;
public:
// Initialize the land factory. Note that refrences to the given
// store and reader are stored in the class, so the given objects
// must be valid for a long as you plan to use this factory.
ESMLandFactory(ESMS::ESMStore &st, ESM::ESMReader &rd)
: store(st), reader(rd) {}
// True if this factory has any data for the given grid cell.
bool has(int x, int y);
};
}
#endif

38
components/terrain/heightmap.hpp
View file

@ -1,38 +0,0 @@
#ifndef TERRAIN_HEIGHTMAP_H
#define TERRAIN_HEIGHTMAP_H
/*
Generic interface for a structure holding heightmap data.
A HeightMap returns information about landscape data in the form of
a regular grid of float heights.
*/
namespace Terrain
{
struct HeightMap
{
// Get height from grid position, counted from 0 to getNumX/Y().
virtual float getHeight(int x, int y) = 0;
// Get heigth from vertex index, assumed to be y*getNumX() + x.
virtual float getHeight(int index) = 0;
virtual float getMinX() = 0;
virtual float getMaxX() = 0;
virtual float getMinY() = 0;
virtual float getMaxY() = 0;
virtual int getNumX() = 0;
virtual int getNumY() = 0;
// True if the given coordinate is within the grid
bool isWithin(float x, float y)
{
return
x >= getMinX() && x < getMaxX() &&
y >= getMinY() && y < getMaxY();
}
};
}
#endif

72
components/terrain/heightmapbuf.hpp
View file

@ -1,72 +0,0 @@
#ifndef TERRAIN_HEIGHTMAPBUF_H
#define TERRAIN_HEIGHTMAPBUF_H
/*
A HeightMap implementation that stores heigths in a buffer.
*/
#include "heightmap.hpp"
#include "land_factory.hpp"
#include <vector>
#include <cassert>
namespace Terrain
{
class HeightMapBuffer : public HeightMap
{
std::vector<float> buf;
float beginX, sizeX, endX;
float beginY, sizeY, endY;
int numX, numY;
public:
void load(LandDataPtr data, const LandInfo &info)
{
// We don't support other kinds of grid data yet.
assert(info.grid == LGT_Quadratic);
assert(info.data == LDT_Float);
// Set up internal data
beginX = info.xoffset;
sizeX = info.xsize;
endX = beginX+sizeX;
numX = info.numx;
beginY = info.yoffset;
sizeY = info.ysize;
endY = beginY+sizeY;
numY = info.numy;
// Prepare the buffer and load it
buf.resize(numX*numY);
data.read(&buf[0], buf.size()*sizeof(float));
}
// Functions inherited from HeightMap:
float getHeight(int x, int y)
{
assert(x>=0 && x<numX);
assert(y>=0 && y<numY);
return getHeight(x + y*numX);
}
float getHeight(int index)
{
assert(index >= 0 && index < buf.size());
return buf[index];
}
float getMinX() { return beginX; }
float getMaxX() { return endX; }
float getMinY() { return beginY; }
float getMaxY() { return endY; }
int getNumX() { return numX; }
int getNumY() { return numY; }
};
}
#endif

43
components/terrain/land_factory.hpp
View file

@ -1,43 +0,0 @@
#ifndef TERRAIN_LAND_FACTORY_H
#define TERRAIN_LAND_FACTORY_H
namespace Terrain
{
enum LandInfoGridType
{
LGT_Quadratic
};
enum LandInfoDataType
{
LDT_Float
};
struct LandInfo
{
// Type information
LandInfoGridType grid;
LandInfoDataType data;
// Landscape size and number of vertices. Note that xsize and
// ysize may be negative, signaling a flipped landscape in that
// direction.
float xsize, ysize;
int numx, numy;
// World offset along the same x/y axes. Whether these are set or
// used depends on the client implementation.
float xoffset, yoffset;
};
/*
Factory class that provides streams to land data cells. Each
"cell" has a unique integer coordinate in the plane.
*/
struct LandFactory
{
// True if this factory has any data for the given grid cell.
virtual bool has(int x, int y) = 0;
};
}
#endif

1
components/terrain/tests/.gitignore vendored
View file

@ -1 +0,0 @@
*_test

14
components/terrain/tests/Makefile
View file

@ -1,14 +0,0 @@
GCC=g++
all: triangle_test esm_test
LIB_INC=-I../../../libs/
triangle_test: triangle_test.cpp
$(GCC) $^ -o $@
esm_test: esm_test.cpp
$(GCC) $^ -o $@ $(LIB_INC)
clean:
rm *_test

10
components/terrain/tests/esm_test.cpp
View file

@ -1,10 +0,0 @@
#include <iostream>
using namespace std;
#include "../esm_land_factory.hpp"
int main()
{
cout << "under development\n";
return 0;
}

1
components/terrain/tests/output/esm_test.out
View file

@ -1 +0,0 @@
under development

55
components/terrain/tests/output/triangle_test.out
View file

@ -1,55 +0,0 @@
Cell types:
\ / \ /
/ \ / \
\ / \ /
/ \ / \
Full index list:
0
6
5
0
1
6
1
2
6
6
2
7
2
8
7
2
3
8
3
4
8
8
4
9
5
6
10
10
6
11
6
12
11
6
7
12
7
8
12
12
8
13
8
14
13
8
9
14

18
components/terrain/tests/test.sh
View file

@ -1,18 +0,0 @@
#!/bin/bash
make || exit
mkdir -p output
PROGS=*_test
for a in $PROGS; do
if [ -f "output/$a.out" ]; then
echo "Running $a:"
./$a | diff output/$a.out -
else
echo "Creating $a.out"
./$a > "output/$a.out"
git add "output/$a.out"
fi
done

93
components/terrain/tests/triangle_test.cpp
View file

@ -1,93 +0,0 @@
#include <iostream>
using namespace std;
#include "../triangulator.hpp"
const int X = 4;
const int Y = 4;
typedef Terrain::Triangulator<short,X,Y> Triangles4x4;
int main()
{
Triangles4x4 t;
cout << "Cell types:\n";
for(int y=0;y<Y;y++)
{
for(int x=0;x<X;x++)
{
if(t.cellType(x,y)) cout << "/ ";
else cout << "\\ ";
}
cout << endl;
}
cout << endl;
cout << "Full index list:\n";
for(int i=0; i<X*Y*3; i++)
cout << t.getData()[i] << endl;
return 0;
}
/* Code we might add later:
// Get the vertex indices belonging to a given triangle
void getTriangle(int trinum, Index &p1, Index &p2, Index &p3)
{
assert(trinum >= 0 && trinum < TriNum);
trinum *= 3;
p1 = array[trinum++];
p2 = array[trinum++];
p3 = array[trinum];
}
/*
Get height interpolation weights for a given grid square. The
input is the grid square number (x,y) and the relative position
within that square (xrel,yrel = [0.0..1.0].) The weights are
returned as three vertex index + weight factor pairs.
A more user-friendly version for HeightMap structs is given
below.
* /
void getWeights(int x, int y, float xrel, float yrel,
Index &p1, float w1,
Index &p2, float w2,
Index &p3, float w3)
{
// Find cell index
int index = y*SizeX + x;
// First triangle in cell
index *= 2;
// The rest depends on how the cell is triangulated
if(cellType(x,y))
{
}
else
{
// Cell is divided as \ from 0,0 to 1,1
if(xrel < yrel)
{
// Bottom left triangle.
// Order is (0,0),(1,1),(0,1).
getTriangle(index, p1,p2,p3);
}
else
{
// Top right triangle
// Order is (0,0),(1,0),(1,1).
getTriangle(index+1, p1,p2,p3);
}
}
}
*/

104
components/terrain/triangulator.hpp
View file

@ -1,104 +0,0 @@
#ifndef TERRAIN_TRIANGULATOR_H
#define TERRAIN_TRIANGULATOR_H
/*
The triangulator is a simple math helper class, used for dividing a
regular square grid into alternating set of triangles. It divides a
grid like this:
+----+----+
| | |
| | |
+----+----+
| | |
| | |
+----+----+
into this:
+----+----+
| \ 2|3 / |
|1 \ | / 4|
+----+----+
|5 / | \ 8|
| / 6|7 \ |
+----+----+
Since the triangulation information is typically the same for all
terrains of the same size, once instance can usually be shared.
*/
#include <cassert>
namespace Terrain
{
// Index number type, number of grid cells (not vertices) in X and Y
// directions.
template <typename Index, int SizeX, int SizeY>
class Triangulator
{
// Number of triangles
static const int TriNum = SizeX * SizeY * 2;
// 3 indices per triangle
Index array[TriNum * 3];
public:
// Get raw triangle data pointer. Typically used for creating
// meshes.
const Index *getData() { return array; }
// Return whether a given cell is divided as / (true) or \
// (false).
static bool cellType(int x, int y)
{
assert(x >= 0 && x < SizeX);
assert(y >= 0 && y < SizeY);
bool even = (x & 1) == 1;
if((y & 1) == 1) even = !even;
return even;
}
// Constructor sets up the index buffer
Triangulator()
{
int index = 0;
for ( int y = 0; y < SizeX; y++ )
for ( int x = 0; x < SizeY; x++ )
{
// Get vertex indices
Index line1 = y*(SizeX+1) + x;
Index line2 = line1 + SizeX+1;
if(cellType(x,y))
{
// Top left
array[index++] = line1;
array[index++] = line1 + 1;
array[index++] = line2;
// Bottom right
array[index++] = line2;
array[index++] = line1 + 1;
array[index++] = line2 + 1;
}
else
{
// Bottom left
array[index++] = line1;
array[index++] = line2 + 1;
array[index++] = line2;
// Top right
array[index++] = line1;
array[index++] = line1 + 1;
array[index++] = line2 + 1;
}
}
assert(index == TriNum*3);
}
};
} // Namespace
#endif