Examples with Point3 org.sunflow.math.Point3 used on opensource projects

Example 21 with Point3

use of org.sunflow.math.Point3 in project joons-renderer by joonhyublee.

the class CornellBox method intersects.

public boolean intersects(BoundingBox box) {
    // this could be optimized
    BoundingBox b = new BoundingBox();
    b.include(new Point3(minX, minY, minZ));
    b.include(new Point3(maxX, maxY, maxZ));
    if (b.intersects(box)) {
        // the box is overlapping or enclosed
        if (!b.contains(new Point3(box.getMinimum().x, box.getMinimum().y, box.getMinimum().z))) {
            return true;
        }
        if (!b.contains(new Point3(box.getMinimum().x, box.getMinimum().y, box.getMaximum().z))) {
            return true;
        }
        if (!b.contains(new Point3(box.getMinimum().x, box.getMaximum().y, box.getMinimum().z))) {
            return true;
        }
        if (!b.contains(new Point3(box.getMinimum().x, box.getMaximum().y, box.getMaximum().z))) {
            return true;
        }
        if (!b.contains(new Point3(box.getMaximum().x, box.getMinimum().y, box.getMinimum().z))) {
            return true;
        }
        if (!b.contains(new Point3(box.getMaximum().x, box.getMinimum().y, box.getMaximum().z))) {
            return true;
        }
        if (!b.contains(new Point3(box.getMaximum().x, box.getMaximum().y, box.getMinimum().z))) {
            return true;
        }
        if (!b.contains(new Point3(box.getMaximum().x, box.getMaximum().y, box.getMaximum().z))) {
            return true;
        }
    // all vertices of the box are inside - the surface of the box is
    // not intersected
    }
    return false;
}

Example 22 with Point3

use of org.sunflow.math.Point3 in project joons-renderer by joonhyublee.

the class CornellBox method getSamples.

@Override
public void getSamples(ShadingState state) {
    if (lightBounds.contains(state.getPoint()) && state.getPoint().z < maxZ) {
        int n = state.getDiffuseDepth() > 0 ? 1 : samples;
        float a = area / n;
        for (int i = 0; i < n; i++) {
            // random offset on unit square
            double randX = state.getRandom(i, 0, n);
            double randY = state.getRandom(i, 1, n);
            Point3 p = new Point3();
            p.x = (float) (lxmin * (1 - randX) + lxmax * randX);
            p.y = (float) (lymin * (1 - randY) + lymax * randY);
            p.z = maxZ - 0.001f;
            LightSample dest = new LightSample();
            // prepare shadow ray to sampled point
            dest.setShadowRay(new Ray(state.getPoint(), p));
            // check that the direction of the sample is the same as the
            // normal
            float cosNx = dest.dot(state.getNormal());
            if (cosNx <= 0) {
                return;
            }
            // light source facing point ?
            // (need to check with light source's normal)
            float cosNy = dest.getShadowRay().dz;
            if (cosNy > 0) {
                // compute geometric attenuation and probability scale
                // factor
                float r = dest.getShadowRay().getMax();
                float g = cosNy / (r * r);
                float scale = g * a;
                // set final sample radiance
                dest.setRadiance(radiance, radiance);
                dest.getDiffuseRadiance().mul(scale);
                dest.getSpecularRadiance().mul(scale);
                dest.traceShadow(state);
                state.addSample(dest);
            }
        }
    }
}

Example 23 with Point3

use of org.sunflow.math.Point3 in project joons-renderer by joonhyublee.

the class Cylinder method prepareShadingState.

@Override
public void prepareShadingState(ShadingState state) {
    state.init();
    state.getRay().getPoint(state.getPoint());
    Instance parent = state.getInstance();
    Point3 localPoint = state.transformWorldToObject(state.getPoint());
    state.getNormal().set(localPoint.x, localPoint.y, 0);
    state.getNormal().normalize();
    float phi = (float) Math.atan2(state.getNormal().y, state.getNormal().x);
    if (phi < 0) {
        phi += 2 * Math.PI;
    }
    state.getUV().x = phi / (float) (2 * Math.PI);
    state.getUV().y = (localPoint.z + 1) * 0.5f;
    state.setShader(parent.getShader(0));
    state.setModifier(parent.getModifier(0));
    // into world space
    Vector3 worldNormal = state.transformNormalObjectToWorld(state.getNormal());
    Vector3 v = state.transformVectorObjectToWorld(new Vector3(0, 0, 1));
    state.getNormal().set(worldNormal);
    state.getNormal().normalize();
    state.getGeoNormal().set(state.getNormal());
    // compute basis in world space
    state.setBasis(OrthoNormalBasis.makeFromWV(state.getNormal(), v));
}

Example 24 with Point3

use of org.sunflow.math.Point3 in project joons-renderer by joonhyublee.

the class JuliaFractal method prepareShadingState.

@Override
public void prepareShadingState(ShadingState state) {
    state.init();
    state.getRay().getPoint(state.getPoint());
    Instance parent = state.getInstance();
    // compute local normal
    Point3 p = state.transformWorldToObject(state.getPoint());
    float gx1w = p.x - DELTA;
    float gx1x = p.y;
    float gx1y = p.z;
    float gx1z = 0;
    float gx2w = p.x + DELTA;
    float gx2x = p.y;
    float gx2y = p.z;
    float gx2z = 0;
    float gy1w = p.x;
    float gy1x = p.y - DELTA;
    float gy1y = p.z;
    float gy1z = 0;
    float gy2w = p.x;
    float gy2x = p.y + DELTA;
    float gy2y = p.z;
    float gy2z = 0;
    float gz1w = p.x;
    float gz1x = p.y;
    float gz1y = p.z - DELTA;
    float gz1z = 0;
    float gz2w = p.x;
    float gz2x = p.y;
    float gz2y = p.z + DELTA;
    float gz2z = 0;
    for (int i = 0; i < maxIterations; i++) {
        {
            // z = z*z + c
            float nw = gx1w * gx1w - gx1x * gx1x - gx1y * gx1y - gx1z * gx1z + cw;
            gx1x = 2 * gx1w * gx1x + cx;
            gx1y = 2 * gx1w * gx1y + cy;
            gx1z = 2 * gx1w * gx1z + cz;
            gx1w = nw;
        }
        {
            // z = z*z + c
            float nw = gx2w * gx2w - gx2x * gx2x - gx2y * gx2y - gx2z * gx2z + cw;
            gx2x = 2 * gx2w * gx2x + cx;
            gx2y = 2 * gx2w * gx2y + cy;
            gx2z = 2 * gx2w * gx2z + cz;
            gx2w = nw;
        }
        {
            // z = z*z + c
            float nw = gy1w * gy1w - gy1x * gy1x - gy1y * gy1y - gy1z * gy1z + cw;
            gy1x = 2 * gy1w * gy1x + cx;
            gy1y = 2 * gy1w * gy1y + cy;
            gy1z = 2 * gy1w * gy1z + cz;
            gy1w = nw;
        }
        {
            // z = z*z + c
            float nw = gy2w * gy2w - gy2x * gy2x - gy2y * gy2y - gy2z * gy2z + cw;
            gy2x = 2 * gy2w * gy2x + cx;
            gy2y = 2 * gy2w * gy2y + cy;
            gy2z = 2 * gy2w * gy2z + cz;
            gy2w = nw;
        }
        {
            // z = z*z + c
            float nw = gz1w * gz1w - gz1x * gz1x - gz1y * gz1y - gz1z * gz1z + cw;
            gz1x = 2 * gz1w * gz1x + cx;
            gz1y = 2 * gz1w * gz1y + cy;
            gz1z = 2 * gz1w * gz1z + cz;
            gz1w = nw;
        }
        {
            // z = z*z + c
            float nw = gz2w * gz2w - gz2x * gz2x - gz2y * gz2y - gz2z * gz2z + cw;
            gz2x = 2 * gz2w * gz2x + cx;
            gz2y = 2 * gz2w * gz2y + cy;
            gz2z = 2 * gz2w * gz2z + cz;
            gz2w = nw;
        }
    }
    float gradX = length(gx2w, gx2x, gx2y, gx2z) - length(gx1w, gx1x, gx1y, gx1z);
    float gradY = length(gy2w, gy2x, gy2y, gy2z) - length(gy1w, gy1x, gy1y, gy1z);
    float gradZ = length(gz2w, gz2x, gz2y, gz2z) - length(gz1w, gz1x, gz1y, gz1z);
    Vector3 n = new Vector3(gradX, gradY, gradZ);
    state.getNormal().set(state.transformNormalObjectToWorld(n));
    state.getNormal().normalize();
    state.getGeoNormal().set(state.getNormal());
    state.setBasis(OrthoNormalBasis.makeFromW(state.getNormal()));
    state.getPoint().x += state.getNormal().x * epsilon * 20;
    state.getPoint().y += state.getNormal().y * epsilon * 20;
    state.getPoint().z += state.getNormal().z * epsilon * 20;
    state.setShader(parent.getShader(0));
    state.setModifier(parent.getModifier(0));
}

Example 25 with Point3

use of org.sunflow.math.Point3 in project joons-renderer by joonhyublee.

the class Plane method update.

@Override
public boolean update(ParameterList pl, SunflowAPI api) {
    center = pl.getPoint("center", center);
    Point3 b = pl.getPoint("point1", null);
    Point3 c = pl.getPoint("point2", null);
    if (b != null && c != null) {
        Point3 v0 = center;
        Point3 v1 = b;
        Point3 v2 = c;
        Vector3 ng = normal = Vector3.cross(Point3.sub(v1, v0, new Vector3()), Point3.sub(v2, v0, new Vector3()), new Vector3()).normalize();
        if (Math.abs(ng.x) > Math.abs(ng.y) && Math.abs(ng.x) > Math.abs(ng.z)) {
            k = 0;
        } else if (Math.abs(ng.y) > Math.abs(ng.z)) {
            k = 1;
        } else {
            k = 2;
        }
        float ax, ay, bx, by, cx, cy;
        switch(k) {
            case 0:
                {
                    ax = v0.y;
                    ay = v0.z;
                    bx = v2.y - ax;
                    by = v2.z - ay;
                    cx = v1.y - ax;
                    cy = v1.z - ay;
                    break;
                }
            case 1:
                {
                    ax = v0.z;
                    ay = v0.x;
                    bx = v2.z - ax;
                    by = v2.x - ay;
                    cx = v1.z - ax;
                    cy = v1.x - ay;
                    break;
                }
            case 2:
            default:
                {
                    ax = v0.x;
                    ay = v0.y;
                    bx = v2.x - ax;
                    by = v2.y - ay;
                    cx = v1.x - ax;
                    cy = v1.y - ay;
                }
        }
        float det = bx * cy - by * cx;
        bnu = -by / det;
        bnv = bx / det;
        bnd = (by * ax - bx * ay) / det;
        cnu = cy / det;
        cnv = -cx / det;
        cnd = (cx * ay - cy * ax) / det;
    } else {
        normal = pl.getVector("normal", normal);
        k = 3;
        bnu = bnv = bnd = 0;
        cnu = cnv = cnd = 0;
    }
    return true;
}