C# ShadingState.getInstance方法代码示例

        public void prepareShadingState(ShadingState state)
        {
            state.init();
            state.getRay().getPoint(state.getPoint());
            Instance parent = state.getInstance();
            Point3 localPoint = parent.transformWorldToObject(state.getPoint());
            state.getNormal().set(localPoint.x, localPoint.y, localPoint.z);
            state.getNormal().normalize();

            float phi = (float)Math.Atan2(state.getNormal().y, state.getNormal().x);
            if (phi < 0)
                phi += (float)(2 * Math.PI);
            float theta = (float)Math.Acos(state.getNormal().z);
            state.getUV().y = theta / (float)Math.PI;
            state.getUV().x = phi / (float)(2 * Math.PI);
            Vector3 v = new Vector3();
            v.x = -2 * (float)Math.PI * state.getNormal().y;
            v.y = 2 * (float)Math.PI * state.getNormal().x;
            v.z = 0;
            state.setShader(parent.getShader(0));
            state.setModifier(parent.getModifier(0));
            // into world space
            Vector3 worldNormal = parent.transformNormalObjectToWorld(state.getNormal());
            v = parent.transformVectorObjectToWorld(v);
            state.getNormal().set(worldNormal);
            state.getNormal().normalize();
            state.getGeoNormal().set(state.getNormal());
            // compute basis in world space
            state.setBasis(OrthoNormalBasis.makeFromWV(state.getNormal(), v));
        }

 public Color getRadiance(ShadingState state)
 {
     Point3[] p = new Point3[3];
     if (!state.getTrianglePoints(p))
         return getFillColor(state);
     // transform points into camera space
     Point3 center = state.getPoint();
     Matrix4 w2c = state.getWorldToCamera();
     center = w2c.transformP(center);
     for (int i = 0; i < 3; i++)
         p[i] = w2c.transformP(state.getInstance().transformObjectToWorld(p[i]));
     float cn = 1.0f / (float)Math.Sqrt(center.x * center.x + center.y * center.y + center.z * center.z);
     for (int i = 0, i2 = 2; i < 3; i2 = i, i++)
     {
         // compute orthogonal projection of the shading point onto each
         // triangle edge as in:
         // http://mathworld.wolfram.com/Point-LineDistance3-Dimensional.html
         float t = (center.x - p[i].x) * (p[i2].x - p[i].x);
         t += (center.y - p[i].y) * (p[i2].y - p[i].y);
         t += (center.z - p[i].z) * (p[i2].z - p[i].z);
         t /= p[i].distanceToSquared(p[i2]);
         float projx = (1 - t) * p[i].x + t * p[i2].x;
         float projy = (1 - t) * p[i].y + t * p[i2].y;
         float projz = (1 - t) * p[i].z + t * p[i2].z;
         float n = 1.0f / (float)Math.Sqrt(projx * projx + projy * projy + projz * projz);
         // check angular width
         float dot = projx * center.x + projy * center.y + projz * center.z;
         if (dot * n * cn >= cosWidth)
             return getLineColor(state);
     }
     return getFillColor(state);
 }

 public void prepareShadingState(ShadingState state)
 {
     state.init();
     state.getRay().getPoint(state.getPoint());
     Instance parent = state.getInstance();
     Point3 n = parent.transformWorldToObject(state.getPoint());
     state.getNormal().set(n.x * (2 * n.x * n.x - 1), n.y * (2 * n.y * n.y - 1), n.z * (2 * n.z * n.z - 1));
     state.getNormal().normalize();
     state.setShader(parent.getShader(0));
     state.setModifier(parent.getModifier(0));
     // into world space
     Vector3 worldNormal = parent.transformNormalObjectToWorld(state.getNormal());
     state.getNormal().set(worldNormal);
     state.getNormal().normalize();
     state.getGeoNormal().set(state.getNormal());
     // create basis in world space
     state.setBasis(OrthoNormalBasis.makeFromW(state.getNormal()));
 }

        public void prepareShadingState(ShadingState state)
        {
            state.init();
            state.getRay().getPoint(state.getPoint());
            Point3 localPoint = state.getInstance().transformWorldToObject(state.getPoint());

            localPoint.x -= particles[3 * state.getPrimitiveID() + 0];
            localPoint.y -= particles[3 * state.getPrimitiveID() + 1];
            localPoint.z -= particles[3 * state.getPrimitiveID() + 2];

            state.getNormal().set(localPoint.x, localPoint.y, localPoint.z);
            state.getNormal().normalize();

            state.setShader(state.getInstance().getShader(0));
            state.setModifier(state.getInstance().getModifier(0));
            // into object space
            Vector3 worldNormal = state.getInstance().transformNormalObjectToWorld(state.getNormal());
            state.getNormal().set(worldNormal);
            state.getNormal().normalize();
            state.getGeoNormal().set(state.getNormal());
            state.setBasis(OrthoNormalBasis.makeFromW(state.getNormal()));
        }

 public void prepareShadingState(ShadingState state)
 {
     state.init();
     state.getRay().getPoint(state.getPoint());
     int n = state.getPrimitiveID();
     switch (n)
     {
         case 0:
             state.getNormal().set(new Vector3(1, 0, 0));
             break;
         case 1:
             state.getNormal().set(new Vector3(-1, 0, 0));
             break;
         case 2:
             state.getNormal().set(new Vector3(0, 1, 0));
             break;
         case 3:
             state.getNormal().set(new Vector3(0, -1, 0));
             break;
         case 4:
             state.getNormal().set(new Vector3(0, 0, 1));
             break;
         case 5:
             state.getNormal().set(new Vector3(0, 0, -1));
             break;
         default:
             state.getNormal().set(new Vector3(0, 0, 0));
             break;
     }
     state.getGeoNormal().set(state.getNormal());
     state.setBasis(OrthoNormalBasis.makeFromW(state.getNormal()));
     state.setShader(state.getInstance().getShader(0));
     state.setModifier(state.getInstance().getModifier(0));
 }

 public void prepareShadingState(ShadingState state)
 {
     state.getInstance().prepareShadingState(state);
 }

 public void prepareShadingState(ShadingState state)
 {
     if (state.getDepth() == 0)
         state.setShader(state.getInstance().getShader(0));
 }

            public void add(ShadingState state)
            {
                if (n == 0)
                    c = Color.black();
                if (state != null)
                {
                    c.add(state.getResult());
					alpha += state.getInstance() == null ? 0 : 1;
                }
                n++;
            }

        public void prepareShadingState(ShadingState state)
        {
            state.init();
            state.getRay().getPoint(state.getPoint());
            Instance parent = state.getInstance();
            // get local point
            Point3 p = parent.transformWorldToObject(state.getPoint());
            // compute local normal
            float deriv = p.x * p.x + p.y * p.y + p.z * p.z - ri2 - ro2;
            state.getNormal().set(p.x * deriv, p.y * deriv, p.z * deriv + 2 * ro2 * p.z);
            state.getNormal().normalize();

            double phi = Math.Asin(MathUtils.clamp(p.z / ri, -1, 1));
            double theta = Math.Atan2(p.y, p.x);
            if (theta < 0)
                theta += 2 * Math.PI;
            state.getUV().x = (float)(theta / (2 * Math.PI));
            state.getUV().y = (float)((phi + Math.PI / 2) / Math.PI);
            state.setShader(parent.getShader(0));
            state.setModifier(parent.getModifier(0));
            // into world space
            Vector3 worldNormal = parent.transformNormalObjectToWorld(state.getNormal());
            state.getNormal().set(worldNormal);
            state.getNormal().normalize();
            state.getGeoNormal().set(state.getNormal());
            // make basis in world space
            state.setBasis(OrthoNormalBasis.makeFromW(state.getNormal()));
        }

 private Color lookupShadingCache(ShadingState state, IShader shader)
 {
     lock (lockObj)
     {
         if (state.getNormal() == null)
             return null;
         cacheLookups++;
         int cx = (int)(state.getRasterX() * shadingCacheResolution);
         int cy = (int)(state.getRasterY() * shadingCacheResolution);
         int hash = hashfunc(cx, cy);
         CacheEntry e = _shadingCache[hash & (_shadingCache.Length - 1)];
         if (e == null)
         {
             cacheEmptyEntryMisses++;
             return null;
         }
         // entry maps to correct pixel
         if (e.cx == cx && e.cy == cy)
         {
             // search further
             for (Sample s = e.first; s != null; s = s.next)
             {
                 if (s.i != state.getInstance())
                     continue;
                 // if (s.prim != state.getPrimitiveID())
                 // continue;
                 if (s.s != shader)
                     continue;
                 if (state.getNormal().dot(s.nx, s.ny, s.nz) < 0.95f)
                     continue;
                 // we have a match
                 cacheHits++;
                 return s.c;
             }
         }
         else
             cacheWrongEntryMisses++;
         return null;
     }
 }

            public void set(ShadingState state)
            {
                if (state == null)
                    c = Color.BLACK;
                else
                {
                    c = state.getResult();
                    shader = state.getShader();
                    instance = state.getInstance();
                    if (state.getNormal() != null)
                    {
                        nx = state.getNormal().x;
                        ny = state.getNormal().y;
                        nz = state.getNormal().z;
                    }
					alpha = state.getInstance() == null ? 0 : 1;
                }
                n = 1;
            }

 public Color shadeHit(ShadingState state)
 {
     state.getInstance().prepareShadingState(state);
     IShader shader = getShader(state);
     return (shader != null) ? shader.GetRadiance(state) : Color.BLACK;
 }

 public void prepareShadingState(ShadingState state)
 {
     state.init();
     state.getRay().getPoint(state.getPoint());
     Instance parent = state.getInstance();
     float u = state.getU();
     float v = state.getV();
     float[] bu = bernstein(u);
     float[] bdu = bernsteinDeriv(u);
     float[] bv = bernstein(v);
     float[] bdv = bernsteinDeriv(v);
     getPatchPoint(u, v, patches[state.getPrimitiveID()], bu, bv, bdu, bdv, new Point3(), state.getNormal());
     state.getNormal().set(parent.transformNormalObjectToWorld(state.getNormal()));
     state.getNormal().normalize();
     state.getGeoNormal().set(state.getNormal());
     state.getUV().set(u, v);
     state.setShader(parent.getShader(0));
     state.setModifier(parent.getModifier(0));
     // FIXME: use actual derivatives to create basis
     state.setBasis(OrthoNormalBasis.makeFromW(state.getNormal()));
 }

            public void prepareShadingState(ShadingState state)
            {
                state.init();
                Instance parent = state.getInstance();
                int primID = state.getPrimitiveID();
                float u = state.getU();
                float v = state.getV();
                float w = 1 - u - v;
                // state.getRay().getPoint(state.getPoint());
                int tri = 3 * primID;
                int index0 = triangleMesh.triangles[tri + 0];
                int index1 = triangleMesh.triangles[tri + 1];
                int index2 = triangleMesh.triangles[tri + 2];
                Point3 v0p = triangleMesh.getPoint(index0);
                Point3 v1p = triangleMesh.getPoint(index1);
                Point3 v2p = triangleMesh.getPoint(index2);

                // get object space point from barycentric coordinates
                state.getPoint().x = w * v0p.x + u * v1p.x + v * v2p.x;
                state.getPoint().y = w * v0p.y + u * v1p.y + v * v2p.y;
                state.getPoint().z = w * v0p.z + u * v1p.z + v * v2p.z;
                // move into world space
                state.getPoint().set(parent.transformObjectToWorld(state.getPoint()));

                Vector3 ng = Point3.normal(v0p, v1p, v2p);
                if (parent != null)
                    ng = parent.transformNormalObjectToWorld(ng);
                ng.normalize();
                state.getGeoNormal().set(ng);
                switch (triangleMesh.normals.interp)
                {
                    case ParameterList.InterpolationType.NONE:
                    case ParameterList.InterpolationType.FACE:
                        {
                            state.getNormal().set(ng);
                            break;
                        }
                    case ParameterList.InterpolationType.VERTEX:
                        {
                            int i30 = 3 * index0;
                            int i31 = 3 * index1;
                            int i32 = 3 * index2;
                            float[] normals = triangleMesh.normals.data;
                            state.getNormal().x = w * normals[i30 + 0] + u * normals[i31 + 0] + v * normals[i32 + 0];
                            state.getNormal().y = w * normals[i30 + 1] + u * normals[i31 + 1] + v * normals[i32 + 1];
                            state.getNormal().z = w * normals[i30 + 2] + u * normals[i31 + 2] + v * normals[i32 + 2];
                            if (parent != null)
                                state.getNormal().set(parent.transformNormalObjectToWorld(state.getNormal()));
                            state.getNormal().normalize();
                            break;
                        }
                    case ParameterList.InterpolationType.FACEVARYING:
                        {
                            int idx = 3 * tri;
                            float[] normals = triangleMesh.normals.data;
                            state.getNormal().x = w * normals[idx + 0] + u * normals[idx + 3] + v * normals[idx + 6];
                            state.getNormal().y = w * normals[idx + 1] + u * normals[idx + 4] + v * normals[idx + 7];
                            state.getNormal().z = w * normals[idx + 2] + u * normals[idx + 5] + v * normals[idx + 8];
                            if (parent != null)
                                state.getNormal().set(parent.transformNormalObjectToWorld(state.getNormal()));
                            state.getNormal().normalize();
                            break;
                        }
                }
                float uv00 = 0, uv01 = 0, uv10 = 0, uv11 = 0, uv20 = 0, uv21 = 0;
                switch (triangleMesh.uvs.interp)
                {
                    case ParameterList.InterpolationType.NONE:
                    case ParameterList.InterpolationType.FACE:
                        {
                            state.getUV().x = 0;
                            state.getUV().y = 0;
                            break;
                        }
                    case ParameterList.InterpolationType.VERTEX:
                        {
                            int i20 = 2 * index0;
                            int i21 = 2 * index1;
                            int i22 = 2 * index2;
                            float[] uvs = triangleMesh.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];
                            break;
                        }
                    case ParameterList.InterpolationType.FACEVARYING:
                        {
                            int idx = tri << 1;
                            float[] uvs = triangleMesh.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];
                            break;
                        }
//.........这里部分代码省略.........

        public void prepareShadingState(ShadingState state)
        {
            state.init();
            state.getRay().getPoint(state.getPoint());
            Instance parent = state.getInstance();
            // compute local normal
            Point3 p = parent.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((float)gradX, (float)gradY, (float)gradZ);
            state.getNormal().set(parent.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));
//.........这里部分代码省略.........