float noise2(const float x, const float y){
int bx0, bx1, by0, by1, b00, b10, b01, b11;
float rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
int i, j;
setup(x, bx0,bx1, rx0,rx1);
setup(y, by0,by1, ry0,ry1);
i = p[bx0];
j = p[bx1];
b00 = p[i + by0];
b10 = p[j + by0];
b01 = p[i + by1];
b11 = p[j + by1];
sx = s_curve(rx0);
sy = s_curve(ry0);
q = g2[b00]; u = at2(rx0,ry0);
q = g2[b10]; v = at2(rx1,ry0);
a = lerp(sx, u, v);
q = g2[b01]; u = at2(rx0,ry1);
q = g2[b11]; v = at2(rx1,ry1);
b = lerp(sx, u, v);
return lerp(sy, a, b);
}
T
noise2 (
T vec[2])
{
int bx0, bx1, by0, by1, b00, b10, b01, b11;
T rx0, rx1, ry0, ry1, sx, sy, a, b, u, v;
int i, j;
setup(vec[0],bx0,bx1,rx0,rx1);
setup(vec[1],by0,by1,ry0,ry1);
i = p[bx0];
j = p[bx1];
b00 = p[i + by0];
b10 = p[j + by0];
b01 = p[i + by1];
b11 = p[j + by1];
sx = s_curve(rx0);
sy = s_curve(ry0);
u = at2(rx0,ry0,b00);
v = at2(rx1,ry0,b10);
a = lerp(sx, u, v);
u = at2(rx0,ry1,b01);
v = at2(rx1,ry1,b11);
b = lerp(sx, u, v);
return lerp(sy, a, b);
}
double Perlin::noise2(double vec[2])
{
int bx0, bx1, by0, by1, b00, b10, b01, b11;
double rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
int i, j;
if (mStart)
{
srand(mSeed);
mStart = false;
init();
}
setup(0,bx0,bx1,rx0,rx1);
setup(1,by0,by1,ry0,ry1); i = p[bx0];
j = p[bx1]; b00 = p[i + by0];
b10 = p[j + by0];
b01 = p[i + by1];
b11 = p[j + by1];
sx = s_curve(rx0);
sy = s_curve(ry0);
#define at2(rx,ry) ( rx * q[0] + ry * q[1] )
q = g2[b00];
u = at2(rx0,ry0);
q = g2[b10];
v = at2(rx1,ry0);
a = lerp(sx, u, v); q = g2[b01];
u = at2(rx0,ry1);
q = g2[b11];
v = at2(rx1,ry1);
b = lerp(sx, u, v);
return lerp(sy, a, b);
}
float noise2(float vec[2])
{
int bx0, bx1, by0, by1, b00, b10, b01, b11;
float rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
register int i, j;
if (start) {
start = 0;
init();
}
setup(0, bx0,bx1, rx0,rx1);
setup(1, by0,by1, ry0,ry1);
i = p[ bx0 ];
j = p[ bx1 ];
b00 = p[ i + by0 ];
b10 = p[ j + by0 ];
b01 = p[ i + by1 ];
b11 = p[ j + by1 ];
sx = s_curve(rx0);
sy = s_curve(ry0);
#define at2(rx,ry) ( rx * q[0] + ry * q[1] )
q = g2[ b00 ] ; u = at2(rx0,ry0);
q = g2[ b10 ] ; v = at2(rx1,ry0);
a = lerp(sx, u, v);
q = g2[ b01 ] ; u = at2(rx0,ry1);
q = g2[ b11 ] ; v = at2(rx1,ry1);
b = lerp(sx, u, v);
return lerp(sy, a, b);
}
//----------------------------------------------------------------------------
float FvPerlinNoise::Noise2(const FvVector2& vec)
{
int bx0, bx1, by0, by1, b00, b10, b01, b11;
float rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
register int i, j;
if (start) {
start = false;
Init();
}
setup(0, bx0,bx1, rx0,rx1);
setup(1, by0,by1, ry0,ry1);
i = p[ bx0 ];
j = p[ bx1 ];
b00 = p[ i + by0 ];
b10 = p[ j + by0 ];
b01 = p[ i + by1 ];
b11 = p[ j + by1 ];
sx = s_curve(rx0);
sy = s_curve(ry0);
q = g2[ b00 ] ; u = at2(rx0,ry0);
q = g2[ b10 ] ; v = at2(rx1,ry0);
a = FV_LERP(sx, u, v);
q = g2[ b01 ] ; u = at2(rx0,ry1);
q = g2[ b11 ] ; v = at2(rx1,ry1);
b = FV_LERP(sx, u, v);
return FV_LERP(sy, a, b);
}
float PerlinNoise::noise2(float x, float y) {
float vec[2] = { x, y };
int bx0, bx1, by0, by1, b00, b10, b01, b11;
float rx0, rx1, ry0, ry1, sx, sy, a, b, t, u, v;
const float* q;
register int i, j;
setup(0, bx0,bx1, rx0,rx1);
setup(1, by0,by1, ry0,ry1);
i = p[ bx0 ];
j = p[ bx1 ];
b00 = p[ i + by0 ];
b10 = p[ j + by0 ];
b01 = p[ i + by1 ];
b11 = p[ j + by1 ];
sx = s_curve(rx0);
sy = s_curve(ry0);
#define at2(rx,ry) (rx * q[0] + ry * q[1])
q = g2[ b00 ] ; u = at2(rx0,ry0);
q = g2[ b10 ] ; v = at2(rx1,ry0);
a = lerp(sx, u, v);
q = g2[ b01 ] ; u = at2(rx0,ry1);
q = g2[ b11 ] ; v = at2(rx1,ry1);
b = lerp(sx, u, v);
return lerp(sy, a, b);
}
double PerlinGenerator::noise2(double vec[2])
{
int bx0, bx1, by0, by1, b00, b10, b01, b11;
double rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
int i, j;
setup(0, t,vec, bx0,bx1, rx0,rx1);
setup(1, t,vec, by0,by1, ry0,ry1);
i = p[ bx0 ];
j = p[ bx1 ];
b00 = p[ i + by0 ];
b10 = p[ j + by0 ];
b01 = p[ i + by1 ];
b11 = p[ j + by1 ];
sx = s_curve(rx0);
sy = s_curve(ry0);
q = g2[ b00 ] ; u = at2(rx0,ry0);
q = g2[ b10 ] ; v = at2(rx1,ry0);
a = perlin_lerp(sx, u, v);
q = g2[ b01 ] ; u = at2(rx0,ry1);
q = g2[ b11 ] ; v = at2(rx1,ry1);
b = perlin_lerp(sx, u, v);
return perlin_lerp(sy, a, b);
}
I noisetest::noise2(I vec[2])
{
int bx0, bx1, by0, by1, b00, b10, b01, b11;
I rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
int i, j;
setup(0, bx0,bx1, rx0,rx1);
setup(1, by0,by1, ry0,ry1);
i = p[ bx0 ];
j = p[ bx1 ];
b00 = p[ i + by0 ];
b10 = p[ j + by0 ];
b01 = p[ i + by1 ];
b11 = p[ j + by1 ];
sx = s_curve(rx0);
sy = s_curve(ry0);
q = g2[ b00 ] ; u = at2(rx0,ry0);
q = g2[ b10 ] ; v = at2(rx1,ry0);
a = lerp(sx, u, v);
q = g2[ b01 ] ; u = at2(rx0,ry1);
q = g2[ b11 ] ; v = at2(rx1,ry1);
b = lerp(sx, u, v);
return lerp(sy, a, b);
}
double noise2(double vec[2])
{
int bx0, bx1, by0, by1, b00, b10, b01, b11;
double rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
int i, j;
if (start) {
start = 0;
noiseinit();
}
setup(0, bx0,bx1, rx0,rx1);
setup(1, by0,by1, ry0,ry1);
i = p[ bx0 ];
j = p[ bx1 ];
b00 = p[ i + by0 ];
b10 = p[ j + by0 ];
b01 = p[ i + by1 ];
b11 = p[ j + by1 ];
sx = s_curve(rx0);
sy = s_curve(ry0);
q = g2[ b00 ] ; u = at2(rx0,ry0);
q = g2[ b10 ] ; v = at2(rx1,ry0);
a = lerp(sx, u, v);
q = g2[ b01 ] ; u = at2(rx0,ry1);
q = g2[ b11 ] ; v = at2(rx1,ry1);
b = lerp(sx, u, v);
return lerp(sy, a, b);
}
float PerlinNoise::Noise2(float x, float y)
{
int bx0, bx1, by0, by1, b00, b10, b01, b11;
float rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
int i, j;
setup(x, bx0,bx1, rx0,rx1);
setup(y, by0,by1, ry0,ry1);
i = p[ bx0 ];
j = p[ bx1 ];
b00 = p[ i + by0 ];
b10 = p[ j + by0 ];
b01 = p[ i + by1 ];
b11 = p[ j + by1 ];
sx = s_curve(rx0);
sy = s_curve(ry0);
#define at2(rx,ry) ( rx * q[0] + ry * q[1] )
q = g2[ b00 ] ; u = at2(rx0,ry0);
q = g2[ b10 ] ; v = at2(rx1,ry0);
a = lerp(sx, u, v);
q = g2[ b01 ] ; u = at2(rx0,ry1);
q = g2[ b11 ] ; v = at2(rx1,ry1);
b = lerp(sx, u, v);
return lerp(sy, a, b);
}
float Perlin::noise2(float vec[2])
{
int bx0, bx1, by0, by1, b00, b10, b01, b11;
float rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
int i, j;
/* commented out by mark
if (mStart)
{
srand(mSeed);
mStart = false;
init();
}
*/
SETUP(0,bx0,bx1,rx0,rx1);
SETUP(1,by0,by1,ry0,ry1);
i = p[bx0];
j = p[bx1];
b00 = p[i + by0];
b10 = p[j + by0];
b01 = p[i + by1];
b11 = p[j + by1];
sx = fade(rx0);
sy = fade(ry0);
#define at2(rx,ry) ( rx * q[0] + ry * q[1] )
q = g2[b00];
u = at2(rx0,ry0);
q = g2[b10];
v = at2(rx1,ry0);
a = lerp(sx, u, v);
q = g2[b01];
u = at2(rx0,ry1);
q = g2[b11];
v = at2(rx1,ry1);
b = lerp(sx, u, v);
return lerp(sy, a, b);
}
double PerlinNoise::noise2(double x, double y)
{
double vec[2];
int bx0, bx1, by0, by1, b00, b10, b01, b11;
double rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
register int i, j;
vec[0] = x;
vec[1] = y;
if (start) {
start = 0;
init();
}
setup(0, bx0,bx1, rx0,rx1);
setup(1, by0,by1, ry0,ry1);
i = p[ bx0 ];
j = p[ bx1 ];
b00 = p[ i + by0 ];
b10 = p[ j + by0 ];
b01 = p[ i + by1 ];
b11 = p[ j + by1 ];
sx = s_curve(rx0);
sy = s_curve(ry0);
#define at2(rx,ry) ( rx * q[0] + ry * q[1] )
q = g2[ b00 ] ; u = at2(rx0,ry0);
q = g2[ b10 ] ; v = at2(rx1,ry0);
a = lerp(sx, u, v);
q = g2[ b01 ] ; u = at2(rx0,ry1);
q = g2[ b11 ] ; v = at2(rx1,ry1);
b = lerp(sx, u, v);
return lerp(sy, a, b);
}
float CPerlinNoise2D::noise(const Fvector2& vec)
{
int bx0, bx1, by0, by1, b00, b10, b01, b11;
float rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
int i, j;
if (!mReady){
srand(mSeed);
mReady = true;
init();
}
setup(0,bx0,bx1,rx0,rx1);
setup(1,by0,by1,ry0,ry1);
i = p[bx0];
j = p[bx1];
b00 = p[i + by0];
b10 = p[j + by0];
b01 = p[i + by1];
b11 = p[j + by1];
sx = s_curve(rx0);
sy = s_curve(ry0);
#define at2(rx,ry) ( rx * q[0] + ry * q[1] )
q = g2[b00];
u = at2(rx0,ry0);
q = g2[b10];
v = at2(rx1,ry0);
a = lerp(sx, u, v);
q = g2[b01];
u = at2(rx0,ry1);
q = g2[b11];
v = at2(rx1,ry1);
b = lerp(sx, u, v);
return lerp(sy, a, b);
}
double perlin2D_lk(double para1, double para2) {
int bx0, bx1, by0, by1, b00, b10, b01, b11;
double rx0, rx1, ry0, ry1, *q, sx, sy, a, b, u, v;
register int i, j;
if (start) {
start = 0;
init_lk();
}
setup_lk(para1, &bx0, &bx1, &rx0, &rx1);
setup_lk(para2, &by0, &by1, &ry0, &ry1);
i = p[bx0];
j = p[bx1];
b00 = p[i + by0];
b10 = p[j + by0];
b01 = p[i + by1];
b11 = p[j + by1]; // create 4 randoms ,together with bz0,bz1 to combine 8 ramdom numbers all together
sx = s_curve_new(rx0);
sy = s_curve_new(ry0);
q = g2[b00];
u = at2(rx0, ry0);
q = g2[b10];
v = at2(rx1, ry0);
a = lerp(sx, u, v);
q = g2[b01];
u = at2(rx0, ry1);
q = g2[b11];
v = at2(rx1, ry1);
b = lerp(sx, u, v);
return lerp(sy, a, b);
}
// 2차원 노이즈 생성
float GNoise::Noise2(float vec[2])
{
int bx0, bx1, by0, by1, b00, b10, b01, b11;
float rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
register int i, j;
if (m_IsStart)
{
m_IsStart = 0;
Init();
}
Setup( vec[0], bx0, bx1, rx0, rx1 );
Setup( vec[1], by0, by1, ry0, ry1 );
i = m_iRandomIndex[ bx0 ];
j = m_iRandomIndex[ bx1 ];
b00 = m_iRandomIndex[ i + by0 ];
b10 = m_iRandomIndex[ j + by0 ];
b01 = m_iRandomIndex[ i + by1 ];
b11 = m_iRandomIndex[ j + by1 ];
sx = s_curve(rx0);
sy = s_curve(ry0);
#define at2(rx,ry) ( rx * q[0] + ry * q[1] )
q = m_vRandomData[ b00 ] ; u = at2(rx0,ry0);
q = m_vRandomData[ b10 ] ; v = at2(rx1,ry0);
a = lerp(sx, u, v);
q = m_vRandomData[ b01 ] ; u = at2(rx0,ry1);
q = m_vRandomData[ b11 ] ; v = at2(rx1,ry1);
b = lerp(sx, u, v);
return lerp(sy, a, b);
}
float PerlinNoise::noise2( const Vector2 & vec )
{
int bx0, bx1, by0, by1, b00, b10, b01, b11;
float rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
register int i, j;
if (start) {
start = false;
init();
}
setup(0, bx0,bx1, rx0,rx1);
setup(1, by0,by1, ry0,ry1);
i = p[ bx0 ];
j = p[ bx1 ];
b00 = p[ i + by0 ];
b10 = p[ j + by0 ];
b01 = p[ i + by1 ];
b11 = p[ j + by1 ];
sx = s_curve(rx0);
sy = s_curve(ry0);
#define at2(rx,ry) ( rx * q[0] + ry * q[1] )
q = g2[ b00 ] ; u = at2(rx0,ry0);
q = g2[ b10 ] ; v = at2(rx1,ry0);
a = Math::lerp(sx, u, v);
q = g2[ b01 ] ; u = at2(rx0,ry1);
q = g2[ b11 ] ; v = at2(rx1,ry1);
b = Math::lerp(sx, u, v);
return Math::lerp(sy, a, b);
}
real shPerlin::noise2(real vec[2])const{
int bx0, bx1, by0, by1, b00, b10, b01, b11;
real rx0, rx1, ry0, ry1, sx, sy, a, b, t, u, v;
const real *q;
int i, j;
setup(0,bx0,bx1,rx0,rx1);
setup(1,by0,by1,ry0,ry1);
i = p[bx0];
j = p[bx1];
b00 = p[i + by0];
b10 = p[j + by0];
b01 = p[i + by1];
b11 = p[j + by1];
sx = s_curve(rx0);
sy = s_curve(ry0);
#define at2(rx,ry) (rx * q[0] + ry * q[1])
q = g2[b00];
u = at2(rx0,ry0);
q = g2[b10];
v = at2(rx1,ry0);
a = lerp(sx, u, v);
q = g2[b01];
u = at2(rx0,ry1);
q = g2[b11];
v = at2(rx1,ry1);
b = lerp(sx, u, v);
return lerp(sy, a, b);
}
int main(int argc, char **argv)
{
std::string str;
int ret;
ArTcpConnection con;
ArRobot robot;
ActionTest at1(-50, 333);
ActionTest at2(25, 666);
ActionTest at3(25, 0);
ActionTest at4(0, -999);
Aria::init();
if ((ret = con.open()) != 0)
{
str = con.getOpenMessage(ret);
printf("Open failed: %s\n", str.c_str());
Aria::shutdown();
return 1;
}
robot.setDeviceConnection(&con);
if (!robot.blockingConnect())
{
printf("Could not connect to robot... exiting\n");
Aria::shutdown();
return 1;
}
robot.addAction(&at1, 100);
robot.addAction(&at2, 100);
robot.addAction(&at3, 100);
robot.addAction(&at4, 100);
robot.run(true);
Aria::shutdown();
return 0;
}
void Event_test::simultaneousThreadUnsafeOneEvent()
{
ThreadSafeCounter count("gov.fnal.counter");
bool wasChanged=false;
AccessTestingProd* at1(new AccessTestingProd("access1","",demo::kThreadUnsafe,count,wasChanged));
AccessTestingProd* at2(new AccessTestingProd("access2","",demo::kThreadUnsafe,count,wasChanged));
std::vector<std::pair<std::string, std::string> > toGet;
toGet.push_back(std::pair<std::string,std::string>("access1",""));
toGet.push_back(std::pair<std::string,std::string>("access2",""));
SumGetterProd* sum3(new SumGetterProd("sum3","",toGet));
demo::Event event;
event.setIndex(1);
event.addProducer(at1);
event.addProducer(at2);
event.addProducer(sum3);
CPPUNIT_ASSERT(event.get("sum3","")==2);
CPPUNIT_ASSERT(count.value()==2);
CPPUNIT_ASSERT(wasChanged==false);
}
void TestLevel::setup(){
INFO("Generating Test Level...");
readFile();
initalizeGrid();
createRenders();
createLevel();
INFO("Removal String so less of make");
waterSurfaceManager = WaterSurfaceManagerPtr(new WaterSurfaceManager());
addGameObject(waterSurfaceManager);
INFO("Setting up the cameras for the Test Level...");
CameraPtr cam3(new Camera(glm::vec3(16, 30, 0), glm::vec3(16, 15, 6),
glm::vec3(0, 1, 0)));
cam3->setProjectionMatrix(
glm::perspective(glm::radians(90.0f),
(float) Global::ScreenWidth/Global::ScreenHeight,
0.1f, 100.f));
addCamera("CinematicCamera", cam3);
setMainCamera("CinematicCamera");
setCullingCamera("CinematicCamera");
CameraPtr cam1(new Camera(glm::vec3(4, 10, -5), glm::vec3(4, 4, -10),
glm::vec3(0, 1, 0)));
cam1->setProjectionMatrix(
glm::perspective(glm::radians(90.0f),
(float) Global::ScreenWidth/Global::ScreenHeight,
0.1f, 100.f));
addCamera("Camera1", cam1);
CameraPtr cam2(new Camera(glm::vec3(0, 1, 0), glm::vec3(-6, -3, 6),
glm::vec3(0, 1, 0)));
cam2->setProjectionMatrix(
glm::perspective(glm::radians(90.0f),
(float) Global::ScreenWidth/Global::ScreenHeight,
0.1f, 100.f));
l1 = LightPtr(new Light(glm::vec3(1), 30.0f, glm::vec3(0, 30, 0)));
l1->setPosition(l1->getDirection());
Uniform3DGridPtr<int> typeGrid = getTypeGrid();
gridCenter = glm::vec3((typeGrid->getMaxX() - typeGrid->getMinX())/2.0f,
(typeGrid->getMaxY() - typeGrid->getMinY())/2.0f,
(typeGrid->getMinZ() - typeGrid->getMaxZ())/2.0f);
l1->setViewMatrix(glm::lookAt(
l1->getPosition(),
gridCenter, glm::vec3(0, 1, 0)));
l1->setProjectionMatrix(glm::ortho<float>(-30,30,-30,30,-70,70));
addLight("Sun", l1);
INFO("Setting up the player for the Test Level...");
cinematicPlayer = CinematicPlayerPtr(new CinematicPlayer(cam3));
cinematicPlayer->setup();
addGameObject("cinematicPlayer", cinematicPlayer);
player = PlayerPtr(new Player(cam1, 2));
player->setup();
addGameObject("player" , player);
CollisionManager::addCollisionObjectToList(player);
debugPlayer = DebugPlayerPtr(new DebugPlayer(cam2));
debugPlayer->setup();
addGameObject("debugPlayer" , debugPlayer);
addCamera("DebugCamera", cam2);
INFO("Creating Switch for the Test Level...");
SwitchPtr s1(new Switch(glm::vec3(0.9f, 0.1f, 0.1f), glm::vec3(29.7, 23, -45),
glm::vec3(0,0,1), -20.0f, 1));
s1->setup();
addGameObject("s1", s1);
CollisionManager::addCollisionObjectToGrid(s1);
std::list<SolidCubePtr> solidCubes;
// INFO("Creating Active Terrain for the Test Level...");
for(int i = 1; i < 15; i++) {
for(int j = 6; j < 11; j++) {
SolidCubePtr at1(new SolidCube(glm::vec3(i*2 + 1, j*2 + 1, -37)));
at1->setup();
RenderEngine::getRenderGrid()->removeObject(at1->getObject());
//RenderEngine::getRenderElement("shadow")->removeObject(at1->getObject());
solidCubes.push_back(at1);
SolidCubePtr at2(new SolidCube(glm::vec3(i*2 + 1, j*2 + 1, -19)));
at2->setup();
RenderEngine::getRenderGrid()->removeObject(at2->getObject());
//RenderEngine::getRenderElement("shadow")->removeObject(at2->getObject());
solidCubes.push_back(at2);
}
}
for(int j = -19; j < -9; j++) {
for(int i = 7; i < 13; i++) {
SolidCubePtr at1(new SolidCube(glm::vec3(1, i*2 + 1, j*2 + 1)));
at1->setup();
RenderEngine::getRenderGrid()->removeObject(at1->getObject());
//RenderEngine::getRenderElement("shadow")->removeObject(at1->getObject());
solidCubes.push_back(at1);
SolidCubePtr at2(new SolidCube(glm::vec3(15 * 2 + 1, i*2 + 1, j*2 + 1)));
at2->setup();
RenderEngine::getRenderGrid()->removeObject(at2->getObject());
//RenderEngine::getRenderElement("shadow")->removeObject(at2->getObject());
solidCubes.push_back(at2);
}
}
ActiveTerrainPtr a1(new ActiveTerrain(s1, glm::vec3(), glm::vec3(), 50.0f));
a1->setup();
a1->setCubes(solidCubes);
addGameObject("a1", a1);
PTR_CAST(SolidCube, (*grid)(0, 10, 22))->getObject()->applyTextureIndex(LoadManager::getTexture("DrainTexture"), 0);
PTR_CAST(SolidCube, (*grid)(0, 10, 23))->getObject()->applyTextureIndex(LoadManager::getTexture("DrainTexture"), 0);
PTR_CAST(SolidCube, (*grid)(0, 10, 22))->getObject()->applyNormalMapIndex(LoadManager::getTexture("RegularNormalMap"), 0);
PTR_CAST(SolidCube, (*grid)(0, 10, 23))->getObject()->applyNormalMapIndex(LoadManager::getTexture("RegularNormalMap"), 0);
shearRegion(1, 4, 11, 11, 22, 23, 1, 0, 0.0f);
shearRegion(5, 8, 10, 10, 22, 23, 1, 0, 0.5f);
PTR_CAST(SolidCube, (*grid)(0, 10, 4))->getObject()->applyTextureIndex(LoadManager::getTexture("DrainTexture"), 0);
PTR_CAST(SolidCube, (*grid)(0, 10, 5))->getObject()->applyTextureIndex(LoadManager::getTexture("DrainTexture"), 0);
PTR_CAST(SolidCube, (*grid)(0, 10, 4))->getObject()->applyNormalMapIndex(LoadManager::getTexture("RegularNormalMap"), 0);
PTR_CAST(SolidCube, (*grid)(0, 10, 5))->getObject()->applyNormalMapIndex(LoadManager::getTexture("RegularNormalMap"), 0);
shearRegion(1, 4, 11, 11, 4, 5, 1, 0, 0.0f);
shearRegion(5, 8, 10, 10, 4, 5, 1, 0, 0.5f);
sky = ObjectPtr(new Object(
LoadManager::getMesh("sphere.obj"),
MaterialManager::getMaterial("None")));
sky->applyTexture(LoadManager::getTexture("Sky"));
sky->enableTexture();
sky->scale(glm::vec3(-50.0f,-50.0f,-50.0f));
sky->translate(Director::getScene()->getCamera()->getEye());
RenderEngine::getRenderElement("textured")->addObject(sky);
ExclamationPtr exclamation = ExclamationPtr(new Exclamation(glm::vec3(10, 27, -30)));
exclamation->setup();
addGameObject("exclamation", exclamation);
}
int main()
{
std::mt19937 gen;
gen.seed(std::chrono::system_clock::now().time_since_epoch().count());
//Settings
MotifGenSettings set1(1.5, &gen, 3);
//Create some global abstract motifs
std::vector<AbstractMotif> am;
am.push_back(AbstractMotif(set1));
am.push_back(AbstractMotif(set1));
am.push_back(AbstractMotif(set1));
set1.length = 1;
am.push_back(AbstractMotif(set1));
am.push_back(AbstractMotif(set1));
am.push_back(AbstractMotif(set1));
//Abstract themes
ThemeGenSettings set2(3, am, .25, &gen, 3);
AbstractTheme at1(set2);
set2.concreteness = .5;
AbstractTheme at2(set2);
set2.concreteness = .75;
AbstractTheme at3(set2);
set2.concreteness = 1;
AbstractTheme at4(set2);
AbstractTheme at5(set2);
//Concrete themes
ThemeConcreteSettings set3("C4", 0, 80, midi::Instrument::ACOUSTIC_GRAND_PIANO,
1500, &gen, 3);
midi::NoteTrack nt;
std::uint32_t ticks = 0;
ConcreteTheme ct(at1, set3);
ct.addToTrack(nt, ticks);
ticks += ct.ticks() + 5000;
ct.generate(at1, set3);
ct.addToTrack(nt, ticks);
ticks += ct.ticks() + 5000;
ct.generate(at1, set3);
ct.addToTrack(nt, ticks);
ticks += ct.ticks() + 5000;
ct.generate(at4, set3);
ct.addToTrack(nt, ticks);
ticks += ct.ticks() + 5000;
ct.generate(at4, set3);
ct.addToTrack(nt, ticks);
ticks += ct.ticks() + 5000;
ct.generate(at4, set3);
ct.addToTrack(nt, ticks);
ticks += ct.ticks() + 5000;
ct.generate(at4, set3);
ct.addToTrack(nt, ticks);
ticks += ct.ticks() + 5000;
//1 1 2 2 3 3 1 1 4 4 5 5 1 1
//1
/*
ConcreteTheme ct(at1, set3);
ct.addToTrack(nt, ticks);
ticks += ct.ticks() + 5000;
//1
ct.generate(at1, set3);
ct.addToTrack(nt, ticks);
ticks += ct.ticks() + 5000;
//2
ct.generate(at2, set3);
ct.addToTrack(nt, ticks);
ticks += ct.ticks() + 5000;
//2
ct.generate(at2, set3);
ct.addToTrack(nt, ticks);
ticks += ct.ticks() + 5000;
//3
ct.generate(at3, set3);
ct.addToTrack(nt, ticks);
ticks += ct.ticks() + 5000;
//3
ct.generate(at3, set3);
ct.addToTrack(nt, ticks);
ticks += ct.ticks() + 5000;
//1
ct.generate(at1, set3);
ct.addToTrack(nt, ticks);
ticks += ct.ticks() + 5000;
//1
ct.generate(at1, set3);
ct.addToTrack(nt, ticks);
ticks += ct.ticks() + 5000;
//4
ct.generate(at4, set3);
ct.addToTrack(nt, ticks);
ticks += ct.ticks() + 5000;
//4
ct.generate(at4, set3);
ct.addToTrack(nt, ticks);
ticks += ct.ticks() + 5000;
//5
ct.generate(at5, set3);
ct.addToTrack(nt, ticks);
ticks += ct.ticks() + 5000;
//5
ct.generate(at5, set3);
ct.addToTrack(nt, ticks);
ticks += ct.ticks() + 5000;
//1
ct.generate(at1, set3);
ct.addToTrack(nt, ticks);
ticks += ct.ticks() + 5000;
//1
ct.generate(at1, set3);
ct.addToTrack(nt, ticks);
ticks += ct.ticks() + 5000;*/
//Save
midi::MIDI_Type0 mid(nt, midi::TimeDivision(1548));
mid.write("testtheme.mid");
}
