void Scene::display() { // Set lighting light.setLighting(); // Set background color glClearColor(backgroundColor[0], backgroundColor[1], backgroundColor[2], backgroundColor[3]); glColor3f(1,1,1); if (drawAxesOn) drawAxes(-(worldX/2)-5, -(worldY/2)-5, -(worldZ/2)-5); // Draw real time scene /* Thing thing; unsigned long nObjects = model.get_num_objects(); Vec3 * p = 0; Vec3 * r = 0; double * a = 0; for (unsigned long i=0; i<nObjects; i++) { model.get_next_object_state(&p,&r,&a); if (p != 0) { thing.Cube(p->x, p->y, p->z, 0.4,0.4,0.4, *a,p->x,p->y,p->z); } else { std::cout << "its zero" << std::endl;} } */ // Draw box bounding the world WireframeCube(0,0,0, worldX,worldY, worldZ, 0,0,0,0); // Draw recorded scene double radius = 1.0; FrameState * frame = reader.get_next_frame(); if (frame != 0) { unsigned long nObjects = frame->get_num_objects(); for (unsigned long i=0; i<nObjects; i++) { Object * o = frame->get_object(i); if (o != 0) { // Set color based on id int origin = o->getID() >> 28; glColor3f(colors[origin].x, colors[origin].y, colors[origin].z); // Draw an object from the animation record file //Cube(o->x(), o->y(), o->z(), // 0.4,0.4,0.4, // o->a_r(),o->x_r(),o->y_r(),o->z_r()); Sphere(o->x(), o->y(), o->z(), radius); } }
TEST(IntersectTest, IntersectPTest) { Sphere sphere = Sphere(vec3(1,0,0), 1); Ray ray = Ray(vec3(-1,0,0), vec3(0,1,0), 0, 0, 100); EXPECT_FALSE(sphere.intersectP(ray)); Ray ray2 = Ray(vec3(0,0,0), vec3(0,1,0), 0, 0, 100); EXPECT_TRUE(sphere.intersectP(ray2)); }
void RayTracer::initVariables() { // Camera CameraPositionPoint = vec3(0, 0, 0); CameraDirection = vec3(0, 0, -1); View_Plane = ViewPlane(-0.1, 0.1, -0.1, 0.1, 0.1); // World WorldDirection_u = vec3(1, 0, 0); WorldDirection_v = vec3(0, 1, 0); WorldDirection_w = vec3(0, 0, 1); // Object sphere01 = Sphere(vec3(-4, 0, -7), 1); sphere02 = Sphere(vec3(0, 0, -7), 2); sphere03 = Sphere(vec3(4, 0, -7), 1); // HorozonPlane = pla }
void FireFieldSpell::Update() { pPSStream.Update(g_framedelay); pPSStream1.Update(g_framedelay); EERIE_LIGHT * el = dynLightCreate(m_light); if(el) { el->pos = m_pos + Vec3f(0.f, -120.f, 0.f); el->intensity = 4.6f; el->fallstart = Random::getf(150.f, 180.f); el->fallend = Random::getf(290.f, 320.f); el->rgb = Color3f(1.f, 0.8f, 0.6f) + Color3f(Random::getf(-0.1f, 0.f), 0.f, 0.f); el->duration = ArxDurationMs(600); el->extras=0; } if(VisibleSphere(Sphere(m_pos - Vec3f(0.f, 120.f, 0.f), 350.f))) { pPSStream.Render(); pPSStream1.Render(); float fDiff = g_framedelay / 8.f; int nTime = checked_range_cast<int>(fDiff); for(long nn=0;nn<=nTime+1;nn++) { PARTICLE_DEF * pd = createParticle(); if(!pd) { break; } float t = Random::getf() * (glm::pi<float>() * 2.f) - glm::pi<float>(); float ts = std::sin(t); float tc = std::cos(t); pd->ov = m_pos + Vec3f(120.f * ts, 15.f * ts, 120.f * tc) * randomVec(); pd->move = Vec3f(2.f, 1.f, 2.f) + Vec3f(-4.f, -8.f, -4.f) * randomVec3f(); pd->siz = 7.f; pd->tolive = Random::getu(500, 1500); pd->tc = fire2; pd->m_flags = ROTATING | FIRE_TO_SMOKE; pd->m_rotation = Random::getf(-0.1f, 0.1f); pd->scale = Vec3f(-8.f); PARTICLE_DEF * pd2 = createParticle(); if(!pd2) { break; } *pd2 = *pd; pd2->delay = Random::getu(60, 210); } } }
void Extent::loadSphere( Iff & iff ) { iff.enterChunk(TAG_SPHR); Vector center = iff.read_floatVector(); real radius = iff.read_float(); setSphere( Sphere(center,radius) ); iff.exitChunk(TAG_SPHR); }
EClipStatus CSensorVision::GetBoxClipStatus(CActor* pActor, const bbox3& Box) const { //???check FOV too? sphere Sphere(pActor->Position, Radius); switch (Sphere.clipstatus(Box)) { case sphere::Inside: return Inside; case sphere::Clipped: return Clipped; case sphere::Outside: default: return Outside; } }
void test(){ Sphere s = Sphere((vec3) {0.,0.,0}, 5., (Color) {100, 100, 100}); Intersection i = s.intersects((vec3) {0,0,-10}, (vec3) {0,0,1}); assertEqual(i.distance, 5., "Intersection distance"); assertEqual(i.point, (vec3) {0,0,-5}, "Intersection point"); assertEqual(i.normal, (vec3) {0,0,-1}, "Intersection normal"); assertEqual(i.obj, &s, "Intersection object"); }
std::shared_ptr<RuntimeGameObject> RuntimeGameObject::Create(_In_ const std::shared_ptr<RuntimeGameWorld>& world, _In_ const std::map<std::wstring, std::wstring>& properties) { CHECK_NOT_NULL(g_gameObjectFactory); // Get details from the gameplay module GameObjectCreateParameters parameters = g_gameObjectFactory(world, properties); // Create base object with those parameters std::shared_ptr<RuntimeGameObject> object(GDKNEW RuntimeGameObject(world, parameters)); // stash away these initial properties for later object->_initialProperties = properties; // do we have rigid body info? (requires a collision primitive) if (parameters.collisionPrimitive) { RigidBodyCreateParameters rigidBodyParams(parameters.position, 100.0f, parameters.collisionPrimitive.get()); rigidBodyParams.type = PhysicsBodyTypeToRigidBodyType(parameters.physicsType); rigidBodyParams.gravityScale = (parameters.floating) ? 0.0f : 1.0f; object->_body = world->GetPhysicsWorld()->CreateBody(object, rigidBodyParams); } // if we're in the editor, let's create the picking mesh & sphere if (world->IsEditing()) { std::vector<Triangle> triangles; Matrix identity = Matrix::Identity(); auto& visuals = object->GetVisualInfos(); if (visuals.size()) { for (auto i = 0; i < visuals.size(); ++i) { Collision::TriangleListFromGeometry(Content::LoadGeometryContent(visuals[i].geometry), identity, 0, triangles); } object->_triangleMesh = CollisionPrimitive::Create(TriangleMesh(SpacePartitionType::AabbTree, triangles)); // loose sphere around the AABB. Not a best fit, but fast to compute and "good enough" as a pre-test Vector3 aabbMin, aabbMax; GetAabbForPrimitive(object->_triangleMesh.get(), &aabbMin, &aabbMax); object->_sphere = CollisionPrimitive::Create(Sphere((aabbMin + aabbMax) * 0.5f, (aabbMax - aabbMin).Length() * 0.5f)); } } // Bind the object and controller, if one was provided if (parameters.controller) { parameters.controller->OnCreate(object); } return object; }
void Light::ProcessRayQuery(const RayOctreeQuery& query, PODVector<RayQueryResult>& results) { // Do not record a raycast result for a directional light, as it would block all other results if (lightType_ == LIGHT_DIRECTIONAL) return; float distance = query.maxDistance_; switch (query.level_) { case RAY_AABB: Drawable::ProcessRayQuery(query, results); return; case RAY_OBB: { Matrix3x4 inverse(node_->GetWorldTransform().Inverse()); Ray localRay = query.ray_.Transformed(inverse); distance = localRay.HitDistance(GetWorldBoundingBox().Transformed(inverse)); if (distance >= query.maxDistance_) return; } break; case RAY_TRIANGLE: if (lightType_ == LIGHT_SPOT) { distance = query.ray_.HitDistance(GetFrustum()); if (distance >= query.maxDistance_) return; } else { distance = query.ray_.HitDistance(Sphere(node_->GetWorldPosition(), range_)); if (distance >= query.maxDistance_) return; } break; case RAY_TRIANGLE_UV: LOGWARNING("RAY_TRIANGLE_UV query level is not supported for Light component"); return; } // If the code reaches here then we have a hit RayQueryResult result; result.position_ = query.ray_.origin_ + distance * query.ray_.direction_; result.normal_ = -query.ray_.direction_; result.distance_ = distance; result.drawable_ = this; result.node_ = node_; result.subObject_ = M_MAX_UNSIGNED; results.Push(result); }
//------------------------------------------------------------------------ void CVehicleDamageBehaviorBurn::Update(const float deltaTime) { m_timeCounter -= deltaTime; if (m_timeCounter <= 0.0f) { CGameRules *pGameRules = g_pGame->GetGameRules(); if (pGameRules && gEnv->bServer) { Vec3 worldPos; if (m_pHelper) worldPos = m_pHelper->GetWorldTM().GetTranslation(); else worldPos = m_pVehicle->GetEntity()->GetWorldTM().GetTranslation(); SEntityProximityQuery query; query.box = AABB(worldPos-Vec3(m_radius), worldPos+Vec3(m_radius)); gEnv->pEntitySystem->QueryProximity(query); IEntity* pEntity = 0; for (int i = 0; i < query.nCount; ++i) { if ((pEntity = query.pEntities[i]) && pEntity->GetPhysics()) { float damage = (pEntity->GetId() == m_pVehicle->GetEntityId()) ? m_selfDamage : m_damage; // SNH: need to check vertical distance here as the QueryProximity() call seems to work in 2d only Vec3 pos = pEntity->GetWorldPos(); if(abs(pos.z - worldPos.z) < m_radius) { if (damage > 0.f) { HitInfo hitInfo(m_shooterId, pEntity->GetId(), m_pVehicle->GetEntityId(), -1, m_radius); hitInfo.damage = damage; hitInfo.pos = worldPos; hitInfo.type = pGameRules->GetHitTypeId("fire"); pGameRules->ServerHit(hitInfo); } } } } if (gEnv->pAISystem) gEnv->pAISystem->RegisterDamageRegion(this, Sphere(worldPos, m_radius)); } m_timeCounter = m_interval; } m_pVehicle->NeedsUpdate(); }
void sph(double angle) { GLfloat blue_mat[] = { 1, 1, 0, 1 }; glPushMatrix(); glTranslatef(0.75, 0.0, 0); glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, blue_mat ); Sphere(1.0, 20, 20); glPopMatrix(); glFinish(); }
// Berechne die kleinste einschliessende Kugel fuer n Punkte, wobei // die Punkte q1,q2 und q3 auf dem Rand der gesuchten Kugel liegen Sphere Sphere::ses3(int n, std::vector<Vector3d>& p,Vector3d& q1,Vector3d& q2,Vector3d& q3) { Sphere S(q1,q2,q3); ///ADD YOUR CODE HERE! for(int i=0;i<n;i++){ if((p[i]-S.center).length()>S.radius) S=Sphere(q1,q2,q3,p[i]); } return S; }
void Extent::loadSphere_old (Iff & iff ) { iff.enterChunk(TAG_CNTR); const Vector center = iff.read_floatVector(); iff.exitChunk(TAG_CNTR); iff.enterChunk(TAG_RADI); const real radius = iff.read_float(); iff.exitChunk(TAG_RADI); setSphere(Sphere(center, radius)); }
bool CScreensaverCyclone::Start() { int i, j; std::string fraqShader = kodi::GetAddonPath("resources/shaders/frag.glsl"); std::string vertShader = kodi::GetAddonPath("resources/shaders/vert.glsl"); if (!LoadShaderFiles(vertShader, fraqShader) || !CompileAndLink()) return false; gCycloneSettings.Load(); srand((unsigned)time(nullptr)); // Window initialization glViewport(X(), Y(), Width(), Height()); glEnable(GL_DEPTH_TEST); glFrontFace(GL_CCW); glEnable(GL_CULL_FACE); glClearColor(0.0, 0.0, 0.0, 1.0); m_modelMat = glm::mat4(1.0f); m_projMat = glm::perspective(glm::radians(80.0f), (GLfloat)Height() / (GLfloat)Width(), 50.0f, 3000.0f); if (!rsRandi(500)) // Easter egg view { m_projMat = glm::rotate(m_projMat, glm::radians(90.0f), glm::vec3(1.0f, 0.0f, 0.0f)); m_projMat = glm::translate(m_projMat, glm::vec3(0.0f, -(WIDTH * 2), 0.0f)); } else // Normal view m_projMat = glm::translate(m_projMat, glm::vec3(0.0f, 0.0f, -(WIDTH * 2))); Sphere(float(gCycloneSettings.dSize) / 4.0f, 3, 2); m_lightingEnabled = 1; // Initialize cyclones and their particles for (i = 0; i < 13; i++) m_fact[i] = float(factorial(i)); m_cyclones = new CCyclone*[gCycloneSettings.dCyclones]; m_particles = new CParticle*[gCycloneSettings.dParticles * gCycloneSettings.dCyclones]; for (i = 0; i < gCycloneSettings.dCyclones; i++) { m_cyclones[i] = new CCyclone; for (j=i*gCycloneSettings.dParticles; j<((i+1)*gCycloneSettings.dParticles); j++) m_particles[j] = new CParticle(m_cyclones[i]); } glGenBuffers(1, &m_vertexVBO); glBindBuffer(GL_ARRAY_BUFFER, m_vertexVBO); m_lastTime = kodi::time::GetTimeSec<double>(); m_startOK = true; return true; }
//================================================================================================// void BrainCell::Spawn(Vec2 pos) { IsActive = true; oPos = Pos = pos; frame = 0; fStartLife = fLife = 3; mSphere = Sphere(20,pos+Vec2(32,32)); iTakeDamageTicks = 0; iAttackTicks = 0; pulsate = 0; }
// Berechne die kleinste einschliessende Kugel fuer n Punkte, Sphere Sphere::ses0(int n,std::vector<Vector3d>& p) { Sphere S = Sphere(p[0]); for(int i=1;i<n;i++){ if((p[i]-S.center).length()>S.radius){ S=ses1(i,p,p[i]); } } ///ADD YOUR CODE HERE! return S; }
int main (int argn, char **argc) { double x, y; FILE *file; file = fopen (argc[1], "r"); fscanf (file, "%*s%lf%*s%lf", &x, &y); fclose (file); file = fopen (argc[2], "w"); fprintf (file, "%.14le", Sphere (x - M_PI_4, y - M_PI_4)); fclose (file); return 0; }
//============================================================================== Sphere Sphere::getCompoundShape(const Sphere& b) const { const Sphere& a = *this; /// TODO test this /* Vec3 centerDiff = b.center - a.center; F32 radiusDiff = b.radius - a.radius; Vec3 radiusDiffSqr = radiusDiff * radiusDiff; F32 lenSqr = centerDiff.getLengthSquared(); if(radiusDiffSqrt >= 0.0) { if(radiusDiff >= 0.0) { return b; } else { return a; } } else { F32 l = sqrt(lenSqr); F32 t = (l + b.radius - a.radius) / (2.0 * l); return Sphere(a.center + t * centerDiff, (l + a.radius + b.radius) / 2.0); } */ Vec4 c = b.getCenter() - a.getCenter(); // Vector from one center to the // other F32 cLen = c.getLength(); if(cLen + b.getRadius() < a.getRadius()) { return a; } else if(cLen + a.getRadius() < b.getRadius()) { return b; } Vec4 bnorm = c / cLen; Vec4 ca = (-bnorm) * a.getRadius() + a.getCenter(); Vec4 cb = (bnorm) * b.getRadius() + b.getCenter(); return Sphere((ca + cb) / 2.0, (ca - cb).getLength() / 2.0); }
void Scene::parseLineForSphere(std::string line, Sphere &sphere, const int &material_offset) { std::vector<std::string> parts; // vector for ;-seperated variables strsplit(line, ';', parts); // split line if (parts.size() != 3) { std::cout << "parseLineForSphere error in line: " << line << std::endl; return; } else { Vector3 center = strtoVect(parts[0]); float radius = lexical_cast<float>(parts[1]); int matID = lexical_cast<int>(parts[2]) + material_offset; if (matID >= nummats) { cout << "specified material does not exist! Replaced by default" << endl; sphere = Sphere(center, radius, &stdDiffuse); } else { sphere = Sphere(center, radius, &materials[matID]); } } }
int main (int argn __attribute__ ((unused)), char **argc) { FILE *file; double x, y; file = fopen (argc[1], "r"); if (fscanf (file, "%*s%lf%*s%lf", &x, &y) != 2) return 1; fclose (file); file = fopen (argc[2], "w"); fprintf (file, "%.14le", Sphere (x - M_PI_4, y - M_PI_4)); fclose (file); return 0; }
bool StickyTrap::Initialize(DirectX::XMFLOAT3 p_startPosition, DirectX::XMFLOAT3 p_endPosition, unsigned int p_stickyTrapID, RakNet::RakNetGUID p_guid) { m_stickyTrapBag = new Object(); m_stickyTrapBag->Initialize("../Shurikenjutsu/Models/StickyTrapJar.SSP", p_startPosition); m_stickyTrap = new Object(); int randomModel = std::rand() % 4 + 1; if (randomModel == 1) { m_stickyTrap->Initialize("../Shurikenjutsu/Models/StickyTrap1Shape.SSP", p_endPosition); } else if (randomModel == 2) { m_stickyTrap->Initialize("../Shurikenjutsu/Models/StickyTrap2Shape.SSP", p_endPosition); } else { m_stickyTrap->Initialize("../Shurikenjutsu/Models/StickyTrap3Shape.SSP", p_endPosition); } int randomY = std::rand() % 8; m_stickyTrap->SetRotation(DirectX::XMFLOAT3(0.0f,(float)randomY,0.0f)); m_startPosition = p_startPosition; m_isThrowing = true; m_stickyTrapSphere = Sphere(p_endPosition, STICKY_TRAP_RADIUS); m_StickyTrapID = p_stickyTrapID; m_speed = STICKY_TRAP_SPEED; float x = (p_endPosition.x - p_startPosition.x); float z = (p_endPosition.z - p_startPosition.z); float length = sqrtf(x*x + z*z); m_percentX = x / length; m_percentZ = z / length; m_angle = asinf((9.82f * length) / (m_speed * m_speed)) * 0.5f; m_guid = p_guid; m_stickyParticles = new ParticleEmitter(); m_stickyParticles->Initialize(GraphicsEngine::GetDevice(), p_endPosition, DirectX::XMFLOAT3(0.0f, 1.0f, 0.0f), DirectX::XMFLOAT2(0.2f, 0.2f), PARTICLE_PATTERN_BUBBLES); m_stickyParticles->SetEmitParticleState(true); m_trail = new Trail(); if (!m_trail->Initialize(50.0f, 0.2f, 0.2f, DirectX::XMFLOAT4(0.83f, 0.86f, 0.06f, 1.0f), "../Shurikenjutsu/2DTextures/Particles/Trail.png")) { ConsolePrintErrorAndQuit("A sticky trap trail failed to initialize!"); } return true; }
Sphere Frustum::bounding_sphere() const { Vec3f mi = near[0]; Vec3f ma = near[0]; for (int i = 0; i < 4; i++) { mi = min(near[i], mi); ma = max(near[i], ma); mi = min(far[i], mi); ma = max(far[i], ma); } const Vec3f center = mi + (ma - mi) / Vec3f(2); const float radius = distance(ma, center); return Sphere(center, radius); }
bool Ellipsoid::Intersects(const Segment& s, CollisionInfo* const pInfo) const { Vector InvExtents = 1.0f / m_Extents; Segment ScaledSegment(s.m_Point1 * InvExtents, s.m_Point2 * InvExtents); if (Sphere(m_Center * InvExtents, 1.0f).Intersects(ScaledSegment, pInfo)) { if (pInfo) { pInfo->m_Intersection *= m_Extents; pInfo->m_Plane = Plane((pInfo->m_Plane.m_Normal * InvExtents).GetNormalized(), pInfo->m_Intersection); } return true; } return false; }
void Deferred_lighting_renderer::render_light_probe(const scene::Light_probe& light_probe, const Rendering_context& context) { const float4x4& world = light_probe.world_transformation(); OBB obb(world); const auto& camera = context.camera(); if (Intersection_type::Outside == camera.frustum().intersect(obb)) { return; } Rendering_device& device = rendering_tool_.device(); auto& change_per_light_data = change_per_light_.data(); change_per_light_data.world = world; change_per_light_data.light_transformation = invert(world * camera.view()); change_per_light_data.position_vs = light_probe.world_position() * camera.view(); change_per_light_.update(device); device.set_shader_resources(1, &light_probe.texture(), light_probe_texture_offset_); techniques_.volume_light_probe_specular->use(); if (Intersection_type::Outside != Sphere(camera.world_position(), camera.greatest_distance_to_near_plane()).intersect(obb)) { // camera is inside the light volume device.set_rasterizer_state(lighting_rasterizer_states_[Cull_state::Front]); device.set_depth_stencil_state(inside_lighting_volume_ds_state_light_, 1); } else { // camera is outside the light volume device.set_rasterizer_state(lighting_rasterizer_states_[Cull_state::Back]); device.set_depth_stencil_state(outside_lighting_volume_ds_state_prepare_, 1); device.set_blend_state(z_only_blend_state_); box_volume_.render(rendering_tool_); device.set_rasterizer_state(lighting_rasterizer_states_[Cull_state::Front]); device.set_depth_stencil_state(outside_lighting_volume_ds_state_light_, 2); } device.set_blend_state(lighting_blend_state_); box_volume_.render(rendering_tool_); }
//----------------------------------------------------------------------- bool Light::isInLightRange(const Ogre::AxisAlignedBox& container) const { bool isIntersect = true; //Check the 2 simple / obvious situations. Light is directional or light source is inside the container if ((mLightType != LT_DIRECTIONAL) && (container.intersects(mDerivedPosition) == false)) { //Check that the container is within the sphere of the light isIntersect = Math::intersects(Sphere(mDerivedPosition, mRange),container); //If this is a spotlight, do a more specific check if ((isIntersect) && (mLightType == LT_SPOTLIGHT) && (mSpotOuter.valueRadians() <= Math::PI)) { //Create a rough bounding box around the light and check if Quaternion localToWorld = Vector3::NEGATIVE_UNIT_Z.getRotationTo(mDerivedDirection); Real boxOffset = Math::Sin(mSpotOuter * 0.5) * mRange; AxisAlignedBox lightBoxBound; lightBoxBound.merge(Vector3::ZERO); lightBoxBound.merge(localToWorld * Vector3(boxOffset, boxOffset, -mRange)); lightBoxBound.merge(localToWorld * Vector3(-boxOffset, boxOffset, -mRange)); lightBoxBound.merge(localToWorld * Vector3(-boxOffset, -boxOffset, -mRange)); lightBoxBound.merge(localToWorld * Vector3(boxOffset, -boxOffset, -mRange)); lightBoxBound.setMaximum(lightBoxBound.getMaximum() + mDerivedPosition); lightBoxBound.setMinimum(lightBoxBound.getMinimum() + mDerivedPosition); isIntersect = lightBoxBound.intersects(container); //If the bounding box check succeeded do one more test if (isIntersect) { //Check intersection again with the bounding sphere of the container //Helpful for when the light is at an angle near one of the vertexes of the bounding box isIntersect = isInLightRange(Sphere(container.getCenter(), container.getHalfSize().length())); } } } return isIntersect; }
HorizontalWidget::HorizontalWidget( QWidget* parent ) :QWidget( parent ), sphereRadio( 120.0 ), m_azimuth( 0 ), m_zenith( 0 ) { QVBoxLayout* mainLayout = new QVBoxLayout; setLayout( mainLayout ); QWidget* examinerWidget = new QWidget; examinerWidget->setFixedSize( 490, 300 ); mainLayout->addWidget(examinerWidget); m_rootNode = new SoSeparator; m_rootNode->addChild( Ejes( ) ); m_rootNode->addChild( Text() ); m_rootNode->addChild( Sphere() ); m_rootNode->addChild( Horizon() ); m_rootNode->addChild( AzimuthLine() ); m_rootNode->addChild( ZenithLine() ); m_rootNode->addChild( Star() ); SoQtExaminerViewer* myRenderArea = new SoQtExaminerViewer( examinerWidget ); myRenderArea->setSceneGraph( m_rootNode ); SbColor col( 0.86f, 0.86f, 0.86f ); myRenderArea->setBackgroundColor(col); myRenderArea->show( ); QWidget* labelsWidget = new QWidget; mainLayout->addWidget( labelsWidget ); QGridLayout* labelsLayout = new QGridLayout; labelsWidget->setLayout( labelsLayout ); QLabel* m_AzimuthLabel = new QLabel; m_AzimuthLabel->setText( "Azimuth:" ); labelsLayout->addWidget( m_AzimuthLabel, 0, 0, 1, 1 ); m_azimuthValue = new QLabel; m_azimuthValue->setText( QString::number( m_azimuth ) ); labelsLayout->addWidget( m_azimuthValue, 0, 1, 1, 3 ); QLabel* m_zenithLabel = new QLabel; m_zenithLabel->setText( "Zenith:" ); labelsLayout->addWidget( m_zenithLabel, 1, 0, 1, 1 ); m_zenithValue = new QLabel; m_zenithValue->setText( QString::number( m_zenith ) ); labelsLayout->addWidget( m_zenithValue, 1, 1, 1, 3 ); }
bool Ellipsoid::Intersects( const Triangle& t, CollisionInfo* const pInfo /*= NULL*/ ) const { Vector InvExtents = 1.0f / m_Extents; Triangle ScaledTriangle( t.m_Vec1 * InvExtents, t.m_Vec2 * InvExtents, t.m_Vec3 * InvExtents ); if( Sphere( m_Center * InvExtents, 1.0f ).Intersects( ScaledTriangle, pInfo ) ) { if( pInfo ) { pInfo->m_Intersection *= m_Extents; pInfo->m_Plane = Plane( ( pInfo->m_Plane.m_Normal * InvExtents ).GetNormalized(), pInfo->m_Intersection ); } return true; } return false; }
Sphere Sphere::FromString(const char *str, const char **outEndStr) { assume(str); if (!str) return Sphere(vec::nan, FLOAT_NAN); Sphere s; MATH_SKIP_WORD(str, "Sphere("); MATH_SKIP_WORD(str, "pos:("); s.pos = PointVecFromString(str, &str); MATH_SKIP_WORD(str, " r:"); s.r = DeserializeFloat(str, &str); if (outEndStr) *outEndStr = str; return s; }
Radiance3 RayTracer::L_scatteredIndirect(const shared_ptr<Surfel>& surfel, const Vector3& wo, Random& rnd) const{ Radiance3 L(0,0,0); float r = m_settings.gatheringDistance; //Find the nearby photons Array<Photon> intersected; photons.getIntersectingMembers(Sphere(surfel->position, r), intersected); //Cone filter constant, set to 1 now. GUI option not implemented. (To change this, we need to add a max(0,filtered value) into code int k = 1; //Added the energy photon by photon for (int i = 0; i < intersected.size(); ++i){ Photon p = intersected[i]; L += ((p.power / (G3D::pi() * r * r)) * surfel->finiteScatteringDensity(PathDirection::EYE_TO_SOURCE, -p.direction, wo)) * (1 - (p.origin - surfel->position).magnitude()/(k*r)) / (1 - 2.0/(3.0*k)); } return L; }
virtual bool OverlapObjects_GiantSphereVsKP::CommonSetup() { TestBase::CommonSetup(); LoadMeshesFromFile_(*this, "kp.bin"); const Point Min(-9560.175781f, -1093.885132f, -9461.288086f); const Point Max(9538.423828f, 4906.125488f, 9637.304688f); const Point Center = (Max + Min)*0.5f; const Point Extents = (Max - Min)*0.5f; // RegisterSphereOverlap(Sphere(Center, Extents.Magnitude()*0.25f)); RegisterSphereOverlap(Sphere(Center, 2500.0f)); mCreateDefaultEnvironment = false; return true; }