int kore(int argc, char** argv) {
Kore::System::setName("Shader");
Kore::System::setup();
Kore::WindowOptions options;
options.title = "Shader";
options.width = 1024;
options.height = 768;
options.x = 100;
options.y = 100;
options.targetDisplay = -1;
options.mode = WindowModeWindow;
options.rendererOptions.depthBufferBits = 16;
options.rendererOptions.stencilBufferBits = 8;
options.rendererOptions.textureFormat = 0;
options.rendererOptions.antialiasing = 0;
Kore::System::initWindow(options);
Kore::System::setCallback(update);
FileReader vs("shader.vert");
FileReader fs("shader.frag");
vertexShader = new Shader(vs.readAll(), vs.size(), VertexShader);
fragmentShader = new Shader(fs.readAll(), fs.size(), FragmentShader);
VertexStructure structure;
structure.add("pos", Float3VertexData);
program = new Program;
program->setVertexShader(vertexShader);
program->setFragmentShader(fragmentShader);
program->link(structure);
vertices = new VertexBuffer(3, structure);
float* v = vertices->lock();
v[0] = -1;
v[1] = -1;
v[2] = 0.5;
v[3] = 1;
v[4] = -1;
v[5] = 0.5;
v[6] = -1;
v[7] = 1;
v[8] = 0.5;
vertices->unlock();
indices = new IndexBuffer(3);
int* i = indices->lock();
i[0] = 0;
i[1] = 1;
i[2] = 2;
indices->unlock();
Kore::System::start();
return 0;
}
void initGraphics() {
FileReader vs("shader.vert");
FileReader fs("shader.frag");
vertexShader = new Shader(vs.readAll(), vs.size(), VertexShader);
fragmentShader = new Shader(fs.readAll(), fs.size(), FragmentShader);
VertexStructure structure;
structure.add("pos", Float3VertexData);
structure.add("tex", Float2VertexData);
program = new Program;
program->setVertexShader(vertexShader);
program->setFragmentShader(fragmentShader);
program->link(structure);
tex = program->getTextureUnit("tex");
texture = new Texture(width, height, Image::RGBA32, false);
image = (int*)texture->lock();
for (int y = 0; y < texture->texHeight; ++y) {
for (int x = 0; x < texture->texWidth; ++x) {
image[y * texture->texWidth + x] = 0;
}
}
texture->unlock();
// Correct for the difference between the texture's desired size and the actual power of 2 size
float xAspect = (float)texture->width / texture->texWidth;
float yAspect = (float)texture->height / texture->texHeight;
vb = new VertexBuffer(4, structure, 0);
float* v = vb->lock();
{
int i = 0;
v[i++] = -1; v[i++] = 1; v[i++] = 0.5; v[i++] = 0; v[i++] = 0;
v[i++] = 1; v[i++] = 1; v[i++] = 0.5; v[i++] = xAspect; v[i++] = 0;
v[i++] = 1; v[i++] = -1; v[i++] = 0.5; v[i++] = xAspect; v[i++] = yAspect;
v[i++] = -1; v[i++] = -1; v[i++] = 0.5; v[i++] = 0; v[i++] = yAspect;
}
vb->unlock();
ib = new IndexBuffer(6);
int* ii = ib->lock();
{
int i = 0;
ii[i++] = 0; ii[i++] = 1; ii[i++] = 3;
ii[i++] = 1; ii[i++] = 2; ii[i++] = 3;
}
ib->unlock();
}
void Graphics2::initShaders() {
if (videoPipeline != nullptr) return;
VertexStructure structure;
structure.add("vertexPosition", Float3VertexData);
structure.add("texPosition", Float2VertexData);
structure.add("vertexColor", Float4VertexData);
FileReader fs("painter-video.frag");
FileReader vs("painter-video.vert");
Shader* fragmentShader = new Shader(fs.readAll(), fs.size(), FragmentShader);
Shader* vertexShader = new Shader(vs.readAll(), vs.size(), VertexShader);
videoPipeline = new PipelineState();
videoPipeline->setFragmentShader(fragmentShader);
videoPipeline->setVertexShader(vertexShader);
// videoPipeline->inputLayout[0] = { &structure };
// videoPipeline->compile();
videoPipeline->link(structure);
}
int main(int argc, const char* argv[])
{
/********************** ARGUMENTS ***********************/
string inputFile = argv[1];
string outputStem = argv[2];
string seedFile = outputStem + "_seed";
string vertexFile = outputStem + "_vertex.dat";
string metaFile = outputStem + "_meta.dat";
string tempFile = outputStem + "_temp";
cout << fixed << showpoint << setprecision(1);
/********************* TILE SORT *************************/
cout << "Starting First Pass: Tile Sorting\n";
SVAReader* reader = new SVAReader(inputFile);
TileSort* tiler = new TileSort(500*7000,VERTICES_PER_PAGE);
while (reader->hasNext())
{
tiler->Insert(reader->getNext());
}
int Objects = tiler->sortTile();
delete reader;
cout << "First Pass Complete: " << Objects << "\n\n";
/******************* CREATE STRUCTURES ******************/
int Pages = ceil((Objects+0.0) / (VERTICES_PER_PAGE+0.0));
MetadataEntry* metadataStructure;
metadataStructure = new MetadataEntry[Pages];
VertexStructure* vertexStructure = new VertexStructure(vertexFile,true);
#ifndef MEMORY_MAPPING
boost::shared_ptr<SpatialIndex::IStorageManager> tmp_btree_file (SpatialIndex::StorageManager::createNewDiskStorageManager (tempFile, PAGE_SIZE));
vertex_to_page_id_map* btree = new vertex_to_page_id_map (tmp_btree_file,PAGE_SIZE);
#endif
/******************** MAKE VERTEX PAGES ********************/
cout << "Starting Second Pass: Making Vertices Pages\n";
for (int pageId=0;pageId<Pages;pageId++)
{
VertexPage* vp = new VertexPage();
for (int i=0;i<VERTICES_PER_PAGE;i++)
if (tiler->hasNext())
{
Vertex_info* vinfo = tiler->getNext();
vp->vertices[i].Vector[0] = vinfo->vi.coords[0];
vp->vertices[i].Vector[1] = vinfo->vi.coords[1];
vp->vertices[i].Vector[2] = vinfo->vi.coords[2];
#ifdef MEMORY_MAPPING
idMap[vinfo->vid] = pageId;
#else
btree->insert(vinfo->vid,pageId);
#endif
delete vinfo;
}
vertexStructure->Put(vp);
metadataStructure[pageId].MakeMetaData(vp);
if (pageId%100000==0 && pageId!=0) cout << "Page Processed : " << pageId << " Out of " << Pages <<"\n";
delete vp;
}
delete vertexStructure;
cout << "Second Pass Complete\n\n";
/******************** MAKE META DATA STRUCTURE ********************/
cout << "Starting Third Pass: Replacing Vertex Ids with Page Ids\n";
tiler->Rewind();
for (id pageId=0;pageId<Pages;pageId++)
{
vector<Vertex> pageVoronoiMBR;
for (int i=0;i<VERTICES_PER_PAGE;i++)
if (tiler->hasNext())
{
Vertex_info* vinfo = tiler->getNext();
Box voronoiBoundingBox = vinfo->vi.voronoi_mbr.as_box();
pageVoronoiMBR.push_back(voronoiBoundingBox.low);
pageVoronoiMBR.push_back(voronoiBoundingBox.high);
for (vector<vertex_id>::iterator it = vinfo->vi.neighbours.begin();it != vinfo->vi.neighbours.end();it++)
{
#ifdef MEMORY_MAPPING
id linkPageId = idMap[*it];
#else
dias::map_query_result queryResult = btree->range_query (std::make_pair (*it, *it));
id linkPageId = queryResult[0].second;
#endif
if (linkPageId!= pageId) {
metadataStructure[pageId].pageLinks.insert(linkPageId);
}
}
delete vinfo;
}
Box::boundingBox(metadataStructure[pageId].voronoiMbr,pageVoronoiMBR);
if (pageId%100000==0 && pageId!=0) cout << "Page Processed : " << pageId << " Out of " << Pages <<"\n";
}
cout << "Third Pass Complete: " << Pages << "\n\n";
delete tiler;
// for (int pageId=0;pageId<Pages;pageId++) {
//// links += metadataStructure[pageId]->pageLinks.size();
// metadataStructure[pageId].pageLinks.clear();
// }
//
//// long overlapping = 0;
// long emptybb = 0;
//
// for(int i=0; i<Pages; i++) {
// for(int j=i+1; j<Pages; j++) {
//
// if(Box::overlap(metadataStructure[i].pageMbr, metadataStructure[j].pageMbr)) {
// metadataStructure[i].pageLinks.insert(j);
// metadataStructure[j].pageLinks.insert(i);
//// overlapping++;
// }
//// } else {
//// Box combined;
//// Box::combine(metadataStructure[i]->pageMbr, metadataStructure[j]->pageMbr, combined);
//// long ov = 0;
//// for(int k=0; k<Pages; k++) {
//// if(Box::overlap(metadataStructure[k]->pageMbr, combined)) {
//// ov++;
//// }
//// }
////
//// if(ov == 2) {
//// metadataStructure[i]->pageLinks.insert(j);
//// metadataStructure[js]->pageLinks.insert(i);
//// emptybb++;
//// }
//// }
// }
// }
//
// ofstream out("test2");
// for (int pageId=0;pageId<Pages;pageId++) {
// out << metadataStructure[pageId].pageLinks.size() << endl;
// }
// out.close();
SpatialIndex::IStorageManager* rtreeStorageManager = SpatialIndex::StorageManager::createNewDiskStorageManager(seedFile, PAGE_SIZE);
SpatialIndex::id_type indexIdentifier=1;
data_stream* ds = new data_stream(metadataStructure,Pages);
SpatialIndex::ISpatialIndex *seedTree = SpatialIndex::RTree::createAndBulkLoadNewRTree (
SpatialIndex::RTree::BLM_STR,
*ds,
*rtreeStorageManager,
dias::fill_factor, dias::index_node_capacity,
37, 3,
SpatialIndex::RTree::RV_RSTAR,
indexIdentifier);
cout << "Forth Pass Complete\n\n";
/******************* DELETE STRUCTURES ******************/
//delete ds;
vector<SpatialIndex::id_type> keys;
rtreeStorageManager->getKeys(&keys);
map<uint32_t,SpatialIndex::id_type> mapping;
for (vector<SpatialIndex::id_type>::iterator iter = keys.begin(); iter != keys.end(); ++iter) {
SpatialIndex::Region m_nodeMBR;
SpatialIndex::id_type id = *iter;
nodeSkeleton * nss = readNode(id, rtreeStorageManager);
if (nss->nodeType == SpatialIndex::RTree::PersistentLeaf) {
for (int i = 0; i < nss->children; i++) {
MetadataEntry m = MetadataEntry(nss->m_pData[i], nss->m_pDataLength[i]);
mapping.insert (pair<uint32_t,SpatialIndex::id_type>(m.pageId, *iter));
}
}
}
cout << "Mapping done\n\n";
for (vector<SpatialIndex::id_type>::iterator iter = keys.begin(); iter != keys.end(); ++iter) {
SpatialIndex::Region m_nodeMBR;
SpatialIndex::id_type id = *iter;
nodeSkeleton * nss = readNode(id, rtreeStorageManager);
if (nss->nodeType == SpatialIndex::RTree::PersistentLeaf) {
for(int i=0; i<nss->children; i++) {
MetadataEntry m = MetadataEntry(nss->m_pData[i], nss->m_pDataLength[i]);
set<uint32_t> updatedLinks;
for(set<uint32_t>::iterator it = m.pageLinks.begin(); it != m.pageLinks.end(); ++it) {
map<uint32_t,SpatialIndex::id_type>::iterator res = mapping.find(*it);
if(res != mapping.end()) {
updatedLinks.insert(res->second);
} else {
cout << "Unable to find mapping for " << *it << endl;
}
}
// if(m.pageLinks.size() != updatedLinks.size()) {
// cout << "Unequal sizes: " << m.pageLinks.size() << " :: " << updatedLinks.size() << endl;
// }
m.pageLinks.swap(updatedLinks);
int length = nss->m_pDataLength[i];
m.serialize(&nss->m_pData[i], length);
}
writeNode(id, rtreeStorageManager, nss);
}
}
cout << "Done: " << Pages << "\n\n";
delete rtreeStorageManager;
}
