Games101Homework【6】Code Part

特别标注：本文章为代码部分，比较水，如果想看解释的请看如下链接（如果没有就说明还没写完）

main.cpp: 

#include "Renderer.hpp"
#include "Scene.hpp"
#include "Triangle.hpp"
#include "Vector.hpp"
#include "global.hpp"
#include <chrono>// In the main function of the program, we create the scene (create objects and
// lights) as well as set the options for the render (image width and height,
// maximum recursion depth, field-of-view, etc.). We then call the render
// function().
int main(int argc, char** argv)
{Scene scene(1280, 960);MeshTriangle bunny("../models/bunny/bunny.obj");scene.Add(&bunny);scene.Add(std::make_unique<Light>(Vector3f(-20, 70, 20), 1));scene.Add(std::make_unique<Light>(Vector3f(20, 70, 20), 1));scene.buildBVH();Renderer r;auto start = std::chrono::system_clock::now();r.Render(scene);auto stop = std::chrono::system_clock::now();std::cout << "Render complete: \n";std::cout << "Time taken: " << std::chrono::duration_cast<std::chrono::hours>(stop - start).count() << " hours\n";std::cout << "          : " << std::chrono::duration_cast<std::chrono::minutes>(stop - start).count() << " minutes\n";std::cout << "          : " << std::chrono::duration_cast<std::chrono::seconds>(stop - start).count() << " seconds\n";return 0;
}

 Scene.hpp:

//
// Created by Göksu Güvendiren on 2019-05-14.
//#pragma once#include <vector>
#include "Vector.hpp"
#include "Object.hpp"
#include "Light.hpp"
#include "AreaLight.hpp"
#include "BVH.hpp"
#include "Ray.hpp"//场景的物体信息，宽高，背景，光线最大深度，fov，bvh树信息（感觉有点杂，可能需要优化？）
//提供光源、物体列表添加，光线追踪算法，等等
class Scene
{
public:// setting up optionsint width = 1280;int height = 960;double fov = 90;Vector3f backgroundColor = Vector3f(0.235294, 0.67451, 0.843137);int maxDepth = 5;Scene(int w, int h) : width(w), height(h){}void Add(Object *object) { objects.push_back(object); }void Add(std::unique_ptr<Light> light) { lights.push_back(std::move(light)); }const std::vector<Object*>& get_objects() const { return objects; }const std::vector<std::unique_ptr<Light> >&  get_lights() const { return lights; }//返回场景中第一个与光线相交的交点信息Intersection intersect(const Ray& ray) const;//bvhBVHAccel *bvh;//创建bvhvoid buildBVH();//实现基于Whitted风格的光线传输算法Vector3f castRay(const Ray &ray, int depth) const;//检测光线是否与场景中的物体相交。bool trace(const Ray &ray, const std::vector<Object*> &objects, float &tNear, uint32_t &index, Object **hitObject);//该函数用于处理区域光源的光线投射，计算光线如何在场景中反射并产生光照std::tuple<Vector3f, Vector3f> HandleAreaLight(const AreaLight &light, const Vector3f &hitPoint, const Vector3f &N,const Vector3f &shadowPointOrig,const std::vector<Object *> &objects, uint32_t &index,const Vector3f &dir, float specularExponent);// 场景中的物体和光的liststd::vector<Object* > objects;std::vector<std::unique_ptr<Light> > lights;// Compute reflection directionVector3f reflect(const Vector3f &I, const Vector3f &N) const{return I - 2 * dotProduct(I, N) * N;}// 根据斯涅尔定律计算折射方向的函数Vector3f refract(const Vector3f &I, const Vector3f &N, const float &ior) const{float cosi = clamp(-1, 1, dotProduct(I, N));float etai = 1, etat = ior;Vector3f n = N;if (cosi < 0) { cosi = -cosi; } else { std::swap(etai, etat); n= -N; }float eta = etai / etat;float k = 1 - eta * eta * (1 - cosi * cosi);return k < 0 ? 0 : eta * I + (eta * cosi - sqrtf(k)) * n;}// 计算Fresnel方程void fresnel(const Vector3f &I, const Vector3f &N, const float &ior, float &kr) const{float cosi = clamp(-1, 1, dotProduct(I, N));float etai = 1, etat = ior;if (cosi > 0) {  std::swap(etai, etat); }// Compute sini using Snell's lawfloat sint = etai / etat * sqrtf(std::max(0.f, 1 - cosi * cosi));// Total internal reflectionif (sint >= 1) {kr = 1;}else {float cost = sqrtf(std::max(0.f, 1 - sint * sint));cosi = fabsf(cosi);float Rs = ((etat * cosi) - (etai * cost)) / ((etat * cosi) + (etai * cost));float Rp = ((etai * cosi) - (etat * cost)) / ((etai * cosi) + (etat * cost));kr = (Rs * Rs + Rp * Rp) / 2;}// As a consequence of the conservation of energy, transmittance is given by:// kt = 1 - kr;}
};

 Secne.cpp:

See Assignment 5 for details

//
// Created by Göksu Güvendiren on 2019-05-14.
//#include "Scene.hpp"void Scene::buildBVH() {printf(" - Generating BVH...\n\n");this->bvh = new BVHAccel(objects, 1, BVHAccel::SplitMethod::NAIVE);
}
/*** 对场景进行交点检测。* * @param ray 射线对象，用于进行交点检测。* @return 返回交点信息，如果射线与场景中的任何物体相交，则返回相交的最短距离和相关物体信息。*/
Intersection Scene::intersect(const Ray &ray) const
{return this->bvh->Intersect(ray);
}bool Scene::trace(const Ray &ray,const std::vector<Object*> &objects,float &tNear, uint32_t &index, Object **hitObject)
{*hitObject = nullptr;for (uint32_t k = 0; k < objects.size(); ++k) {float tNearK = kInfinity;uint32_t indexK;Vector2f uvK;if (objects[k]->intersect(ray, tNearK, indexK) && tNearK < tNear) {*hitObject = objects[k];tNear = tNearK;index = indexK;}}return (*hitObject != nullptr);
}// Implementation of the Whitted-syle light transport algorithm (E [S*] (D|G) L)
//
// This function is the function that compute the color at the intersection point
// of a ray defined by a position and a direction. Note that thus function is recursive (it calls itself).
//
// If the material of the intersected object is either reflective or reflective and refractive,
// then we compute the reflection/refracton direction and cast two new rays into the scene
// by calling the castRay() function recursively. When the surface is transparent, we mix
// the reflection and refraction color using the result of the fresnel equations (it computes
// the amount of reflection and refractin depending on the surface normal, incident view direction
// and surface refractive index).
//
// If the surface is duffuse/glossy we use the Phong illumation model to compute the color
// at the intersection point.
Vector3f Scene::castRay(const Ray &ray, int depth) const
{if (depth > this->maxDepth) {return Vector3f(0.0,0.0,0.0);}Intersection intersection = Scene::intersect(ray);Material *m = intersection.m;Object *hitObject = intersection.obj;Vector3f hitColor = this->backgroundColor;
//    float tnear = kInfinity;Vector2f uv;uint32_t index = 0;if(intersection.happened) {Vector3f hitPoint = intersection.coords;Vector3f N = intersection.normal; // normalVector2f st; // st coordinateshitObject->getSurfaceProperties(hitPoint, ray.direction, index, uv, N, st);
//        Vector3f tmp = hitPoint;switch (m->getType()) {case REFLECTION_AND_REFRACTION:{Vector3f reflectionDirection = normalize(reflect(ray.direction, N));Vector3f refractionDirection = normalize(refract(ray.direction, N, m->ior));Vector3f reflectionRayOrig = (dotProduct(reflectionDirection, N) < 0) ?hitPoint - N * EPSILON :hitPoint + N * EPSILON;Vector3f refractionRayOrig = (dotProduct(refractionDirection, N) < 0) ?hitPoint - N * EPSILON :hitPoint + N * EPSILON;Vector3f reflectionColor = castRay(Ray(reflectionRayOrig, reflectionDirection), depth + 1);Vector3f refractionColor = castRay(Ray(refractionRayOrig, refractionDirection), depth + 1);float kr;fresnel(ray.direction, N, m->ior, kr);hitColor = reflectionColor * kr + refractionColor * (1 - kr);break;}case REFLECTION:{float kr;fresnel(ray.direction, N, m->ior, kr);Vector3f reflectionDirection = reflect(ray.direction, N);Vector3f reflectionRayOrig = (dotProduct(reflectionDirection, N) < 0) ?hitPoint + N * EPSILON :hitPoint - N * EPSILON;hitColor = castRay(Ray(reflectionRayOrig, reflectionDirection),depth + 1) * kr;break;}default:{// [comment]// We use the Phong illumation model int the default case. The phong model// is composed of a diffuse and a specular reflection component.// [/comment]Vector3f lightAmt = 0, specularColor = 0;Vector3f shadowPointOrig = (dotProduct(ray.direction, N) < 0) ?hitPoint + N * EPSILON :hitPoint - N * EPSILON;// [comment]// Loop over all lights in the scene and sum their contribution up// We also apply the lambert cosine law// [/comment]for (uint32_t i = 0; i < get_lights().size(); ++i){auto area_ptr = dynamic_cast<AreaLight*>(this->get_lights()[i].get());if (area_ptr){// Do nothing for this assignment}else{Vector3f lightDir = get_lights()[i]->position - hitPoint;// square of the distance between hitPoint and the lightfloat lightDistance2 = dotProduct(lightDir, lightDir);lightDir = normalize(lightDir);float LdotN = std::max(0.f, dotProduct(lightDir, N));Object *shadowHitObject = nullptr;float tNearShadow = kInfinity;// is the point in shadow, and is the nearest occluding object closer to the object than the light itself?bool inShadow = bvh->Intersect(Ray(shadowPointOrig, lightDir)).happened;lightAmt += (1 - inShadow) * get_lights()[i]->intensity * LdotN;Vector3f reflectionDirection = reflect(-lightDir, N);specularColor += powf(std::max(0.f, -dotProduct(reflectionDirection, ray.direction)),m->specularExponent) * get_lights()[i]->intensity;}}hitColor = lightAmt * (hitObject->evalDiffuseColor(st) * m->Kd + specularColor * m->Ks);break;}}}return hitColor;
}

Triangle.hpp：

#pragma once#include "BVH.hpp"
#include "Intersection.hpp"
#include "Material.hpp"
#include "OBJ_Loader.hpp"
#include "Object.hpp"
#include "Triangle.hpp"
#include <cassert>
#include <array>
//检测射线是否和三角形相交
bool rayTriangleIntersect(const Vector3f& v0, const Vector3f& v1,const Vector3f& v2, const Vector3f& orig,const Vector3f& dir, float& tnear, float& u, float& v)
{Vector3f edge1 = v1 - v0;Vector3f edge2 = v2 - v0;Vector3f pvec = crossProduct(dir, edge2);float det = dotProduct(edge1, pvec);if (det == 0 || det < 0)return false;Vector3f tvec = orig - v0;u = dotProduct(tvec, pvec);if (u < 0 || u > det)return false;Vector3f qvec = crossProduct(tvec, edge1);v = dotProduct(dir, qvec);if (v < 0 || u + v > det)return false;float invDet = 1 / det;tnear = dotProduct(edge2, qvec) * invDet;u *= invDet;v *= invDet;return true;
}
//存储了三角形的三个顶点，两个边向量，三张tex坐标，一个法线，一张纹理
//提供了判断与光线相交，获取表面信息，表面颜色，边界盒的方法
class Triangle : public Object
{
public:Vector3f v0, v1, v2; // vertices A, B ,C , counter-clockwise orderVector3f e1, e2;     // 2 edges v1-v0, v2-v0;Vector3f t0, t1, t2; // texture coordsVector3f normal;Material* m;Triangle(Vector3f _v0, Vector3f _v1, Vector3f _v2, Material* _m = nullptr): v0(_v0), v1(_v1), v2(_v2), m(_m){e1 = v1 - v0;e2 = v2 - v0;normal = normalize(crossProduct(e1, e2));}//检测射线是否与三角形相交bool intersect(const Ray& ray) override;//检测射线是否与三角形相交bool intersect(const Ray& ray, float& tnear,uint32_t& index) const override;//获取射线与三角形交点信息Intersection getIntersection(Ray ray) override;//获取表面信息void getSurfaceProperties(const Vector3f& P, const Vector3f& I,const uint32_t& index, const Vector2f& uv,Vector3f& N, Vector2f& st) const override{N = normal;//        throw std::runtime_error("triangle::getSurfaceProperties not//        implemented.");}//获取三角形表面颜色Vector3f evalDiffuseColor(const Vector2f&) const override;//获取三角形的边界盒Bounds3 getBounds() override;
};
//存储了边界盒，顶点，三角形数量，索引，纹理坐标，三角形，加速结构树和材质等信息
//包括初始化函数，获取表面信息，获取三角形颜色，获取边界盒的方法
class MeshTriangle : public Object
{
public:
/*** 构造函数 - 从文件加载三角形网格* * @param filename 要加载的文件名，支持OBJ文件格式。* * 此构造函数负责从指定的文件加载三角形网格，并对其进行初始化，* 包括计算顶点的最小和最大值以建立包围盒，以及为每个三角形分配材质并构建BVH加速结构。*/
MeshTriangle(const std::string& filename)
{// 使用objl库的Loader类加载文件objl::Loader loader;loader.LoadFile(filename);// 断言确保加载的网格只有一个assert(loader.LoadedMeshes.size() == 1);auto mesh = loader.LoadedMeshes[0];// 初始化最小和最大顶点坐标，用于计算包围盒,浮点数的最大值Vector3f min_vert = Vector3f{std::numeric_limits<float>::infinity(),std::numeric_limits<float>::infinity(),std::numeric_limits<float>::infinity()};Vector3f max_vert = Vector3f{-std::numeric_limits<float>::infinity(),-std::numeric_limits<float>::infinity(),-std::numeric_limits<float>::infinity()};// 遍历网格的顶点，每三个顶点构成一个面for (int i = 0; i < mesh.Vertices.size(); i += 3) {std::array<Vector3f, 3> face_vertices;// 计算面的三个顶点，并更新最小和最大顶点坐标for (int j = 0; j < 3; j++) {auto vert = Vector3f(mesh.Vertices[i + j].Position.X,mesh.Vertices[i + j].Position.Y,mesh.Vertices[i + j].Position.Z) *60.f; // 对顶点坐标进行缩放face_vertices[j] = vert;min_vert = Vector3f(std::min(min_vert.x, vert.x),std::min(min_vert.y, vert.y),std::min(min_vert.z, vert.z));max_vert = Vector3f(std::max(max_vert.x, vert.x),std::max(max_vert.y, vert.y),std::max(max_vert.z, vert.z));}// 为每个面创建新的材质auto new_mat =new Material(MaterialType::DIFFUSE_AND_GLOSSY,Vector3f(0.5, 0.5, 0.5), Vector3f(0, 0, 0));new_mat->Kd = 0.6; // 设置漫反射系数new_mat->Ks = 0.0; // 设置镜面反射系数new_mat->specularExponent = 0; // 设置镜面反射指数// 将面的三个顶点和材质添加到三角形列表中triangles.emplace_back(face_vertices[0], face_vertices[1],face_vertices[2], new_mat);}// 根据最小和最大顶点坐标计算并设置包围盒，可用于射线检测和碰撞检测，但是算出来没有使用（！！！）bounding_box = Bounds3(min_vert, max_vert);// 准备三角形指针列表，用于构建BVHstd::vector<Object*> ptrs;for (auto& tri : triangles)ptrs.push_back(&tri);// 创建并设置BVH加速结构bvh = new BVHAccel(ptrs);
}bool intersect(const Ray& ray) { return true; }/*** 检测一条射线与一组三角形的交点。* * @param ray 表示射线的对象。* @param tnear 用于记录最近的交点距离，如果找到更近的交点，会更新这个值。* @param index 用于记录与射线相交的三角形的索引，如果找到交点，会更新这个值。* @return 如果射线与三角形组相交，则返回true；否则返回false。*/bool intersect(const Ray& ray, float& tnear, uint32_t& index) const{bool intersect = false; // 初始化没有交点标志// 遍历所有三角形进行相交测试for (uint32_t k = 0; k < numTriangles; ++k) {// 获取当前三角形的顶点const Vector3f& v0 = vertices[vertexIndex[k * 3]];const Vector3f& v1 = vertices[vertexIndex[k * 3 + 1]];const Vector3f& v2 = vertices[vertexIndex[k * 3 + 2]];float t, u, v; // 用于存储交点参数和UV坐标// 执行射线-三角形交点测试，并检查是否找到更近的交点if (rayTriangleIntersect(v0, v1, v2, ray.origin, ray.direction, t,u, v) &&t < tnear) {tnear = t; // 更新最近交点距离index = k; // 更新相交三角形的索引intersect |= true; // 更新有交点标志}}return intersect; // 返回是否有交点}Bounds3 getBounds() { return bounding_box; }void getSurfaceProperties(const Vector3f& P, const Vector3f& I,const uint32_t& index, const Vector2f& uv,Vector3f& N, Vector2f& st) const{const Vector3f& v0 = vertices[vertexIndex[index * 3]];const Vector3f& v1 = vertices[vertexIndex[index * 3 + 1]];const Vector3f& v2 = vertices[vertexIndex[index * 3 + 2]];Vector3f e0 = normalize(v1 - v0);Vector3f e1 = normalize(v2 - v1);N = normalize(crossProduct(e0, e1));const Vector2f& st0 = stCoordinates[vertexIndex[index * 3]];const Vector2f& st1 = stCoordinates[vertexIndex[index * 3 + 1]];const Vector2f& st2 = stCoordinates[vertexIndex[index * 3 + 2]];st = st0 * (1 - uv.x - uv.y) + st1 * uv.x + st2 * uv.y;}/*** 计算并返回一个基于贴图坐标st的漫反射颜色。* * @param st 贴图坐标，是一个二维向量，用于指定纹理上的位置。* @return Vector3f 返回计算得到的漫反射颜色，以三维向量表示。*/Vector3f evalDiffuseColor(const Vector2f& st) const{float scale = 5; // 缩放因子，用于调整纹理周期// 根据st的x和y坐标，基于位运算创建一个图案//st.x * scale和st.y * scale取余，并判断它们是否大于0.5，然后进行异或运算得到最终结果float pattern =(fmodf(st.x * scale, 1) > 0.5) ^ (fmodf(st.y * scale, 1) > 0.5);// 使用线性插值根据pattern选择两种颜色之一进行返回return lerp(Vector3f(0.815, 0.235, 0.031), // 第一种颜色Vector3f(0.937, 0.937, 0.231), // 第二种颜色pattern);}Intersection getIntersection(Ray ray){Intersection intersec;if (bvh) {intersec = bvh->Intersect(ray);}return intersec;}// 空间包围盒，用于快速判断几何体是否可能相交Bounds3 bounding_box;// 顶点数组，存储几何体的顶点信息std::unique_ptr<Vector3f[]> vertices;// 三角形数量，表示此几何体由多少个三角形组成uint32_t numTriangles;// 顶点索引数组，用于指定每个三角形由哪些顶点构成std::unique_ptr<uint32_t[]> vertexIndex;// 纹理坐标数组，存储每个顶点对应的纹理坐标std::unique_ptr<Vector2f[]> stCoordinates;// 存储每个三角形的具体信息，可用于更详细的形状描述std::vector<Triangle> triangles;// 二叉空间分割加速结构，用于快速查询和碰撞检测BVHAccel* bvh;// 材质指针，用于指定几何体的表面特性Material* m;
};inline bool Triangle::intersect(const Ray& ray) { return true; }
inline bool Triangle::intersect(const Ray& ray, float& tnear,uint32_t& index) const
{return false;
}
/*** 获取三角形的边界盒* 该函数计算并返回包含三角形顶点的边界盒。边界盒由三角形的三个顶点确定。** @return Bounds3 返回表示三角形边界盒的Bounds3对象。*/
inline Bounds3 Triangle::getBounds() { return Union(Bounds3(v0, v1), v2); }/*** 获取射线与三角形的交点信息* * @param ray 射线对象，包含射线的起点和方向* @return Intersection 结构体，包含交点信息。如果不存在交点，则返回一个空的Intersection对象。*/
inline Intersection Triangle::getIntersection(Ray ray)
{Intersection inter; // 初始化一个空的交点信息// 如果射线方向与三角形法线的点积大于0，则射线方向与三角形面向反，不考虑此交点if (dotProduct(ray.direction, normal) > 0)return inter;double u, v, t_tmp = 0;// 计算pvec，这是第一步，用于后续计算交点参数Vector3f pvec = crossProduct(ray.direction, e2);// 计算Determinant，用于判断射线是否与三角形平面相交double det = dotProduct(e1, pvec);// 如果det的绝对值小于EPSILON，表示射线与三角形不相交if (fabs(det) < EPSILON)return inter;// 计算det的倒数，用于后面求解交点参数double det_inv = 1. / det;// 计算tvec，这是用于计算u参数的Vector3f tvec = ray.origin - v0;// 计算u参数，如果u不在[0, 1]范围内，则交点不在三角形上u = dotProduct(tvec, pvec) * det_inv;if (u < 0 || u > 1)return inter;// 计算qvec，用于计算v参数Vector3f qvec = crossProduct(tvec, e1);// 计算v参数，如果v不在[0, 1]范围内，或u + v大于1，则交点不在三角形上v = dotProduct(ray.direction, qvec) * det_inv;if (v < 0 || u + v > 1)return inter;// 计算t参数的临时值，用于最终确定交点位置t_tmp = dotProduct(e2, qvec) * det_inv;// TODO: 找到射线与三角形的交点return inter; // 返回交点信息
}inline Vector3f Triangle::evalDiffuseColor(const Vector2f&) const
{return Vector3f(0.5, 0.5, 0.5);
}

Material.cpp :

//
// Created by LEI XU on 5/16/19.
//#ifndef RAYTRACING_MATERIAL_H
#define RAYTRACING_MATERIAL_H#include "Vector.hpp"enum MaterialType { DIFFUSE_AND_GLOSSY, REFLECTION_AND_REFRACTION, REFLECTION };/*** 类：Material* 描述：表示一种材质，包括材质类型、颜色、发射光、折射率、漫反射系数、镜面反射系数和镜面反射光泽度等属性。*/
class Material{
public:MaterialType m_type; // 材质类型Vector3f m_color; // 颜色Vector3f m_emission; // 发射光颜色float ior; // 折射率float Kd; // 漫反射系数float Ks; // 镜面反射系数float specularExponent; // 镜面反射光泽度// 构造函数/*** 构造一个Material对象。* @param t 材质类型，默认为DIFFUSE_AND_GLOSSY。* @param c 材质颜色，默认为(1,1,1)。* @param e 材质发射光颜色，默认为(0,0,0)。*/inline Material(MaterialType t=DIFFUSE_AND_GLOSSY, Vector3f c=Vector3f(1,1,1), Vector3f e=Vector3f(0,0,0));// 获取材质类型/*** 获取材质的类型。* @return 返回材质的类型。*/inline MaterialType getType();// 获取材质颜色/*** 获取材质的颜色。* @return 返回材质的颜色。*/inline Vector3f getColor();// 根据纹理坐标获取材质颜色/*** 根据给定的纹理坐标(u, v)获取材质的颜色。* @param u 纹理坐标u。* @param v 纹理坐标v。* @return 返回根据纹理坐标获取的颜色。*/inline Vector3f getColorAt(double u, double v);// 获取材质的发射光颜色/*** 获取材质的发射光颜色。* @return 返回材质的发射光颜色。*/inline Vector3f getEmission();};Material::Material(MaterialType t, Vector3f c, Vector3f e){m_type = t;m_color = c;m_emission = e;
}MaterialType Material::getType(){return m_type;}
Vector3f Material::getColor(){return m_color;}
Vector3f Material::getEmission() {return m_emission;}Vector3f Material::getColorAt(double u, double v) {return Vector3f();
}
#endif //RAYTRACING_MATERIAL_H

Object.cpp:

//
// Created by LEI XU on 5/13/19.
//
#pragma once
#ifndef RAYTRACING_OBJECT_H
#define RAYTRACING_OBJECT_H#include "Vector.hpp"
#include "global.hpp"
#include "Bounds3.hpp"
#include "Ray.hpp"
#include "Intersection.hpp"/*** @class Object* 对象类，定义了基本的交互和几何属性。* 该类是一个抽象基类，用于定义所有几何体对象的公共接口。*/
class Object
{
public:// 构造函数，默认构造Object() {}// 虚拟析构函数，确保子类可以正确销毁virtual ~Object() {}/*** @brief 检测光线是否与对象相交。* @param ray 入射光线。* @return 如果光线与对象相交返回true，否则返回false。*/virtual bool intersect(const Ray& ray) = 0;/*** @brief 检测光线是否与对象相交，并返回相交距离和材质ID。* @param ray 入射光线。* @param t 返回的相交距离。* @param materialID 返回的材质ID。* @return 如果光线与对象相交返回true，否则返回false。*/virtual bool intersect(const Ray& ray, float &t, uint32_t &materialID) const = 0;/*** @brief 获取与光线相交的详细信息。* @param _ray 入射光线。* @return 返回相交信息对象。*/virtual Intersection getIntersection(Ray _ray) = 0;/*** @brief 获取表面属性。* @param normal 法向量。* @param viewDir 观察方向。* @param materialID 材质ID。* @param texCoord 纹理坐标。* @param out_color 输出的颜色。* @param out_uv 输出的纹理坐标。*/virtual void getSurfaceProperties(const Vector3f &normal, const Vector3f &viewDir, const uint32_t &materialID, const Vector2f &texCoord, Vector3f &out_color, Vector2f &out_uv) const = 0;/*** @brief 评估漫反射颜色。* @param texCoord 纹理坐标。* @return 返回漫反射颜色。*/virtual Vector3f evalDiffuseColor(const Vector2f &) const =0;/*** @brief 获取对象的边界盒。* @return 返回边界盒对象。*/virtual Bounds3 getBounds()=0;
};#endif //RAYTRACING_OBJECT_H

 Ray.cpp:

//
// Created by LEI XU on 5/16/19.
//#ifndef RAYTRACING_RAY_H
#define RAYTRACING_RAY_H
#include "Vector.hpp"
/*** 表示一个射线的结构体。* 射线由起点和方向定义，可以用参数化形式表示：Destination = origin + t*direction，其中t为参数。*/
struct Ray{Vector3f origin;       // 射线的起点Vector3f direction, direction_inv; // 射线的方向和其倒数，用于快速计算double t;              // 传输时间，或参数t的初始值// 射线的构造函数，初始化起点、方向和传输时间t。// 方向向量会被标准化，并计算其倒数以优化计算。Ray(const Vector3f& ori, const Vector3f& dir, const double _t = 0.0): origin(ori), direction(dir),t(_t) {direction_inv = Vector3f(1./direction.x, 1./direction.y, 1./direction.z); // 计算方向的倒数t_min = 0.0; // 参数t的最小值，默认为0t_max = std::numeric_limits<double>::max(); // 参数t的最大值，默认为double的最大值}/*** 通过参数t计算射线上的点。* @param t 射线参数* @return 射线上对应参数t的点*/Vector3f operator()(double t) const{return origin+direction*t;}/*** 重载输出流运算符，以便于将射线对象输出到标准输出。* @param os 输出流对象* @param r 射线对象* @return 输出流对象，支持链式操作*/friend std::ostream &operator<<(std::ostream& os, const Ray& r){os<<"[origin:="<<r.origin<<", direction="<<r.direction<<", time="<< r.t<<"]\n";return os;}
};
#endif //RAYTRACING_RAY_H

 Renderer.hpp:

//
// Created by goksu on 2/25/20.
//
#include "Scene.hpp"#pragma once
struct hit_payload
{float tNear;uint32_t index;Vector2f uv;Object* hit_obj;
};
//把上节课光线追踪算法移到了Scene中
//该类只提供Render函数计算发射方向，发出射线，接收颜色，绘制等功能，集中在Render函数中
class Renderer
{
public:void Render(const Scene& scene);private:
};

Renderer.cpp:

//
// Created by goksu on 2/25/20.
//#include <fstream>
#include "Scene.hpp"
#include "Renderer.hpp"inline float deg2rad(const float& deg) { return deg * M_PI / 180.0; }const float EPSILON = 0.00001;void Renderer::Render(const Scene& scene)
{std::vector<Vector3f> framebuffer(scene.width * scene.height);float scale = tan(deg2rad(scene.fov * 0.5));float imageAspectRatio = scene.width / (float)scene.height;Vector3f eye_pos(-1, 5, 10);int m = 0;for (uint32_t j = 0; j < scene.height; ++j) {for (uint32_t i = 0; i < scene.width; ++i) {// generate primary ray directionfloat x = (2 * (i + 0.5) / (float)scene.width - 1) *imageAspectRatio * scale;float y = (1 - 2 * (j + 0.5) / (float)scene.height) * scale;// TODO: Find the x and y positions of the current pixel to get the// direction//  vector that passes through it.// Also, don't forget to multiply both of them with the variable// *scale*, and x (horizontal) variable with the *imageAspectRatio*// Don't forget to normalize this direction!}UpdateProgress(j / (float)scene.height);}UpdateProgress(1.f);// save framebuffer to fileFILE* fp = fopen("binary.ppm", "wb");(void)fprintf(fp, "P6\n%d %d\n255\n", scene.width, scene.height);for (auto i = 0; i < scene.height * scene.width; ++i) {static unsigned char color[3];color[0] = (unsigned char)(255 * clamp(0, 1, framebuffer[i].x));color[1] = (unsigned char)(255 * clamp(0, 1, framebuffer[i].y));color[2] = (unsigned char)(255 * clamp(0, 1, framebuffer[i].z));fwrite(color, 1, 3, fp);}fclose(fp);    
}

Bonds3.hpp:

//
// Created by LEI XU on 5/16/19.
//#ifndef RAYTRACING_BOUNDS3_H
#define RAYTRACING_BOUNDS3_H
#include "Ray.hpp"
#include "Vector.hpp"
#include <limits>
#include <array>class Bounds3
{public:Vector3f pMin, pMax; // two points to specify the bounding boxBounds3(){double minNum = std::numeric_limits<double>::lowest();double maxNum = std::numeric_limits<double>::max();pMax = Vector3f(minNum, minNum, minNum);pMin = Vector3f(maxNum, maxNum, maxNum);}Bounds3(const Vector3f p) : pMin(p), pMax(p) {}Bounds3(const Vector3f p1, const Vector3f p2){pMin = Vector3f(fmin(p1.x, p2.x), fmin(p1.y, p2.y), fmin(p1.z, p2.z));pMax = Vector3f(fmax(p1.x, p2.x), fmax(p1.y, p2.y), fmax(p1.z, p2.z));}//返回对角线Vector3f Diagonal() const { return pMax - pMin; }int maxExtent() const{Vector3f d = Diagonal();if (d.x > d.y && d.x > d.z)return 0;else if (d.y > d.z)return 1;elsereturn 2;}double SurfaceArea() const{Vector3f d = Diagonal();return 2 * (d.x * d.y + d.x * d.z + d.y * d.z);}Vector3f Centroid() { return 0.5 * pMin + 0.5 * pMax; }Bounds3 Intersect(const Bounds3& b){return Bounds3(Vector3f(fmax(pMin.x, b.pMin.x), fmax(pMin.y, b.pMin.y),fmax(pMin.z, b.pMin.z)),Vector3f(fmin(pMax.x, b.pMax.x), fmin(pMax.y, b.pMax.y),fmin(pMax.z, b.pMax.z)));}Vector3f Offset(const Vector3f& p) const{Vector3f o = p - pMin;if (pMax.x > pMin.x)o.x /= pMax.x - pMin.x;if (pMax.y > pMin.y)o.y /= pMax.y - pMin.y;if (pMax.z > pMin.z)o.z /= pMax.z - pMin.z;return o;}bool Overlaps(const Bounds3& b1, const Bounds3& b2){bool x = (b1.pMax.x >= b2.pMin.x) && (b1.pMin.x <= b2.pMax.x);bool y = (b1.pMax.y >= b2.pMin.y) && (b1.pMin.y <= b2.pMax.y);bool z = (b1.pMax.z >= b2.pMin.z) && (b1.pMin.z <= b2.pMax.z);return (x && y && z);}bool Inside(const Vector3f& p, const Bounds3& b){return (p.x >= b.pMin.x && p.x <= b.pMax.x && p.y >= b.pMin.y &&p.y <= b.pMax.y && p.z >= b.pMin.z && p.z <= b.pMax.z);}inline const Vector3f& operator[](int i) const{return (i == 0) ? pMin : pMax;}inline bool IntersectP(const Ray& ray, const Vector3f& invDir,const std::array<int, 3>& dirisNeg) const;
};inline bool Bounds3::IntersectP(const Ray& ray, const Vector3f& invDir,const std::array<int, 3>& dirIsNeg) const
{// invDir: ray direction(x,y,z), invDir=(1.0/x,1.0/y,1.0/z), use this because Multiply is faster that Division// dirIsNeg: ray direction(x,y,z), dirIsNeg=[int(x>0),int(y>0),int(z>0)], use this to simplify your logic// TODO test if ray bound intersects}
/*** 计算两个边界框的并集。* * @param b1 第一个边界框。* @param b2 第二个边界框。* @return 返回包含这两个边界框的并集的新边界框对象。*/
inline Bounds3 Union(const Bounds3& b1, const Bounds3& b2)
{Bounds3 ret;ret.pMin = Vector3f::Min(b1.pMin, b2.pMin);ret.pMax = Vector3f::Max(b1.pMax, b2.pMax);return ret;
}
/*** 计算给定边界和点的并集。* * @param b 输入的边界对象。* @param p 输入的点。* @return 返回扩展后的边界对象，即原边界和点p的并集。*/
inline Bounds3 Union(const Bounds3& b, const Vector3f& p)
{Bounds3 ret;ret.pMin = Vector3f::Min(b.pMin, p);ret.pMax = Vector3f::Max(b.pMax, p);return ret;
}#endif // RAYTRACING_BOUNDS3_H

BVH.hpp:

//
// Created by LEI XU on 5/16/19.
//#ifndef RAYTRACING_BVH_H
#define RAYTRACING_BVH_H#include <atomic>
#include <vector>
#include <memory>
#include <ctime>
#include "Object.hpp"
#include "Ray.hpp"
#include "Bounds3.hpp"
#include "Intersection.hpp"
#include "Vector.hpp"struct BVHBuildNode;
// BVHAccel Forward Declarations
struct BVHPrimitiveInfo;// BVHAccel Declarations
inline int leafNodes, totalLeafNodes, totalPrimitives, interiorNodes;
//
class BVHAccel {public:// BVHAccel Public Types// 定义分割方法，包括简单和SAH（表面面积哈希）enum class SplitMethod { NAIVE, SAH };// BVHAccel Public Methods// 构造函数，创建BVH加速结构。// @param p 指向对象的指针数组，这些对象将被包含在BVH中。// @param maxPrimsInNode 节点中允许的最大基本体数量，默认为1。// @param splitMethod 分割方法，默认为NAIVE。BVHAccel(std::vector<Object*> p, int maxPrimsInNode = 1, SplitMethod splitMethod = SplitMethod::NAIVE);// 获取整个BVH的包围盒。Bounds3 WorldBound() const;~BVHAccel();// 射线与BVH的交点检测,内部调用getIntersectionIntersection Intersect(const Ray &ray) const;// 递归检测射线与BVH节点的交点Intersection getIntersection(BVHBuildNode* node, const Ray& ray)const;// 射线与BVH是否相交的快速检测，没有实现这个函数（废弃！！！！！！）bool IntersectP(const Ray &ray) const;// BVH的根节点。BVHBuildNode* root;// BVHAccel Private Methods// 递归构建BVH。BVHBuildNode* recursiveBuild(std::vector<Object*>objects);// BVHAccel Private Data// 节点中允许的最大基本体数量const int maxPrimsInNode;// 分割方法。const SplitMethod splitMethod;// 物体数组std::vector<Object*> primitives;
};struct BVHBuildNode {Bounds3 bounds;BVHBuildNode *left;BVHBuildNode *right;Object* object;public:int splitAxis=0, firstPrimOffset=0, nPrimitives=0;// BVHBuildNode Public MethodsBVHBuildNode(){bounds = Bounds3();left = nullptr;right = nullptr;object = nullptr;}
};#endif //RAYTRACING_BVH_H

BVH.cpp:

#include <algorithm>
#include <cassert>
#include "BVH.hpp"BVHAccel::BVHAccel(std::vector<Object*> p, int maxPrimsInNode,SplitMethod splitMethod): maxPrimsInNode(std::min(255, maxPrimsInNode)), splitMethod(splitMethod),primitives(std::move(p))
{time_t start, stop;time(&start);if (primitives.empty())return;root = recursiveBuild(primitives);time(&stop);double diff = difftime(stop, start);int hrs = (int)diff / 3600;int mins = ((int)diff / 60) - (hrs * 60);int secs = (int)diff - (hrs * 3600) - (mins * 60);printf("\rBVH Generation complete: \nTime Taken: %i hrs, %i mins, %i secs\n\n",hrs, mins, secs);
}/*** 递归构建BVH（Bounding Volume Hierarchy）树的函数。* * @param objects 包含所有待加速物体的向量。* @return 返回构建好的BVH树的根节点。*/
BVHBuildNode* BVHAccel::recursiveBuild(std::vector<Object*> objects)
{BVHBuildNode* node = new BVHBuildNode();// 计算BVH节点内所有几何体的边界Bounds3 bounds;for (int i = 0; i < objects.size(); ++i)bounds = Union(bounds, objects[i]->getBounds());if (objects.size() == 1) {// 当只有一个物体时，创建叶子节点node->bounds = objects[0]->getBounds();node->object = objects[0];node->left = nullptr;node->right = nullptr;return node;}else if (objects.size() == 2) {// 当只有两个物体时，递归构建左右子树node->left = recursiveBuild(std::vector{objects[0]});node->right = recursiveBuild(std::vector{objects[1]});node->bounds = Union(node->left->bounds, node->right->bounds);return node;}else {// 对物体进行划分，以构建内部节点Bounds3 centroidBounds;for (int i = 0; i < objects.size(); ++i)//求所有质心的包围盒centroidBounds =Union(centroidBounds, objects[i]->getBounds().Centroid());//求包围盒对角线的x，y，z最大值//（边界最大维度：边界包围盒（bounding volume）的最大轴向尺寸，//如长方体包围盒的x、y、z轴方向上的最大尺寸。int dim = centroidBounds.maxExtent();//根据给定的dim值，对objects中的物体进行排序。//当dim为0时，按物体边界中心点的x坐标升序排序；//当dim为1时，按物体边界中心点的y坐标升序排序；//当dim为2时，按物体边界中心点的z坐标升序排序。//排序使用std::sort函数，并通过lambda函数比较两个物体的边界中心点的坐标。switch (dim) {case 0:// 根据物体边界中心点的x坐标进行排序std::sort(objects.begin(), objects.end(), [](auto f1, auto f2) {return f1->getBounds().Centroid().x < f2->getBounds().Centroid().x;});break;case 1:// 根据物体边界中心点的y坐标进行排序std::sort(objects.begin(), objects.end(), [](auto f1, auto f2) {return f1->getBounds().Centroid().y <f2->getBounds().Centroid().y;});break;case 2:// 根据物体边界中心点的z坐标进行排序std::sort(objects.begin(), objects.end(), [](auto f1, auto f2) {return f1->getBounds().Centroid().z <f2->getBounds().Centroid().z;});break;}// 根据排序将物体分为左右两组auto beginning = objects.begin();auto middling = objects.begin() + (objects.size() / 2);auto ending = objects.end();auto leftshapes = std::vector<Object*>(beginning, middling);auto rightshapes = std::vector<Object*>(middling, ending);// 确保分割后的物体数量正确assert(objects.size() == (leftshapes.size() + rightshapes.size()));// 递归构建左右子树node->left = recursiveBuild(leftshapes);node->right = recursiveBuild(rightshapes);// 计算当前节点的边界node->bounds = Union(node->left->bounds, node->right->bounds);}return node;
}
/*** BVHAccel的交点检测函数* 用于检测给定的光线是否与BVH加速结构中的几何体相交，并返回第一个交点信息。* * @param ray 输入的光线。* @return 返回一个Intersection结构体，包含了相交信息。如果不相交，则返回一个空的Intersection。*/
Intersection BVHAccel::Intersect(const Ray& ray) const
{Intersection isect;if (!root)return isect;isect = BVHAccel::getIntersection(root, ray);return isect;
}Intersection BVHAccel::getIntersection(BVHBuildNode* node, const Ray& ray) const
{// TODO Traverse the BVH to find intersection}

Intersection.hpp:

//
// Created by LEI XU on 5/16/19.
//#ifndef RAYTRACING_INTERSECTION_H
#define RAYTRACING_INTERSECTION_H
#include "Vector.hpp"
#include "Material.hpp"
class Object;
class Sphere;
//交点信息
struct Intersection
{/*** 默认构造函数初始化交点信息。* - happened 初始值为 false，表示未发生交点。* - coords 和 normal 初始化为 Vector3f 的零向量。* - distance 初始化为 double 类型的最大值，表示最远距离。* - obj 和 m 初始化为 nullptr，分别表示未指向任何对象和材质。*/Intersection(){happened=false;coords=Vector3f();normal=Vector3f();distance= std::numeric_limits<double>::max();obj =nullptr;m=nullptr;}// 表示是否发生了交点bool happened;// 交点的坐标Vector3f coords;// 交点处的法向量Vector3f normal;// 交点到原点的距离double distance;// 发生交点的对象Object* obj;// 对象的材质信息Material* m;
};
#endif //RAYTRACING_INTERSECTION_H

Vector.hpp:

//
// Created by LEI XU on 5/13/19.
//
#pragma once
#ifndef RAYTRACING_VECTOR_H
#define RAYTRACING_VECTOR_H#include <iostream>
#include <cmath>
#include <algorithm>//定义了一系列的向量操作
class Vector3f {
public:float x, y, z;Vector3f() : x(0), y(0), z(0) {}Vector3f(float xx) : x(xx), y(xx), z(xx) {}Vector3f(float xx, float yy, float zz) : x(xx), y(yy), z(zz) {}//向量加减乘除Vector3f operator * (const float &r) const { return Vector3f(x * r, y * r, z * r); }Vector3f operator / (const float &r) const { return Vector3f(x / r, y / r, z / r); }Vector3f operator * (const Vector3f &v) const { return Vector3f(x * v.x, y * v.y, z * v.z); }Vector3f operator - (const Vector3f &v) const { return Vector3f(x - v.x, y - v.y, z - v.z); }Vector3f operator + (const Vector3f &v) const { return Vector3f(x + v.x, y + v.y, z + v.z); }Vector3f operator - () const { return Vector3f(-x, -y, -z); }Vector3f& operator += (const Vector3f &v) { x += v.x, y += v.y, z += v.z; return *this; }friend Vector3f operator * (const float &r, const Vector3f &v){ return Vector3f(v.x * r, v.y * r, v.z * r); }//向量输出friend std::ostream & operator << (std::ostream &os, const Vector3f &v){ return os << v.x << ", " << v.y << ", " << v.z; }double       operator[](int index) const;double&      operator[](int index);static Vector3f Min(const Vector3f &p1, const Vector3f &p2) {return Vector3f(std::min(p1.x, p2.x), std::min(p1.y, p2.y),std::min(p1.z, p2.z));}static Vector3f Max(const Vector3f &p1, const Vector3f &p2) {return Vector3f(std::max(p1.x, p2.x), std::max(p1.y, p2.y),std::max(p1.z, p2.z));}
};inline double Vector3f::operator[](int index) const {//通过使用地址别名技巧，将对象的地址与数组的首地址绑定，再通过[index]操作符访问对应的分量return (&x)[index];
}class Vector2f
{
public:Vector2f() : x(0), y(0) {}Vector2f(float xx) : x(xx), y(xx) {}Vector2f(float xx, float yy) : x(xx), y(yy) {}Vector2f operator * (const float &r) const { return Vector2f(x * r, y * r); }Vector2f operator + (const Vector2f &v) const { return Vector2f(x + v.x, y + v.y); }float x, y;
};inline Vector3f lerp(const Vector3f &a, const Vector3f& b, const float &t)
{ return a * (1 - t) + b * t; }inline Vector3f normalize(const Vector3f &v)
{float mag2 = v.x * v.x + v.y * v.y + v.z * v.z;if (mag2 > 0) {float invMag = 1 / sqrtf(mag2);return Vector3f(v.x * invMag, v.y * invMag, v.z * invMag);}return v;
}inline float dotProduct(const Vector3f &a, const Vector3f &b)
{ return a.x * b.x + a.y * b.y + a.z * b.z; }inline Vector3f crossProduct(const Vector3f &a, const Vector3f &b)
{return Vector3f(a.y * b.z - a.z * b.y,a.z * b.x - a.x * b.z,a.x * b.y - a.y * b.x);
}#endif //RAYTRACING_VECTOR_H

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/785986.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【BlossomRPC】接入注册中心

【BlossomRPC】接入注册中心

文章目录 NacosZookeeper自研配置中心 RPC项目 配置中心项目 网关项目 这是BlossomRPC项目的最后一篇文章了&#xff0c;接入完毕注册中心&#xff0c;一个完整的RPC框架就设计完成了。 对于项目对注册中心的整合&#xff0c;其实我们只需要再服务启动的时候将ip/port/servic…
阅读更多...
Qt6.6添加多媒体模块Multimedia报错问题

Qt6.6添加多媒体模块Multimedia报错问题

问题 QT包含多媒体模块Multimedia时提示未知的模块&#xff1a; error: Project ERROR: Unknown module(s) in QT: multimedia 在帮助文档中只可以找到QMediaPlayer类&#xff0c;但是点进去是空的&#xff0c;这是因为没有安装多媒体模块及对应的帮助文档。 解决 使用在线…
阅读更多...
● 435. 无重叠区间 ● 763.划分字母区间 ● 56. 合并区间

● 435. 无重叠区间 ● 763.划分字母区间 ● 56. 合并区间

● 435. 无重叠区间 class Solution:def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:if len(intervals)1:return 0intervalssorted(intervals,keylambda x:(x[0],x[1]))res0for i in range(1,len(intervals)):if intervals[i][0]<intervals[i-1][…
阅读更多...
1049. 最后一块石头的重量 II（力扣LeetCode）

1049. 最后一块石头的重量 II（力扣LeetCode）

文章目录 1049. 最后一块石头的重量 II题目描述动态规划 1049. 最后一块石头的重量 II 题目描述 有一堆石头&#xff0c;用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。 每一回合&#xff0c;从中选出任意两块石头&#xff0c;然后将它们一起粉碎。假设石…
阅读更多...
代码随想录算法训练营第41天|343. 整数拆分 |96.不同的二叉搜索树

代码随想录算法训练营第41天|343. 整数拆分 |96.不同的二叉搜索树

代码随想录算法训练营第41天|343. 整数拆分 |96.不同的二叉搜索树 详细布置 今天两题都挺有难度&#xff0c;建议大家思考一下没思路&#xff0c;直接看题解&#xff0c;第一次做&#xff0c;硬想很难想出来。 343. 整数拆分 https://programmercarl.com/0343.%E6%95%B4%E6%…
阅读更多...
【Go】十三、面向对象：方法

【Go】十三、面向对象：方法

文章目录 1、面向对象2、结构体实例的创建3、结构体之间的转换4、方法5、结构体值拷贝6、方法的注意点7、方法和函数的区别8、跨包创建结构体实例 1、面向对象 Go的结构体struct ⇒ Java的Class类Go基于struct来实现OOP相比Java&#xff0c;Go去掉了方法重载、构造函数和析构函…
阅读更多...
css- 4

css- 4

1.浮动 1. 浮动最初用于实现文字环绕效果 2. 现在&#xff0c;浮动是主流的布局方式之一 1.1元素浮动之后的特点 元素浮动之后&#xff0c;称为浮动元素&#xff0c;具有如下特点&#xff1a; 1. 浮动元素脱离文档流 2. 多个浮动的元素会水平排列&#xff0c;一行放不下自动换…
阅读更多...
Redis高级面试题-2024

Redis高级面试题-2024

说说你对Redis的理解 Redis是一个基于Key-Value存储结构的开源内存数据库&#xff0c;也是一种NoSQL数据库。 它支持多种数据类型&#xff0c;包括String、Map、Set、ZSet和List&#xff0c;以满足不同应用场景的需求。 Redis以内存存储和优化的数据结构为基础&#xff0c;提…
阅读更多...
chatglm.cpp编译与执行

chatglm.cpp编译与执行

ChatGLM3介绍 ChatGLM3是由智谱AI和清华大学KEG实验室联合发布的对话预训练模型。作为第三代大型语言模型&#xff0c;ChatGLM3不仅理解和生成人类语言&#xff0c;还能执行代码、调用工具&#xff0c;并以markdown格式进行响应。其目标是打造更智能、更安全的代码解释器和工具…
阅读更多...
常用的对象方法帮助快速理解

常用的对象方法帮助快速理解

Object.assign()方法用于将所有可枚举属性的值从一个或多个源对象复制到目标对象。它将返回目标对象。 const target { a: 1, b: 2 }; const source { b: 4, c: 5 }; const returnedTarget Object.assign(target, source); console.log(target);// { a: 1, b: 4, c: 5 } co…
阅读更多...
125. 验证回文串

125. 验证回文串

思路 首先枚举出字母和数字(orz…看了其他人的题解, 才想起来Character.isLetterOrDigit可以直接判断字符串是否字母或数字);声明左指针指向入参第0位, 右指针指向入参最后一位, 用于判断左指针指向的元素(简称左元素)是否等于右指针指向的元素(简称右元素), 每遍历一次都会让…
阅读更多...
【力扣一刷】代码随想录day27（39. 组合总和、40.组合总和II、131.分割回文串）

【力扣一刷】代码随想录day27（39. 组合总和、40.组合总和II、131.分割回文串）

目录 【39. 组合总和】中等题 【40.组合总和II】中等题 【131. 分割回文串】中等题 【39. 组合总和】中等题 思路&#xff1a; 确定终止条件&#xff1a;sum target时记录路径并返回。剪枝&#xff1a;当前节点的路径之和已经大于sum就不可能再等于sum了&#xff0c;结束该分支…
阅读更多...
16进制的字符串转byte[]数组 以及将字节数组转换成十六进制的字符串

16进制的字符串转byte[]数组 以及将字节数组转换成十六进制的字符串

16进制的字符串转byte[]数组 public class ClientString16 {@Testpublic void get16Str(){String str="48 47 12 00 14 12 16 08 15 0d 30 0f 02 30 30 30 30 30 30 30 30 30 30 00 c2";byte[] bytes = hexStringToByteArray(str);getBytetoString(bytes);//String …
阅读更多...
【御控物联】JavaScript JSON结构转换（12）：对象To数组——键值互换属性重组

【御控物联】JavaScript JSON结构转换（12）：对象To数组——键值互换属性重组

文章目录 一、JSON结构转换是什么&#xff1f;二、核心构件之转换映射三、案例之《JSON对象 To JSON数组》四、代码实现五、在线转换工具六、技术资料 一、JSON结构转换是什么&#xff1f; JSON结构转换指的是将一个JSON对象或JSON数组按照一定规则进行重组、筛选、映射或转换…
阅读更多...
LeetCode 每日一题 2024/3/25-2024/3/31

LeetCode 每日一题 2024/3/25-2024/3/31

记录了初步解题思路 以及本地实现代码&#xff1b;并不一定为最优 也希望大家能一起探讨 一起进步 目录 3/25 518. 零钱兑换 II3/26 2642. 设计可以求最短路径的图类3/27 2580. 统计将重叠区间合并成组的方案数3/28 1997. 访问完所有房间的第一天3/29 2908. 元素和最小的山形三…
阅读更多...
【御控物联】JavaScript JSON结构转换（8）：数组To数组——多层属性重组

【御控物联】JavaScript JSON结构转换（8）：数组To数组——多层属性重组

文章目录 一、JSON结构转换是什么&#xff1f;二、案例之《JSON数组 To JSON数组》三、代码实现四、在线转换工具五、技术资料 一、JSON结构转换是什么&#xff1f; JSON结构转换指的是将一个JSON对象或JSON数组按照一定规则进行重组、筛选、映射或转换&#xff0c;生成新的JS…
阅读更多...
Java

Java

1.学生和老师都会有work方法&#xff0c;学生的工作是学习&#xff0c;老师的工作是教书&#xff0c;我利用了一个接口来实现&#xff1b; 2.同时&#xff0c;老师和学生都是人&#xff0c;并且都有姓名&#xff0c;姓名&#xff0c;年龄和身高等特征&#xff0c;我用了一个继承…
阅读更多...
http协议补充

http协议补充

7.7实现http请求 class httprequest { public:void Deserialize(std::string content){while (true){auto pos content.find(sep);if (pos std::string::npos){break;}std::string temp content.substr(0, pos);if (temp.empty()){break;}req_header_.push_back(temp);cont…
阅读更多...
离散数学-

离散数学-

数学
阅读更多...
Redis 服务

Redis 服务

任务描述：请采用 redis 服务，实现高并发数据和海量数据的读写。 （1）利用 linux2 搭建 redis cluster 集群，使用端口 7001-7003模拟主节点，7004-7006 模拟从节点，让其他主机可以访问 redis 集群。 [root@linux4 ~]# yum install -y redis policycoreutils-python-utils…
阅读更多...
最新文章

Copyright @ 2022~2023