quadmesh.java

Sunflow是一个照片级的渲染系统

                    }
                }
            }
        } else {
            // setup for quadratic equation
            float b = A[X] * Rzy + A[Y] * Rxz + A[Z] * Ryx + B[X] * Czy + B[Y] * Cxz + B[Z] * Cyx;
            float c = C[X] * Rzy + C[Y] * Rxz + C[Z] * Ryx;
            float discrim = b * b - 4 * a * c;
            // reject trivial cases
            if (c * (a + b + c) > 0 && (discrim < 0 || a * c < 0 || b / a > 0 || b / a < -2))
                return;
            // solve quadratic
            float q = b > 0 ? -0.5f * (b + (float) Math.sqrt(discrim)) : -0.5f * (b - (float) Math.sqrt(discrim));
            // check first solution
            float Axy = A[X] * Q[Y] - A[Y] * Q[X];
            float u = q / a;
            if (u >= 0 && u <= 1) {
                float d = u * Axy - Cyx;
                float v = -(u * Bxy + Ryx) / d;
                if (v >= 0 && v <= 1) {
                    float t = (A[X] * u * v + B[X] * u + C[X] * v - R[X]) / Q[X];
                    if (r.isInside(t)) {
                        r.setMax(t);
                        state.setIntersection(primID, u, v);
                    }
                }
            }
            u = c / q;
            if (u >= 0 && u <= 1) {
                float d = u * Axy - Cyx;
                float v = -(u * Bxy + Ryx) / d;
                if (v >= 0 && v <= 1) {
                    float t = (A[X] * u * v + B[X] * u + C[X] * v - R[X]) / Q[X];
                    if (r.isInside(t)) {
                        r.setMax(t);
                        state.setIntersection(primID, u, v);
                    }
                }
            }
        }
    }

    public int getNumPrimitives() {
        return quads.length / 4;
    }

    public void prepareShadingState(ShadingState state) {
        state.init();
        Instance parent = state.getInstance();
        int primID = state.getPrimitiveID();
        float u = state.getU();
        float v = state.getV();
        state.getRay().getPoint(state.getPoint());
        int quad = 4 * primID;
        int index0 = quads[quad + 0];
        int index1 = quads[quad + 1];
        int index2 = quads[quad + 2];
        int index3 = quads[quad + 3];
        Point3 v0p = getPoint(index0);
        Point3 v1p = getPoint(index1);
        Point3 v2p = getPoint(index2);
        Point3 v3p = getPoint(index2);
        float tanux = (1 - v) * (v1p.x - v0p.x) + v * (v2p.x - v3p.x);
        float tanuy = (1 - v) * (v1p.y - v0p.y) + v * (v2p.y - v3p.y);
        float tanuz = (1 - v) * (v1p.z - v0p.z) + v * (v2p.z - v3p.z);

        float tanvx = (1 - u) * (v3p.x - v0p.x) + u * (v2p.x - v1p.x);
        float tanvy = (1 - u) * (v3p.y - v0p.y) + u * (v2p.y - v1p.y);
        float tanvz = (1 - u) * (v3p.z - v0p.z) + u * (v2p.z - v1p.z);

        float nx = tanuy * tanvz - tanuz * tanvy;
        float ny = tanuz * tanvx - tanux * tanvz;
        float nz = tanux * tanvy - tanuy * tanvx;

        Vector3 ng = new Vector3(nx, ny, nz);
        ng = parent.transformNormalObjectToWorld(ng);
        ng.normalize();
        state.getGeoNormal().set(ng);

        float k00 = (1 - u) * (1 - v);
        float k10 = u * (1 - v);
        float k01 = (1 - u) * v;
        float k11 = u * v;

        switch (normals.interp) {
            case NONE:
            case FACE: {
                state.getNormal().set(ng);
                break;
            }
            case VERTEX: {
                int i30 = 3 * index0;
                int i31 = 3 * index1;
                int i32 = 3 * index2;
                int i33 = 3 * index3;
                float[] normals = this.normals.data;
                state.getNormal().x = k00 * normals[i30 + 0] + k10 * normals[i31 + 0] + k11 * normals[i32 + 0] + k01 * normals[i33 + 0];
                state.getNormal().y = k00 * normals[i30 + 1] + k10 * normals[i31 + 1] + k11 * normals[i32 + 1] + k01 * normals[i33 + 1];
                state.getNormal().z = k00 * normals[i30 + 2] + k10 * normals[i31 + 2] + k11 * normals[i32 + 2] + k01 * normals[i33 + 2];
                state.getNormal().set(parent.transformNormalObjectToWorld(state.getNormal()));
                state.getNormal().normalize();
                break;
            }
            case FACEVARYING: {
                int idx = 3 * quad;
                float[] normals = this.normals.data;
                state.getNormal().x = k00 * normals[idx + 0] + k10 * normals[idx + 3] + k11 * normals[idx + 6] + k01 * normals[idx + 9];
                state.getNormal().y = k00 * normals[idx + 1] + k10 * normals[idx + 4] + k11 * normals[idx + 7] + k01 * normals[idx + 10];
                state.getNormal().z = k00 * normals[idx + 2] + k10 * normals[idx + 5] + k11 * normals[idx + 8] + k01 * normals[idx + 11];
                state.getNormal().set(parent.transformNormalObjectToWorld(state.getNormal()));
                state.getNormal().normalize();
                break;
            }
        }
        float uv00 = 0, uv01 = 0, uv10 = 0, uv11 = 0, uv20 = 0, uv21 = 0, uv30 = 0, uv31 = 0;
        switch (uvs.interp) {
            case NONE:
            case FACE: {
                state.getUV().x = 0;
                state.getUV().y = 0;
                break;
            }
            case VERTEX: {
                int i20 = 2 * index0;
                int i21 = 2 * index1;
                int i22 = 2 * index2;
                int i23 = 2 * index3;
                float[] uvs = this.uvs.data;
                uv00 = uvs[i20 + 0];
                uv01 = uvs[i20 + 1];
                uv10 = uvs[i21 + 0];
                uv11 = uvs[i21 + 1];
                uv20 = uvs[i22 + 0];
                uv21 = uvs[i22 + 1];
                uv20 = uvs[i23 + 0];
                uv21 = uvs[i23 + 1];
                break;
            }
            case FACEVARYING: {
                int idx = quad << 1;
                float[] uvs = this.uvs.data;
                uv00 = uvs[idx + 0];
                uv01 = uvs[idx + 1];
                uv10 = uvs[idx + 2];
                uv11 = uvs[idx + 3];
                uv20 = uvs[idx + 4];
                uv21 = uvs[idx + 5];
                uv30 = uvs[idx + 6];
                uv31 = uvs[idx + 7];
                break;
            }
        }
        if (uvs.interp != InterpolationType.NONE) {
            // get exact uv coords and compute tangent vectors
            state.getUV().x = k00 * uv00 + k10 * uv10 + k11 * uv20 + k01 * uv30;
            state.getUV().y = k00 * uv01 + k10 * uv11 + k11 * uv21 + k01 * uv31;
            float du1 = uv00 - uv20;
            float du2 = uv10 - uv20;
            float dv1 = uv01 - uv21;
            float dv2 = uv11 - uv21;
            Vector3 dp1 = Point3.sub(v0p, v2p, new Vector3()), dp2 = Point3.sub(v1p, v2p, new Vector3());
            float determinant = du1 * dv2 - dv1 * du2;
            if (determinant == 0.0f) {
                // create basis in world space
                state.setBasis(OrthoNormalBasis.makeFromW(state.getNormal()));
            } else {
                float invdet = 1.f / determinant;
                // Vector3 dpdu = new Vector3();
                // dpdu.x = (dv2 * dp1.x - dv1 * dp2.x) * invdet;
                // dpdu.y = (dv2 * dp1.y - dv1 * dp2.y) * invdet;
                // dpdu.z = (dv2 * dp1.z - dv1 * dp2.z) * invdet;
                Vector3 dpdv = new Vector3();
                dpdv.x = (-du2 * dp1.x + du1 * dp2.x) * invdet;
                dpdv.y = (-du2 * dp1.y + du1 * dp2.y) * invdet;
                dpdv.z = (-du2 * dp1.z + du1 * dp2.z) * invdet;
                dpdv = parent.transformVectorObjectToWorld(dpdv);
                // create basis in world space
                state.setBasis(OrthoNormalBasis.makeFromWV(state.getNormal(), dpdv));
            }
        } else
            state.setBasis(OrthoNormalBasis.makeFromW(state.getNormal()));
        int shaderIndex = faceShaders == null ? 0 : (faceShaders[primID] & 0xFF);
        state.setShader(parent.getShader(shaderIndex));
        state.setModifier(parent.getModifier(shaderIndex));
    }

    protected Point3 getPoint(int i) {
        i *= 3;
        return new Point3(points[i], points[i + 1], points[i + 2]);
    }

    public PrimitiveList getBakingPrimitives() {
        return null;
    }
}