void Viewer::draw() { alwaysAssertM(render_system, "Rendersystem not created"); render_system->setColorClearValue(ColorRGB(0, 0, 0)); render_system->clear(); if (pcloud) { render_system->setMatrixMode(Graphics::RenderSystem::MatrixMode::MODELVIEW); render_system->pushMatrix(); render_system->setMatrixMode(Graphics::RenderSystem::MatrixMode::PROJECTION); render_system->pushMatrix(); camera = cameraFromBBox(pcloud->getAABB(), width, height, rotation); render_system->setCamera(camera); Real scale = pcloud->getAABB().getExtent().length(); pcloud->draw(*render_system, (show_normals ? 0.05 * scale : -1)); if (show_bbox) { render_system->setColor(ColorRGB(1, 1, 0)); drawOutlineBox(pcloud->getAABB()); } render_system->setMatrixMode(Graphics::RenderSystem::MatrixMode::PROJECTION); render_system->popMatrix(); render_system->setMatrixMode(Graphics::RenderSystem::MatrixMode::MODELVIEW); render_system->popMatrix(); } glutSwapBuffers(); }
void OsmAnd::MapPresentationEnvironment_P::initialize() { _defaultBackgroundColorAttribute = owner->resolvedStyle->getAttribute(QLatin1String("defaultColor")); _defaultBackgroundColor = ColorRGB(0xf1, 0xee, 0xe8); _shadowOptionsAttribute = owner->resolvedStyle->getAttribute(QLatin1String("shadowRendering")); _shadowMode = ShadowMode::NoShadow; _shadowColor = ColorRGB(0x96, 0x96, 0x96); _polygonMinSizeToDisplayAttribute = owner->resolvedStyle->getAttribute(QLatin1String("polygonMinSizeToDisplay")); _polygonMinSizeToDisplay = 0.0; _roadDensityZoomTileAttribute = owner->resolvedStyle->getAttribute(QLatin1String("roadDensityZoomTile")); _roadDensityZoomTile = 0; _roadsDensityLimitPerTileAttribute = owner->resolvedStyle->getAttribute(QLatin1String("roadsDensityLimitPerTile")); _roadsDensityLimitPerTile = 0; _defaultSymbolPathSpacingAttribute = owner->resolvedStyle->getAttribute(QLatin1String("defaultSymbolPathSpacing")); _defaultSymbolPathSpacing = 0.0f; _defaultBlockPathSpacingAttribute = owner->resolvedStyle->getAttribute(QLatin1String("defaultBlockPathSpacing")); _defaultBlockPathSpacing = 0.0f; _globalPathPaddingAttribute = owner->resolvedStyle->getAttribute(QLatin1String("globalPathPadding")); _globalPathPadding = 0.0f; _desiredStubsStyle = MapStubStyle::Unspecified; }
//---------------------------------------------------------------------------- TriMesh* InverseKinematics::CreatePlane () { int iVertexQuantity = 4; int iTriangleQuantity = 2; Vector3f* akVertex = new Vector3f[iVertexQuantity]; float fSize = 16.0f; akVertex[0] = Vector3f(-fSize,-fSize,-0.1f); akVertex[1] = Vector3f(+fSize,-fSize,-0.1f); akVertex[2] = Vector3f(+fSize,+fSize,-0.1f); akVertex[3] = Vector3f(-fSize,+fSize,-0.1f); ColorRGB* akColor = new ColorRGB[iVertexQuantity]; akColor[0] = ColorRGB(0.0f,0.0f,0.25f); akColor[1] = ColorRGB(0.0f,0.0f,0.50f); akColor[2] = ColorRGB(0.0f,0.0f,0.75f); akColor[3] = ColorRGB(0.0f,0.0f,1.00f); int* aiConnect = new int[3*iTriangleQuantity]; aiConnect[0] = 0; aiConnect[1] = 1; aiConnect[2] = 2; aiConnect[3] = 0; aiConnect[4] = 2; aiConnect[5] = 3; TriMesh* pkPlane = new TriMesh(iVertexQuantity,akVertex,NULL,akColor, NULL,iTriangleQuantity,aiConnect); return pkPlane; }
World::World() { pointLights = new std::vector<PointLight*>(); sceneObjects = new std::vector<SceneObject*>(); ambientColor = ColorRGB(0.02, 0.02, 0.02); backgroundColor = ColorRGB(0.1, 0.1, 0.1); backgroundEnabled = true; }
//---------------------------------------------------------------------------- void Boolean2D::OnDisplay () { ClearScreen(); DrawPolySolid(*mPoly0, ColorRGB(255, 0, 0)); DrawPolySolid(*mPoly1, ColorRGB(0, 255, 0)); if (mActive) { DrawPolySolid(*mActive, ColorRGB(0, 0, 255)); } WindowApplication2::OnDisplay(); }
void OsmAnd::MapPresentationEnvironment_P::initialize() { _roadDensityZoomTile = 0; _roadsDensityLimitPerTile = 0; _shadowRenderingMode = 0; _shadowRenderingColor = ColorRGB(0x96, 0x96, 0x96); _polygonMinSizeToDisplay = 0.0; _defaultBgColor = ColorRGB(0xf1, 0xee, 0xe8); owner->style->resolveAttribute(QLatin1String("defaultColor"), _attributeRule_defaultColor); owner->style->resolveAttribute(QLatin1String("shadowRendering"), _attributeRule_shadowRendering); owner->style->resolveAttribute(QLatin1String("polygonMinSizeToDisplay"), _attributeRule_polygonMinSizeToDisplay); owner->style->resolveAttribute(QLatin1String("roadDensityZoomTile"), _attributeRule_roadDensityZoomTile); owner->style->resolveAttribute(QLatin1String("roadsDensityLimitPerTile"), _attributeRule_roadsDensityLimitPerTile); }
bool PhongMetalMaterial::specularDirection(const ONB& uvw, const Vector3D& v_in, const Vector3D& p, const Vector2D& uv, Vector2D& seed, ColorRGB& color, Vector3D& v_out) { float phi = 2* PI* seed.getX(); //the phong exponent is stored in the red value for the texture at that point float exponent = phong_exp->value(uv, p).getRed(); float cosTheta = pow(1-seed.getY(), 1.0/(exponent+1)); float sinTheta = sqrt(1-cosTheta*cosTheta); float x = cos(phi) * sinTheta; float y = sin(phi) * sinTheta; float z = cosTheta; ONB basis; Vector3D w = v_in - 2*dotProduct(v_in, uvw.w())*uvw.w(); basis.initFromW(w); //color = R->value(uv, p); ColorRGB r = R->value(uv, p); float c = 1 - (dotProduct(v_in, uvw.w())); color = r + (ColorRGB(1, 1, 1) + (-r))*(c*c*c*c*c); v_out = x*basis.u() + y*basis.v() + z*basis.w(); if(exponent <10000) seed.scramble(); return (dotProduct(v_out, uvw.w()) >0 ); }
//---------------------------------------------------------------------------- void BallRubberBand::OnDisplay () { ClearScreen(); const int halfSize = mWidth/2, sizeM1 = mWidth-1; const double dHalfSize = (double)halfSize; // Draw the coordinate axes. ColorRGB gray(192, 192, 192); DrawLine(0, halfSize, sizeM1, halfSize, gray); DrawLine(halfSize, 0, halfSize, sizeM1, gray); // Draw the ball's path. The orbit starts in green, finishes in blue, // and is a blend of the two colors between. int numPositions = (int)mPosition.size(); float invNumPositions = 1.0f/numPositions; for (int i = 0; i < numPositions-1; ++i) { float w = i*invNumPositions, omw = 1.0f - w; unsigned char blue = (unsigned char)(255.0f*omw); unsigned char green = (unsigned char)(255.0f*w); int x0 = (int)(mPosition[i].X() + dHalfSize + 0.5); int y0 = (int)(mPosition[i].Y() + dHalfSize + 0.5); int x1 = (int)(mPosition[i+1].X() + dHalfSize + 0.5); int y1 = (int)(mPosition[i+1].Y() + dHalfSize + 0.5); DrawLine(x0, y0, x1, y1, ColorRGB(0, green, blue)); } WindowApplication2::OnDisplay(); }
int main() { // Build scene SceneList scene; scene.push_back(new Sphere(Point3(-320,0,50), 200.0f, ColorRGBA(255,0,0,255))); scene.push_back(new Sphere(Point3(320, 0, 50), 200.0f, ColorRGBA(0, 0, 255, 255))); scene.push_back(new Sphere(Point3(0, 0, -50), 200.0f, ColorRGBA(0, 255, 0, 255))); scene.push_back(new Plane(Vector3(0,1,0), Vector3(0, -150, 0), ColorRGBA(255,255,255,255))); // Render the scene RayTraceSettings settings; settings.resolutionWidth = 600; settings.resolutionHeight = 480; settings.depth = 255; settings.clearColor = ColorRGB(50,50,50); settings.eyePosition = Point3(0, 0, 600); RayTracer rayTracer(settings); rayTracer.renderScene(scene); rayTracer.saveToFile("rayTracerTest.tga"); // Clean up the scene std::for_each(scene.begin(), scene.end(), deleteDynamicObject()); return 0; }
/********************************************************************************************************************** * Scene::InitializeScene * * Initialize scene **********************************************************************************************************************/ bool Scene::InitializeScene( __in const unsigned int width, ///< Scene width __in const unsigned int height, ///< Scene height __in SceneCamera* pCamera) ///< Camera handle { ///@todo Initialize scene with a scene file, parse it and populate /// object and light list m_screenWidth = width; m_screenHeight = height; m_pSceneCamera = pCamera; ///@note This is a statically initialized scene. I need to dynamically parse a scene file and initialize // Clear object list m_vObjectList.clear(); // Create a sphere and ass to list SceneObject* pSphere = new Sphere(Vector3D(0.0,0.0,10.0, false), 1.0, "Sphere", ColorRGB(), SceneObjectMaterial()); m_vObjectList.push_back(pSphere); return true; }
//---------------------------------------------------------------------------- Cloth::Cloth () : Application("Cloth",0,0,640,480,ColorRGB(0.85f,0.85f,1.00f)) { m_pkSpline = NULL; m_pkModule = NULL; }
void Properties70::parse(Reader &reader, const Reader::Node &node) { properties.clear(); if (!node.properties.empty()) throw new Exception("Properties70 isn't supposed to have direct properties"); Reader::Node pnode; Reader::NodeChildren children = node.children; while (reader.next(pnode, children)) { if (pnode.name != NodeName::P) throw new Exception("Properties70 can only have P subnodes"); PropertyValue value; std::string key = pnode.properties.at(0).getString(); value.stype = pnode.properties.at(1).getString(); value.constructor = pnode.properties.at(2).getString(); value.flags = pnode.properties.at(3).getString(); if (value.stype == "bool") { value.value.set(!! pnode.properties.at(4).getInt32()); } else if ( value.stype == "Vector3D" || value.stype == "Lcl Translation" || value.stype == "Lcl Rotation" || value.stype == "Lcl Scaling") { value.value.set(Vector3D(pnode.properties.at(4).getDouble(), pnode.properties.at(5).getDouble(), pnode.properties.at(6).getDouble())); } else if (value.stype == "ColorRGB") { value.value.set(ColorRGB(pnode.properties.at(4).getDouble(), pnode.properties.at(5).getDouble(), pnode.properties.at(6).getDouble())); } else if (value.stype == "object") { // well... no value. } else if (pnode.properties.size() != 5) { throw Exception("cannot handle unknown Properties70 multi-valued/value-less entry"); } else { value.value = pnode.properties.at(4).value(); } properties.emplace(key, value); } }
const ColorRGB Scene3D::traceRay(const Ray& ray, int depth) const { float closest_t_value = NO_INTERSECT; const SceneObject* closest_object = findClosest(ray, closest_t_value); if (closest_object == 0) return ColorRGB(0,0,0); ColorRGB retColor(0,0,0); for (int i = 0; i < lights.size(); i++) { Vector3D normL = ((*lights[i]).get_position()-ray.getPointAt(closest_t_value)).normalize(); Vector3D normN = (*closest_object).surface_normal(ray.getPointAt(closest_t_value)); retColor += (*lights[i]).get_color()*(*closest_object).get_color()*std::max((normL*normN),float(0)); if (depth < 6 && (*closest_object).get_reflectivity() > 0) { Ray reflected_ray = ray.reflect(ray.getPointAt(closest_t_value), (*closest_object).surface_normal(ray.getPointAt(closest_t_value))); ColorRGB reflection_color = traceRay(reflected_ray, depth+1); retColor+= (*closest_object).get_reflectivity()*reflection_color; } } return retColor; }
//---------------------------------------------------------------------------- ColorRGB ColorRGB::operator* (float fScalar) const { return ColorRGB( fScalar*m_afTuple[0], fScalar*m_afTuple[1], fScalar*m_afTuple[2]); }
//---------------------------------------------------------------------------- ColorRGB ColorRGB::operator+ (const ColorRGB& rkC) const { return ColorRGB( m_afTuple[0] + rkC.m_afTuple[0], m_afTuple[1] + rkC.m_afTuple[1], m_afTuple[2] + rkC.m_afTuple[2]); }
ColorRGB ColorRGB::jetColorMap(Real val) { val = Math::clamp(val, 0, 1); return ColorRGB(ColorRGBInternal::base(val - 0.25), ColorRGBInternal::base(val), ColorRGBInternal::base(val + 0.25)); }
//---------------------------------------------------------------------------- GelatinCube::GelatinCube () : Application("GelatinCube",0,0,640,480, ColorRGB(0.713725f,0.807843f,0.929411f)) { m_pkSpline = NULL; m_pkModule = NULL; }
//---------------------------------------------------------------------------- Rope::Rope () : Application("Rope",0,0,640,480,ColorRGB(0.75f,0.85f,0.95f)) { m_pkSpline = NULL; m_pkModule = NULL; m_fLastIdle = 0.0f; }
CornellBox::CornellBox() : SceneObject( glm::translate<float>(0, 0, -40) * glm::scale<float>(20, 20, 20) * glm::translate<float>(-0.5, -0.5, 0.5), ColorRGB()) { _calculateGeometry(); }
/** Get a unit magnitude color by dividing by the magnitude. */ ColorRGB unit() const { Real len = length(); if (std::abs(len) < 32 * std::numeric_limits<Real>::min()) return ColorRGB(0, 0, 0); else return *this / len; }
//---------------------------------------------------------------------------- DrawImplicitSurface::DrawImplicitSurface () : Application2("DrawImplicitSurface",0,0,g_iSize,g_iSize, ColorRGB(1.0f,1.0f,1.0f)), m_kRT(F,DF,g_iSize,g_iSize) { m_iMaxSample = 100; m_bBlur = false; }
void HouseScene::start() { camera->position = glm::vec4(-6.5f,30,-261, 1); camera->movement_speed = 100; camera->rotation_speed /= 2; camera->have_skybox = false; white = game->texture_manager->load_png("white_pixel.png", GAME); white_normal = game->texture_manager->load_png("normal_pixel.png", GAME); camera->background = ColorRGB(0,0,0); point_light_shader.create("LightPass/point", ENGINE); light[0].transform.set_position(0, 100, 200); auto* p = light[0].add_component<PointLight>(); p->model.material.set_shader(&point_light_shader); p->set_diffuse_color(255, 150, 120); p->diffuse_intensity = 3; p->attenuation = .0005; p->specular_intensity =25; p->set_specular_color(255, 150,120); //Directional light dir_light_shader.create("LightPass/directional", ENGINE); material.create("Geometry/material", GAME); //sponza - sibenik sponza.add_component(game->mesh_manager->load_model("sponza", Owner::GAME, material)); sponza.transform.set_position(0, 0, 0); sponza.transform.set_rotation(0, 90, 0); sponza.transform.set_scale(.2f,.2f,.2f); auto* l = sponza.add_component<DirectionalLight>(); l->model.material.set_shader(&dir_light_shader); l->set_rotation(-70, 10, 0); l->diffuse_intensity = 2; l->set_diffuse_color(255, 235, 200); l->specular_intensity = 30.0; l->set_specular_color(255, 235, 200); l->ambient_intensity = .25f; l->set_ambient_color(255, 235, 200); l->blur = 2; l->shadow_strength = .8f; material.set_uniform("g_Time", 0); material.set_uniform("g_Power", 0); }
//---------------------------------------------------------------------------- MapTextureToQuad::MapTextureToQuad () : Application2("MapTextureToQuad",0,0,256,256,ColorRGB(1.0f,1.0f,1.0f)) { m_pkMap = NULL; m_pkImage = NULL; m_bMouseDown = false; m_iSelected = -1; }
//---------------------------------------------------------------------------- void WrigglingSnake::CreateSnakeHead () { // Create the snake head as a paraboloid that is attached to the last // ring of vertices on the snake body. These vertices are generated // for t = 1. int iSliceSamples = m_spkSnakeBody->GetSliceSamples(); // number of rays (determined by slice samples of tube surface) int iRQ = iSliceSamples - 1; // number of shells (your choice, specified in application constructor) int iSQ = m_iShellQuantity, iSQm1 = iSQ-1; // generate vertices (to be filled in by UpdateSnakeHead) int iVQuantity = 1 + iRQ*iSQm1; Vector3f* akVertex = new Vector3f[iVQuantity]; // generate vertex colors coordinates ColorRGB* akColor = new ColorRGB[iVQuantity]; for (int i = 0; i < iVQuantity; i++) akColor[i] = ColorRGB(0.0f,0.25f,0.0f); // generate triangles int iTQuantity = iRQ*(2*iSQm1-1); int* aiConnect = new int[3*iTQuantity]; int* piConnect = aiConnect; int iT = 0; for (int iR0 = iRQ-1, iR1 = 0; iR1 < iRQ; iR0 = iR1++) { *piConnect++ = 0; *piConnect++ = 1+iSQm1*iR0; *piConnect++ = 1+iSQm1*iR1; iT++; for (int iS = 1; iS < iSQm1 ; iS++) { int i00 = iS+iSQm1*iR0; int i01 = iS+iSQm1*iR1; int i10 = i00+1; int i11 = i01+1; *piConnect++ = i00; *piConnect++ = i10; *piConnect++ = i11; *piConnect++ = i00; *piConnect++ = i11; *piConnect++ = i01; iT += 2; } } assert( iT == iTQuantity ); m_spkSnakeHead = new TriMesh(iVQuantity,akVertex,NULL,akColor,NULL, iTQuantity,aiConnect); m_spkSnakeRoot->AttachChild(m_spkSnakeHead); UpdateSnakeHead(); }
int ThrowRayOnScene(Ray3D ray, const Scene *sc, Intersection *intersection) { float dist, far_dist = FLT_MAX; Intersection test; size_t i, l; for(i=0 ; i<sc->nbSpheres ; ++i) { if(!TestRaySphereIntersection(ray, sc->spheres[i], &test)) continue; dist = SqrNorm(Vector(ray.origin, test.position)); if(dist >= far_dist) continue; far_dist = dist; *intersection = test; } if(far_dist == FLT_MAX) return 0; Color3f lights_contrib = ColorRGB(0,0,0); for(l=0 ; l<sc->nbLights ; ++l) { const Light *light = &sc->lights[l]; Vector3D lvec = Normalize( Vector(intersection->position, light->position) ); const float strength = DotProduct(intersection->normal, lvec); if(strength <= 0.f) continue; lights_contrib = AddColors( lights_contrib, MultColors( intersection->color, MultColors( light->color, ColorRGB(strength, strength, strength) ) ) ); } intersection->color = lights_contrib; return 1; }
void OccupancyGrid::initialize() { for (size_t i = 0; i < height; i++) { for (size_t j = 0; j < width; j++) { cells[i][j].c = ColorRGB(0.0f, 0.0f, 0.0f); cells[i][j].v = -1; } } }
//---------------------------------------------------------------------------- WaterDropFormation::WaterDropFormation () : Application("WaterDropFormation",0,0,640,480,ColorRGB(0.5f,0.0f,1.0f)) { m_pkSpline = NULL; m_pkCircle = NULL; m_akCtrlPoint = NULL; m_akTarget = NULL; m_fSimTime = 0.0f; m_fSimDelta = 0.05f; }
//---------------------------------------------------------------------------- WrigglingSnake::WrigglingSnake () : Application("WrigglingSnake",0,0,640,480, ColorRGB(1.0f,0.823529f,0.607843f)) { m_iNumCtrl = 32; m_iDegree = 3; m_pkCenter = NULL; m_afAmplitude = new float[m_iNumCtrl]; m_afPhase = new float[m_iNumCtrl]; m_iShellQuantity = 4; }
Environment::Environment() { sun.setDiffuse(ColorRGB(0.7,0.7,0.7)); sun.setDirection(0.3,-0.5,0.3); sun.setShininess(7); sun.setSpecular(0.3,0.3,0.3); ambient.setColor(0.3,0.3,0.3); changed=true; wireframe=false; shadow=true; light=true; }
void CornellBox::_calculateGeometry() { v0 = glm::vec3(0, 0, 1); v1 = glm::vec3(1, 0, 1); v2 = glm::vec3(0, 1, 1); v3 = glm::vec3(1, 1, 1); v4 = glm::vec3(0, 0, -2); v5 = glm::vec3(1, 0, -2); v6 = glm::vec3(0, 1, -2); v7 = glm::vec3(1, 1, -2); l0 = glm::vec3(0.4, 0.99, -0.9); l1 = glm::vec3(0.6, 0.99, -0.9); l2 = glm::vec3(0.4, 0.99, -1.1); l3 = glm::vec3(0.6, 0.99, -1.1); //bottom triangles.push_back(new Triangle(localToWorld, v0, v4, v1, ColorRGB(0.5, 0.5, 0.4))); triangles.push_back(new Triangle(localToWorld, v1, v4, v5, ColorRGB(0.5, 0.5, 0.4))); //left triangles.push_back(new Triangle(localToWorld, v0, v2, v4, ColorRGB(1.0, 0.0, 0.0))); triangles.push_back(new Triangle(localToWorld, v2, v6, v4, ColorRGB(1.0, 0.0, 0.0))); //right triangles.push_back(new Triangle(localToWorld, v1, v5, v3, ColorRGB(0.0, 1.0, 0.0))); triangles.push_back(new Triangle(localToWorld, v3, v5, v7, ColorRGB(0.0, 1.0, 0.0))); //top triangles.push_back(new Triangle(localToWorld, v2, v3, v6, ColorRGB(0.5, 0.5, 0.4))); triangles.push_back(new Triangle(localToWorld, v3, v7, v6, ColorRGB(0.5, 0.5, 0.4))); //back triangles.push_back(new Triangle(localToWorld, v4, v6, v5, ColorRGB(0.5, 0.5, 0.4))); triangles.push_back(new Triangle(localToWorld, v5, v6, v7, ColorRGB(0.5, 0.5, 0.4))); //light // triangles.push_back(new Triangle(localToWorld, l0, l2, l1, ColorRGB(1.0, 1.0, 1.0))); // triangles.push_back(new Triangle(localToWorld, l1, l2, l3, ColorRGB(1.0, 1.0, 1.0))); }