ElementCoordinatesMappingLocal::ElementCoordinatesMappingLocal(
const Element& e,
const CoordinateSystem &global_coords)
: _coords(global_coords), _matR2global(3,3)
{
assert(e.getDimension() <= global_coords.getDimension());
_points.reserve(e.getNNodes());
for(unsigned i = 0; i < e.getNNodes(); i++)
_points.emplace_back(e.getNode(i)->getCoords());
auto const element_dimension = e.getDimension();
auto const global_dimension = global_coords.getDimension();
if (global_dimension == element_dimension)
{
_matR2global.setIdentity();
return;
}
detail::getRotationMatrixToGlobal(element_dimension, global_dimension, _points, _matR2global);
#ifdef OGS_USE_EIGEN
detail::rotateToLocal(_matR2global.transpose(), _points);
#else
RotationMatrix* m(_matR2global.transpose());
detail::rotateToLocal(*m, _points);
delete m;
#endif
}
//------------------------------------------------------------------------------
// void BuildValidCoordinateSystemList()
//------------------------------------------------------------------------------
void ShowSummaryDialog::BuildValidCoordinateSystemList()
{
CoordinateSystem *tmpCS = NULL;
SpacePoint *origin = NULL;
std::string currentCS = coordSysComboBox->GetValue().c_str();
std::string newCS = currentCS;
Integer sz;
// The only valid coordinate system for use here:
// 1) have a celestial body origin, and
// 2) do not have a spacecraft as the origin or the primary or the secondary
// get the names of the coordinate systems
StringArray coordSystemNames;
wxArrayString csNames = coordSysComboBox->GetStrings();
for (Integer ii = 0; ii < (Integer) csNames.GetCount(); ii++)
coordSystemNames.push_back((csNames.Item(ii)).c_str());
sz = (Integer) coordSystemNames.size();
coordSysComboBox->Clear();
for (Integer ii = 0; ii < sz; ii++)
{
if (ii == 0) newCS = coordSystemNames.at(ii);
else if (currentCS == coordSystemNames.at(ii)) newCS = currentCS;
tmpCS = (CoordinateSystem*) theGuiInterpreter->GetConfiguredObject(coordSystemNames.at(ii));
origin = tmpCS->GetOrigin();
if (origin->IsOfType("CelestialBody") && (!tmpCS->UsesSpacecraft())) // add it to the list
coordSysComboBox->Append(wxString(coordSystemNames[ii].c_str()));
}
coordSysComboBox->SetValue(newCS.c_str());
currentCoordSysName = coordSysComboBox->GetValue().c_str();
}
SPFeatureI FeatureCoverage::newFeature(geos::geom::Geometry *geom, bool load) {
if ( load) {
Locker<std::mutex> lock(_loadmutex);
if (!connector()->dataIsLoaded()) {
connector()->loadData(this);
}
}
Locker<> lock(_mutex);
IlwisTypes tp = geometryType(geom);
auto *newfeature = createNewFeature(tp);
if (newfeature ){
if ( geom) {
CoordinateSystem *csy = GeometryHelper::getCoordinateSystem(geom);
if ( csy && !csy->isEqual(coordinateSystem().ptr())){
CsyTransform trans(csy, coordinateSystem());
geom->apply_rw(&trans);
}
GeometryHelper::setCoordinateSystem(geom, coordinateSystem().ptr());
newfeature->geometry(geom);
}else
setFeatureCount(itUNKNOWN,1,0);
_features.push_back(newfeature);
return _features.back();
}
return SPFeatureI();
}
void FrameMetricWrapper::spaceSelected()
{
if (mInternalUpdate)
return;
CoordinateSystem space = mSpaceSelector->getValue();
if (space.isValid())
mData->setSpace(space);
}
//------------------------------------------------------------------------------
void Publisher::SetDataMJ2000EqOrigin(CelestialBody *cb)
{
if (cb == NULL)
return;
#if DBGLVL_PUBLISHER_DATA_REP
MessageInterface::ShowMessage
("Publisher::SetDataMJ2000EqOrigin() cb=%s<%p>\n", cb->GetName().c_str(),
cb);
#endif
dataMJ2000EqOrigin = cb;
std::string originName = cb->GetName();
std::string csName = originName + "MJ2000Eq";
std::map<std::string, CoordinateSystem*>::iterator csIter =
coordSysMap.find(csName);
if (coordSysMap.find(csName) != coordSysMap.end())
{
// set coordinate system from the map
dataCoordSystem = coordSysMap.find(csName)->second;
}
else
{
// check as local name
csName = "Local-" + csName;
if (coordSysMap.find(csName) != coordSysMap.end())
dataCoordSystem = coordSysMap.find(csName)->second;
else
{
// Create coordinate system if not exist
CoordinateSystem *newCs = (CoordinateSystem*)internalCoordSystem->Clone();
newCs->SetName(csName);
newCs->SetStringParameter("Origin", originName);
newCs->SetRefObject(cb, Gmat::CELESTIAL_BODY, originName);
newCs->Initialize();
coordSysMap[csName] = newCs;
dataCoordSystem = newCs;
#if DBGLVL_PUBLISHER_DATA_REP
MessageInterface::ShowMessage
(" ===> %s not found in the map, so created <%p>\n", csName.c_str(),
newCs);
#endif
}
}
// set to subscribers
std::list<Subscriber*>::iterator current = subscriberList.begin();
while (current != subscriberList.end())
{
(*current)->SetDataMJ2000EqOrigin(cb);
(*current)->SetDataCoordSystem(dataCoordSystem);
current++;
}
}
bool CoordinateSystemConnector::loadMetaData(IlwisObject* data, const IOOptions& options)
{
Ilwis3Connector::loadMetaData(data, options);
CoordinateSystem *csy = static_cast<CoordinateSystem *>(data);
QString ellipsoideName;
IEllipsoid ell = getEllipsoid();
GeodeticDatum *datum = getDatum(ellipsoideName);
if ( !ell.isValid() && ellipsoideName != sUNDEF){
QString ellres = QString("ilwis://tables/ellipsoid?code=%1").arg(ellipsoideName);
if (!ell.prepare(ellres)) {
return ERROR1("No ellipsoid for this code %1",ellipsoideName);
}
}
QString cb = _odf->value("CoordSystem", "CoordBounds");
QStringList cbparts = cb.split(" ");
if ( cbparts.size() == 4 && cbparts[0] != "-1e+308") {
bool ok1, ok2, ok3, ok4;
Envelope box( Coordinate(
cbparts[0].toDouble(&ok1),
cbparts[1].toDouble(&ok2)),
Coordinate(
cbparts[2].toDouble(&ok3),
cbparts[3].toDouble(&ok4)));
if ( !( ok1 && ok2 && ok3 && ok4)) {
return ERROR2(ERR_NO_INITIALIZED_2, TR("envelop"), csy->name());
}
csy->envelope(box);
} else {
QString type = _odf->value("CoordSystem", "Type");
if ( type == "LatLon") {
Envelope box(Coordinate(-180,-90), Coordinate(180,90));
csy->envelope(box);
}
}
if ( type() == itCONVENTIONALCOORDSYSTEM ) {
ConventionalCoordinateSystem *csycc = static_cast<ConventionalCoordinateSystem *>(csy);
IProjection proj = getProjection(csycc);
if ( !proj.isValid()) {
return ERROR1(ERR_NO_INITIALIZED_1, "projection");
}
csycc->setDatum(datum);
csycc->setEllipsoid(ell);
csycc->setProjection(proj);
proj->setCoordinateSystem(csycc);
proj->setParameter(Projection::pvELLCODE, ell->toProj4());
csycc->prepare();
} else if ( type() == itUNKNOWN){
//TODO: other types of csy
}
return true;
}
void Ship :: setupCamera () const
{
CoordinateSystem camera = getCameraCoordinateSystem();
const Vector3& camera_position = camera.getPosition();
const Vector3& camera_up = camera.getUp();
Vector3 look_at = camera_position + camera.getForward();
gluLookAt(camera_position.x, camera_position.y, camera_position.z,
look_at.x, look_at.y, look_at.z,
camera_up.x, camera_up.y, camera_up.z);
}
static void extrudePoint(double X[3],const double Z[3])
{
if (Z[0]==0 && Z[1]==0 && Z[2]>=0) return; /*The coordinate system is WCS*/
CoordinateSystem<double> XYZ;
createObjectCoordSystem(&XYZ,Z);
double nX[3];
XYZ.fromLocalToGlobal(nX,X);
vec_copy(X,nX);
}
int main(){
int xsize, ysize;
unsigned char * imgbuf;
double inFluxScale;
#ifdef _WIN32
if (!loadBitmap("G:\\sources2\\__BR\\RC\\crocodile\\reprojection-pseudocode\\lovell.bmp", &xsize, &ysize, &imgbuf, &inFluxScale)){
#else
if (!loadBitmap("/home/awson/data/Work/crocodile/reprojection-pseudocode/lovell.bmp", &xsize, &ysize, &imgbuf, &inFluxScale)){
#endif
printf("Can't load the input!");
return -1;
}
CoordinateSystem inCS = {
{0, 0}
, {500, 500}
, { {-0.000027778, 0}
, { 0, 0.000027778}
}
};
inCS.prepare();
CoordinateSystem outCS = {
{0, 0}
, {500, 500}
, { {-0.00002, -0.00002}
, {-0.00002, 0.00002}
}
};
outCS.prepare();
vector<double> inp(xsize * ysize);
vector<double> outp(xsize * ysize);
unsigned char * it = imgbuf;
for (double & v : inp) v = double(*it++);
printf("Start repro ...\n");
reprojection(
inCS
, outCS
, {xsize, ysize}
, {xsize, ysize}
, inp.data()
, outp.data()
);
printf("Done repro!\n");
// Dirty! Reuse imgbuf.
it = imgbuf;
for (double v : outp) *it++ = (unsigned char)(min(255.0, v));
saveBitmap("image.bmp", xsize, ysize, imgbuf, inFluxScale * pixelAreaRatio(inCS, outCS));
free(imgbuf);
}
void World::playerFireBullet()
{
if (m_playerShip.isAlive() && m_playerShip.isBulletReady())
{
CoordinateSystem cs = m_playerShip.getCoordinate();
m_bullets[m_nextBulletIndex].fire(cs.getPosition(), cs.getForward(), m_playerShip.getId());
m_playerShip.reloadBullet();
m_nextBulletIndex++;
if (m_nextBulletIndex == Const::BULLET_COUNT){
m_nextBulletIndex = 0;
}
}
}
AxisConnector::AxisConnector(CoordinateSystem space, SpaceProviderPtr spaceProvider)
{
mSpaceProvider = spaceProvider;
mListener = mSpaceProvider->createListener();
mListener->setSpace(space);
connect(mListener.get(), SIGNAL(changed()), this, SLOT(changedSlot()));
mRep = AxesRep::New(space.toString() + "_axis");
mRep->setCaption(space.toString(), Vector3D(1, 0, 0));
mRep->setShowAxesLabels(false);
mRep->setFontSize(0.08);
mRep->setAxisLength(0.03);
this->changedSlot();
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// clear the screen - any drawing before here will not display
glLoadIdentity();
// set up the camera here
camera.setCamera();
// camera is set up - any drawing before here will display incorrectly
// Draw Skybox
glPushMatrix();
glTranslatef(camera.getPosition().x,
camera.getPosition().y,
camera.getPosition().z);
glDepthMask(GL_FALSE);
skybox.draw();
glDepthMask(GL_TRUE);
glPopMatrix();
// Draw Saturn
glPushMatrix();
glTranslatef(saturnInfo.x, 0.f, saturnInfo.z);
glScalef(saturnInfo.radius, saturnInfo.radius, saturnInfo.radius);
saturn.draw();
glPopMatrix();
// Draw Moons
for (int i = 0; i < 10; i++)
{
glPushMatrix();
glTranslatef(moonInfo[i].x, 0.f, moonInfo[i].z);
glScalef(moonInfo[i].radius, moonInfo[i].radius, moonInfo[i].radius);
moons[i].draw();
glPopMatrix();
}
// Draw rings
glPushMatrix();
glTranslatef(ringInfo.x, 0.f, ringInfo.z);
glScalef(ringInfo.radius, ringInfo.radius, ringInfo.radius);
ring.draw();
glPopMatrix();
// send the current image to the screen - any drawing after here will not display
glutSwapBuffers();
}
//---------------------------------------------------------------------------
Body::Body(const CoordinateSystem<3> xyz, shared_ptr<SurfaceModel> shell)
: coordinate_(xyz), toptol_(shell->getTolerances())
//---------------------------------------------------------------------------
{
shells_.push_back(shell);
addBodyPointers();
}
string Ellipse::createPathNodes(Point point, CoordinateSystem& drawing, bool alwaysShowFirstPoint) {
string path("");
Point startPoint = drawing.map(getFirstPoint());
path += "M " + NumberUtil::formatFloat(startPoint.getX()) + ","
+ NumberUtil::formatFloat(startPoint.getY());
for (int i = 1; i <= 4; i++) {
Point nextPoint = drawing.map(EllipticalArc::point((float) (M_PI * i / 2.0), m_radius, m_centre,m_eccentricity));
path += " A " + NumberUtil::formatFloat(m_radius) + ","
+ NumberUtil::formatFloat(m_radius * m_eccentricity)
+ NumberUtil::formatFloat(m_inclination) + " 0,0 "
+ NumberUtil::formatFloat(nextPoint.getX()) + ","
+ NumberUtil::formatFloat(nextPoint.getY());
}
path += " Z ";
return path;
}
void SOP_SceneCacheSource::transformObject( IECore::Object *object, const Imath::M44d &transform, bool &hasAnimatedTopology, bool &hasAnimatedPrimVars, std::vector<InternedString> &animatedPrimVars )
{
Primitive *primitive = IECore::runTimeCast<Primitive>( object );
if ( primitive )
{
TransformOpPtr transformer = new TransformOp();
transformer->inputParameter()->setValue( primitive );
transformer->copyParameter()->setTypedValue( false );
transformer->matrixParameter()->setValue( new M44dData( transform ) );
transformer->operate();
std::vector<std::string> &primVars = transformer->primVarsParameter()->getTypedValue();
for ( std::vector<std::string>::iterator it = primVars.begin(); it != primVars.end(); ++it )
{
if ( std::find( animatedPrimVars.begin(), animatedPrimVars.end(), *it ) == animatedPrimVars.end() )
{
animatedPrimVars.push_back( *it );
hasAnimatedPrimVars = true;
}
}
return;
}
Group *group = IECore::runTimeCast<Group>( object );
if ( group )
{
MatrixTransformPtr matTransform = matrixTransform( transform );
matTransform->matrix *= group->getTransform()->transform();
group->setTransform( matTransform );
return;
}
CoordinateSystem *coord = IECore::runTimeCast<CoordinateSystem>( object );
if ( coord )
{
MatrixTransformPtr matTransform = matrixTransform( transform );
matTransform->matrix *= coord->getTransform()->transform();
coord->setTransform( matTransform );
return;
}
}
void special(int special_key, int x, int y)
{
special_key_pressed[special_key] = true;
switch(special_key)
{
case GLUT_KEY_END:
camera.reset();
break;
}
}
void special(int special_key, int x, int y)
{
switch(special_key)
{
case GLUT_KEY_RIGHT:
camera.setYaw(-0.1);
break;
case GLUT_KEY_LEFT:
camera.setYaw(0.1);
break;
case GLUT_KEY_UP:
camera.setPitch(0.1);
break;
case GLUT_KEY_DOWN:
camera.setPitch(-0.1);
break;
case GLUT_KEY_END:
camera.reset();
break;
}
}
IlwisObject *InternalIlwisObjectFactory::createCsyFromCode(const Resource& resource, const IOOptions &options) const {
QString code = resource.code();
bool isUnknown = code == "unknown" || code == "csy:unknown";
QString projParms = code;
if ( code.left(6) == "proj4:"){
projParms = code.mid(6);
}else if(!isUnknown && code.left(5) == "epsg:"){
QString query = QString("select * from projectedcsy where code='%1'").arg(code);
InternalDatabaseConnection db;
if ( db.exec(query)) {
if (db.next()) {
QSqlRecord rec = db.record();
projParms = rec.value("proj_params").toString();
} else {
kernel()->issues()->log(TR(ERR_COULDNT_CREATE_OBJECT_FOR_2).arg("coordinatesystem", resource.name()));
return 0;
}
}
}
CoordinateSystem *csy = 0;
if ( isUnknown){
csy = createFromResource<BoundsOnlyCoordinateSystem>(resource, options);
csy->name("unknown");
csy->code("unknown");
csy->setDescription(TR("Unknown coordinate system"));
}else {
csy = createFromResource<ConventionalCoordinateSystem>(resource, options);
csy->setDescription(resource.name());
csy->prepare("proj4=" + projParms);
}
return csy;
}
void keyboard(unsigned char key, int x, int y)
{
Vector3 origin = Vector3::ZERO;
Vector3 direction_to_origin;
switch (key)
{
case 27: // on [ESC]
exit(0); // normal exit
break;
case ' ':
camera.moveForward(0.5);
break;
case 'w':
camera.moveUp(0.5);
break;
case 'a':
camera.moveLeft(0.5);
break;
case 's':
camera.moveDown(0.5);
break;
case 'd':
camera.moveRight(0.5);
break;
case 'h':
direction_to_origin = origin - camera.getPosition();
camera.rotateToVector(direction_to_origin, 0.1);
break;
case ',':
camera.setRoll(0.1);
break;
case '.':
camera.setRoll(-0.1);
break;
case '/':
camera.moveBackward(0.5);
break;
}
}
void World::update()
{
handleKeyPress();
m_playerShip.update(*this);
int i = 0;
// bullet
for (; i < Const::BULLET_COUNT; i++)
{
m_bullets[i].update(*this);
}
int abc = 0;
// enemy ships
Vector3 playerPosition = m_playerShip.getPosition();
for (i = 0; i < Const::ENEMY_SHIP_AMOUNT;i++){
if (m_ships[i].isAlive()){
double distance = m_ships[i].getPosition().getDistanceSquared(playerPosition);
if (distance < Const::NEAR_TO_PLAYER){
m_ships[i].runAi(*this);
m_ships[i].update(*this);
abc++;
}
}
}
CoordinateSystem cs = m_playerShip.getCoordinate();
Vector3 position = cs.getPosition();
Vector3 up = cs.getUp();
m_camera.setUp(cs.getUp());
Vector3 forward = cs.getForward();
m_camera.setForward(forward);
position += 20 * up;
position -= 100 * forward;
m_camera.setPosition(position);
checkCollision();
}
bool CoordinateSystemSerializerV1::store(IlwisObject *obj, const IOOptions &options)
{
if (!VersionedSerializer::store(obj, options))
return false;
CoordinateSystem *csy = static_cast<CoordinateSystem *>(obj);
if ( csy->ilwisType() == itCONVENTIONALCOORDSYSTEM){
VersionedDataStreamFactory *factory = kernel()->factory<VersionedDataStreamFactory>("ilwis::VersionedDataStreamFactory");
if (!factory)
return false;
std::unique_ptr<DataInterface> projstreamer(factory->create(Version::interfaceVersion, itPROJECTION,_stream));
if ( !projstreamer)
return false;
ConventionalCoordinateSystem *ccsy = static_cast<ConventionalCoordinateSystem *>(csy);
storeSystemPath(ccsy->projection()->resource());
projstreamer->store(ccsy->projection().ptr(),options);
std::unique_ptr<DataInterface> ellstreamer(factory->create(Version::interfaceVersion, itELLIPSOID,_stream));
if ( !ellstreamer)
return false;
storeSystemPath(ccsy->ellipsoid()->resource());
ellstreamer->store(ccsy->ellipsoid().ptr(),options);
const std::unique_ptr<GeodeticDatum>& datum = ccsy->datum();
if ( datum){
_stream << itGEODETICDATUM << datum->name() << datum->code() << datum->description() << datum->area() << datum->authority();
for(int i =0; i < 10; ++i)
_stream << datum->parameter((GeodeticDatum::DatumParameters)i);
}else
_stream << itUNKNOWN;
_stream << ccsy->unit();
}
_stream << csy->envelope().min_corner().x << csy->envelope().min_corner().y << csy->envelope().max_corner().x << csy->envelope().max_corner().y;
return true;
}
bool CoordinateSystemSerializerV1::loadMetaData(IlwisObject *obj, const IOOptions &options)
{
if (!VersionedSerializer::loadMetaData(obj, options))
return false;
CoordinateSystem *csy = static_cast<CoordinateSystem *>(obj);
VersionedDataStreamFactory *factory = kernel()->factory<VersionedDataStreamFactory>("ilwis::VersionedDataStreamFactory");
if (!factory)
return false;
if ( csy->ilwisType() == itCONVENTIONALCOORDSYSTEM){
ConventionalCoordinateSystem *convCsy = static_cast<ConventionalCoordinateSystem *>(obj);
quint64 type;
QString version, url;
_stream >> url;
_stream >> type;
if ( type != itUNKNOWN){
_stream >> version;
std::unique_ptr<DataInterface> projstreamer(factory->create(version, type,_stream));
if ( !projstreamer)
return false;
IProjection proj(itPROJECTION);
projstreamer->loadMetaData(proj.ptr(), options );
convCsy->setProjection(proj);
}
void init()
{
for (int i = 0; i < 256; i++)
{
key_pressed[i] = false;
}
for (int i = 0; i < 128; i++)
{
special_key_pressed[i] = false;
}
initDisplay();
camera.setPosition({70000.0, 0.0, 70000.0});
world.init();
}
//---------------------------------------------------------------------------
Body::Body(const CoordinateSystem<3> xyz, vector<shared_ptr<SurfaceModel> >& shells)
: coordinate_(xyz), shells_(shells), toptol_(0.0, 0.0, 0.0, 0.0)
//---------------------------------------------------------------------------
{
double gap=0.0, neighbour=0.0, kink=0.0, bend=0.0;
for (size_t ki=0; ki<shells.size(); ki++)
{
tpTolerances toptol = shells[ki]->getTolerances();
gap = std::max(toptol.gap, gap);
neighbour = std::max(toptol.neighbour, neighbour);
kink = std::max(toptol.kink, kink);
bend = std::max(toptol.bend, bend);
}
toptol_ = tpTolerances(gap, neighbour, kink, bend);
addBodyPointers();
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// clear the screen - any drawing before here will not display
glLoadIdentity();
// set up the camera here
camera.setCamera();
// Draw the world
world.drawSkybox(camera);
world.drawSaturn();
world.drawMoons();
world.drawRings(camera);
// send the current image to the screen - any drawing after here will not display
glutSwapBuffers();
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// clear the screen - any drawing before here will not display
glLoadIdentity();
// set up the camera here
camera.setCamera();
// camera is set up - any drawing before here will display incorrectly
drawOrientationCube();
glColor3f(0.75f, 0.75f, 0.75f);
glutSolidSphere(0.5, 20, 15);
// send the current image to the screen - any drawing after here will not display
glutSwapBuffers();
}
IlwisObject *InternalIlwisObjectFactory::createCsy(const Resource& resource, const IOOptions &options) const {
CoordinateSystem *csy = 0;
if ( resource.ilwisType() == itBOUNDSONLYCSY){ // by default to csy unknow but this may be changed later
csy = createFromResource<BoundsOnlyCoordinateSystem>(resource, options);
csy->name("unknown");
csy->code("unknown");
csy->setDescription(TR("Unknown coordinate system"));
}else if ( resource.ilwisType() == itCONVENTIONALCOORDSYSTEM){
csy = createFromResource<ConventionalCoordinateSystem>(resource, options);
csy->name(resource.name());
csy->code(resource.code());
}
return csy;
}
void L2Projector::init(const DiscreteSpace& space,
const CoordinateSystem& coordSys,
const Expr& expr,
const LinearSolver<double>& solver)
{
TEST_FOR_EXCEPTION(space.basis().size() != expr.size(),
RuntimeError,
"mismatched vector structure between basis and expr");
TEST_FOR_EXCEPTION(space.basis().size() == 0,
RuntimeError,
"Empty basis?");
Expr v = new TestFunction(space.basis()[0], "dummy_v[0]");
Expr u = new UnknownFunction(space.basis()[0], "dummy_u[0]");
for (int i=1; i<space.basis().size(); i++)
{
v.append(new TestFunction(space.basis()[i], "dummy_v["
+ Teuchos::toString(i)+"]"));
u.append(new UnknownFunction(space.basis()[i], "dummy_u["
+ Teuchos::toString(i)+"]"));
}
CellFilter interior = new MaximalCellFilter();
Expr eqn = 0.0;
Expr J = coordSys.jacobian();
for (int i=0; i<space.basis().size(); i++)
{
eqn = eqn + Integral(space.cellFilters(i),
J*v[i]*(u[i]-expr[i]),
new GaussianQuadrature(4));
}
Expr bc;
prob_ = LinearProblem(space.mesh(), eqn, bc, v, u, space.vecType());
solver_ = solver;
}
void init()
{
for (int i = 0; i < 256; i++)
{
key_pressed[i] = false;
}
for (int i = 0; i < 20; i++)
{
special_key_pressed[i] = false;
}
initDisplay();
camera.setPosition(Vector3(70000.0, 0.0, 70000.0));
skybox.load("Models/Skybox.obj");
saturn.load(saturnInfo.filename);
for (int i = 0; i < 10; i++)
{
moons[i].load(moonInfo[i].filename);
}
ring.load(ringInfo.filename);
}
void RingSystem :: draw (const CoordinateSystem& camera_coordinates) const
{
const Vector3& camera_position = camera_coordinates.getPosition();
RingSectorIndex camera_index(camera_position);
if(DEBUGGING_CHOOSING_SECTORS)
cout << "Drawing around ring sector " << camera_index << endl;
for(int dx = -RING_SECTOR_DRAW_FROM_CAMERA_COUNT; dx <= RING_SECTOR_DRAW_FROM_CAMERA_COUNT; dx++)
{
short x = camera_index.getX() + dx;
for(int dy = -RING_SECTOR_DRAW_FROM_CAMERA_COUNT; dy <= RING_SECTOR_DRAW_FROM_CAMERA_COUNT; dy++)
{
short y = camera_index.getY() + dy;
for(int dz = -RING_SECTOR_DRAW_FROM_CAMERA_COUNT; dz <= RING_SECTOR_DRAW_FROM_CAMERA_COUNT; dz++)
{
short z = camera_index.getZ() + dz;
RingSectorIndex ring_sector_index(x, y, z);
const RingSector& ring_sector = getRingSector(ring_sector_index);
unsigned int particle_count = (unsigned int)ring_sector.mv_ring_particles.size();
if(DEBUGGING_CHOOSING_SECTORS && dx == 0 && dy == 0 && dz == 0)
{
cout << "\tRing Sector " << ring_sector.m_index << "\t==> " << ring_sector.m_index.getCenter() << endl;
cout << "\t\t " << particle_count << " particles" << endl;
}
for(unsigned int i = 0; i < particle_count; i++)
{
ring_sector.mv_ring_particles[i].draw(camera_position);
if(DEBUGGING_CHOOSING_SECTORS && dx == 0 && dy == 0 && dz == 0)
cout << "\t\t#" << i << ":\t" << ring_sector.mv_ring_particles[i].getPosition() << endl;
}
}
}
}
}