Vector calculateMagneticFieldPoint(double I, double permeability, Vector l, Vector r) {
const double constant = permeability / (4 * M_PI);
const Vector r1 = vectorSubstract(r, l);
const double r1LenSq = vectorGetLengthSq(r1);
const double r1Len = sqrt(r1LenSq);
return vectorMultiply(vectorCrossProduct(l, r1), constant * I / r1LenSq / r1Len);
}
Line *createLine(vector camera, png_uint_32 x, png_uint_32 y) {
Line *retval = malloc(sizeof(Line));
retval->start = camera;
vector planePoint = vectorCreate(-8.0 + 16.0 * ((double)x / (double)WIDTH), 0.0, 10.0 - 10.0 * ((double)y / (double)HEIGHT));
vector dir = vectorSubtraction(planePoint, camera);
retval->end = vectorAddition(camera, vectorMultiply(dir,50));
return retval;
}
void operator*=(const MyMatrix &b){
for(int i = 0; i < _dim; i++){
std::vector<float> temporalVectorA((unsigned long) _dim,0);
for (int h = 0; h < _dim; h++){
temporalVectorA[h] = vecvec[i][h];
}
for(int k = 0; k < _dim; k++){
std::vector<float> temporalVectorB((unsigned long) _dim,0);
for(int l = 0; l < _dim; l++){
temporalVectorB[l] = b.get(l, k);
}
vecvec[i][k] = vectorMultiply(temporalVectorA, temporalVectorB);
}
}
}
vector rayTrace(Line *ray, Primitive **primitives, Light **lights, float r_idx) {
Intersection *bestIntersection = NULL;
vector retval = vectorCreate(0.0, 0.0, 0.0);
for (int p = 0; p < 10; p++) {
if (!primitives[p])
break;
Intersection *thisIntersection = primitiveIntersect(primitives[p], ray);
if (!bestIntersection) {
bestIntersection = thisIntersection;
continue;
}
if (thisIntersection && thisIntersection->distance < bestIntersection->distance) {
free(bestIntersection);
bestIntersection = thisIntersection;
}
}
if (bestIntersection) {
Primitive *primitive = bestIntersection->primitive;
Material *material = primitive->material;
vector mcolor = vectorMultiply(material->color, 0.0);
vector N = primitiveNormal(primitive, bestIntersection);
vector V = vectorUnit(vectorSubtraction(ray->end, ray->start));
for (int l = 0; l < 2; l++) {
Light *light = lights[l];
vector lvec = vectorSubtraction(light->location, bestIntersection->intersectionPoint);
vector pcolor = material->color;
vector lcolor = light->color;
Intersection *linter = NULL;
Line *lightRay = makeLine(bestIntersection->intersectionPoint, light->location);
float shade = 0.0;
for (int p = 0; p < 3; p++) {
if (primitives[p] == primitive)
continue;
if ((linter = primitiveIntersect(primitives[p], lightRay)))
shade += 1.0 - linter->primitive->material->transparency;
}
free(lightRay);
if (shade < 1.0) {
if (material->specular > 0.0) {
float sintensity = 0.0;
vector L = vectorUnit(lvec);
vector R = vectorSubtraction(L, vectorMultiply(N, 2 * vectorDotProduct(L,N)));
float dot = vectorDotProduct(V, R);
if (dot > 0.0) {
sintensity = pow(dot, 20) * material->specular * light->intensity * (1.0 - shade);
}
if (sintensity > 0.0) {
mcolor = vectorAddition(mcolor, vectorMultiply(lcolor, sintensity));
}
}
if (material->diffuse > 0.0) {
float dintensity = material->diffuse * vectorDotProduct(vectorUnit(lvec), primitive->normal(bestIntersection->primitive, bestIntersection)) * light->intensity * (1.0 - shade);
if (dintensity > 0.0) {
mcolor = vectorAddition(mcolor, vectorMultiply(vectorCProduct(pcolor, lcolor), dintensity));
}
}
}
free(linter);
}
if (material->reflection > 0.0) {
vector R = vectorUnit(vectorSubtraction(V, vectorMultiply(N, 2 * vectorDotProduct(V,N))));
Line *rline = makeLine(vectorAddition(bestIntersection->intersectionPoint, vectorMultiply(R, EPS)), vectorAddition(bestIntersection->intersectionPoint, vectorMultiply(R, 30)));
vector rcolor = rayTrace(rline, primitives, lights, r_idx);
mcolor = vectorAddition(vectorMultiply(mcolor, 1.0 - material->reflection), vectorMultiply(rcolor, material->reflection));
free(rline);
}
if (material->transparency > 0) {
float refraction = material->refraction;
float n = r_idx / refraction;
vector Nr = vectorMultiply(N, bestIntersection->direction);
float cosI = - vectorDotProduct(Nr, V);
float cosT2 = 1.0 - n * n * (1.0 - cosI * cosI);
if (cosT2 > 0.0) {
vector T = vectorAddition(vectorMultiply(V, n), vectorMultiply(Nr, n * cosI - sqrt(cosT2)));
Line *rline = makeLine(vectorAddition(bestIntersection->intersectionPoint, vectorMultiply(T, EPS)), vectorAddition(bestIntersection->intersectionPoint, vectorMultiply(T, 30)));
vector rfcol = rayTrace(rline, primitives, lights, r_idx);
mcolor = vectorAddition(vectorMultiply(mcolor, 1.0 - material->transparency), vectorMultiply(rfcol, material->transparency));
free(rline);
}
}
retval = mcolor;
free(bestIntersection);
}
return retval;
}
Vector calculateElecticFieldPoint(double q, Vector r) {
const double rLenSq = vectorGetLengthSq(r);
const double rLen = sqrt(rLenSq);
return vectorMultiply(r, COULOMB_CONSTANT * q / rLenSq / rLen);
}
Vector calculateCoulombForce(double q, Vector E) {
return vectorMultiply(E, q);
}
Vector calculateLorenzForce(double q, Vector E, Vector v, Vector B) {
return vectorMultiply(vectorSum(E, vectorCrossProduct(v, B)), q);
}
