void *NexeMain(void *data) {
PostMessage("Running Boom thread.");
while (1) {
layer1(2, 9);
}
return NULL;
}
//Calls layer 1,2,and 3 within layer 4
char* receive(struct l2pdu* lay2,char*buf,char pos)
{
struct l3pdu* final;
struct l2pdu* ptr2;
int i,i2;
layer1(lay2,pos);
ptr2 = layer2(final,lay2,pos); //empty structures passed in to satisfy parameter requirements
final = layer3(ptr2, buf,pos);
//Calls layer 3, 2,and 1 within layer 4
struct l2pdu* transmit(char*buf, char pos)
{
struct l3pdu* strptr3;
struct l2pdu* strptr2;
struct l2pdu* strptr1;
strptr3 = layer3(strptr2,buf,pos); //empty structures passed in to satisfy parameter requirements
strptr2= layer2(strptr3,strptr2,pos);
strptr1 = layer1(strptr2,pos);
return strptr1;
}
int main(void) {
if (!NaClCrashDumpInit()) {
fprintf(stderr, "ERROR: failed to set up crash dumping\n");
return 2;
}
fprintf(stderr, "** intended_exit_status=166\n");
layer1(2, 9);
return 1;
}
Level::Level()
: hero(nullptr)
, hero_panel(nullptr)
, map(nullptr)
, scene_graph()
{
SceneNode::PtrNode layer1(new SceneNode());
layers.push_back(layer1.get());
scene_graph.addChild(std::move(layer1));
SceneNode::PtrNode layer2(new SceneNode());
layers.push_back(layer2.get());
scene_graph.addChild(std::move(layer2));
SceneNode::PtrNode layer3(new SceneNode());
layers.push_back(layer3.get());
scene_graph.addChild(std::move(layer3));
SceneNode::PtrNode layer4(new SceneNode());
layers.push_back(layer4.get());
scene_graph.addChild(std::move(layer4));
SceneNode::PtrNode layer5(new SceneNode());
layers.push_back(layer5.get());
scene_graph.addChild(std::move(layer5));
texture_generator.load(SystemImage::TextContinueButton, "textures/text_continue_button.png");
texture_generator.load(SystemImage::LifeFlower, "textures/life_flower.png");
//World::current_level->getTG().load(201, "textures/smoke_puffup.png");
std::unique_ptr<HeroPanel> h_panel(new HeroPanel(texture_generator));
hero_panel = h_panel.get();
h_panel->initPosition();
node_vector.push_back(hero_panel);
layers[3]->addChild(std::move(h_panel));
std::cout << "Level created" << std::endl;
}
int main ( int argc , char **argv ) {
#if 0
BackGenEngine::BLogger logger;
BackGenEngine::BDynamicModuleSystem dm ( &logger );
dm.loadModule ( "../../modules/asset/image/BImageAsset" );
#endif
#if 0
DIR *dh;//directory handle
struct dirent *file;//a 'directory entity' AKA file
dh = opendir ( "./" );
while ( file = readdir ( dh ) ) {
printf ( "%s\n", file->d_name );
}
return 0;
#endif
#if 0
BoxE::Core::BSettings s;
s.setValue ( "a", 'a' );
std::cout << "a: " << s.value ( "a" ).value<char>();
#endif
BoxE::Math::BMatrix4x4f m1;
m1.setToIdentity();
m1.rotateX ( 90 );
BoxE::Math::BMatrix4x4f m2 ( m1.getInverse() );
BoxE::Math::BMatrix4x4f m3 ( m1 * m2 );
#if 0
BackGenEngine::BLogger logger;
BackGenEngine::BActionManager actionm;
BackGenEngine::BDynamicModuleSystem mod_sys ( &logger );
mod_sys.loadModule ( "../../modules/component/transformation/BTransformationComponent" );
mod_sys.loadModule ( "../../modules/component/meshrenderer/BMeshRendererComponent" );
mod_sys.loadModule ( "../../modules/component/cubemesh/BCubeMesh" );
mod_sys.loadModule ( "../../modules/asset/image/BImageAsset" );
mod_sys.loadModule ( "../../modules/asset/texture/BTextureAsset" );
mod_sys.loadModule ( "../../modules/asset/material/BMaterialAsset" );
mod_sys.loadModule ( "../../modules/asset_loader/image_tga/TGAloader" );
mod_sys.loadModule ( "../../modules/asset_loader/texture/Textureloader" );
mod_sys.loadModule ( "../../modules/asset_saver/texture/TextureSaver" );
BSDLWindow window ( "pokus", BackGenEngine::BAbstractWindow::screen_resolution_t ( 800, 600, 0 ), 32, false, &logger );
window.init();
window.show();
BOpenGLRenderer renderer ( &logger );
renderer.init();
renderer.onScreenChanged ( BoxE::Math::BVector3f ( 800, 600 , 0 ), false );
BackGenEngine::BProject project ( 0, &mod_sys, &logger );
project.setBaseDir ( "/home/backgen/pokusgame/" );
BackGenEngine::BScene scene ( &renderer, &logger );
BackGenEngine::BLayer *pc_layer = scene.getLayersManager().createLayer ( "vrstva1", BackGenEngine::BLayer::GUI );
//mod_sys.loadModule ( "../../modules/component/transformation/BTransformationComponent" );
//project.setName ( "Testing" );
//window.show();
BackGenEngine::BObject *pc_triangles = new BackGenEngine::BObject ( "Object1", 0 );
BackGenEngine::BAbstractComponent *pc_transform = mod_sys.createComponent ( "Transformation", &scene );
( ( BTransformationComponent * ) pc_transform )->position().setXYZ ( 0.0f, 0.0f, -5.0f );
BackGenEngine::BAbstractComponent *pc_cubemesh = mod_sys.createComponent ( "CubeMesh", &scene );
BackGenEngine::BAbstractComponent *pc_meshrenderer = mod_sys.createComponent ( "MeshRenderer", &scene );
pc_triangles->insertComponent ( pc_transform );
pc_triangles->insertComponent ( pc_cubemesh );
pc_triangles->insertComponent ( pc_meshrenderer );
/* PokusRenderComponent *pc_rendr_comp = new PokusRenderComponent ( &scene );
pc_triangles->insertComponent ( pc_rendr_comp );*/
pc_layer->insertObject ( pc_triangles );
BackGenEngine::BButtonAction quitAction ( "Quit", BackGenEngine::BAbstractWindow::BK_ESCAPE, &window );
actionm.insert ( &quitAction );
BackGenEngine::BActionManager::actions_hash_t::ConstIterator iter = actionm.constBegin();
/* BoxE::Math::BMatrix4x4f ortho;
ortho.setOrthographic ( 0, 800, 0, 600, 0.0f, 1.0f );
renderer.pushMatrix ( BOpenGLRenderer::MT_PROJECTION );
renderer.setMatrix ( BOpenGLRenderer::MT_PROJECTION, ortho );*/
BackGenEngine::BObject *pc_camera_object = new BackGenEngine::BObject ( "Camera", 0 );
BBaseCameraComponent *pc_camera_component = new BBaseCameraComponent ( &scene );
pc_camera_component->resize ( 800, 600 );
pc_camera_component->insertLayer ( pc_layer );
/* glViewport ( 0, 0, 800, 600 );
glMatrixMode ( GL_PROJECTION );
glLoadIdentity();
glOrtho ( 0, 800, 0, 600, -1, 1 );*/
BImageAsset *pc_image = ( BImageAsset * ) mod_sys.createAsset ( "Image", &project, &renderer, &project.getAssetManager(), &logger );
pc_image->setName ( "image1" );
pc_image->setPath ( "skin.tga" );
pc_image->use();
BTextureAsset *pc_texture = ( BTextureAsset * ) mod_sys.createAsset ( "Texture", &project, &renderer, &project.getAssetManager(), &logger );
pc_texture->setImage ( pc_image );
pc_texture->setMipmaping ( true );
//pc_texture->setPath( "texture1.texture" );
BMaterialAsset *pc_material = ( BMaterialAsset * ) mod_sys.createAsset ( "Material", &project, &renderer, &project.getAssetManager(), &logger );
pc_material->setTextureUnit ( 0, pc_texture );
( ( BMeshRendererComponent * ) pc_meshrenderer )->setMaterialAsset ( pc_material );
( ( BMeshRendererComponent * ) pc_meshrenderer )->setTiling ( BoxE::Math::BVector2f ( 2.0f, 2.0f ) );
float i = 0;
BoxE::Math::BMatrix4x4f rot;
while ( !window.update() && quitAction.isUp() ) {
i += 1;
( ( BTransformationComponent * ) pc_transform )->rotation().y ( i );
pc_camera_component->render();
renderer.beginRender ( true, true, BoxE::Math::BVector3f ( 0.0f, 0.0f, 0.0f ) );
renderer.drawSreenTexture ( pc_camera_component->getOutputTexture() );
//renderer.drawSreenTexture ( pc_texture->getTexture() );
renderer.endRender();
SDL_GL_SwapBuffers( );
// renderer.popMatrix ( BOpenGLRenderer::MT_PROJECTION );
//renderer.popMatrix ( BOpenGLRenderer::MT_WORLD );
};
#endif
//BoxE::Math::BMatrix4x4f matrix( BoxE::Math::BMatrix4x4f::IDENTITY );
#if 0
BackGenEngine::BObject obj1 ( "obj1" );
BackGenEngine::BObject obj2 ( "obj2", &obj1 );
BackGenEngine::BObject obj3 ( "obj3" );
BackGenEngine::BObject obj4 ( "obj4", &obj1 );
BackGenEngine::BObject::objects_list_t::ConstIterator it = obj1.constObjectsBegin();
while ( it != obj1.constObjectsEnd() ) {
std::cout << ( *it )->name() << std::endl;
++it;
}
obj1.name ( "OBJ1" );
BackGenEngine::BLayersManager lm;
BackGenEngine::BLayer layer1 ( "layer", BackGenEngine::BLayer::NORMAL );
layer1.insertObject ( &obj1 );
BackGenEngine::BLayer *layer2 = lm.createLayer ( "layer1", BackGenEngine::BLayer::NORMAL );
if ( lm.removeLayer ( "layer1" ) ) {
std::cout << obj1.layer()->name() << std::endl;
}
BackGenEngine::BTagsManager tm;
BackGenEngine::BTag *tag1 = tm.createTag ( "tag1" );
BackGenEngine::BTag *tag2 = tm.createTag ( "tag1" );
tm.removeTag ( tag1 );
if ( tm.containTag ( "tag1" ) ) {
std::cout << "obsahuje" << std::endl;
}
#endif
#if 0
BackGenEngine::BLogger logger;
BackGenEngine::BActionManager actionm;
BSDLWindow window ( "TestApp", BackGenEngine::BAbstractWindow::screen_resolution_t ( 800, 600, 0 ), 32, false, &logger );
window.init();
window.show();
window.onKeyDown().connect ( &on_key_down );
window.onMouseMotion().connect ( &mouse );
BackGenEngine::BButtonAction quitAction ( "Quit", BackGenEngine::BAbstractWindow::BK_ESCAPE, &window );
actionm.insert ( &quitAction );
BackGenEngine::BActionManager::actions_hash_t::ConstIterator iter = actionm.constBegin();
while ( !window.update() && quitAction.isUp() ) {
};
#endif
#if 0
BoxE::Core::BLibrary SDL ( "SDL" );
if ( !SDL.load() ) {
std::cout << "ERROR: " << SDL.errorString().constData() << std::endl;
}
void *a = SDL.resolv ( "SDL_Init" );
if ( !a ) {
std::cout << "ERROR: " << SDL.errorString().constData() << std::endl;
}
//void* a = BoxE::Core::BLibrary::resolve( "/usr/lib/libSDL.so", "SDL_Init" );
#endif
#if 0
BoxE::Core::BFile out2;
out2.setFilename ( "a.txt" );
// out2.open(BoxE::Core::BIODevice::WriteOnly);
BoxE::Core::BTextStream stream ( &out2 );
// stream << "1";
out2.close();
out2.open ( BoxE::Core::BIODevice::ReadOnly );
std::cout << stream.readAll().constData() << std::endl;
#endif
return 0;
}
Pairing * PairGeneratorSector::run(HitCollection & hits, const GeometrySupplement & geomSupplement,
uint nThreads, const TripletConfigurations & layerTriplets, const Grid & grid)
{
std::vector<uint> oracleOffset;
uint totalMaxPairs = 0;
uint nLayerTriplets = layerTriplets.size();
for(uint e = 0; e < grid.config.nEvents; ++e){
for(uint p = 0; p < nLayerTriplets; ++p){
TripletConfiguration layerPair(layerTriplets, p);
LayerGrid layer1(grid, layerPair.layer1(),e);
LayerGrid layer2(grid, layerPair.layer2(),e);
uint nMaxPairs = layer1.size()*layer2.size();
nMaxPairs = 32 * std::ceil(nMaxPairs / 32.0); //round to next multiple of 32
oracleOffset.push_back(totalMaxPairs);
totalMaxPairs += nMaxPairs;
}
}
LOG << "Initializing oracle offsets for pair gen...";
clever::vector<uint, 1> m_oracleOffset(oracleOffset, ctx);
LOG << "done[" << m_oracleOffset.get_count() << "]" << std::endl;
LOG << "Initializing oracle for pair gen...";
clever::vector<uint, 1> m_oracle(0, std::ceil(totalMaxPairs / 32.0), ctx);
LOG << "done[" << m_oracle.get_count() << "]" << std::endl;
LOG << "Initializing prefix sum for pair gen...";
clever::vector<uint, 1> m_prefixSum(0, grid.config.nEvents*nLayerTriplets*nThreads+1, ctx);
LOG << "done[" << m_prefixSum.get_count() << "]" << std::endl;
//ctx.select_profile_event(KERNEL_COMPUTE_EVT());
LOG << "Running pair gen kernel...";
cl_event evt = pairCount.run(
//configuration
layerTriplets.transfer.buffer(Layer1()), layerTriplets.transfer.buffer(Layer2()), grid.config.nLayers,
grid.transfer.buffer(Boundary()),
grid.config.MIN_Z, grid.config.sectorSizeZ(), grid.config.nSectorsZ,
grid.config.MIN_PHI, grid.config.sectorSizePhi(), grid.config.nSectorsPhi,
layerTriplets.transfer.buffer(pairSpreadZ()), layerTriplets.transfer.buffer(pairSpreadPhi()),
// hit input
hits.transfer.buffer(GlobalX()), hits.transfer.buffer(GlobalY()), hits.transfer.buffer(GlobalZ()),
// intermeditate data: oracle for hit pairs, prefix sum for found pairs
m_oracle.get_mem(), m_oracleOffset.get_mem(), m_prefixSum.get_mem(),
//local
local_param(sizeof(cl_uint), (grid.config.nSectorsZ+1)*(grid.config.nSectorsPhi+1)),
//thread config
range(nThreads, nLayerTriplets, grid.config.nEvents),
range(nThreads, 1,1));
PairGeneratorSector::events.push_back(evt);
LOG << "done" << std::endl;
if(PROLIX){
PLOG << "Fetching prefix sum for pair gen...";
std::vector<uint> vPrefixSum(m_prefixSum.get_count());
transfer::download(m_prefixSum,vPrefixSum,ctx);
PLOG << "done" << std::endl;
PLOG << "Prefix sum: ";
for(auto i : vPrefixSum){
PLOG << i << " ; ";
}
PLOG << std::endl;
}
if(PROLIX){
PLOG << "Fetching oracle for pair gen...";
std::vector<uint> oracle(m_oracle.get_count());
transfer::download(m_oracle,oracle,ctx);
PLOG << "done" << std::endl;
PLOG << "Oracle: ";
for(auto i : oracle){
PLOG << i << " ; ";
}
PLOG << std::endl;
}
//Calculate prefix sum
PrefixSum prefixSum(ctx);
evt = prefixSum.run(m_prefixSum.get_mem(), m_prefixSum.get_count(), nThreads, PairGeneratorSector::events);
uint nFoundPairs;
transfer::downloadScalar(m_prefixSum, nFoundPairs, ctx, true, m_prefixSum.get_count()-1, 1, &evt);
if(PROLIX){
PLOG << "Fetching prefix sum for pair gen...";
std::vector<uint> vPrefixSum(m_prefixSum.get_count());
transfer::download(m_prefixSum,vPrefixSum,ctx);
PLOG << "done" << std::endl;
PLOG << "Prefix sum: ";
for(auto i : vPrefixSum){
PLOG << i << " ; ";
}
PLOG << std::endl;
}
LOG << "Initializing pairs...";
Pairing * hitPairs = new Pairing(ctx, nFoundPairs, grid.config.nEvents, layerTriplets.size());
LOG << "done[" << hitPairs->pairing.get_count() << "]" << std::endl;
LOG << "Running pair gen store kernel...";
evt = pairStore.run(
//configuration
layerTriplets.transfer.buffer(Layer1()), layerTriplets.transfer.buffer(Layer2()), grid.config.nLayers,
//grid
grid.transfer.buffer(Boundary()), grid.config.nSectorsZ, grid.config.nSectorsPhi,
// input for oracle and prefix sum
m_oracle.get_mem(), m_oracleOffset.get_mem(), m_prefixSum.get_mem(),
// output of pairs
hitPairs->pairing.get_mem(), hitPairs->pairingOffsets.get_mem(),
//thread config
range(nThreads, nLayerTriplets, grid.config.nEvents),
range(nThreads, 1,1));
PairGeneratorSector::events.push_back(evt);
LOG << "done" << std::endl;
if(PROLIX){
PLOG << "Fetching pairs...";
std::vector<uint2> pairs = hitPairs->getPairings();
PLOG <<"done[" << pairs.size() << "]" << std::endl;
PLOG << "Pairs:" << std::endl;
for(uint i = 0; i < nFoundPairs; ++i){
PLOG << "[" << i << "] " << pairs[i].x << "-" << pairs[i].y << std::endl;
}
PLOG << "Fetching pair offets...";
std::vector<uint> pairOffsets = hitPairs->getPairingOffsets();
PLOG <<"done[" << pairOffsets.size() << "]" << std::endl;
PLOG << "Pair Offsets:" << std::endl;
for(uint i = 0; i < pairOffsets.size(); ++i){
PLOG << "[" << i << "] " << pairOffsets[i] << std::endl;
}
}
return hitPairs;
}
int main(int argc, char *argv[]) {
ANN::BPNet cpu_one;
ANN::BPLayer layer1(56, ANN::ANLayerInput);
ANN::BPLayer layer2(64, ANN::ANLayerHidden);
ANN::BPLayer layer3(64, ANN::ANLayerHidden);
ANN::BPLayer layer4(64, ANN::ANLayerHidden);
ANN::BPLayer layer5(9, ANN::ANLayerOutput);
layer1.ConnectLayer(&layer2);
layer2.ConnectLayer(&layer3);
layer3.ConnectLayer(&layer4);
layer4.ConnectLayer(&layer5);
cpu_one.AddLayer(&layer1);
cpu_one.AddLayer(&layer2);
cpu_one.AddLayer(&layer3);
cpu_one.AddLayer(&layer4);
cpu_one.AddLayer(&layer5);
ANN::TrainingSet input;
input.AddInput(fInp1, 56);
input.AddOutput(fOut1, 9);
input.AddInput(fInp2, 56);
input.AddOutput(fOut2, 9);
input.AddInput(fInp3, 56);
input.AddOutput(fOut3, 9);
input.AddInput(fInp4, 56);
input.AddOutput(fOut4, 9);
input.AddInput(fInp5, 56);
input.AddOutput(fOut5, 9);
input.AddInput(fInp6, 56);
input.AddOutput(fOut6, 9);
input.AddInput(fInp7, 56);
input.AddOutput(fOut7, 9);
input.AddInput(fInp8, 56);
input.AddOutput(fOut8, 9);
input.AddInput(fInp9, 56);
input.AddOutput(fOut9, 9);
input.AddInput(fInp10, 56);
input.AddOutput(fOut10, 9);
std::vector<float> errors;
cpu_one.SetLearningRate(0.5);
cpu_one.SetMomentum(0);
cpu_one.SetWeightDecay(0);
cpu_one.SetTrainingSet(input);
bool b = false;
float f;
errors = cpu_one.TrainFromData(300, 0, b, f);
std::cout<< cpu_one <<std::endl;
/*
cpu_one.ExpToFS("foo.bar");
cpu_one.ImpFromFS("foo.bar");
cpu_one.SetTrainingSet(input);
std::cout<< cpu_one <<std::endl;
*/
return 0;
}
