DRReturn PlanetSektor::move(float fTime, Camera* cam)
{
RenderPlanet* render = dynamic_cast<RenderPlanet*>(mRenderer);
//mLastRelativeCameraPosition = cam->getSektorPositionAtSektor(this);
if(mParent) mLastRelativeCameraPosition = mParent->getCameraPosition() - getPosition();
else mLastRelativeCameraPosition = cam->getSektorPositionAtSektor(this);
mTheta = acos(mRadius/mLastRelativeCameraPosition.length())*RADTOGRAD;
Unit distance = mLastRelativeCameraPosition.length()-mRadius;
distance = distance.convertTo(KM);
// mLastRelativeCameraPosition.print("cameraPos");
//printf("\rdistance: %.3f KM, theta: %f", static_cast<double>(distance), mTheta);
std::vector<int>* ebene = GlobalRenderer::Instance().getEbenenCount();
char buffer[256]; memset(buffer, 0, 256);
for(uint i = 1; i < ebene->size(); i++)
sprintf(buffer, "%s %d ", buffer, (*ebene)[i]);
printf("\r%s", buffer);
if(EnIsButtonPressed(SDLK_k))
cam->setAxis(DRVector3(-1.0f, 0.0f, 0.0f), DRVector3(0.0f, 1.0f, 0.0f), DRVector3(0.0f, 0.0f, -1.0f));
if(isObjectInSektor(mLastRelativeCameraPosition))
{
for(u32 i = 0; i < 6; i++)
{
//horizont culling
DRVector3 camPos = mLastRelativeCameraPosition.getVector3().normalize();
double angle = acos(camPos.dot(DRVector3(mSubPlanets[i].x, mSubPlanets[i].y, mSubPlanets[i].z)))*RADTOGRAD-45.0;
//printf("\r %d, angle: %f (%f Grad) ", i, angle, angle*RADTOGRAD);
if(angle < mTheta)
{
getChild(mSubPlanets[i]*static_cast<short>(1000));
}
//else
//printf("\r %d, angle: %f, horizontAngle: %f", i, angle*RADTOGRAD, horizontAngle*RADTOGRAD);
}
}
else
{
//removeInactiveChilds(1.0f);
}
removeInactiveChilds(GlobalRenderer::Instance().getTimeForInactiveChilds());
if(mRenderer)
{
// set player distance to renderer for sort
if(render->getRenderNoisePlanetToTexture())
render->getRenderNoisePlanetToTexture()->setCurrentDistance(static_cast<DRReal>(mLastRelativeCameraPosition.length().convertTo(M)));
// remove renderer, if we didn't need him
if(mNotRenderSeconds >= GlobalRenderer::Instance().getTimeForInactiveChilds())
DR_SAVE_DELETE(mRenderer);
}
return DR_OK;
}
DRReturn DRGeometrieSphere::initSphere(GLuint segmentSize)
{
// vertex and index calculation
GLuint vertexCount = segmentSize*segmentSize;
GLuint indexCount = 2*segmentSize*segmentSize-2*segmentSize;
// memory allocation
if(init(vertexCount, indexCount, 0, true)) LOG_ERROR("no memory allocatet for geometrie!", DR_ERROR);
// generate a round line
for(uint i = 0; i < segmentSize; i++)
{
DRReal _sin = sinf(((PI)/(float)(segmentSize-1))*(float)i);
DRReal _cos = cosf(((PI)/(float)(segmentSize-1))*(float)i);
mVertices[i] = DRVector3(_cos, _sin, 0.0f);
}
// rotate the line to make a whole sphere (rotation count = segmentSize)
for(uint j = 0; j < segmentSize; j++)
{
// PI/segs*2 = 360°
// PI/segs = 180°
DRMatrix rot = DRMatrix::rotationX((PI/(segmentSize-1)*2)*j);
for(uint i = 0; i < segmentSize; i++)
{
if(segmentSize*j + i >= vertexCount) LOG_ERROR("critical 1", DR_ERROR);
mVertices[segmentSize*j + i] = mVertices[i].transformNormal(rot);//*DRRandom::rReal(1.02, 0.98f);
mColors[segmentSize*j + i] = DRColor((float)i/(float)segmentSize, (float)j/(float)segmentSize, fabs((float)i/((float)j+0.001f)));
}
}
mVertexCount = vertexCount;
// generate indices to render sphere as QUAD_STRIP
for(uint j = 0; j < segmentSize-1; j++)
{
for(uint i = 0; i < segmentSize; i++)
{
if(i*2+1+(segmentSize*2)*j >= indexCount) LOG_ERROR("critical 2", DR_ERROR);
if(j*segmentSize + segmentSize+i >= vertexCount) LOG_ERROR("critical 3", DR_ERROR);
mIndices[i*2+(segmentSize*2)*j] = j*segmentSize + segmentSize+i;
mIndices[i*2+1+(segmentSize*2)*j] = j*segmentSize + i;
}
}
mIndexCount = indexCount;
mRenderMode = GL_QUAD_STRIP;
return DR_OK;
}
DRReturn PlanetSektor::render(float fTime, Camera* cam)
{
#if SDL_VERSION_ATLEAST(1,3,0)
Uint8 *keystate = SDL_GetKeyboardState(NULL);
#else
Uint8 *keystate = SDL_GetKeyState(NULL);
#endif
//if(isObjectInSektor(cam->getSektorPosition())) return DR_OK;
//Unit distance1 = Vector3Unit(mSektorPosition - cam->getSektorPosition()).length();
//Unit distance1 = Vector3Unit(mSektorPosition - mLastRelativeCameraPosition).length();
Unit distance1 = (-mLastRelativeCameraPosition).length();
//DRVector3 diff = Vector3Unit(mSektorPosition - cam->getSektorPosition()).convertTo(KM).getVector3();
distance1 = distance1.convertTo(mRadius.getType());
double distance2 = 200.0f;
Unit radius1 = mRadius;
double radius2 = ((radius1 * distance2) / distance1);
//DRVector3 pos = (mSektorPosition - cam->getSektorPosition()).getVector3().normalize();
//DRVector3 pos = (mSektorPosition - mLastRelativeCameraPosition).getVector3().normalize();
DRVector3 pos = (-mLastRelativeCameraPosition).getVector3().normalize();
// DRVector3 relCameraPos = -pos*distance1/mRadius;
pos *= static_cast<DRReal>(distance2);
/* printf("\r %f %f %f, %.8f, %s x:%s y:%s z:%s (%f %f %f)", pos.x, pos.y, pos.z, radius2, distance1.print().data(),
absCameraPosition.x.print().data(), absCameraPosition.y.print().data(),
absCameraPosition.z.print().data(), diff.x, diff.y, diff.z);
//*/
//glTranslatef(pos.x, pos.y, pos.z);
//glScaled(radius2, radius2, radius2);
mMatrix = DRMatrix::scaling(DRVector3(static_cast<DRReal>(radius2))) * DRMatrix::translation(pos) * cam->getKameraMatrixRotation();
//glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
//if(mRenderer && !isObjectInSektor(cam->getSektorPosition()))
//DRReturn ret = mRenderer->render(fTime, cam);
if(!isObjectInSektor(mLastRelativeCameraPosition))
{
mNotRenderSeconds = 0.0f;
if(!mRenderer)
mRenderer = new RenderPlanet(mID, getSektorPathName(), &mPlanetNoiseParameters);
if(!mRenderer) LOG_ERROR("no renderer", DR_ERROR);
if(radius2 > 160.0f) mRenderer->setCurrentDetail(10);
else if(radius2 > 140.0f) mRenderer->setCurrentDetail(9);
else if(radius2 > 120.0f) mRenderer->setCurrentDetail(8);
else if(radius2 > 90.0f) mRenderer->setCurrentDetail(7);
else if(radius2 > 70.0f) mRenderer->setCurrentDetail(6);
else if(radius2 > 30.0f) mRenderer->setCurrentDetail(5);
else if(radius2 > 25.0f) mRenderer->setCurrentDetail(4);
else if(radius2 > 15.0f) mRenderer->setCurrentDetail(3);
else if(radius2 > 5.0f) mRenderer->setCurrentDetail(2);
else if(radius2 > 1.0f) mRenderer->setCurrentDetail(1);
else mRenderer->setCurrentDetail(0);
//GlobalRenderer::getSingleton().getPlanetShaderPtr()->bind();
ShaderProgram* shader = mRenderer->getShaderProgram();
if(!shader) LOG_ERROR("RenderPlanet hasn't valid shader", DR_ERROR);
shader->bind();
shader->setUniformMatrix("modelview", mMatrix);
shader->setUniformMatrix("projection", GlobalRenderer::Instance().getProjectionMatrix().transpose());
DRGrafikError("PlanetSektor::render");
DRReturn ret = mRenderer->render(fTime, cam);
shader->unbind();
// GlobalRenderer::getSingleton().getPlanetShaderPtr()->unbind();
if(ret) LOG_ERROR("Fehler bei call planet renderer", DR_ERROR);
//child didn't need to render
return DR_NOT_ERROR;
//return DR_OK;
}
else
{
mNotRenderSeconds += fTime;
}
return DR_OK;
}
void test()
{
//tests
DRMatrix m1(DRMatrix::identity());
float mat[] = {1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f};
if(memcmp(m1, mat, sizeof(float)*16) != 0)
LOG_WARNING("matrix identity isn't valid");
DRMatrix m2 = m1.rotationX(30.0f);
DRMatrix m3 = DRMatrix::axis(DRVector3(1.0f, 0.0f, 0.0f),
DRVector3(0.0f, 1.0f, 0.0f),
DRVector3(0.0f, 0.0f, 1.0));
if(memcmp(m1, m3, sizeof(float)*16) != 0)
LOG_WARNING("matrix axis isn't valid");
DREngineLog.writeMatrixToLog(m1);
DREngineLog.writeMatrixToLog(m2);
DREngineLog.writeMatrixToLog(m3);
DRVector3 rot1(1.0f, 0.0f, 0.0f);
m2 = DRMatrix::rotationY(90.0f);
rot1 = rot1.transformCoords(m2);
DREngineLog.writeVector3ToLog(rot1, "1/0/0 90 Grad um y-Achse rotiert");
rot1 = rot1.transformCoords(m2.invert());
DREngineLog.writeVector3ToLog(rot1, "zurueckrotiert, 1/0/0 erwartet!");
DREngineLog.writeToLog("RekursionTest: %d", rekursionTest(0));
//Speicher test
/* LOG_INFO("Speichertest");
std::list<void*> pointer;
void* t = NULL;
u32 count = 0;
do
{
t = malloc(16384);
if(t) pointer.push_back(t);
count++;
if(count > 192073)
break;
} while(t);
DRLog.writeToLog("count: %d, %u kByte wurden reserviert!", count, count*16384/1024);
for(std::list<void*>::iterator it = pointer.begin(); it != pointer.end(); it++)
free(*it);
pointer.clear();
//* */
// Unit test
printf("\n");
Unit parsec(1.0, PARSEC);
Unit lj = parsec.convertTo(LIGHTYEAR);
DREngineLog.writeToLog("%s -> %s", parsec.print().data(), lj.print().data());
lj = Unit(1.0, LIGHTYEAR);
parsec = lj.convertTo(PARSEC);
DREngineLog.writeToLog("%s -> %s", lj.print().data(), parsec.print().data());
Unit ae = lj.convertTo(AE);
DREngineLog.writeToLog("%s -> %s", lj.print().data(), ae.print().data());
ae = parsec.convertTo(AE);
DREngineLog.writeToLog("%s -> %s", parsec.print().data(), ae.print().data());
parsec = ae.convertTo(PARSEC);
DREngineLog.writeToLog("%s -> %s", ae.print().data(), parsec.print().data());
Unit m = parsec.convertTo(M);
DREngineLog.writeToLog("%s -> %s", parsec.print().data(), m.print().data());
Unit kpc(1.0, KILOPARSEC);
m = kpc.convertTo(M);
DREngineLog.writeToLog("%s -> %s", kpc.print().data(), m.print().data());
m = Unit(1.0, M);
kpc = m.convertTo(KILOPARSEC);
DREngineLog.writeToLog("%s -> %s", m.print().data(), kpc.print().data());
printf("\n");
Unit aes(0.005, AE);
DREngineLog.writeToLog("%s -> %s", aes.print().data(), aes.convertTo(KM).print().data());
//Vector Unit Test
Vector3Unit u1(100, 200, 70, M), u2(1, 0, 0, KILOPARSEC), u3(100, 20, 17, LIGHTYEAR);
u1.print("u1");
u2.print("u2");
u3.print("u3");
u1 *= Unit(20, KM);
u1.print("u1* 20 km");
Vector3Unit(u1 + u2).print("u1+u2");
Vector3Unit(u2+u3).print("u2+u3");
Vector3Unit(u1*Unit(1, LIGHTYEAR)).print("u1*1 Lichtjahr");
DRVector3 v(1.0f, 7.0f, 2.0f);
DREngineLog.writeVector3ToLog(v, "init");
v = v.normalize();
DREngineLog.writeVector3ToLog(v, "normalized");
v *= 7.0f;
DREngineLog.writeVector3ToLog(v, "multiplikator");
// ---------------------------------- ReferenzHolder Test --------------------------------
DREngineLog.writeToLog("DRIndexReferenzHolder test");
DRIndexReferenzHolder referenzHolder(10);
uint tests[10];
tests[0] = referenzHolder.getFree();
referenzHolder.add(tests[0]);
tests[1] = referenzHolder.getFree();
DREngineLog.writeToLog("index1 (0): %d, index2 (1): %d", tests[0], tests[1]);
referenzHolder.remove(tests[0]);
tests[2] = referenzHolder.getFree();
referenzHolder.remove(tests[1]);
tests[3] = referenzHolder.getFree();
DREngineLog.writeToLog("index3 (2): %d, index4 (1): %d", tests[2], tests[3]);
for(int i = 0; i < 5; i++)
tests[4+i] = referenzHolder.getFree();
referenzHolder.remove(tests[7]);
tests[9] = referenzHolder.getFree();
DREngineLog.writeToLog("index10: (6): %d", tests[9]);
DRTextureManager::Instance().test();
// Random Test
}
DRReturn move(float fTime)
{
float fRotSpeed = 2.0f;
float fSpeed = 20.0f;
int numKeys = 0;
//Kamera
#if SDL_VERSION_ATLEAST(1,3,0)
Uint8 *keystate = SDL_GetKeyboardState(&numKeys);
#else
Uint8 *keystate = SDL_GetKeyState(NULL);
#endif
/*for(uint i = 0; i < numKeys; i++)
{
if(keystate[i]) DRLog.writeToLog("%d button pressed: %d", i, (int)keystate[i]);
}
//*/
// return DR_OK;
int mouseMove_x = 0, mouseMove_y = 0;
// holen der Maus bewegung seit letztem frame und der bitmaks welche Tasten gedrückt sind
Uint8 mousePressed = SDL_GetRelativeMouseState(&mouseMove_x, &mouseMove_y);
//if(gCurrentControlMode != 0 )
//{
// die Kamera wird rotiert, gesteuert durch die Tasten w, s (x Achse, hoch/runter), <-, -> (y Achse links/rechts), e und q (z Achse seitlich)
g_cam->rotateRel(DRVector3(keystate[SDLK_s]-keystate[SDLK_w], keystate[SDLK_RIGHT]-keystate[SDLK_LEFT], keystate[SDLK_q]-keystate[SDLK_e])*fTime);
// wenn die rechte maustaste gedrückt ist
if((mousePressed & 4) == 4)
// wird die Kamera auch abhängig von der Mausposition gedreht
g_cam->rotateRel(DRVector3(-mouseMove_y, -mouseMove_x, 0.0f)*fTime*fRotSpeed);
//}
if(gControlModes[gCurrentControlMode].mValue.getType() == M)
g_cam->translateRel(DRVector3(keystate[SDLK_d]-keystate[SDLK_a], keystate[SDLK_PAGEUP]-keystate[SDLK_PAGEDOWN], keystate[SDLK_DOWN]-keystate[SDLK_UP])*fTime*gControlModes[gCurrentControlMode].mValue);
else
g_cam->translateRel_SektorPosition(DRVector3(keystate[SDLK_d]-keystate[SDLK_a], keystate[SDLK_PAGEUP]-keystate[SDLK_PAGEDOWN], keystate[SDLK_DOWN]-keystate[SDLK_UP])*fTime*gControlModes[gCurrentControlMode].mValue, gControlModes[gCurrentControlMode].mValue.getType());
//set control mode
if(EnIsButtonPressed(SDLK_1)) gCurrentControlMode = 0;
else if(EnIsButtonPressed(SDLK_2)) gCurrentControlMode = 1;
else if(EnIsButtonPressed(SDLK_3)) gCurrentControlMode = 2;
else if(EnIsButtonPressed(SDLK_4)) gCurrentControlMode = 3;
else if(EnIsButtonPressed(SDLK_5)) gCurrentControlMode = 4;
else if(EnIsButtonPressed(SDLK_6)) gCurrentControlMode = 5;
else if(EnIsButtonPressed(SDLK_7)) gCurrentControlMode = 6;
else if(EnIsButtonPressed(SDLK_8)) gCurrentControlMode = 7;
else if(EnIsButtonPressed(SDLK_9)) gCurrentControlMode = 8;
GlobalRenderer::Instance().setTimeForInactiveChild(gControlModes[gCurrentControlMode].mTime);
g_Player.setCurrentSpeed(gControlModes[gCurrentControlMode].mValue);
// R-Taste
if(EnIsButtonPressed(SDLK_r)) wireframe = !wireframe;
//if(EnIsButtonPressed(SDLK_z)) blockCount++;
if(keystate[SDLK_z]) blockCount++;
if(fTime == 0.0f) fTime = 0.00166f;
//if(g_Player.getSektor()->moveAll(fTime, g_cam))
if(g_Player.getSektor()->moveAll(fTime, g_Player.getCamera()))
LOG_ERROR("Fehler bei move sektor", DR_ERROR);
return DR_OK;
}
