int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
#endif
{
// Initialize the environment.
DMAPP_INIT();
// Configuration
DMAPP.GetConfig()->SetFullScreen(false);
DMAPP.GetConfig()->SetShowMouse();
// Initialize the app
DMAPP.Initialize();
// Create a scene and show it.
TestScene* s = new TestScene();
s->Initialize();
DMSCENE.AddScene("test", s);
DMSCENE.SetCurrentScene("test");
// Start game.
DMAPP.Start();
// Shutdown after gaming.
DMAPP.Shutdown();
// You should clear scene before all cleaned.
DMSCENE.ClearScenes();
return 0;
}
int main(int argc, char **argv) {
TestScene *scene = new TestScene(argc, argv, std::min(1, argc - 1));
options.parse(argc, argv);
size_t count = 0;
carve::input::Input inputs;
std::vector<carve::poly::Polyhedron *> polys;
std::vector<carve::line::PolylineSet *> lines;
std::vector<carve::point::PointSet *> points;
// Test polyhedron
carve::poly::Polyhedron *test1 = makeCube(-1,-1,-1,1,1,1);
carve::poly::Polyhedron *test2 = makeCube(0,0,0,2,2,2);
polys.push_back(test1);
polys.push_back(test2);
carve::csg::CSG testt;
carve::poly::Polyhedron *test3 = testt.compute(test1, test2, carve::csg::CSG::INTERSECTION);
polys.push_back(test3);
scene->draw_list_base = genSceneDisplayList(polys, lines, points, &count, scene->is_wireframe);
scene->draw_flags.assign(count, true);
scene->run();
delete scene;
return 0;
}
int main(int argc, char **argv) {
carve::poly::Polyhedron *input = readPLY(argv[1]);
double offset = strtod(argv[2], NULL);
TestScene *scene = new TestScene(argc, argv, 3);
glNewList(scene->draw_list_base, GL_COMPILE);
doOffset(input, offset);
glEndList();
glNewList(scene->draw_list_base + 1, GL_COMPILE);
drawPolyhedron(input, .6, .6, .6, 1.0, false);
glEndList();
glNewList(scene->draw_list_base + 2, GL_COMPILE);
drawPolyhedronWireframe(input);
glEndList();
scene->draw_flags[0] = true;
scene->draw_flags[1] = true;
scene->draw_flags[2] = true;
scene->run();
delete scene;
return 0;
}
cocos2d::CCScene* CocoStudioAnimationTest::scene()
{
TestScene* scene = TestScene::create();
CocoStudioAnimationTest* layer = CocoStudioAnimationTest::create();
scene->addChild(layer);
return scene;
}
cocos2d::CCScene* PixelSpriteTest::scene()
{
TestScene* scene = TestScene::create();
PixelSpriteTest* layer = PixelSpriteTest::create();
scene->addChild(layer);
return scene;
}
TestScene *TestScene::create(const Size3D &size)
{
TestScene *scene = new TestScene();
if(scene->initWithSize(size)){
return scene;
}
delete scene;
return NULL;
}
void ExtensionsMainLayer::menuCallback(CCObject* pSender)
{
CCMenuItemFont* pItem = (CCMenuItemFont*)pSender;
int nIndex = pItem->getZOrder() - kItemTagBasic;
switch (nIndex)
{
#if (CC_TARGET_PLATFORM != CC_PLATFORM_MARMALADE) // MARMALADE CHANGE: Not yet avaiable on Marmalade
case TEST_NOTIFICATIONCENTER:
{
runNotificationCenterTest();
}
break;
#endif
case TEST_CCCONTROLBUTTON:
{
CCControlSceneManager* pManager = CCControlSceneManager::sharedControlSceneManager();
CCScene* pScene = pManager->currentControlScene();
CCDirector::sharedDirector()->replaceScene(pScene);
}
break;
#if (CC_TARGET_PLATFORM != CC_PLATFORM_MARMALADE) // MARMALADE CHANGE: Not yet avaiable on Marmalade
case TEST_COCOSBUILDER:
{
TestScene* pScene = new CocosBuilderTestScene();
if (pScene)
{
pScene->runThisTest();
pScene->release();
}
}
break;
#endif
#if (CC_TARGET_PLATFORM != CC_PLATFORM_MARMALADE) // MARMALADE CHANGE: Not yet avaiable on Marmalade
case TEST_HTTPCLIENT:
{
runHttpClientTest();
}
break;
#endif
#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS) || (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID) || (CC_TARGET_PLATFORM == CC_PLATFORM_MAC) || (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
case TEST_EDITBOX:
{
runEditBoxTest();
}
break;
#endif
case TEST_TABLEVIEW:
{
runTableViewTest();
}
break;
default:
break;
}
}
TestScene* TestScene::Create()
{
TestScene* ts = new TestScene();
ts->AutoRelease();
if (!ts->Init())
{
return NULL;
}
return ts;
}
void TestController::menuCallback(CCObject * pSender)
{
// get the userdata, it's the index of the menu item clicked
CCMenuItem* pMenuItem = (CCMenuItem *)(pSender);
int nIdx = pMenuItem->getZOrder() - 10000;
// create the test scene and run it
TestScene* pScene = CreateTestScene(nIdx);
if (pScene)
{
pScene->runThisTest();
pScene->release();
}
}
TestScene* TestScene::createWithPhysics()
{
TestScene *ret = new (std::nothrow) TestScene();
if (ret && ret->initWithPhysics())
{
ret->autorelease();
return ret;
}
else
{
CC_SAFE_DELETE(ret);
return nullptr;
}
}
void TestController::menuCallback(Object * pSender)
{
Director::sharedDirector()->purgeCachedData();
// get the userdata, it's the index of the menu item clicked
MenuItem* pMenuItem = (MenuItem *)(pSender);
int idx = pMenuItem->getZOrder() - 10000;
// create the test scene and run it
TestScene* pScene = g_aTestNames[idx].callback();
if (pScene)
{
pScene->runThisTest();
pScene->release();
}
}
void ExtensionsMainLayer::menuCallback(CCObject* pSender)
{
CCMenuItemFont* pItem = (CCMenuItemFont*)pSender;
int nIndex = pItem->getZOrder() - kItemTagBasic;
switch (nIndex)
{
case TEST_NOTIFICATIONCENTER:
{
runNotificationCenterTest();
}
break;
case TEST_CCCONTROLBUTTON:
{
CCControlSceneManager* pManager = CCControlSceneManager::sharedControlSceneManager();
CCScene* pScene = pManager->currentControlScene();
CCDirector::sharedDirector()->replaceScene(pScene);
}
break;
case TEST_TEXTUREWATCHER:
{
static bool s_bOpened = false;
s_bOpened = !s_bOpened;
CCTextureWatcher::sharedTextureWatcher()->setDisplayWatcher(s_bOpened);
}
break;
case TEST_COCOSBUILDER:
{
TestScene* pScene = new CocosBuilderTestScene();
if (pScene)
{
pScene->runThisTest();
pScene->release();
}
}
break;
default:
break;
}
}
Scene* TestScene::create()
{
TestScene* scene = TestScene::createWithPhysics();
scene->getPhysicsWorld()->setGravity(Vect(0.0f, -700.0f));
scene->getPhysicsWorld()->setDebugDrawMask(PhysicsWorld::DEBUGDRAW_ALL);
scene->scheduleUpdate();
Size visibleSize = Director::getInstance()->getVisibleSize();
Vec2 origin = Director::getInstance()->getVisibleOrigin();
PhysicsBody* edgeBody = PhysicsBody::createEdgeBox(visibleSize, PhysicsMaterial(0.1f, 0.0f, 0.5f), 3);
Node* edgeNode = Node::create();
edgeNode->setPosition(Point(visibleSize.width / 2 + origin.x, visibleSize.height / 2 + origin.y));
edgeNode->setPhysicsBody(edgeBody);
scene->addChild(edgeNode);
Player* sprite = Player::create();
sprite->setPosition(Point(visibleSize.width / 2 + origin.x, visibleSize.height / 2 + origin.y));
/*Sprite* sprite = Sprite::create("testSprite.png");
sprite->setPosition(Point(visibleSize.width / 2 + origin.x, visibleSize.height / 2 + origin.y));
MyBodyParser::getInstance()->parseJsonFile("test.json");
auto spriteBody = MyBodyParser::getInstance()->bodyFormJson(sprite, "Test", PhysicsMaterial(1, 1, 0));
if (spriteBody != nullptr)
{
spriteBody->setDynamic(true);
sprite->setPhysicsBody(spriteBody);
}*/
scene->addChild(sprite);
return scene;
}
int main(int argc, char **argv) {
TestScene *scene = new TestScene(argc, argv, 2);
GLuint tex_1 = initTexture(128, 128, carve_texture);
GLuint tex_2 = initTexture(128, 128, brick_texture);
GLuint tex_3 = initTexture(128, 128, leaf_texture);
g_scale = 10.0;
carve::interpolate::FaceVertexAttr<tex_t> fv_tex;
carve::interpolate::FaceAttr<GLuint> f_tex_num;
carve::mesh::MeshSet<3> *base = NULL;
bool b = true;
for (int x = -10; x <= +10; x += 5) {
for (int y = -10; y <= +10; y += 5) {
for (int z = -10; z <= +10; z += 5) {
double rot = x * .17 + y * .06 + z * .09;
carve::mesh::MeshSet<3> *r = texturedCube(fv_tex, f_tex_num, b ? tex_2 : tex_3,
carve::math::Matrix::TRANS(x/2.5, y/2.5, z/2.5) *
carve::math::Matrix::ROT(rot, 1,2,3));
b = !b;
if (base) {
carve::mesh::MeshSet<3> *temp = base;
carve::csg::CSG csg;
fv_tex.installHooks(csg);
f_tex_num.installHooks(csg);
base = csg.compute(temp, r, carve::csg::CSG::UNION);
delete temp;
delete r;
} else {
base = r;
}
}
}
}
carve::mesh::MeshSet<3> *r1 = texturedCube(fv_tex, f_tex_num, tex_1,
carve::math::Matrix::TRANS(0,0,4) *
carve::math::Matrix::SCALE(4,4,4));
carve::mesh::MeshSet<3> *r2 = texturedCube(fv_tex, f_tex_num, tex_1,
carve::math::Matrix::TRANS(0,0,5) *
carve::math::Matrix::SCALE(2, 2, 2));
carve::csg::CSG csg;
fv_tex.installHooks(csg);
f_tex_num.installHooks(csg);
carve::mesh::MeshSet<3> *r3 = csg.compute(base, r1, carve::csg::CSG::INTERSECTION, NULL, carve::csg::CSG::CLASSIFY_EDGE);
carve::mesh::MeshSet<3> *r4 = csg.compute(r3, r2, carve::csg::CSG::UNION, NULL, carve::csg::CSG::CLASSIFY_EDGE);
glNewList(scene->draw_list_base, GL_COMPILE);
drawTexturedPolyhedron(r4, fv_tex, f_tex_num);
glEndList();
glNewList(scene->draw_list_base+1, GL_COMPILE);
drawWireframePolyhedron(r3);
glEndList();
scene->draw_flags[0] = true;
scene->draw_flags[1] = true;
scene->run();
destroyTexture(tex_1);
destroyTexture(tex_2);
destroyTexture(tex_3);
delete scene;
return 0;
}
int main(int argc, char **argv) {
carve::mesh::MeshSet<3> *a = makeCube(carve::math::Matrix::ROT(1.0, 1.0, 1.0, 1.0));
std::vector<carve::mesh::MeshSet<3>::vertex_t> shape;
for (int i = 0; i < POINTS; ++i) {
double r = 2.0 + .4 * sin(i * 3 * M_TWOPI / POINTS) + .8 * sin(i * 5 * M_TWOPI / POINTS);
shape.push_back(carve::mesh::MeshSet<3>::vertex_t(carve::geom::VECTOR(r * cos(i * M_TWOPI / POINTS), r * sin(i * M_TWOPI / POINTS), 0.0)));
}
std::vector<carve::mesh::MeshSet<3>::vertex_t *> face_verts;
for (int i = 0; i < POINTS; ++i) {
face_verts.push_back(&shape[i]);
}
std::vector<carve::mesh::MeshSet<3>::face_t *> faces;
faces.push_back(new carve::mesh::MeshSet<3>::face_t(face_verts.begin(), face_verts.end()));
carve::mesh::MeshSet<3> *b = new carve::mesh::MeshSet<3>(faces);
std::list<std::pair<carve::csg::FaceClass, carve::mesh::MeshSet<3> *> > b_sliced;
carve::csg::CSG csg;
csg.hooks.registerHook(new carve::csg::CarveTriangulator, carve::csg::CSG::Hooks::PROCESS_OUTPUT_FACE_BIT);
csg.sliceAndClassify(a, b, b_sliced);
TestScene *scene = new TestScene(argc, argv, 6);
glNewList(scene->draw_list_base + 0, GL_COMPILE);
drawMeshSet(a, .4, .6, .8, 1.0);
glEndList();
glNewList(scene->draw_list_base + 1, GL_COMPILE);
drawMeshSet(b, .8, .6, .4, 1.0);
glEndList();
glNewList(scene->draw_list_base + 2, GL_COMPILE);
{
int n = 0;
for (std::list<std::pair<carve::csg::FaceClass, carve::mesh::MeshSet<3> *> >::iterator i = b_sliced.begin(); i != b_sliced.end(); ++i) {
float r, g, b;
switch ((*i).first) {
case carve::csg::FACE_IN: r = 0.0; g = 0.0; b = 1.0; break;
case carve::csg::FACE_OUT: r = 1.0; g = 0.0; b = 0.0; break;
case carve::csg::FACE_ON_ORIENT_OUT: r = 1.0; g = 1.0; b = 0.0; break;
case carve::csg::FACE_ON_ORIENT_IN: r = 0.0; g = 1.0; b = 1.0; break;
}
drawMeshSet((*i).second, r, g, b, 1.0);
++n;
}
}
glEndList();
glNewList(scene->draw_list_base + 3, GL_COMPILE);
{
int n = 0;
for (std::list<std::pair<carve::csg::FaceClass, carve::mesh::MeshSet<3> *> >::iterator i = b_sliced.begin(); i != b_sliced.end(); ++i) {
float r, g, b;
switch ((*i).first) {
case carve::csg::FACE_IN: r = 0.3; g = 0.3; b = 0.7; break;
case carve::csg::FACE_OUT: r = 0.7; g = 0.3; b = 0.3; break;
case carve::csg::FACE_ON_ORIENT_OUT: r = 0.7; g = 0.7; b = 0.3; break;
case carve::csg::FACE_ON_ORIENT_IN: r = 0.3; g = 0.7; b = 0.7; break;
}
drawMeshSetWireframe((*i).second, -1, false, false);
++n;
}
}
glEndList();
scene->run();
delete scene;
return 0;
}
#include <vector>
#ifdef _MSC_VER
#pragma warning(push, 0)
#include <catch.hpp>
#pragma warning(pop)
#else
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wall"
#include <catch.hpp>
#pragma GCC diagnostic pop
#endif
TEST_CASE("DetourPipelineTest/Pipeline", "Tests about the pipeline behavior")
{
TestScene ts;
dtCrowd* crowd = ts.createSquareScene(20, 0.5);
REQUIRE(crowd != 0);
dtPipelineBehavior* pipeline = dtPipelineBehavior::allocate();
float posAgt1[] = {0, 0.2f, 0};
float destAgt1[] = {15, 0, 0};
dtCrowdAgent ag;
// Adding the agents to the crowd
REQUIRE(crowd->addAgent(ag, posAgt1));
ts.defaultInitializeAgent(*crowd, ag.id);
int WINAPI WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
XEngine *engine = XEngine::GetInstance();
if( engine->Init(hInstance) == FALSE )
{
return -1;
}
Rect rec(Position(-10000.0, 10000.0), Position(10000.0, -10000.0));
TestScene *scene = new TestScene;
scene->SetTime(0);
//Scene *scene = new Scene;
scene->Init(rec);
scene->camera->MoveForwardBy(-40);
scene->camera->MoveUpBy(18);
scene->camera->Pitch(-XM_PI / 10);
Material material;
material.ambient = XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f);
material.diffuse = XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f);
material.specular = XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f);
material.power = 9.0f;
//material.texture = SRVBatch::GetInstance()->LoadSRV("media/", "cup.jpg");
Particle *fire = new Particle;
fire->Init("media/","fire.png");
fire->SetPosition(0, 0, 10);
//scene->AddRenderableThing(*fire);
SkyBox *sky = new SkyBox;
//sky->Init("textures/", "skymap.dds");
sky->Init("textures/", "Above_The_Sea.dds");
//sky->Init("textures/", "desert_skymap.dds");
scene->AddSky(sky);
Terrain *terrain = new Terrain;
//terrain->Init("terrain/testHight.bmp", "terrain/", "dirt01.dds");
terrain->Init("terrain/heightmap01.bmp", "terrain/", "grass.jpg");
scene->AddTerrain(terrain);
Wall *wall = new Wall;
wall->Init(30, 30, 0.3);
wall->Pitch(XM_PI / 2);
wall->SetPosition(0, -3, 0);
//scene->AddRenderableThing(*wall);
//¿É¼ûÐÔ²âÊÔ
Wall *wall0 = new Wall;
wall0->Init(30, 30, 0.3);
wall0->Pitch(XM_PI / 2);
wall0->SetPosition(1000, -3, 0);
//scene->AddRenderableThing(*wall0);
Obj *obj = new Obj;
obj->CreateBox(1, 3, 2, material);
obj->SetPosition(5, 1, 12);
obj->Yaw(XM_PI / 3);
obj->Roll(XM_PI / 3);
obj->SetScale(1.3);
//scene->AddRenderableThing(*obj);
Cube *cube = new Cube;
cube->Init(2);
cube->Pitch(XM_PI / 3);
cube->Roll(XM_PI / 3);
cube->SetMaterial(material);
//scene->AddRenderableThing(*cube);
Ball *ball = new Ball;
ball->Init(1);
ball->SetPosition(0, 0, 6);
Obj *objInWall = new Obj;
objInWall->CreateBox(1, 1, 1, material);
objInWall->SetPosition(0, 1, 0);
ball->AddChild(objInWall);
//scene->AddRenderableThing(*ball);
Ship *ship = new Ship;
//ship->Init();
//ship->SetPosition(-10, 0, 0);
//scene->AddRenderableThing(*ship);
Model *test = new Model;
test->LoadModel("media/", "chair.obj");
test->SetScale(1.7);
test->SetPosition(-15, 0, 0);
test->Pitch(-1.2);
test->Yaw(-1.5);
//scene->AddRenderableThing(*test);
//SmileBoy *smileBoy= new SmileBoy;
//smileBoy->Init();
//smileBoy->SetHandleInput(FALSE);
//scene->AddRenderableThing(*smileBoy);
Female *female = new Female;
female->Init();
//female->SetPosition(-7, 0,0);
female->SetHandleInput(TRUE);
scene->AddRenderableThing(*female);
RenderSystem::GetInstance()->SetShadowOpen(true);
engine->LoadScene(scene);
{
Light *light = new Light;
light->type = 0;
light->position = XMFLOAT4(0.0f, 5.0f, -5.0f, 1.0f);
XMStoreFloat4(&light->direction, XMVector4Normalize(XMVectorSet(1.0f, -1.0f, 0.0f, 0.0f)));
light->ambient = XMFLOAT4(0.4f, 0.2f, 0.3f, 1.0f);
light->diffuse = XMFLOAT4(0.3f, 0.4f, 0.5f, 1.0f);
light->specular = XMFLOAT4(0.5f, 0.3f, 0.2f, 1.0f);
light->attenuation0 = 0.0f;
light->attenuation1 = 0.0f;
light->attenuation2 = 0.0f;
light->alpha = 0.0f;
light->beta = 0.0f;
light->falloff = 0.0f;
scene->AddLight(light);
}
//*******************************************
engine->Run();
return 0;
}
void ExtensionsMainLayer::menuCallback(CCObject* pSender)
{
CCMenuItemFont* pItem = (CCMenuItemFont*)pSender;
int nIndex = pItem->getZOrder() - kItemTagBasic;
switch (nIndex)
{
#if (CC_TARGET_PLATFORM != CC_PLATFORM_MARMALADE) // MARMALADE CHANGE: Not yet avaiable on Marmalade
case TEST_NOTIFICATIONCENTER:
{
runNotificationCenterTest();
}
break;
#endif
case TEST_CCCONTROLBUTTON:
{
CCControlSceneManager* pManager = CCControlSceneManager::sharedControlSceneManager();
CCScene* pScene = pManager->currentControlScene();
CCDirector::sharedDirector()->replaceScene(pScene);
}
break;
case TEST_COCOSBUILDER:
{
TestScene* pScene = new CocosBuilderTestScene();
if (pScene)
{
pScene->runThisTest();
pScene->release();
}
}
break;
#if (CC_TARGET_PLATFORM != CC_PLATFORM_MARMALADE && CC_TARGET_PLATFORM != CC_PLATFORM_NACL && CC_TARGET_PLATFORM != CC_PLATFORM_EMSCRIPTEN && CC_TARGET_PLATFORM != CC_PLATFORM_WINRT)
case TEST_HTTPCLIENT:
{
runHttpClientTest();
}
break;
#endif
#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS) || (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID) || (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32) || (CC_TARGET_PLATFORM == CC_PLATFORM_WP8)
case TEST_WEBSOCKET:
{
runWebSocketTest();
}
break;
#endif
#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS) || (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID) || (CC_TARGET_PLATFORM == CC_PLATFORM_MAC) || (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32) || (CC_TARGET_PLATFORM == CC_PLATFORM_TIZEN) || (CC_TARGET_PLATFORM == CC_PLATFORM_WP8) || (CC_TARGET_PLATFORM == CC_PLATFORM_WINRT)
case TEST_EDITBOX:
{
runEditBoxTest();
}
break;
#endif
case TEST_TABLEVIEW:
{
runTableViewTest();
}
break;
case TEST_COMPONENTS:
{
runComponentsTestLayerTest();
}
break;
case TEST_ARMATURE:
{
ArmatureTestScene *pScene = new ArmatureTestScene();
if (pScene)
{
pScene->runThisTest();
pScene->release();
}
}
break;
case TEST_SCENEEDITOR:
{
SceneEditorTestScene *pScene = new SceneEditorTestScene();
if (NULL != pScene)
{
pScene->runThisTest();
pScene->release();
}
}
break;
case TEST_COCOSGUI:
{
CocoStudioGUITestScene* pScene = new CocoStudioGUITestScene();
pScene->runThisTest();
pScene->release();
}
break;
case TEST_ACTIONTIMELINE:
{
TimelineTestScene* pScene = new TimelineTestScene();
pScene->runThisTest();
pScene->release();
}
default:
break;
}
}
TestScene CreateTestScene(egl::graphics::LightManager& light_manager) {
using egl::SceneNode;
namespace ef = egl::factories;
static constexpr float kPi = 3.14159265;
static constexpr float k2Pi = 3.14159265 * 2;
static constexpr float kPi2 = 3.14159265 / 2;
static constexpr float kPi3 = 3.14159265 / 3;
auto scene_root = ef::MakeCubeNode(nullptr);
scene_root->SetOffset(0.f, 0.f, 0.f);
auto rotating_bawse = ef::MakeCubeNode(scene_root.get());
rotating_bawse->SetOffset(0.0, 0.0, -15.0);
std::vector<glm::vec3> offsets = {
{ 2.f, 0.f, 0.f },
{ -2.f, 0.f, 0.f },
{ 0.f, 2.f, 0.f },
{ 0.f, -2.f, 0.f },
{ 0.f, 0.f, 2.f },
{ 0.f, 0.f, -4.f },
};
std::vector<glm::vec3> orientation_offsets = {
{ 0.f, kPi2, 0.f },
{ 0.f, -kPi2, 0.f },
{ kPi2, 0.f, 0.f },
{ -kPi2, 0.f, 0.f },
{ 0.f, 0.f, 0.f },
{ 0.f, kPi, 0.f },
};
std::vector<std::unique_ptr<SceneNode>> children;
for (size_t i = 0; i < offsets.size(); i++) {
auto child = ef::MakeCubeNode(rotating_bawse.get());
auto o = offsets[i];
child->SetOffset(o[0], o[1], o[2]);
auto oo = orientation_offsets[i];
child->RotateBodyAxes(oo[0], oo[1], oo[2]);
children.push_back(std::move(child));
}
for (auto& child : children) {
child->AddMutator([](SceneNode* obj, float dT) {
obj->RotateBodyAxes(0, 0, kPi * dT);
});
}
constexpr float kWo = 25.f;
std::vector<glm::vec3> wall_offsets {
{ kWo, 0.f, 0.f },
{ -kWo, 0.f, 0.f },
{ 0.f, kWo, 0.f },
{ 0.f, -kWo, 0.f },
{ 0.f, 0.f, kWo },
{ 0.f, 0.f, -kWo },
};
std::vector<glm::vec3> wall_orientation_offsets = {
{ 0.f, kPi2, 0.f },
{ 0.f, -kPi2, 0.f },
{ kPi2, 0.f, 0.f },
{ -kPi2, 0.f, 0.f },
{ 0.f, 0.f, 0.f },
{ 0.f, kPi, 0.f },
};
std::vector<std::unique_ptr<SceneNode>> walls;
for (size_t i = 0; i < 6; i++) {
auto o = wall_offsets[i];
auto oo = wall_orientation_offsets[i];
auto p_wall = ef::MakeCubeNode(rotating_bawse.get());
p_wall->SetOffset(o[0], o[1], o[2]);
p_wall->RotateBodyAxes(oo[0], oo[1], oo[2]);
//p_wall->Scale(2 * kWo, 2 * kWo, 0.1f);
p_wall->Scale(kWo, kWo, 1.f);
walls.push_back(std::move(p_wall));
}
auto rogue_entity = ef::MakeCubeNode(rotating_bawse.get());
constexpr float e_x = 0.25, e_y = 0.25, e_z = 0.25;
rogue_entity->SetOffset(0.f, 0.f, 6.f);
rogue_entity->Scale(2 * e_x, 2 * e_y, 2 * e_z);
rogue_entity->SetExtents(e_x, e_y, e_z);
rogue_entity->AddMutator([t = 0.f](SceneNode* obj, float dT) mutable {
t = std::fmod((t + dT), k2Pi);
obj->SetOffset(0.f, 0.f, 5.f + 2 * std::sin(t));
obj->RotateBodyAxes(dT * kPi, dT * kPi, 0.f);
});
//auto rogue_light_node = ef::MakeLightNode(rogue_entity.get(), light_manager);
//rogue_light_node->ClearMutators();
//rogue_light_node->AddMutator([theta = 3 * 1.57f](egl::SceneNode* sp, float dT) mutable {
// theta = std::fmod(theta + 10 * dT, 2 * 3.14159265);
// sp->SetOffset(0.f, 1.5 * std::cos(theta), 1.5 * sin(theta));
//});
children.push_back(std::move(rogue_entity));
auto static_box = ef::MakeCubeNode(scene_root.get());
static_box->SetOffset(5.f, 0.f, 0.f);
static_box->RotateBodyAxes(kPi3, kPi3, 0.f);
static_box->AddMutator([](SceneNode* obj, float dT) {
obj->RotateBodyAxes(0, 0, kPi3 * dT);
});
// auto light_node = ef::MakeLightNode(scene_root.get(), light_manager);
auto light_node2 = ef::MakeLightNode(scene_root.get(), light_manager);
light_node2->ClearMutators();
light_node2->AddMutator([theta = 1.57f](egl::SceneNode* sp, float dT) mutable {
theta = std::fmod(theta + dT, 2 * 3.14159265);
sp->SetOffset(1.5 * std::cos(theta), 0.f, 1.5 * sin(theta));
});
auto light_node3 = ef::MakeLightNode(scene_root.get(), light_manager);
light_node3->ClearMutators();
light_node3->AddMutator([theta = 3 * 1.57f](egl::SceneNode* sp, float dT) mutable {
theta = std::fmod(theta + dT, 2 * 3.14159265);
sp->SetOffset(0.f, 1.5 * std::cos(theta), 1.5 * sin(theta));
});
TestScene scene;
scene.push_back(std::move(scene_root));
scene.push_back(std::move(rotating_bawse));
for(auto& child : children) { scene.push_back(std::move(child)); }
for (auto& wall : walls) { scene.push_back(std::move(wall)); }
// scene.push_back(std::move(rogue_entity));
scene.push_back(std::move(static_box));
//scene.push_back(std::move(rogue_light_node));
// scene.push_back(std::move(light_node));
scene.push_back(std::move(light_node2));
scene.push_back(std::move(light_node3));
return scene;
}
int main(int argc, char **argv) {
carve::mesh::MeshSet<3> *a = makeCube(carve::math::Matrix::ROT(1.0, 1.0, 1.0, 1.0));
std::vector<carve::geom3d::Vector> shape;
carve::input::PolyhedronData data;
for (int i = 0; i < POINTS; ++i) {
double r = 2.0 + .4 * sin(i * 3 * M_TWOPI / POINTS) + .8 * sin(i * 5 * M_TWOPI / POINTS);
data.addVertex(carve::geom::VECTOR(r * cos(i * M_TWOPI / POINTS), r * sin(i * M_TWOPI / POINTS), 0.0));
}
std::vector<int> face_verts;
for (int i = 0; i < POINTS; ++i) {
face_verts.push_back(i);
}
data.addFace(face_verts.begin(), face_verts.end());
carve::mesh::MeshSet<3> *b = new carve::mesh::MeshSet<3>(data.points, data.getFaceCount(), data.faceIndices);
std::list<carve::mesh::MeshSet<3> *> a_sliced, b_sliced;
carve::csg::CSG csg;
csg.hooks.registerHook(new carve::csg::CarveTriangulator, carve::csg::CSG::Hooks::PROCESS_OUTPUT_FACE_BIT);
csg.slice(a, b, a_sliced, b_sliced);
TestScene *scene = new TestScene(argc, argv, 6);
glNewList(scene->draw_list_base + 0, GL_COMPILE);
drawMeshSet(a, .4, .6, .8, 1.0);
glEndList();
glNewList(scene->draw_list_base + 1, GL_COMPILE);
drawMeshSet(b, .8, .6, .4, 1.0);
glEndList();
glNewList(scene->draw_list_base + 2, GL_COMPILE);
{
int n = 0;
for (std::list<carve::mesh::MeshSet<3> *>::iterator i = a_sliced.begin(); i != a_sliced.end(); ++i) {
float r = n & 1 ? .3 : .7;
float g = n & 2 ? .3 : .7;
float b = n & 4 ? .3 : .7;
drawMeshSet(*i, r, g, b, 1.0);
++n;
}
}
glEndList();
glNewList(scene->draw_list_base + 3, GL_COMPILE);
{
int n = 0;
for (std::list<carve::mesh::MeshSet<3> *>::iterator i = a_sliced.begin(); i != a_sliced.end(); ++i) {
drawMeshSetWireframe(*i, -1, false, false);
++n;
}
}
glEndList();
glNewList(scene->draw_list_base + 4, GL_COMPILE);
{
int n = 0;
for (std::list<carve::mesh::MeshSet<3> *>::iterator i = b_sliced.begin(); i != b_sliced.end(); ++i) {
float r = n & 1 ? .3 : .7;
float g = n & 2 ? .3 : .7;
float b = n & 4 ? .3 : .7;
drawMeshSet(*i, r, g, b, 1.0);
++n;
}
}
glEndList();
glNewList(scene->draw_list_base + 5, GL_COMPILE);
{
int n = 0;
for (std::list<carve::mesh::MeshSet<3> *>::iterator i = b_sliced.begin(); i != b_sliced.end(); ++i) {
drawMeshSetWireframe(*i, -1, false, false);
++n;
}
}
glEndList();
scene->run();
delete scene;
return 0;
}
int main(int argc, char **argv) {
carve::mesh::MeshSet<3> *a = makeTorus(30, 30, 2.0, 0.8, carve::math::Matrix::ROT(0.5, 1.0, 1.0, 1.0));
carve::input::PolyhedronData data;
for (int i = 0; i < DIM; i++) {
double x = -3.0 + 6.0 * i / double(DIM - 1);
for (int j = 0; j < DIM; j++) {
double y = -3.0 + 6.0 * j / double(DIM - 1);
double z = -1.0 + 2.0 * cos(sqrt(x * x + y * y) * 2.0) / sqrt(1.0 + x * x + y * y);
size_t n = data.addVertex(carve::geom::VECTOR(x, y, z));
if (i && j) {
data.addFace(n - DIM - 1, n - 1, n - DIM);
data.addFace(n - 1, n, n - DIM);
}
}
}
for (int i = 0; i < DIM; i++) {
double x = -3.0 + 6.0 * i / double(DIM - 1);
for (int j = 0; j < DIM; j++) {
double y = -3.0 + 6.0 * j / double(DIM - 1);
double z = 1.0 + 2.0 * cos(sqrt(x * x + y * y) * 2.0) / sqrt(1.0 + x * x + y * y);
size_t n = data.addVertex(carve::geom::VECTOR(x, y, z));
if (i && j) {
data.addFace(n - DIM - 1, n - 1, n - DIM);
data.addFace(n - 1, n, n - DIM);
}
}
}
carve::mesh::MeshSet<3> *b = data.createMesh(carve::input::opts());
CARVE_ASSERT(b->meshes.size() == 2);
Between between_collector(a, b);
carve::mesh::MeshSet<3> *c = carve::csg::CSG().compute(a, b, between_collector, NULL, carve::csg::CSG::CLASSIFY_EDGE);
TestScene *scene = new TestScene(argc, argv, 3);
glNewList(scene->draw_list_base + 0, GL_COMPILE);
drawMeshSet(a, .4, .6, .8, 1.0);
glEndList();
glNewList(scene->draw_list_base + 1, GL_COMPILE);
drawMeshSet(b, .8, .6, .4, 1.0);
glEndList();
glNewList(scene->draw_list_base + 2, GL_COMPILE);
drawMeshSet(c, .2, .2, .8, 1.0);
drawMeshSetWireframe(c, -1, false, false);
glEndList();
scene->run();
delete scene;
delete a;
delete b;
delete c;
return 0;
}
int main(int argc, char **argv) {
TestScene *scene = new TestScene(argc, argv, std::min(1, argc - 1));
options.parse(argc, argv);
size_t count = 0;
carve::input::Input inputs;
std::vector<carve::mesh::MeshSet<3> *> polys;
std::vector<carve::line::PolylineSet *> lines;
std::vector<carve::point::PointSet *> points;
if (options.files.size() == 0) {
if (options.obj) {
readOBJ(std::cin, inputs);
} else if (options.vtk) {
readVTK(std::cin, inputs);
} else {
readPLY(std::cin, inputs);
}
} else {
for (size_t idx = 0; idx < options.files.size(); ++idx) {
std::string &s(options.files[idx]);
std::string::size_type i = s.rfind(".");
if (i != std::string::npos) {
std::string ext = s.substr(i, s.size() - i);
if (!strcasecmp(ext.c_str(), ".obj")) {
readOBJ(s, inputs);
} else if (!strcasecmp(ext.c_str(), ".vtk")) {
readVTK(s, inputs);
} else {
readPLY(s, inputs);
}
} else {
readPLY(s, inputs);
}
}
}
for (std::list<carve::input::Data *>::const_iterator i = inputs.input.begin(); i != inputs.input.end(); ++i) {
carve::mesh::MeshSet<3> *p;
carve::point::PointSet *ps;
carve::line::PolylineSet *l;
if ((p = carve::input::Input::create<carve::mesh::MeshSet<3> >(*i, carve::input::opts("avoid_cavities", "true"))) != NULL) {
polys.push_back(p);
std::cerr << "loaded polyhedron "
<< polys.back() << " has " << polys.back()->meshes.size()
<< " manifolds (" << std::count_if(polys.back()->meshes.begin(),
polys.back()->meshes.end(),
carve::mesh::Mesh<3>::IsClosed()) << " closed)" << std::endl;
std::cerr << "closed: ";
for (size_t i = 0; i < polys.back()->meshes.size(); ++i) {
std::cerr << (polys.back()->meshes[i]->isClosed() ? '+' : '-');
}
std::cerr << std::endl;
std::cerr << "negative: ";
for (size_t i = 0; i < polys.back()->meshes.size(); ++i) {
std::cerr << (polys.back()->meshes[i]->isNegative() ? '+' : '-');
}
std::cerr << std::endl;
} else if ((l = carve::input::Input::create<carve::line::PolylineSet>(*i)) != NULL) {
lines.push_back(l);
std::cerr << "loaded polyline set "
<< lines.back() << std::endl;
} else if ((ps = carve::input::Input::create<carve::point::PointSet>(*i)) != NULL) {
points.push_back(ps);
std::cerr << "loaded point set "
<< points.back() << std::endl;
}
}
scene->draw_list_base = genSceneDisplayList(polys, lines, points, &count, scene->is_wireframe);
scene->draw_flags.assign(count, true);
scene->run();
delete scene;
return 0;
}
int
main (int argc, char* argv[])
{
try
{
TestScene* scene = NULL;
int runner = 0;
for (int i = 1; i < argc; i++)
{
std::string arg(argv[i]);
std::transform(arg.begin(), arg.end(), arg.begin(), ::tolower);
if (0 == arg.compare("ogre") || 0 == arg.compare("ogre3d"))
{
runner = 1;
}
else if (0 == arg.compare("osg"))
{
runner = 2;
}
else if (0 == arg.compare("panda") || 0 == arg.compare("panda3d"))
{
runner = 3;
}
else if (0 == arg.compare("1"))
{
scene = new TestScene1();
}
else if (0 == arg.compare("2"))
{
scene = new TestScene2();
}
else if (0 == arg.compare("3"))
{
scene = new TestScene3();
}
else if (0 == arg.compare("4"))
{
scene = new TestScene4();
}
else if (0 == arg.compare("5"))
{
scene = new TestScene5();
}
else if (0 == arg.compare("6"))
{
scene = new TestScene6();
}
else if (0 == arg.compare("7"))
{
scene = new TestScene7();
}
else if (0 == arg.compare("8"))
{
scene = new TestScene8();
}
else if (0 == arg.compare("8.1"))
{
scene = new TestScene81();
}
else if (0 == arg.compare("8.2"))
{
scene = new TestScene82();
}
else if (0 == arg.compare("9"))
{
scene = new TestScene9();
}
else if (0 == arg.compare("10"))
{
scene = new TestScene10();
}
else if (0 == arg.compare("11"))
{
scene = new TestScene11();
}
else if (0 == arg.compare("12"))
{
scene = new TestScene12();
}
else if (0 != arg.compare("purge"))
{
throw std::string("Undefined runner: ") + arg;
}
}
if (!scene)
{
throw "No scene was chosen";
}
// required for runPanda()
argc = 1;
switch (runner)
{
case 0:
scene->runPURGE();
break;
case 1:
scene->runOgre();
break;
case 2:
scene->runOsg();
break;
case 3:
scene->runPanda(argc, argv);
break;
}
return EXIT_SUCCESS;
}
catch (std::string s)
{
std::cerr << "Exception: " << s << std::endl;
return EXIT_FAILURE;
}
catch (char const* c)
{
std::cerr << "Exception: " << c << std::endl;
return EXIT_FAILURE;
}
}
int main(int argc, char **argv) {
TestScene *scene = new TestScene(argc, argv);
typedef std::vector<carve::geom2d::P2> loop_t;
std::vector<loop_t> poly;
std::ifstream in(argv[1]);
while (in.good()) {
std::string s;
std::getline(in, s);
if (s == "BEGIN") {
poly.push_back(loop_t());
} else {
std::istringstream in_s(s);
double x,y;
in_s >> x >> y;
poly.back().push_back(carve::geom::VECTOR(x, y));
}
}
std::vector<std::pair<size_t, size_t> > result;
std::vector<carve::geom2d::P2> merged;
std::vector<carve::triangulate::tri_idx> triangulated;
try {
result = carve::triangulate::incorporateHolesIntoPolygon(poly);
merged.reserve(result.size());
for (size_t i = 0; i < result.size(); ++i) {
merged.push_back(poly[result[i].first][result[i].second]);
}
carve::triangulate::triangulate(merged, triangulated);
carve::triangulate::improve(merged, triangulated);
} catch (carve::exception exc) {
std::cerr << "FAIL: " << exc.str() << std::endl;
return -1;
}
carve::geom::aabb<2> aabb;
aabb.fit(merged.begin(), merged.end());
double scale = 20.0 / std::max(aabb.extent.x, aabb.extent.y);
glNewList(scene->d_list, GL_COMPILE);
glDisable(GL_LIGHTING);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(0.2, 0.3, 0.4, 1.0);
glBegin(GL_TRIANGLES);
for (size_t i = 0; i != triangulated.size(); ++i) {
double x, y;
x = (merged[triangulated[i].a].x - aabb.pos.x) * scale;
y = (merged[triangulated[i].a].y - aabb.pos.y) * scale;
glVertex3f(x, y, 0.0);
x = (merged[triangulated[i].b].x - aabb.pos.x) * scale;
y = (merged[triangulated[i].b].y - aabb.pos.y) * scale;
glVertex3f(x, y, 0.0);
x = (merged[triangulated[i].c].x - aabb.pos.x) * scale;
y = (merged[triangulated[i].c].y - aabb.pos.y) * scale;
glVertex3f(x, y, 0.0);
}
glEnd();
glColor4f(0.0, 0.0, 0.0, 0.1);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_DEPTH_TEST);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glBegin(GL_TRIANGLES);
for (size_t i = 0; i != triangulated.size(); ++i) {
double x, y;
x = (merged[triangulated[i].a].x - aabb.pos.x) * scale;
y = (merged[triangulated[i].a].y - aabb.pos.y) * scale;
glVertex3f(x, y, 0.0);
x = (merged[triangulated[i].b].x - aabb.pos.x) * scale;
y = (merged[triangulated[i].b].y - aabb.pos.y) * scale;
glVertex3f(x, y, 0.0);
x = (merged[triangulated[i].c].x - aabb.pos.x) * scale;
y = (merged[triangulated[i].c].y - aabb.pos.y) * scale;
glVertex3f(x, y, 0.0);
}
glEnd();
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glEnable(GL_DEPTH_TEST);
glColor4f(1, 1, 1, 1);
glBegin(GL_LINE_LOOP);
for (int i = 0; i < merged.size(); ++i) {
glVertex3f((merged[i].x - aabb.pos.x) * scale, (merged[i].y - aabb.pos.y) * scale, 2.0);
}
glEnd();
glEndList();
scene->run();
delete scene;
return 0;
}
